webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 373 insertions, 177 deletions

diff --git a/Source/WebCore/testing/Internals.h b/Source/WebCore/testing/Internals.h
index 1b936332a..f5c08a87d 100644
--- a/Source/WebCore/testing/Internals.h
+++ b/Source/WebCore/testing/Internals.h
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
- * Copyright (C) 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2017 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -24,184 +24,237 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef Internals_h
-#define Internals_h
+#pragma once
 
 #include "CSSComputedStyleDeclaration.h"
 #include "ContextDestructionObserver.h"
-#include "ExceptionCodePlaceholder.h"
-#include "NodeList.h"
-#include <bindings/ScriptValue.h>
-#include <runtime/ArrayBuffer.h>
+#include "ExceptionOr.h"
+#include "PageConsoleClient.h"
 #include <runtime/Float32Array.h>
-#include <wtf/PassRefPtr.h>
-#include <wtf/RefCounted.h>
-#include <wtf/text/WTFString.h>
+
+#if ENABLE(MEDIA_SESSION)
+#include "MediaSessionInterruptionProvider.h"
+#endif
 
 namespace WebCore {
 
+class AudioContext;
 class ClientRect;
 class ClientRectList;
-class DOMStringList;
+class DOMURL;
 class DOMWindow;
 class Document;
-class DocumentMarker;
 class Element;
+class File;
 class Frame;
-class InspectorFrontendChannelDummy;
+class GCObservation;
+class HTMLImageElement;
+class HTMLInputElement;
+class HTMLLinkElement;
+class HTMLMediaElement;
+class HTMLSelectElement;
+class InspectorStubFrontend;
 class InternalSettings;
+class MallocStatistics;
+class MediaSession;
 class MemoryInfo;
-class Node;
+class MockCDMFactory;
+class MockContentFilterSettings;
+class MockPageOverlay;
+class NodeList;
 class Page;
 class Range;
-class ScriptExecutionContext;
-class ShadowRoot;
-class MallocStatistics;
+class RenderedDocumentMarker;
+class RTCPeerConnection;
 class SerializedScriptValue;
+class SourceBuffer;
+class StyleSheet;
 class TimeRanges;
 class TypeConversions;
+class XMLHttpRequest;
 
-typedef int ExceptionCode;
-
-class Internals : public RefCounted<Internals>
-                , public ContextDestructionObserver {
+class Internals final : public RefCounted<Internals>, private ContextDestructionObserver {
 public:
-    static PassRefPtr<Internals> create(Document*);
+    static Ref<Internals> create(Document&);
     virtual ~Internals();
 
-    static void resetToConsistentState(Page*);
+    static void resetToConsistentState(Page&);
 
-    String elementRenderTreeAsText(Element*, ExceptionCode&);
+    ExceptionOr<String> elementRenderTreeAsText(Element&);
+    bool hasPausedImageAnimations(Element&);
 
-    String address(Node*);
+    String address(Node&);
+    bool nodeNeedsStyleRecalc(Node&);
+    String styleChangeType(Node&);
+    String description(JSC::JSValue);
 
     bool isPreloaded(const String& url);
     bool isLoadingFromMemoryCache(const String& url);
-
-    PassRefPtr<CSSComputedStyleDeclaration> computedStyleIncludingVisitedInfo(Node*, ExceptionCode&) const;
-
-#if ENABLE(SHADOW_DOM)
-    typedef ShadowRoot ShadowRootIfShadowDOMEnabledOrNode;
-#else
-    typedef Node ShadowRootIfShadowDOMEnabledOrNode;
-#endif
-    ShadowRootIfShadowDOMEnabledOrNode* ensureShadowRoot(Element* host, ExceptionCode&);
-    ShadowRootIfShadowDOMEnabledOrNode* createShadowRoot(Element* host, ExceptionCode&);
-    ShadowRootIfShadowDOMEnabledOrNode* shadowRoot(Element* host, ExceptionCode&);
-    String shadowRootType(const Node*, ExceptionCode&) const;
-    Element* includerFor(Node*, ExceptionCode&);
-    String shadowPseudoId(Element*, ExceptionCode&);
-    void setShadowPseudoId(Element*, const String&, ExceptionCode&);
+    String xhrResponseSource(XMLHttpRequest&);
+    bool isSharingStyleSheetContents(HTMLLinkElement&, HTMLLinkElement&);
+    bool isStyleSheetLoadingSubresources(HTMLLinkElement&);
+    enum class CachePolicy { UseProtocolCachePolicy, ReloadIgnoringCacheData, ReturnCacheDataElseLoad, ReturnCacheDataDontLoad };
+    void setOverrideCachePolicy(CachePolicy);
+    ExceptionOr<void> setCanShowModalDialogOverride(bool allow);
+    enum class ResourceLoadPriority { ResourceLoadPriorityVeryLow, ResourceLoadPriorityLow, ResourceLoadPriorityMedium, ResourceLoadPriorityHigh, ResourceLoadPriorityVeryHigh };
+    void setOverrideResourceLoadPriority(ResourceLoadPriority);
+    void setStrictRawResourceValidationPolicyDisabled(bool);
+
+    void clearMemoryCache();
+    void pruneMemoryCacheToSize(unsigned size);
+    unsigned memoryCacheSize() const;
+
+    unsigned imageFrameIndex(HTMLImageElement&);
+    void setImageFrameDecodingDuration(HTMLImageElement&, float duration);
+    void resetImageAnimation(HTMLImageElement&);
+
+    void clearPageCache();
+    unsigned pageCacheSize() const;
+
+    void disableTileSizeUpdateDelay();
+
+    Ref<CSSComputedStyleDeclaration> computedStyleIncludingVisitedInfo(Element&) const;
+
+    Node* ensureUserAgentShadowRoot(Element& host);
+    Node* shadowRoot(Element& host);
+    ExceptionOr<String> shadowRootType(const Node&) const;
+    String shadowPseudoId(Element&);
+    void setShadowPseudoId(Element&, const String&);
+
+    // CSS Deferred Parsing Testing
+    unsigned deferredStyleRulesCount(StyleSheet&);
+    unsigned deferredGroupRulesCount(StyleSheet&);
+    unsigned deferredKeyframesRulesCount(StyleSheet&);
+
+    // DOMTimers throttling testing.
+    ExceptionOr<bool> isTimerThrottled(int timeoutId);
+    bool isRequestAnimationFrameThrottled() const;
+    bool areTimersThrottled() const;
+
+    enum EventThrottlingBehavior { Responsive, Unresponsive };
+    void setEventThrottlingBehaviorOverride(std::optional<EventThrottlingBehavior>);
+    std::optional<EventThrottlingBehavior> eventThrottlingBehaviorOverride() const;
 
     // Spatial Navigation testing.
-    unsigned lastSpatialNavigationCandidateCount(ExceptionCode&) const;
+    ExceptionOr<unsigned> lastSpatialNavigationCandidateCount() const;
 
     // CSS Animation testing.
     unsigned numberOfActiveAnimations() const;
-    bool animationsAreSuspended(ExceptionCode&) const;
-    void suspendAnimations(ExceptionCode&) const;
-    void resumeAnimations(ExceptionCode&) const;
-    bool pauseAnimationAtTimeOnElement(const String& animationName, double pauseTime, Element*, ExceptionCode&);
-    bool pauseAnimationAtTimeOnPseudoElement(const String& animationName, double pauseTime, Element*, const String& pseudoId, ExceptionCode&);
+    ExceptionOr<bool> animationsAreSuspended() const;
+    ExceptionOr<void> suspendAnimations() const;
+    ExceptionOr<void> resumeAnimations() const;
+    ExceptionOr<bool> pauseAnimationAtTimeOnElement(const String& animationName, double pauseTime, Element&);
+    ExceptionOr<bool> pauseAnimationAtTimeOnPseudoElement(const String& animationName, double pauseTime, Element&, const String& pseudoId);
 
     // CSS Transition testing.
-    bool pauseTransitionAtTimeOnElement(const String& propertyName, double pauseTime, Element*, ExceptionCode&);
-    bool pauseTransitionAtTimeOnPseudoElement(const String& property, double pauseTime, Element*, const String& pseudoId, ExceptionCode&);
+    ExceptionOr<bool> pauseTransitionAtTimeOnElement(const String& propertyName, double pauseTime, Element&);
+    ExceptionOr<bool> pauseTransitionAtTimeOnPseudoElement(const String& property, double pauseTime, Element&, const String& pseudoId);
 
-    Node* treeScopeRootNode(Node*, ExceptionCode&);
-    Node* parentTreeScope(Node*, ExceptionCode&);
-    bool hasSelectorForIdInShadow(Element* host, const String& idValue, ExceptionCode&);
-    bool hasSelectorForClassInShadow(Element* host, const String& className, ExceptionCode&);
-    bool hasSelectorForAttributeInShadow(Element* host, const String& attributeName, ExceptionCode&);
-    bool hasSelectorForPseudoClassInShadow(Element* host, const String& pseudoClass, ExceptionCode&);
+    Node* treeScopeRootNode(Node&);
+    Node* parentTreeScope(Node&);
 
-    bool attached(Node*, ExceptionCode&);
+    String visiblePlaceholder(Element&);
+    void selectColorInColorChooser(HTMLInputElement&, const String& colorValue);
+    ExceptionOr<Vector<String>> formControlStateOfPreviousHistoryItem();
+    ExceptionOr<void> setFormControlStateOfPreviousHistoryItem(const Vector<String>&);
 
-    String visiblePlaceholder(Element*);
-#if ENABLE(INPUT_TYPE_COLOR)
-    void selectColorInColorChooser(Element*, const String& colorValue);
-#endif
-    Vector<String> formControlStateOfPreviousHistoryItem(ExceptionCode&);
-    void setFormControlStateOfPreviousHistoryItem(const Vector<String>&, ExceptionCode&);
+    ExceptionOr<Ref<ClientRect>> absoluteCaretBounds();
+
+    Ref<ClientRect> boundingBox(Element&);
 
-    PassRefPtr<ClientRect> absoluteCaretBounds(ExceptionCode&);
+    ExceptionOr<Ref<ClientRectList>> inspectorHighlightRects();
+    ExceptionOr<String> inspectorHighlightObject();
 
-    PassRefPtr<ClientRect> boundingBox(Element*, ExceptionCode&);
+    ExceptionOr<unsigned> markerCountForNode(Node&, const String&);
+    ExceptionOr<RefPtr<Range>> markerRangeForNode(Node&, const String& markerType, unsigned index);
+    ExceptionOr<String> markerDescriptionForNode(Node&, const String& markerType, unsigned index);
+    ExceptionOr<String> dumpMarkerRects(const String& markerType);
+    void addTextMatchMarker(const Range&, bool isActive);
+    ExceptionOr<void> setMarkedTextMatchesAreHighlighted(bool);
 
-    PassRefPtr<ClientRectList> inspectorHighlightRects(ExceptionCode&);
-    String inspectorHighlightObject(ExceptionCode&);
+    void invalidateFontCache();
 
-    unsigned markerCountForNode(Node*, const String&, ExceptionCode&);
-    PassRefPtr<Range> markerRangeForNode(Node*, const String& markerType, unsigned index, ExceptionCode&);
-    String markerDescriptionForNode(Node*, const String& markerType, unsigned index, ExceptionCode&);
-    void addTextMatchMarker(const Range*, bool isActive);
+    ExceptionOr<void> setScrollViewPosition(int x, int y);
+    
+    ExceptionOr<Ref<ClientRect>> layoutViewportRect();
+    ExceptionOr<Ref<ClientRect>> visualViewportRect();
+    
+    ExceptionOr<void> setViewBaseBackgroundColor(const String& colorValue);
 
-    void setScrollViewPosition(long x, long y, ExceptionCode&);
-    void setPagination(const String& mode, int gap, ExceptionCode& ec) { setPagination(mode, gap, 0, ec); }
-    void setPagination(const String& mode, int gap, int pageLength, ExceptionCode&);
-    String configurationForViewport(float devicePixelRatio, int deviceWidth, int deviceHeight, int availableWidth, int availableHeight, ExceptionCode&);
+    ExceptionOr<void> setPagination(const String& mode, int gap, int pageLength);
+    ExceptionOr<void> setPaginationLineGridEnabled(bool);
+    ExceptionOr<String> configurationForViewport(float devicePixelRatio, int deviceWidth, int deviceHeight, int availableWidth, int availableHeight);
 
-    bool wasLastChangeUserEdit(Element* textField, ExceptionCode&);
-    bool elementShouldAutoComplete(Element* inputElement, ExceptionCode&);
-    String suggestedValue(Element* inputElement, ExceptionCode&);
-    void setSuggestedValue(Element* inputElement, const String&, ExceptionCode&);
-    void setEditingValue(Element* inputElement, const String&, ExceptionCode&);
-    void setAutofilled(Element*, bool enabled, ExceptionCode&);
-    void scrollElementToRect(Element*, long x, long y, long w, long h, ExceptionCode&);
+    ExceptionOr<bool> wasLastChangeUserEdit(Element& textField);
+    bool elementShouldAutoComplete(HTMLInputElement&);
+    void setEditingValue(HTMLInputElement&, const String&);
+    void setAutofilled(HTMLInputElement&, bool enabled);
+    enum class AutoFillButtonType { AutoFillButtonTypeNone, AutoFillButtonTypeContacts, AutoFillButtonTypeCredentials };
+    void setShowAutoFillButton(HTMLInputElement&, AutoFillButtonType);
+    ExceptionOr<void> scrollElementToRect(Element&, int x, int y, int w, int h);
 
-    void paintControlTints(ExceptionCode&);
+    ExceptionOr<String> autofillFieldName(Element&);
 
-    PassRefPtr<Range> rangeFromLocationAndLength(Element* scope, int rangeLocation, int rangeLength, ExceptionCode&);
-    unsigned locationFromRange(Element* scope, const Range*, ExceptionCode&);
-    unsigned lengthFromRange(Element* scope, const Range*, ExceptionCode&);
-    String rangeAsText(const Range*, ExceptionCode&);
+    ExceptionOr<void> paintControlTints();
 
-    void setDelegatesScrolling(bool enabled, ExceptionCode&);
+    RefPtr<Range> rangeFromLocationAndLength(Element& scope, int rangeLocation, int rangeLength);
+    unsigned locationFromRange(Element& scope, const Range&);
+    unsigned lengthFromRange(Element& scope, const Range&);
+    String rangeAsText(const Range&);
+    Ref<Range> subrange(Range&, int rangeLocation, int rangeLength);
+    ExceptionOr<RefPtr<Range>> rangeForDictionaryLookupAtLocation(int x, int y);
+    RefPtr<Range> rangeOfStringNearLocation(const Range&, const String&, unsigned);
 
-    int lastSpellCheckRequestSequence(ExceptionCode&);
-    int lastSpellCheckProcessedSequence(ExceptionCode&);
+    ExceptionOr<void> setDelegatesScrolling(bool enabled);
+
+    ExceptionOr<int> lastSpellCheckRequestSequence();
+    ExceptionOr<int> lastSpellCheckProcessedSequence();
 
     Vector<String> userPreferredLanguages() const;
     void setUserPreferredLanguages(const Vector<String>&);
 
-    unsigned wheelEventHandlerCount(ExceptionCode&);
-    unsigned touchEventHandlerCount(ExceptionCode&);
+    Vector<String> userPreferredAudioCharacteristics() const;
+    void setUserPreferredAudioCharacteristic(const String&);
+
+    ExceptionOr<unsigned> wheelEventHandlerCount();
+    ExceptionOr<unsigned> touchEventHandlerCount();
+
+    ExceptionOr<RefPtr<NodeList>> nodesFromRect(Document&, int x, int y, unsigned topPadding, unsigned rightPadding, unsigned bottomPadding, unsigned leftPadding, bool ignoreClipping, bool allowShadowContent, bool allowChildFrameContent) const;
 
-    PassRefPtr<NodeList> nodesFromRect(Document*, int x, int y, unsigned topPadding, unsigned rightPadding,
-        unsigned bottomPadding, unsigned leftPadding, bool ignoreClipping, bool allowShadowContent, bool allowChildFrameContent, ExceptionCode&) const;
+    String parserMetaData(JSC::JSValue = JSC::JSValue::JSUndefined);
 
-    void emitInspectorDidBeginFrame();
-    void emitInspectorDidCancelFrame();
+    void updateEditorUINowIfScheduled();
 
-    String parserMetaData(Deprecated::ScriptValue = Deprecated::ScriptValue());
+    bool hasSpellingMarker(int from, int length);
+    bool hasGrammarMarker(int from, int length);
+    bool hasAutocorrectedMarker(int from, int length);
+    void setContinuousSpellCheckingEnabled(bool);
+    void setAutomaticQuoteSubstitutionEnabled(bool);
+    void setAutomaticLinkDetectionEnabled(bool);
+    void setAutomaticDashSubstitutionEnabled(bool);
+    void setAutomaticTextReplacementEnabled(bool);
+    void setAutomaticSpellingCorrectionEnabled(bool);
 
-    bool hasSpellingMarker(int from, int length, ExceptionCode&);
-    bool hasGrammarMarker(int from, int length, ExceptionCode&);
-    bool hasAutocorrectedMarker(int from, int length, ExceptionCode&);
-    void setContinuousSpellCheckingEnabled(bool enabled, ExceptionCode&);
-    void setAutomaticQuoteSubstitutionEnabled(bool enabled, ExceptionCode&);
-    void setAutomaticLinkDetectionEnabled(bool enabled, ExceptionCode&);
-    void setAutomaticDashSubstitutionEnabled(bool enabled, ExceptionCode&);
-    void setAutomaticTextReplacementEnabled(bool enabled, ExceptionCode&);
-    void setAutomaticSpellingCorrectionEnabled(bool enabled, ExceptionCode&);
+    void handleAcceptedCandidate(const String& candidate, unsigned location, unsigned length);
 
-    bool isOverwriteModeEnabled(ExceptionCode&);
-    void toggleOverwriteModeEnabled(ExceptionCode&);
+    bool isOverwriteModeEnabled();
+    void toggleOverwriteModeEnabled();
 
-    unsigned numberOfScrollableAreas(ExceptionCode&);
+    ExceptionOr<RefPtr<Range>> rangeOfString(const String&, RefPtr<Range>&&, const Vector<String>& findOptions);
+    ExceptionOr<unsigned> countMatchesForText(const String&, const Vector<String>& findOptions, const String& markMatches);
+    ExceptionOr<unsigned> countFindMatches(const String&, const Vector<String>& findOptions);
 
-    bool isPageBoxVisible(int pageNumber, ExceptionCode&);
+    unsigned numberOfScrollableAreas();
+
+    ExceptionOr<bool> isPageBoxVisible(int pageNumber);
 
     static const char* internalsId;
 
     InternalSettings* settings() const;
     unsigned workerThreadCount() const;
+    bool areSVGAnimationsPaused() const;
 
-    void setBatteryStatus(const String& eventType, bool charging, double chargingTime, double dischargingTime, double level, ExceptionCode&);
-
-    void setNetworkInformation(const String& eventType, double bandwidth, bool metered, ExceptionCode&);
-
-    void setDeviceProximity(const String& eventType, double value, double min, double max, ExceptionCode&);
+    ExceptionOr<void> setDeviceProximity(const String& eventType, double value, double min, double max);
 
     enum {
         // Values need to be kept in sync with Internals.idl.
@@ -209,140 +262,283 @@ public:
         LAYER_TREE_INCLUDES_TILE_CACHES = 2,
         LAYER_TREE_INCLUDES_REPAINT_RECTS = 4,
         LAYER_TREE_INCLUDES_PAINTING_PHASES = 8,
-        LAYER_TREE_INCLUDES_CONTENT_LAYERS = 16
+        LAYER_TREE_INCLUDES_CONTENT_LAYERS = 16,
+        LAYER_TREE_INCLUDES_ACCELERATES_DRAWING = 32,
+    };
+    ExceptionOr<String> layerTreeAsText(Document&, unsigned short flags) const;
+    ExceptionOr<String> repaintRectsAsText() const;
+    ExceptionOr<String> scrollingStateTreeAsText() const;
+    ExceptionOr<String> mainThreadScrollingReasons() const;
+    ExceptionOr<RefPtr<ClientRectList>> nonFastScrollableRects() const;
+
+    ExceptionOr<void> setElementUsesDisplayListDrawing(Element&, bool usesDisplayListDrawing);
+    ExceptionOr<void> setElementTracksDisplayListReplay(Element&, bool isTrackingReplay);
+
+    enum {
+        // Values need to be kept in sync with Internals.idl.
+        DISPLAY_LIST_INCLUDES_PLATFORM_OPERATIONS = 1,
     };
-    String layerTreeAsText(Document*, unsigned flags, ExceptionCode&) const;
-    String layerTreeAsText(Document*, ExceptionCode&) const;
-    String repaintRectsAsText(ExceptionCode&) const;
-    String scrollingStateTreeAsText(ExceptionCode&) const;
-    String mainThreadScrollingReasons(ExceptionCode&) const;
-    PassRefPtr<ClientRectList> nonFastScrollableRects(ExceptionCode&) const;
+    ExceptionOr<String> displayListForElement(Element&, unsigned short flags);
+    ExceptionOr<String> replayDisplayListForElement(Element&, unsigned short flags);
 
-    void garbageCollectDocumentResources(ExceptionCode&) const;
+    ExceptionOr<void> garbageCollectDocumentResources() const;
 
-    void allowRoundingHacks() const;
+    void beginSimulatedMemoryPressure();
+    void endSimulatedMemoryPressure();
+    bool isUnderMemoryPressure();
 
-    void insertAuthorCSS(const String&, ExceptionCode&) const;
-    void insertUserCSS(const String&, ExceptionCode&) const;
+    ExceptionOr<void> insertAuthorCSS(const String&) const;
+    ExceptionOr<void> insertUserCSS(const String&) const;
 
-#if ENABLE(INSPECTOR)
     unsigned numberOfLiveNodes() const;
     unsigned numberOfLiveDocuments() const;
-    Vector<String> consoleMessageArgumentCounts() const;
-    PassRefPtr<DOMWindow> openDummyInspectorFrontend(const String& url);
+
+    RefPtr<DOMWindow> openDummyInspectorFrontend(const String& url);
     void closeDummyInspectorFrontend();
-    void setInspectorResourcesDataSizeLimits(int maximumResourcesContentSize, int maximumSingleResourceContentSize, ExceptionCode&);
-    void setJavaScriptProfilingEnabled(bool enabled, ExceptionCode&);
-#endif
+    ExceptionOr<void> setInspectorIsUnderTest(bool);
 
-    String counterValue(Element*);
+    String counterValue(Element&);
 
-    int pageNumber(Element*, float pageWidth = 800, float pageHeight = 600);
+    int pageNumber(Element&, float pageWidth = 800, float pageHeight = 600);
     Vector<String> shortcutIconURLs() const;
-    Vector<String> allIconURLs() const;
 
     int numberOfPages(float pageWidthInPixels = 800, float pageHeightInPixels = 600);
-    String pageProperty(String, int, ExceptionCode& = ASSERT_NO_EXCEPTION) const;
-    String pageSizeAndMarginsInPixels(int, int, int, int, int, int, int, ExceptionCode& = ASSERT_NO_EXCEPTION) const;
+    ExceptionOr<String> pageProperty(const String& propertyName, int pageNumber) const;
+    ExceptionOr<String> pageSizeAndMarginsInPixels(int pageNumber, int width, int height, int marginTop, int marginRight, int marginBottom, int marginLeft) const;
+
+    ExceptionOr<float> pageScaleFactor() const;
 
-    void setPageScaleFactor(float scaleFactor, int x, int y, ExceptionCode&);
+    ExceptionOr<void> setPageScaleFactor(float scaleFactor, int x, int y);
+    ExceptionOr<void> setPageZoomFactor(float);
+    ExceptionOr<void> setTextZoomFactor(float);
+
+    ExceptionOr<void> setUseFixedLayout(bool);
+    ExceptionOr<void> setFixedLayoutSize(int width, int height);
+    ExceptionOr<void> setViewExposedRect(float left, float top, float width, float height);
 
     void setHeaderHeight(float);
     void setFooterHeight(float);
 
+    void setTopContentInset(float);
+
 #if ENABLE(FULLSCREEN_API)
-    void webkitWillEnterFullScreenForElement(Element*);
-    void webkitDidEnterFullScreenForElement(Element*);
-    void webkitWillExitFullScreenForElement(Element*);
-    void webkitDidExitFullScreenForElement(Element*);
+    void webkitWillEnterFullScreenForElement(Element&);
+    void webkitDidEnterFullScreenForElement(Element&);
+    void webkitWillExitFullScreenForElement(Element&);
+    void webkitDidExitFullScreenForElement(Element&);
 #endif
 
-    void setApplicationCacheOriginQuota(unsigned long long);
+    WEBCORE_TESTSUPPORT_EXPORT void setApplicationCacheOriginQuota(unsigned long long);
 
     void registerURLSchemeAsBypassingContentSecurityPolicy(const String& scheme);
     void removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(const String& scheme);
 
-    PassRefPtr<MallocStatistics> mallocStatistics() const;
-    PassRefPtr<TypeConversions> typeConversions() const;
-    PassRefPtr<MemoryInfo> memoryInfo() const;
+    void registerDefaultPortForProtocol(unsigned short port, const String& protocol);
+
+    Ref<MallocStatistics> mallocStatistics() const;
+    Ref<TypeConversions> typeConversions() const;
+    Ref<MemoryInfo> memoryInfo() const;
 
     Vector<String> getReferencedFilePaths() const;
 
-    void startTrackingRepaints(ExceptionCode&);
-    void stopTrackingRepaints(ExceptionCode&);
-    void updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(ExceptionCode&);
-    void updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(Node*, ExceptionCode&);
+    ExceptionOr<void> startTrackingRepaints();
+    ExceptionOr<void> stopTrackingRepaints();
+
+    ExceptionOr<void> startTrackingLayerFlushes();
+    ExceptionOr<unsigned> layerFlushCount();
+    
+    ExceptionOr<void> startTrackingStyleRecalcs();
+    ExceptionOr<unsigned> styleRecalcCount();
+    unsigned lastStyleUpdateSize() const;
+
+    ExceptionOr<void> startTrackingCompositingUpdates();
+    ExceptionOr<unsigned> compositingUpdateCount();
 
-    PassRefPtr<ArrayBuffer> serializeObject(PassRefPtr<SerializedScriptValue>) const;
-    PassRefPtr<SerializedScriptValue> deserializeBuffer(PassRefPtr<ArrayBuffer>) const;
+    ExceptionOr<void> updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(Node*);
+    unsigned layoutCount() const;
 
-    void setUsesOverlayScrollbars(bool enabled);
+    Ref<ArrayBuffer> serializeObject(const RefPtr<SerializedScriptValue>&) const;
+    Ref<SerializedScriptValue> deserializeBuffer(ArrayBuffer&) const;
 
-    String getCurrentCursorInfo(ExceptionCode&);
+    bool isFromCurrentWorld(JSC::JSValue) const;
 
-    String markerTextForListItem(Element*, ExceptionCode&);
+    void setUsesOverlayScrollbars(bool);
+    void setUsesMockScrollAnimator(bool);
+
+    ExceptionOr<String> getCurrentCursorInfo();
+
+    String markerTextForListItem(Element&);
+
+    String toolTipFromElement(Element&) const;
 
     void forceReload(bool endToEnd);
 
-#if ENABLE(ENCRYPTED_MEDIA_V2)
+    void enableAutoSizeMode(bool enabled, int minimumWidth, int minimumHeight, int maximumWidth, int maximumHeight);
+
+#if ENABLE(LEGACY_ENCRYPTED_MEDIA)
     void initializeMockCDM();
 #endif
 
+#if ENABLE(ENCRYPTED_MEDIA)
+    Ref<MockCDMFactory> registerMockCDM();
+#endif
+
 #if ENABLE(SPEECH_SYNTHESIS)
     void enableMockSpeechSynthesizer();
 #endif
 
 #if ENABLE(MEDIA_STREAM)
+    void setMockMediaCaptureDevicesEnabled(bool);
+#endif
+
+#if ENABLE(WEB_RTC)
+    void enableMockMediaEndpoint();
     void enableMockRTCPeerConnectionHandler();
+    void emulateRTCPeerConnectionPlatformEvent(RTCPeerConnection&, const String& action);
+    void useMockRTCPeerConnectionFactory(const String&);
 #endif
 
-    String getImageSourceURL(Element*, ExceptionCode&);
+    String getImageSourceURL(Element&);
 
 #if ENABLE(VIDEO)
-    void simulateAudioInterruption(Node*);
+    void simulateAudioInterruption(HTMLMediaElement&);
+    ExceptionOr<bool> mediaElementHasCharacteristic(HTMLMediaElement&, const String&);
 #endif
 
-    bool isSelectPopupVisible(Node*);
+    bool isSelectPopupVisible(HTMLSelectElement&);
 
-    String captionsStyleSheetOverride(ExceptionCode&);
-    void setCaptionsStyleSheetOverride(const String&, ExceptionCode&);
-    void setPrimaryAudioTrackLanguageOverride(const String&, ExceptionCode&);
-    void setCaptionDisplayMode(const String&, ExceptionCode&);
+    ExceptionOr<String> captionsStyleSheetOverride();
+    ExceptionOr<void> setCaptionsStyleSheetOverride(const String&);
+    ExceptionOr<void> setPrimaryAudioTrackLanguageOverride(const String&);
+    ExceptionOr<void> setCaptionDisplayMode(const String&);
 
 #if ENABLE(VIDEO)
-    PassRefPtr<TimeRanges> createTimeRanges(Float32Array* startTimes, Float32Array* endTimes);
-    double closestTimeToTimeRanges(double time, TimeRanges*);
+    Ref<TimeRanges> createTimeRanges(Float32Array& startTimes, Float32Array& endTimes);
+    double closestTimeToTimeRanges(double time, TimeRanges&);
 #endif
 
-    PassRefPtr<ClientRect> selectionBounds(ExceptionCode&);
+    ExceptionOr<Ref<ClientRect>> selectionBounds();
 
 #if ENABLE(VIBRATION)
     bool isVibrating();
 #endif
 
-    bool isPluginUnavailabilityIndicatorObscured(Element*, ExceptionCode&);
+    ExceptionOr<bool> isPluginUnavailabilityIndicatorObscured(Element&);
+    bool isPluginSnapshotted(Element&);
 
 #if ENABLE(MEDIA_SOURCE)
-    void initializeMockMediaSource();
+    WEBCORE_TESTSUPPORT_EXPORT void initializeMockMediaSource();
+    Vector<String> bufferedSamplesForTrackID(SourceBuffer&, const AtomicString&);
+    Vector<String> enqueuedSamplesForTrackID(SourceBuffer&, const AtomicString&);
+    void setShouldGenerateTimestamps(SourceBuffer&, bool);
 #endif
 
-    void beginMediaSessionInterruption();
+#if ENABLE(VIDEO)
+    ExceptionOr<void> beginMediaSessionInterruption(const String&);
     void endMediaSessionInterruption(const String&);
-    void setMediaSessionRestrictions(const String& mediaType, const String& restrictions, ExceptionCode& ec);
+    void applicationDidEnterForeground() const;
+    void applicationWillEnterBackground() const;
+    ExceptionOr<void> setMediaSessionRestrictions(const String& mediaType, const String& restrictions);
+    ExceptionOr<String> mediaSessionRestrictions(const String& mediaType) const;
+    void setMediaElementRestrictions(HTMLMediaElement&, const String& restrictions);
+    ExceptionOr<void> postRemoteControlCommand(const String&, float argument);
+    bool elementIsBlockingDisplaySleep(HTMLMediaElement&) const;
+#endif
+
+#if ENABLE(MEDIA_SESSION)
+    void sendMediaSessionStartOfInterruptionNotification(MediaSessionInterruptingCategory);
+    void sendMediaSessionEndOfInterruptionNotification(MediaSessionInterruptingCategory);
+    String mediaSessionCurrentState(MediaSession&) const;
+    double mediaElementPlayerVolume(HTMLMediaElement&) const;
+    enum class MediaControlEvent { PlayPause, NextTrack, PreviousTrack };
+    void sendMediaControlEvent(MediaControlEvent);
+#endif
+
+#if ENABLE(WIRELESS_PLAYBACK_TARGET)
+    void setMockMediaPlaybackTargetPickerEnabled(bool);
+    ExceptionOr<void> setMockMediaPlaybackTargetPickerState(const String& deviceName, const String& deviceState);
+#endif
+
+#if ENABLE(WEB_AUDIO)
+    void setAudioContextRestrictions(AudioContext&, const String& restrictions);
+#endif
+
+    void simulateSystemSleep() const;
+    void simulateSystemWake() const;
+
+    enum class PageOverlayType { View, Document };
+    ExceptionOr<Ref<MockPageOverlay>> installMockPageOverlay(PageOverlayType);
+    ExceptionOr<String> pageOverlayLayerTreeAsText(unsigned short flags) const;
+
+    void setPageMuted(const String&);
+    String pageMediaState();
+
+    void setPageDefersLoading(bool);
+
+    RefPtr<File> createFile(const String&);
+    void queueMicroTask(int);
+    bool testPreloaderSettingViewport();
+
+#if ENABLE(CONTENT_FILTERING)
+    MockContentFilterSettings& mockContentFilterSettings();
+#endif
+
+#if ENABLE(CSS_SCROLL_SNAP)
+    ExceptionOr<String> scrollSnapOffsets(Element&);
+    void setPlatformMomentumScrollingPredictionEnabled(bool);
+#endif
+
+    ExceptionOr<String> pathStringWithShrinkWrappedRects(const Vector<double>& rectComponents, double radius);
+
+    String getCurrentMediaControlsStatusForElement(HTMLMediaElement&);
+
+    String userVisibleString(const DOMURL&);
+    void setShowAllPlugins(bool);
+
+    String resourceLoadStatisticsForOrigin(const String& origin);
+    void setResourceLoadStatisticsEnabled(bool);
+
+#if ENABLE(READABLE_STREAM_API)
+    bool isReadableStreamDisturbed(JSC::ExecState&, JSC::JSValue);
+#endif
+
+    String composedTreeAsText(Node&);
+    
+    bool isProcessingUserGesture();
+
+    RefPtr<GCObservation> observeGC(JSC::JSValue);
+
+    enum class UserInterfaceLayoutDirection { LTR, RTL };
+    void setUserInterfaceLayoutDirection(UserInterfaceLayoutDirection);
+
+    bool userPrefersReducedMotion() const;
+    
+    void reportBacktrace();
+
+    enum class BaseWritingDirection { Natural, Ltr, Rtl };
+    void setBaseWritingDirection(BaseWritingDirection);
+
+#if ENABLE(POINTER_LOCK)
+    bool pageHasPendingPointerLock() const;
+    bool pageHasPointerLock() const;
+#endif
+
+    Vector<String> accessKeyModifiers() const;
+
+#if PLATFORM(IOS)
+    void setQuickLookPassword(const String&);
+#endif
+
+    void setAsRunningUserScripts(Document&);
 
 private:
-    explicit Internals(Document*);
+    explicit Internals(Document&);
     Document* contextDocument() const;
     Frame* frame() const;
-    Vector<String> iconURLs(Document*, int iconTypesMask) const;
 
-    DocumentMarker* markerAt(Node*, const String& markerType, unsigned index, ExceptionCode&);
-#if ENABLE(INSPECTOR)
-    RefPtr<DOMWindow> m_frontendWindow;
-    OwnPtr<InspectorFrontendChannelDummy> m_frontendChannel;
-#endif
+    ExceptionOr<RenderedDocumentMarker*> markerAt(Node&, const String& markerType, unsigned index);
+
+    std::unique_ptr<InspectorStubFrontend> m_inspectorFrontend;
 };
 
 } // namespace WebCore
-
-#endif