Clean up testing.internals argument type checking.

Source/core/testing/Internals.h

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 74 matching lines @@
 
     bool isPreloaded(const String& url);
     bool isLoadingFromMemoryCache(const String& url);
 
     void crash();
 
     void setStyleResolverStatsEnabled(bool);
     String styleResolverStatsReport(ExceptionState&) const;
     String styleResolverStatsTotalsReport(ExceptionState&) const;
 
-    bool isSharingStyle(Element*, Element*, ExceptionState&) const;
+    bool isSharingStyle(Element*, Element*) const;
 
-    PassRefPtrWillBeRawPtr<CSSComputedStyleDeclaration> computedStyleIncludingVisitedInfo(Node*, ExceptionState&) const;
+    PassRefPtrWillBeRawPtr<CSSStyleDeclaration> computedStyleIncludingVisitedInfo(Node*) const;
 
-    ShadowRoot* shadowRoot(Element* host, ExceptionState&);
-    ShadowRoot* youngestShadowRoot(Element* host, ExceptionState&);
-    ShadowRoot* oldestShadowRoot(Element* host, ExceptionState&);
+    ShadowRoot* shadowRoot(Element* host);
+    ShadowRoot* youngestShadowRoot(Element* host);
+    ShadowRoot* oldestShadowRoot(Element* host);
     ShadowRoot* youngerShadowRoot(Node* shadow, ExceptionState&);
     String shadowRootType(const Node*, ExceptionState&) const;
     bool hasShadowInsertionPoint(const Node*, ExceptionState&) const;
     bool hasContentElement(const Node*, ExceptionState&) const;
     size_t countElementShadow(const Node*, ExceptionState&) const;
-    const AtomicString& shadowPseudoId(Element*, ExceptionState&);
-    void setShadowPseudoId(Element*, const AtomicString&, ExceptionState&);
+    const AtomicString& shadowPseudoId(Element*);
+    void setShadowPseudoId(Element*, const AtomicString&);
 
     // CSS Animation / Transition testing.
     void pauseAnimations(double pauseTime, ExceptionState&);
 
     bool isValidContentSelect(Element* insertionPoint, ExceptionState&);
-    Node* treeScopeRootNode(Node*, ExceptionState&);
-    Node* parentTreeScope(Node*, ExceptionState&);
+    Node* treeScopeRootNode(Node*);
+    Node* parentTreeScope(Node*);
     bool hasSelectorForIdInShadow(Element* host, const AtomicString& idValue, ExceptionState&);
     bool hasSelectorForClassInShadow(Element* host, const AtomicString& className, ExceptionState&);
     bool hasSelectorForAttributeInShadow(Element* host, const AtomicString& attributeName, ExceptionState&);
     bool hasSelectorForPseudoClassInShadow(Element* host, const String& pseudoClass, ExceptionState&);
     unsigned short compareTreeScopePosition(const Node*, const Node*, ExceptionState&) const;
 
-    // FIXME: Rename these functions if walker is prefered.
-    Node* nextSiblingByWalker(Node*, ExceptionState&);
-    Node* firstChildByWalker(Node*, ExceptionState&);
-    Node* lastChildByWalker(Node*, ExceptionState&);
-    Node* nextNodeByWalker(Node*, ExceptionState&);
-    Node* previousNodeByWalker(Node*, ExceptionState&);
+    // FIXME: Rename these functions if walker is preferred.
+    Node* nextSiblingByWalker(Node*);
+    Node* firstChildByWalker(Node*);
+    Node* lastChildByWalker(Node*);
+    Node* nextNodeByWalker(Node*);
+    Node* previousNodeByWalker(Node*);
 
     unsigned updateStyleAndReturnAffectedElementCount(ExceptionState&) const;
     unsigned needsLayoutCount(ExceptionState&) const;
     unsigned hitTestCount(Document*, ExceptionState&) const;
 
     String visiblePlaceholder(Element*);
     void selectColorInColorChooser(Element*, const String& colorValue);
     bool hasAutofocusRequest(Document*);
     bool hasAutofocusRequest();
     Vector<String> formControlStateOfHistoryItem(ExceptionState&);
     void setFormControlStateOfHistoryItem(const Vector<String>&, ExceptionState&);
     void setEnableMockPagePopup(bool, ExceptionState&);
     PassRefPtrWillBeRawPtr<PagePopupController> pagePopupController();
 
     PassRefPtrWillBeRawPtr<ClientRect> unscaledViewportRect(ExceptionState&);
 
     PassRefPtrWillBeRawPtr<ClientRect> absoluteCaretBounds(ExceptionState&);
 
-    PassRefPtrWillBeRawPtr<ClientRect> boundingBox(Element*, ExceptionState&);
+    PassRefPtrWillBeRawPtr<ClientRect> boundingBox(Element*);
 
     unsigned markerCountForNode(Node*, const String&, ExceptionState&);
-    unsigned activeMarkerCountForNode(Node*, ExceptionState&);
+    unsigned activeMarkerCountForNode(Node*);
     PassRefPtrWillBeRawPtr<Range> markerRangeForNode(Node*, const String& markerType, unsigned index, ExceptionState&);
     String markerDescriptionForNode(Node*, const String& markerType, unsigned index, ExceptionState&);
     void addTextMatchMarker(const Range*, bool isActive);
-    void setMarkersActive(Node*, unsigned startOffset, unsigned endOffset, bool, ExceptionState&);
-    void setMarkedTextMatchesAreHighlighted(Document*, bool, ExceptionState&);
+    void setMarkersActive(Node*, unsigned startOffset, unsigned endOffset, bool);
+    void setMarkedTextMatchesAreHighlighted(Document*, bool);
 
     void setScrollViewPosition(Document*, long x, long y, ExceptionState&);
     String viewportAsText(Document*, float devicePixelRatio, int availableWidth, int availableHeight, ExceptionState&);
 
     bool wasLastChangeUserEdit(Element* textField, ExceptionState&);
     bool elementShouldAutoComplete(Element* inputElement, ExceptionState&);
     String suggestedValue(Element*, ExceptionState&);
     void setSuggestedValue(Element*, const String&, ExceptionState&);
     void setEditingValue(Element* inputElement, const String&, ExceptionState&);
     void setAutofilled(Element*, bool enabled, ExceptionState&);
     void scrollElementToRect(Element*, long x, long y, long w, long h, ExceptionState&);
 
-    PassRefPtrWillBeRawPtr<Range> rangeFromLocationAndLength(Element* scope, int rangeLocation, int rangeLength, ExceptionState&);
-    unsigned locationFromRange(Element* scope, const Range*, ExceptionState&);
-    unsigned lengthFromRange(Element* scope, const Range*, ExceptionState&);
-    String rangeAsText(const Range*, ExceptionState&);
+    PassRefPtrWillBeRawPtr<Range> rangeFromLocationAndLength(Element* scope, int rangeLocation, int rangeLength);
+    unsigned locationFromRange(Element* scope, const Range*);
+    unsigned lengthFromRange(Element* scope, const Range*);
+    String rangeAsText(const Range*);
 
     PassRefPtrWillBeRawPtr<WebKitPoint> touchPositionAdjustedToBestClickableNode(long x, long y, long width, long height, Document*, ExceptionState&);
     Node* touchNodeAdjustedToBestClickableNode(long x, long y, long width, long height, Document*, ExceptionState&);
     PassRefPtrWillBeRawPtr<WebKitPoint> touchPositionAdjustedToBestContextMenuNode(long x, long y, long width, long height, Document*, ExceptionState&);
     Node* touchNodeAdjustedToBestContextMenuNode(long x, long y, long width, long height, Document*, ExceptionState&);
     PassRefPtrWillBeRawPtr<ClientRect> bestZoomableAreaForTouchPoint(long x, long y, long width, long height, Document*, ExceptionState&);
 
     int lastSpellCheckRequestSequence(Document*, ExceptionState&);
     int lastSpellCheckProcessedSequence(Document*, ExceptionState&);
 
     Vector<AtomicString> userPreferredLanguages() const;
     void setUserPreferredLanguages(const Vector<String>&);
 
-    unsigned activeDOMObjectCount(Document*, ExceptionState&);
-    unsigned wheelEventHandlerCount(Document*, ExceptionState&);
-    unsigned scrollEventHandlerCount(Document*, ExceptionState&);
-    unsigned touchEventHandlerCount(Document*, ExceptionState&);
+    unsigned activeDOMObjectCount(Document*);
+    unsigned wheelEventHandlerCount(Document*);
+    unsigned scrollEventHandlerCount(Document*);
+    unsigned touchEventHandlerCount(Document*);
     PassRefPtrWillBeRawPtr<LayerRectList> touchEventTargetLayerRects(Document*, ExceptionState&);
 
     // This is used to test rect based hit testing like what's done on touch screens.
     PassRefPtrWillBeRawPtr<StaticNodeList> nodesFromRect(Document*, int x, int y, unsigned topPadding, unsigned rightPadding,
         unsigned bottomPadding, unsigned leftPadding, bool ignoreClipping, bool allowChildFrameContent, ExceptionState&) const;
 
     void emitInspectorDidBeginFrame(int frameId = 0);
     void emitInspectorDidCancelFrame();
 
-    bool hasSpellingMarker(Document*, int from, int length, ExceptionState&);
-    bool hasGrammarMarker(Document*, int from, int length, ExceptionState&);
-    void setContinuousSpellCheckingEnabled(bool enabled, ExceptionState&);
+    bool hasSpellingMarker(Document*, int from, int length);
+    bool hasGrammarMarker(Document*, int from, int length);
+    void setContinuousSpellCheckingEnabled(bool);
 
-    bool isOverwriteModeEnabled(Document*, ExceptionState&);
-    void toggleOverwriteModeEnabled(Document*, ExceptionState&);
+    bool isOverwriteModeEnabled(Document*);
+    void toggleOverwriteModeEnabled(Document*);
 
-    unsigned numberOfScrollableAreas(Document*, ExceptionState&);
+    unsigned numberOfScrollableAreas(Document*);
 
-    bool isPageBoxVisible(Document*, int pageNumber, ExceptionState&);
+    bool isPageBoxVisible(Document*, int pageNumber);
 
     static const char* internalsId;
 
     InternalSettings* settings() const;
     InternalRuntimeFlags* runtimeFlags() const;
     InternalProfilers* profilers();
     unsigned workerThreadCount() const;
 
     void setDeviceProximity(Document*, const String& eventType, double value, double min, double max, ExceptionState&);
 
     String layerTreeAsText(Document*, unsigned flags, ExceptionState&) const;
     String layerTreeAsText(Document*, ExceptionState&) const;
     String elementLayerTreeAsText(Element*, unsigned flags, ExceptionState&) const;
     String elementLayerTreeAsText(Element*, ExceptionState&) const;
 
     bool scrollsWithRespectTo(Element*, Element*, ExceptionState&);
     bool isUnclippedDescendant(Element*, ExceptionState&);
 
-    String scrollingStateTreeAsText(Document*, ExceptionState&) const;
+    String scrollingStateTreeAsText(Document*) const;
     String mainThreadScrollingReasons(Document*, ExceptionState&) const;
     PassRefPtrWillBeRawPtr<ClientRectList> nonFastScrollableRects(Document*, ExceptionState&) const;
 
-    void garbageCollectDocumentResources(Document*, ExceptionState&) const;
+    void garbageCollectDocumentResources(Document*) const;
     void evictAllResources() const;
 
     unsigned numberOfLiveNodes() const;
     unsigned numberOfLiveDocuments() const;
     String dumpRefCountedInstanceCounts() const;
     Vector<String> consoleMessageArgumentCounts(Document*) const;
     PassRefPtrWillBeRawPtr<LocalDOMWindow> openDummyInspectorFrontend(const String& url);
     void closeDummyInspectorFrontend();
     Vector<unsigned long> setMemoryCacheCapacities(unsigned long minDeadBytes, unsigned long maxDeadBytes, unsigned long totalBytes);
     void setInspectorResourcesDataSizeLimits(int maximumResourcesContentSize, int maximumSingleResourceContentSize, ExceptionState&);
@@ skipping 29 matching lines @@
     void forceFullRepaint(Document*, ExceptionState&);
 
     PassRefPtrWillBeRawPtr<ClientRectList> draggableRegions(Document*, ExceptionState&);
     PassRefPtrWillBeRawPtr<ClientRectList> nonDraggableRegions(Document*, ExceptionState&);
 
     PassRefPtr<ArrayBuffer> serializeObject(PassRefPtr<SerializedScriptValue>) const;
     PassRefPtr<SerializedScriptValue> deserializeBuffer(PassRefPtr<ArrayBuffer>) const;
 
     String getCurrentCursorInfo(Document*, ExceptionState&);
 
-    String markerTextForListItem(Element*, ExceptionState&);
+    String markerTextForListItem(Element*);
 
     void forceReload(bool endToEnd);
 
-    String getImageSourceURL(Element*, ExceptionState&);
+    String getImageSourceURL(Element*);
 
     bool isSelectPopupVisible(Node*);
     bool selectPopupItemStyleIsRtl(Node*, int);
     int selectPopupItemStyleFontHeight(Node*, int);
 
     PassRefPtrWillBeRawPtr<ClientRect> selectionBounds(ExceptionState&);
-    String baseURL(Document*, ExceptionState&);
+    String baseURL(Document*);
 
     bool loseSharedGraphicsContext3D();
 
     void forceCompositingUpdate(Document*, ExceptionState&);
 
     void setZoomFactor(float);
 
     void setShouldRevealPassword(Element*, bool, ExceptionState&);
 
     ScriptPromise createResolvedPromise(ScriptState*, ScriptValue);
     ScriptPromise createRejectedPromise(ScriptState*, ScriptValue);
     ScriptPromise addOneToPromise(ExecutionContext*, ScriptPromise);
 
     void trace(Visitor*);
 
     void setValueForUser(Element*, const String&);
 
     String textSurroundingNode(Node*, int x, int y, unsigned long maxLength);
 
     void setFocused(bool);
 
-    bool ignoreLayoutWithPendingStylesheets(Document*, ExceptionState&);
+    bool ignoreLayoutWithPendingStylesheets(Document*);
 
     void setNetworkStateNotifierTestOnly(bool);
     // Test must call setNetworkStateNotifierTestOnly(true) before calling setNetworkConnectionInfo.
     void setNetworkConnectionInfo(const String&, ExceptionState&);
     String serializeNavigationMarkup(Document*);
 
     unsigned countHitRegions(CanvasRenderingContext2D*);
 
 private:
     explicit Internals(Document*);
     Document* contextDocument() const;
     LocalFrame* frame() const;
     Vector<String> iconURLs(Document*, int iconTypesMask) const;
     PassRefPtrWillBeRawPtr<ClientRectList> annotatedRegions(Document*, bool draggable, ExceptionState&);
 
     DocumentMarker* markerAt(Node*, const String& markerType, unsigned index, ExceptionState&);
     RefPtrWillBeMember<InternalRuntimeFlags> m_runtimeFlags;
     RefPtrWillBeMember<InternalProfilers> m_profilers;
 };
 
 } // namespace blink
 
 #endif