/*
 * 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.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "core/testing/Internals.h"

#include <deque>
#include <memory>

#include "bindings/core/v8/ExceptionMessages.h"
#include "bindings/core/v8/ExceptionState.h"
#include "bindings/core/v8/ScriptFunction.h"
#include "bindings/core/v8/ScriptPromise.h"
#include "bindings/core/v8/ScriptPromiseResolver.h"
#include "bindings/core/v8/SerializedScriptValue.h"
#include "bindings/core/v8/SerializedScriptValueFactory.h"
#include "bindings/core/v8/V8IteratorResultValue.h"
#include "bindings/core/v8/V8ThrowException.h"
#include "core/HTMLNames.h"
#include "core/SVGNames.h"
#include "core/animation/DocumentTimeline.h"
#include "core/dom/ClientRect.h"
#include "core/dom/ClientRectList.h"
#include "core/dom/DOMArrayBuffer.h"
#include "core/dom/DOMNodeIds.h"
#include "core/dom/DOMPoint.h"
#include "core/dom/DOMStringList.h"
#include "core/dom/Document.h"
#include "core/dom/Element.h"
#include "core/dom/ExceptionCode.h"
#include "core/dom/Iterator.h"
#include "core/dom/NodeComputedStyle.h"
#include "core/dom/PseudoElement.h"
#include "core/dom/Range.h"
#include "core/dom/StaticNodeList.h"
#include "core/dom/StyleEngine.h"
#include "core/dom/TreeScope.h"
#include "core/dom/ViewportDescription.h"
#include "core/dom/shadow/ElementShadow.h"
#include "core/dom/shadow/ElementShadowV0.h"
#include "core/dom/shadow/FlatTreeTraversal.h"
#include "core/dom/shadow/SelectRuleFeatureSet.h"
#include "core/dom/shadow/ShadowRoot.h"
#include "core/editing/Editor.h"
#include "core/editing/PlainTextRange.h"
#include "core/editing/SurroundingText.h"
#include "core/editing/iterators/TextIterator.h"
#include "core/editing/markers/DocumentMarker.h"
#include "core/editing/markers/DocumentMarkerController.h"
#include "core/editing/serializers/Serialization.h"
#include "core/editing/spellcheck/IdleSpellCheckCallback.h"
#include "core/editing/spellcheck/SpellCheckRequester.h"
#include "core/editing/spellcheck/SpellChecker.h"
#include "core/frame/EventHandlerRegistry.h"
#include "core/frame/FrameConsole.h"
#include "core/frame/FrameView.h"
#include "core/frame/LocalDOMWindow.h"
#include "core/frame/LocalFrame.h"
#include "core/frame/Settings.h"
#include "core/frame/VisualViewport.h"
#include "core/html/HTMLContentElement.h"
#include "core/html/HTMLIFrameElement.h"
#include "core/html/HTMLImageElement.h"
#include "core/html/HTMLInputElement.h"
#include "core/html/HTMLMediaElement.h"
#include "core/html/HTMLSelectElement.h"
#include "core/html/HTMLTextAreaElement.h"
#include "core/html/canvas/CanvasFontCache.h"
#include "core/html/canvas/CanvasRenderingContext.h"
#include "core/html/forms/FormController.h"
#include "core/html/shadow/ShadowElementNames.h"
#include "core/html/shadow/TextControlInnerElements.h"
#include "core/input/EventHandler.h"
#include "core/input/KeyboardEventManager.h"
#include "core/inspector/InspectorInstrumentation.h"
#include "core/inspector/MainThreadDebugger.h"
#include "core/layout/LayoutMenuList.h"
#include "core/layout/LayoutObject.h"
#include "core/layout/LayoutTreeAsText.h"
#include "core/layout/api/LayoutMenuListItem.h"
#include "core/layout/api/LayoutViewItem.h"
#include "core/layout/compositing/CompositedLayerMapping.h"
#include "core/layout/compositing/PaintLayerCompositor.h"
#include "core/loader/DocumentLoader.h"
#include "core/loader/FrameLoader.h"
#include "core/loader/HistoryItem.h"
#include "core/page/ChromeClient.h"
#include "core/page/FocusController.h"
#include "core/page/Page.h"
#include "core/page/PrintContext.h"
#include "core/page/scrolling/ScrollState.h"
#include "core/paint/PaintLayer.h"
#include "core/svg/SVGImageElement.h"
#include "core/testing/CallbackFunctionTest.h"
#include "core/testing/DictionaryTest.h"
#include "core/testing/GCObservation.h"
#include "core/testing/InternalRuntimeFlags.h"
#include "core/testing/InternalSettings.h"
#include "core/testing/LayerRect.h"
#include "core/testing/LayerRectList.h"
#include "core/testing/MockHyphenation.h"
#include "core/testing/OriginTrialsTest.h"
#include "core/testing/RecordTest.h"
#include "core/testing/TypeConversions.h"
#include "core/testing/UnionTypesTest.h"
#include "core/workers/WorkerThread.h"
#include "gpu/command_buffer/client/gles2_interface.h"
#include "platform/Cursor.h"
#include "platform/InstanceCounters.h"
#include "platform/Language.h"
#include "platform/LayoutLocale.h"
#include "platform/RuntimeEnabledFeatures.h"
#include "platform/geometry/IntRect.h"
#include "platform/geometry/LayoutRect.h"
#include "platform/graphics/GraphicsLayer.h"
#include "platform/heap/Handle.h"
#include "platform/instrumentation/tracing/TraceEvent.h"
#include "platform/loader/fetch/MemoryCache.h"
#include "platform/loader/fetch/ResourceFetcher.h"
#include "platform/loader/fetch/ResourceLoadPriority.h"
#include "platform/network/NetworkStateNotifier.h"
#include "platform/scroll/ProgrammaticScrollAnimator.h"
#include "platform/scroll/ScrollbarTheme.h"
#include "platform/testing/URLTestHelpers.h"
#include "platform/weborigin/SchemeRegistry.h"
#include "public/platform/Platform.h"
#include "public/platform/WebConnectionType.h"
#include "public/platform/WebGraphicsContext3DProvider.h"
#include "public/platform/WebLayer.h"
#include "public/platform/modules/remoteplayback/WebRemotePlaybackAvailability.h"
#include "v8/include/v8.h"
#include "wtf/InstanceCounter.h"
#include "wtf/Optional.h"
#include "wtf/PtrUtil.h"
#include "wtf/dtoa.h"
#include "wtf/text/StringBuffer.h"

namespace blink {

namespace {

class UseCounterObserverImpl final : public UseCounter::Observer {
  WTF_MAKE_NONCOPYABLE(UseCounterObserverImpl);

 public:
  UseCounterObserverImpl(ScriptPromiseResolver* resolver,
                         UseCounter::Feature feature)
      : m_resolver(resolver), m_feature(feature) {}

  bool onCountFeature(UseCounter::Feature feature) final {
    if (m_feature != feature)
      return false;
    m_resolver->resolve(feature);
    return true;
  }

  DEFINE_INLINE_VIRTUAL_TRACE() {
    UseCounter::Observer::trace(visitor);
    visitor->trace(m_resolver);
  }

 private:
  Member<ScriptPromiseResolver> m_resolver;
  UseCounter::Feature m_feature;
};

}  // namespace

static WTF::Optional<DocumentMarker::MarkerType> markerTypeFrom(
    const String& markerType) {
  if (equalIgnoringCase(markerType, "Spelling"))
    return DocumentMarker::Spelling;
  if (equalIgnoringCase(markerType, "Grammar"))
    return DocumentMarker::Grammar;
  if (equalIgnoringCase(markerType, "TextMatch"))
    return DocumentMarker::TextMatch;
  return WTF::nullopt;
}

static WTF::Optional<DocumentMarker::MarkerTypes> markerTypesFrom(
    const String& markerType) {
  if (markerType.isEmpty() || equalIgnoringCase(markerType, "all"))
    return DocumentMarker::AllMarkers();
  WTF::Optional<DocumentMarker::MarkerType> type = markerTypeFrom(markerType);
  if (!type)
    return WTF::nullopt;
  return DocumentMarker::MarkerTypes(type.value());
}

static SpellCheckRequester* spellCheckRequester(Document* document) {
  if (!document || !document->frame())
    return 0;
  return &document->frame()->spellChecker().spellCheckRequester();
}

static ScrollableArea* scrollableAreaForNode(Node* node) {
  if (!node)
    return nullptr;

  if (node->isDocumentNode()) {
    // This can be removed after root layer scrolling is enabled.
    if (FrameView* frameView = toDocument(node)->view())
      return frameView->layoutViewportScrollableArea();
  }

  LayoutObject* layoutObject = node->layoutObject();
  if (!layoutObject || !layoutObject->isBox())
    return nullptr;

  return toLayoutBox(layoutObject)->getScrollableArea();
}

static RuntimeEnabledFeatures::Backup* sFeaturesBackup = nullptr;

void Internals::resetToConsistentState(Page* page) {
  DCHECK(page);

  if (!sFeaturesBackup)
    sFeaturesBackup = new RuntimeEnabledFeatures::Backup;
  sFeaturesBackup->restore();
  page->setIsCursorVisible(true);
  page->setPageScaleFactor(1);
  page->deprecatedLocalMainFrame()
      ->view()
      ->layoutViewportScrollableArea()
      ->setScrollOffset(ScrollOffset(), ProgrammaticScroll);
  overrideUserPreferredLanguages(Vector<AtomicString>());
  if (!page->deprecatedLocalMainFrame()
           ->spellChecker()
           .isSpellCheckingEnabled())
    page->deprecatedLocalMainFrame()
        ->spellChecker()
        .toggleSpellCheckingEnabled();
  if (page->deprecatedLocalMainFrame()->editor().isOverwriteModeEnabled())
    page->deprecatedLocalMainFrame()->editor().toggleOverwriteModeEnabled();

  if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
    scrollingCoordinator->reset();

  page->deprecatedLocalMainFrame()->view()->clear();
  KeyboardEventManager::setCurrentCapsLockState(OverrideCapsLockState::Default);
}

Internals::Internals(ExecutionContext* context)
    : m_runtimeFlags(InternalRuntimeFlags::create()),
      m_document(toDocument(context)) {
  m_document->fetcher()->enableIsPreloadedForTest();
}

LocalFrame* Internals::frame() const {
  if (!m_document)
    return nullptr;
  return m_document->frame();
}

InternalSettings* Internals::settings() const {
  if (!m_document)
    return 0;
  Page* page = m_document->page();
  if (!page)
    return 0;
  return InternalSettings::from(*page);
}

InternalRuntimeFlags* Internals::runtimeFlags() const {
  return m_runtimeFlags.get();
}

unsigned Internals::workerThreadCount() const {
  return WorkerThread::workerThreadCount();
}

GCObservation* Internals::observeGC(ScriptValue scriptValue) {
  v8::Local<v8::Value> observedValue = scriptValue.v8Value();
  DCHECK(!observedValue.IsEmpty());
  if (observedValue->IsNull() || observedValue->IsUndefined()) {
    V8ThrowException::throwTypeError(v8::Isolate::GetCurrent(),
                                     "value to observe is null or undefined");
    return nullptr;
  }

  return GCObservation::create(observedValue);
}

unsigned Internals::updateStyleAndReturnAffectedElementCount(
    ExceptionState& exceptionState) const {
  if (!m_document) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "No context document is available.");
    return 0;
  }

  unsigned beforeCount = m_document->styleEngine().styleForElementCount();
  m_document->updateStyleAndLayoutTree();
  return m_document->styleEngine().styleForElementCount() - beforeCount;
}

unsigned Internals::needsLayoutCount(ExceptionState& exceptionState) const {
  LocalFrame* contextFrame = frame();
  if (!contextFrame) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "No context frame is available.");
    return 0;
  }

  bool isPartial;
  unsigned needsLayoutObjects;
  unsigned totalObjects;
  contextFrame->view()->countObjectsNeedingLayout(needsLayoutObjects,
                                                  totalObjects, isPartial);
  return needsLayoutObjects;
}

unsigned Internals::hitTestCount(Document* doc,
                                 ExceptionState& exceptionState) const {
  if (!doc) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "Must supply document to check");
    return 0;
  }

  return doc->layoutViewItem().hitTestCount();
}

unsigned Internals::hitTestCacheHits(Document* doc,
                                     ExceptionState& exceptionState) const {
  if (!doc) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "Must supply document to check");
    return 0;
  }

  return doc->layoutViewItem().hitTestCacheHits();
}

Element* Internals::elementFromPoint(Document* doc,
                                     double x,
                                     double y,
                                     bool ignoreClipping,
                                     bool allowChildFrameContent,
                                     ExceptionState& exceptionState) const {
  if (!doc) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "Must supply document to check");
    return 0;
  }

  if (doc->layoutViewItem().isNull())
    return 0;

  HitTestRequest::HitTestRequestType hitType =
      HitTestRequest::ReadOnly | HitTestRequest::Active;
  if (ignoreClipping)
    hitType |= HitTestRequest::IgnoreClipping;
  if (allowChildFrameContent)
    hitType |= HitTestRequest::AllowChildFrameContent;

  HitTestRequest request(hitType);

  return doc->hitTestPoint(x, y, request);
}

void Internals::clearHitTestCache(Document* doc,
                                  ExceptionState& exceptionState) const {
  if (!doc) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "Must supply document to check");
    return;
  }

  if (doc->layoutViewItem().isNull())
    return;

  doc->layoutViewItem().clearHitTestCache();
}

bool Internals::isPreloaded(const String& url) {
  return isPreloadedBy(url, m_document);
}

bool Internals::isPreloadedBy(const String& url, Document* document) {
  if (!document)
    return false;
  return document->fetcher()->isPreloadedForTest(document->completeURL(url));
}

bool Internals::isLoading(const String& url) {
  if (!m_document)
    return false;
  const String cacheIdentifier = m_document->fetcher()->getCacheIdentifier();
  Resource* resource = memoryCache()->resourceForURL(
      m_document->completeURL(url), cacheIdentifier);
  // We check loader() here instead of isLoading(), because a multipart
  // ImageResource lies isLoading() == false after the first part is loaded.
  return resource && resource->loader();
}

bool Internals::isLoadingFromMemoryCache(const String& url) {
  if (!m_document)
    return false;
  const String cacheIdentifier = m_document->fetcher()->getCacheIdentifier();
  Resource* resource = memoryCache()->resourceForURL(
      m_document->completeURL(url), cacheIdentifier);
  return resource && resource->getStatus() == ResourceStatus::Cached;
}

int Internals::getResourcePriority(const String& url, Document* document) {
  if (!document)
    return ResourceLoadPriority::ResourceLoadPriorityUnresolved;

  Resource* resource = document->fetcher()->allResources().at(
      URLTestHelpers::toKURL(url.utf8().data()));

  if (!resource)
    return ResourceLoadPriority::ResourceLoadPriorityUnresolved;

  return resource->resourceRequest().priority();
}

String Internals::getResourceHeader(const String& url,
                                    const String& header,
                                    Document* document) {
  if (!document)
    return String();
  Resource* resource = document->fetcher()->allResources().at(
      URLTestHelpers::toKURL(url.utf8().data()));
  if (!resource)
    return String();
  return resource->resourceRequest().httpHeaderField(header.utf8().data());
}

bool Internals::isSharingStyle(Element* element1, Element* element2) const {
  DCHECK(element1 && element2);
  return element1->computedStyle() == element2->computedStyle();
}

bool Internals::isValidContentSelect(Element* insertionPoint,
                                     ExceptionState& exceptionState) {
  DCHECK(insertionPoint);
  if (!insertionPoint->isInsertionPoint()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The element is not an insertion point.");
    return false;
  }

  return isHTMLContentElement(*insertionPoint) &&
         toHTMLContentElement(*insertionPoint).isSelectValid();
}

Node* Internals::treeScopeRootNode(Node* node) {
  DCHECK(node);
  return &node->treeScope().rootNode();
}

Node* Internals::parentTreeScope(Node* node) {
  DCHECK(node);
  const TreeScope* parentTreeScope = node->treeScope().parentTreeScope();
  return parentTreeScope ? &parentTreeScope->rootNode() : 0;
}

unsigned short Internals::compareTreeScopePosition(
    const Node* node1,
    const Node* node2,
    ExceptionState& exceptionState) const {
  DCHECK(node1 && node2);
  const TreeScope* treeScope1 =
      node1->isDocumentNode()
          ? static_cast<const TreeScope*>(toDocument(node1))
          : node1->isShadowRoot()
                ? static_cast<const TreeScope*>(toShadowRoot(node1))
                : 0;
  const TreeScope* treeScope2 =
      node2->isDocumentNode()
          ? static_cast<const TreeScope*>(toDocument(node2))
          : node2->isShadowRoot()
                ? static_cast<const TreeScope*>(toShadowRoot(node2))
                : 0;
  if (!treeScope1 || !treeScope2) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        String::format(
            "The %s node is neither a document node, nor a shadow root.",
            treeScope1 ? "second" : "first"));
    return 0;
  }
  return treeScope1->comparePosition(*treeScope2);
}

void Internals::pauseAnimations(double pauseTime,
                                ExceptionState& exceptionState) {
  if (pauseTime < 0) {
    exceptionState.throwDOMException(
        InvalidAccessError, ExceptionMessages::indexExceedsMinimumBound(
                                "pauseTime", pauseTime, 0.0));
    return;
  }

  if (!frame())
    return;

  frame()->view()->updateAllLifecyclePhases();
  frame()->document()->timeline().pauseAnimationsForTesting(pauseTime);
}

bool Internals::isCompositedAnimation(Animation* animation) {
  return animation->hasActiveAnimationsOnCompositor();
}

void Internals::disableCompositedAnimation(Animation* animation) {
  animation->disableCompositedAnimationForTesting();
}

void Internals::disableCSSAdditiveAnimations() {
  RuntimeEnabledFeatures::setCSSAdditiveAnimationsEnabled(false);
}

void Internals::advanceTimeForImage(Element* image,
                                    double deltaTimeInSeconds,
                                    ExceptionState& exceptionState) {
  DCHECK(image);
  if (deltaTimeInSeconds < 0) {
    exceptionState.throwDOMException(
        InvalidAccessError, ExceptionMessages::indexExceedsMinimumBound(
                                "deltaTimeInSeconds", deltaTimeInSeconds, 0.0));
    return;
  }

  ImageResourceContent* resource = nullptr;
  if (isHTMLImageElement(*image)) {
    resource = toHTMLImageElement(*image).cachedImage();
  } else if (isSVGImageElement(*image)) {
    resource = toSVGImageElement(*image).cachedImage();
  } else {
    exceptionState.throwDOMException(
        InvalidAccessError, "The element provided is not a image element.");
    return;
  }

  if (!resource || !resource->hasImage()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The image resource is not available.");
    return;
  }

  Image* imageData = resource->getImage();
  if (!imageData->isBitmapImage()) {
    exceptionState.throwDOMException(
        InvalidAccessError, "The image resource is not a BitmapImage type.");
    return;
  }

  imageData->advanceTime(deltaTimeInSeconds);
}

void Internals::advanceImageAnimation(Element* image,
                                      ExceptionState& exceptionState) {
  DCHECK(image);

  ImageResourceContent* resource = nullptr;
  if (isHTMLImageElement(*image)) {
    resource = toHTMLImageElement(*image).cachedImage();
  } else if (isSVGImageElement(*image)) {
    resource = toSVGImageElement(*image).cachedImage();
  } else {
    exceptionState.throwDOMException(
        InvalidAccessError, "The element provided is not a image element.");
    return;
  }

  if (!resource || !resource->hasImage()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The image resource is not available.");
    return;
  }

  Image* imageData = resource->getImage();
  imageData->advanceAnimationForTesting();
}

bool Internals::hasShadowInsertionPoint(const Node* root,
                                        ExceptionState& exceptionState) const {
  DCHECK(root);
  if (!root->isShadowRoot()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The node argument is not a shadow root.");
    return false;
  }
  return toShadowRoot(root)->containsShadowElements();
}

bool Internals::hasContentElement(const Node* root,
                                  ExceptionState& exceptionState) const {
  DCHECK(root);
  if (!root->isShadowRoot()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The node argument is not a shadow root.");
    return false;
  }
  return toShadowRoot(root)->containsContentElements();
}

size_t Internals::countElementShadow(const Node* root,
                                     ExceptionState& exceptionState) const {
  DCHECK(root);
  if (!root->isShadowRoot()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The node argument is not a shadow root.");
    return 0;
  }
  return toShadowRoot(root)->childShadowRootCount();
}

Node* Internals::nextSiblingInFlatTree(Node* node,
                                       ExceptionState& exceptionState) {
  DCHECK(node);
  if (!node->canParticipateInFlatTree()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "The node argument doesn't particite in the flat tree.");
    return 0;
  }
  return FlatTreeTraversal::nextSibling(*node);
}

Node* Internals::firstChildInFlatTree(Node* node,
                                      ExceptionState& exceptionState) {
  DCHECK(node);
  if (!node->canParticipateInFlatTree()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "The node argument doesn't particite in the flat tree");
    return 0;
  }
  return FlatTreeTraversal::firstChild(*node);
}

Node* Internals::lastChildInFlatTree(Node* node,
                                     ExceptionState& exceptionState) {
  DCHECK(node);
  if (!node->canParticipateInFlatTree()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "The node argument doesn't particite in the flat tree.");
    return 0;
  }
  return FlatTreeTraversal::lastChild(*node);
}

Node* Internals::nextInFlatTree(Node* node, ExceptionState& exceptionState) {
  DCHECK(node);
  if (!node->canParticipateInFlatTree()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "The node argument doesn't particite in the flat tree.");
    return 0;
  }
  return FlatTreeTraversal::next(*node);
}

Node* Internals::previousInFlatTree(Node* node,
                                    ExceptionState& exceptionState) {
  DCHECK(node);
  if (!node->canParticipateInFlatTree()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "The node argument doesn't particite in the flat tree.");
    return 0;
  }
  return FlatTreeTraversal::previous(*node);
}

String Internals::elementLayoutTreeAsText(Element* element,
                                          ExceptionState& exceptionState) {
  DCHECK(element);
  element->document().view()->updateAllLifecyclePhases();

  String representation = externalRepresentation(element);
  if (representation.isEmpty()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "The element provided has no external representation.");
    return String();
  }

  return representation;
}

CSSStyleDeclaration* Internals::computedStyleIncludingVisitedInfo(
    Node* node) const {
  DCHECK(node);
  bool allowVisitedStyle = true;
  return CSSComputedStyleDeclaration::create(node, allowVisitedStyle);
}

ShadowRoot* Internals::createUserAgentShadowRoot(Element* host) {
  DCHECK(host);
  return &host->ensureUserAgentShadowRoot();
}

ShadowRoot* Internals::shadowRoot(Element* host) {
  // FIXME: Internals::shadowRoot() in tests should be converted to
  // youngestShadowRoot() or oldestShadowRoot().
  // https://bugs.webkit.org/show_bug.cgi?id=78465
  return youngestShadowRoot(host);
}

ShadowRoot* Internals::youngestShadowRoot(Element* host) {
  DCHECK(host);
  if (ElementShadow* shadow = host->shadow())
    return &shadow->youngestShadowRoot();
  return 0;
}

ShadowRoot* Internals::oldestShadowRoot(Element* host) {
  DCHECK(host);
  if (ElementShadow* shadow = host->shadow())
    return &shadow->oldestShadowRoot();
  return 0;
}

ShadowRoot* Internals::youngerShadowRoot(Node* shadow,
                                         ExceptionState& exceptionState) {
  DCHECK(shadow);
  if (!shadow->isShadowRoot()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The node provided is not a shadow root.");
    return 0;
  }

  return toShadowRoot(shadow)->youngerShadowRoot();
}

String Internals::shadowRootType(const Node* root,
                                 ExceptionState& exceptionState) const {
  DCHECK(root);
  if (!root->isShadowRoot()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The node provided is not a shadow root.");
    return String();
  }

  switch (toShadowRoot(root)->type()) {
    case ShadowRootType::UserAgent:
      return String("UserAgentShadowRoot");
    case ShadowRootType::V0:
      return String("V0ShadowRoot");
    case ShadowRootType::Open:
      return String("OpenShadowRoot");
    case ShadowRootType::Closed:
      return String("ClosedShadowRoot");
    default:
      NOTREACHED();
      return String("Unknown");
  }
}

const AtomicString& Internals::shadowPseudoId(Element* element) {
  DCHECK(element);
  return element->shadowPseudoId();
}

String Internals::visiblePlaceholder(Element* element) {
  if (element && isTextControlElement(*element)) {
    const TextControlElement& textControlElement =
        toTextControlElement(*element);
    if (!textControlElement.isPlaceholderVisible())
      return String();
    if (HTMLElement* placeholderElement =
            textControlElement.placeholderElement())
      return placeholderElement->textContent();
  }

  return String();
}

void Internals::selectColorInColorChooser(Element* element,
                                          const String& colorValue) {
  DCHECK(element);
  if (!isHTMLInputElement(*element))
    return;
  Color color;
  if (!color.setFromString(colorValue))
    return;
  toHTMLInputElement(*element).selectColorInColorChooser(color);
}

void Internals::endColorChooser(Element* element) {
  DCHECK(element);
  if (!isHTMLInputElement(*element))
    return;
  toHTMLInputElement(*element).endColorChooser();
}

bool Internals::hasAutofocusRequest(Document* document) {
  if (!document)
    document = m_document;
  return document->autofocusElement();
}

bool Internals::hasAutofocusRequest() {
  return hasAutofocusRequest(0);
}

Vector<String> Internals::formControlStateOfHistoryItem(
    ExceptionState& exceptionState) {
  HistoryItem* mainItem = nullptr;
  if (frame())
    mainItem = frame()->loader().currentItem();
  if (!mainItem) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "No history item is available.");
    return Vector<String>();
  }
  return mainItem->getDocumentState();
}

void Internals::setFormControlStateOfHistoryItem(
    const Vector<String>& state,
    ExceptionState& exceptionState) {
  HistoryItem* mainItem = nullptr;
  if (frame())
    mainItem = frame()->loader().currentItem();
  if (!mainItem) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "No history item is available.");
    return;
  }
  mainItem->clearDocumentState();
  mainItem->setDocumentState(state);
}

DOMWindow* Internals::pagePopupWindow() const {
  if (!m_document)
    return nullptr;
  if (Page* page = m_document->page()) {
    LocalDOMWindow* popup =
        toLocalDOMWindow(page->chromeClient().pagePopupWindowForTesting());
    if (popup) {
      // We need to make the popup same origin so layout tests can access it.
      popup->document()->updateSecurityOrigin(m_document->getSecurityOrigin());
    }
    return popup;
  }
  return nullptr;
}

ClientRect* Internals::absoluteCaretBounds(ExceptionState& exceptionState) {
  if (!frame()) {
    exceptionState.throwDOMException(
        InvalidAccessError, "The document's frame cannot be retrieved.");
    return ClientRect::create();
  }

  m_document->updateStyleAndLayoutIgnorePendingStylesheets();
  return ClientRect::create(frame()->selection().absoluteCaretBounds());
}

String Internals::textAffinity() {
  if (frame()
          ->page()
          ->focusController()
          .focusedFrame()
          ->selection()
          .selectionInDOMTree()
          .affinity() == TextAffinity::Upstream) {
    return "Upstream";
  }
  return "Downstream";
}

ClientRect* Internals::boundingBox(Element* element) {
  DCHECK(element);

  element->document().updateStyleAndLayoutIgnorePendingStylesheets();
  LayoutObject* layoutObject = element->layoutObject();
  if (!layoutObject)
    return ClientRect::create();
  return ClientRect::create(
      layoutObject->absoluteBoundingBoxRectIgnoringTransforms());
}

void Internals::setMarker(Document* document,
                          const Range* range,
                          const String& markerType,
                          ExceptionState& exceptionState) {
  if (!document) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "No context document is available.");
    return;
  }

  WTF::Optional<DocumentMarker::MarkerType> type = markerTypeFrom(markerType);
  if (!type) {
    exceptionState.throwDOMException(
        SyntaxError,
        "The marker type provided ('" + markerType + "') is invalid.");
    return;
  }

  document->updateStyleAndLayoutIgnorePendingStylesheets();
  document->markers().addMarker(range->startPosition(), range->endPosition(),
                                type.value());
}

unsigned Internals::markerCountForNode(Node* node,
                                       const String& markerType,
                                       ExceptionState& exceptionState) {
  DCHECK(node);
  WTF::Optional<DocumentMarker::MarkerTypes> markerTypes =
      markerTypesFrom(markerType);
  if (!markerTypes) {
    exceptionState.throwDOMException(
        SyntaxError,
        "The marker type provided ('" + markerType + "') is invalid.");
    return 0;
  }

  return node->document()
      .markers()
      .markersFor(node, markerTypes.value())
      .size();
}

unsigned Internals::activeMarkerCountForNode(Node* node) {
  DCHECK(node);

  // Only TextMatch markers can be active.
  DocumentMarker::MarkerType markerType = DocumentMarker::TextMatch;
  DocumentMarkerVector markers =
      node->document().markers().markersFor(node, markerType);

  unsigned activeMarkerCount = 0;
  for (const auto& marker : markers) {
    if (marker->activeMatch())
      activeMarkerCount++;
  }

  return activeMarkerCount;
}

DocumentMarker* Internals::markerAt(Node* node,
                                    const String& markerType,
                                    unsigned index,
                                    ExceptionState& exceptionState) {
  DCHECK(node);
  WTF::Optional<DocumentMarker::MarkerTypes> markerTypes =
      markerTypesFrom(markerType);
  if (!markerTypes) {
    exceptionState.throwDOMException(
        SyntaxError,
        "The marker type provided ('" + markerType + "') is invalid.");
    return 0;
  }

  DocumentMarkerVector markers =
      node->document().markers().markersFor(node, markerTypes.value());
  if (markers.size() <= index)
    return 0;
  return markers[index];
}

Range* Internals::markerRangeForNode(Node* node,
                                     const String& markerType,
                                     unsigned index,
                                     ExceptionState& exceptionState) {
  DCHECK(node);
  DocumentMarker* marker = markerAt(node, markerType, index, exceptionState);
  if (!marker)
    return nullptr;
  return Range::create(node->document(), node, marker->startOffset(), node,
                       marker->endOffset());
}

String Internals::markerDescriptionForNode(Node* node,
                                           const String& markerType,
                                           unsigned index,
                                           ExceptionState& exceptionState) {
  DocumentMarker* marker = markerAt(node, markerType, index, exceptionState);
  if (!marker)
    return String();
  return marker->description();
}

void Internals::addTextMatchMarker(const Range* range, bool isActive) {
  DCHECK(range);
  if (!range->ownerDocument().view())
    return;

  range->ownerDocument().updateStyleAndLayoutIgnorePendingStylesheets();
  range->ownerDocument().markers().addTextMatchMarker(EphemeralRange(range),
                                                      isActive);

  // This simulates what the production code does after
  // DocumentMarkerController::addTextMatchMarker().
  range->ownerDocument().view()->invalidatePaintForTickmarks();
}

static bool parseColor(const String& value,
                       Color& color,
                       ExceptionState& exceptionState,
                       String errorMessage) {
  if (!color.setFromString(value)) {
    exceptionState.throwDOMException(InvalidAccessError, errorMessage);
    return false;
  }
  return true;
}

void Internals::addCompositionMarker(const Range* range,
                                     const String& underlineColorValue,
                                     bool thick,
                                     const String& backgroundColorValue,
                                     ExceptionState& exceptionState) {
  DCHECK(range);
  range->ownerDocument().updateStyleAndLayoutIgnorePendingStylesheets();

  Color underlineColor;
  Color backgroundColor;
  if (parseColor(underlineColorValue, underlineColor, exceptionState,
                 "Invalid underline color.") &&
      parseColor(backgroundColorValue, backgroundColor, exceptionState,
                 "Invalid background color.")) {
    range->ownerDocument().markers().addCompositionMarker(
        range->startPosition(), range->endPosition(), underlineColor, thick,
        backgroundColor);
  }
}

void Internals::setMarkersActive(Node* node,
                                 unsigned startOffset,
                                 unsigned endOffset,
                                 bool active) {
  DCHECK(node);
  node->document().markers().setMarkersActive(node, startOffset, endOffset,
                                              active);
}

void Internals::setMarkedTextMatchesAreHighlighted(Document* document,
                                                   bool highlight) {
  if (!document || !document->frame())
    return;

  document->frame()->editor().setMarkedTextMatchesAreHighlighted(highlight);
}

void Internals::setFrameViewPosition(Document* document,
                                     long x,
                                     long y,
                                     ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->view()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return;
  }

  FrameView* frameView = document->view();
  bool scrollbarsSuppressedOldValue = frameView->scrollbarsSuppressed();

  frameView->setScrollbarsSuppressed(false);
  frameView->updateScrollOffsetFromInternals(IntSize(x, y));
  frameView->setScrollbarsSuppressed(scrollbarsSuppressedOldValue);
}

String Internals::viewportAsText(Document* document,
                                 float,
                                 int availableWidth,
                                 int availableHeight,
                                 ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->page()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return String();
  }

  document->updateStyleAndLayoutIgnorePendingStylesheets();

  Page* page = document->page();

  // Update initial viewport size.
  IntSize initialViewportSize(availableWidth, availableHeight);
  document->page()->deprecatedLocalMainFrame()->view()->setFrameRect(
      IntRect(IntPoint::zero(), initialViewportSize));

  ViewportDescription description = page->viewportDescription();
  PageScaleConstraints constraints =
      description.resolve(FloatSize(initialViewportSize), Length());

  constraints.fitToContentsWidth(constraints.layoutSize.width(),
                                 availableWidth);
  constraints.resolveAutoInitialScale();

  StringBuilder builder;

  builder.append("viewport size ");
  builder.append(String::number(constraints.layoutSize.width()));
  builder.append('x');
  builder.append(String::number(constraints.layoutSize.height()));

  builder.append(" scale ");
  builder.append(String::number(constraints.initialScale));
  builder.append(" with limits [");
  builder.append(String::number(constraints.minimumScale));
  builder.append(", ");
  builder.append(String::number(constraints.maximumScale));

  builder.append("] and userScalable ");
  builder.append(description.userZoom ? "true" : "false");

  return builder.toString();
}

bool Internals::elementShouldAutoComplete(Element* element,
                                          ExceptionState& exceptionState) {
  DCHECK(element);
  if (isHTMLInputElement(*element))
    return toHTMLInputElement(*element).shouldAutocomplete();

  exceptionState.throwDOMException(InvalidNodeTypeError,
                                   "The element provided is not an INPUT.");
  return false;
}

String Internals::suggestedValue(Element* element,
                                 ExceptionState& exceptionState) {
  DCHECK(element);
  if (!element->isFormControlElement()) {
    exceptionState.throwDOMException(
        InvalidNodeTypeError,
        "The element provided is not a form control element.");
    return String();
  }

  String suggestedValue;
  if (isHTMLInputElement(*element))
    suggestedValue = toHTMLInputElement(*element).suggestedValue();

  if (isHTMLTextAreaElement(*element))
    suggestedValue = toHTMLTextAreaElement(*element).suggestedValue();

  if (isHTMLSelectElement(*element))
    suggestedValue = toHTMLSelectElement(*element).suggestedValue();

  return suggestedValue;
}

void Internals::setSuggestedValue(Element* element,
                                  const String& value,
                                  ExceptionState& exceptionState) {
  DCHECK(element);
  if (!element->isFormControlElement()) {
    exceptionState.throwDOMException(
        InvalidNodeTypeError,
        "The element provided is not a form control element.");
    return;
  }

  if (isHTMLInputElement(*element))
    toHTMLInputElement(*element).setSuggestedValue(value);

  if (isHTMLTextAreaElement(*element))
    toHTMLTextAreaElement(*element).setSuggestedValue(value);

  if (isHTMLSelectElement(*element))
    toHTMLSelectElement(*element).setSuggestedValue(value);
}

void Internals::setEditingValue(Element* element,
                                const String& value,
                                ExceptionState& exceptionState) {
  DCHECK(element);
  if (!isHTMLInputElement(*element)) {
    exceptionState.throwDOMException(InvalidNodeTypeError,
                                     "The element provided is not an INPUT.");
    return;
  }

  toHTMLInputElement(*element).setEditingValue(value);
}

void Internals::setAutofilled(Element* element,
                              bool enabled,
                              ExceptionState& exceptionState) {
  DCHECK(element);
  if (!element->isFormControlElement()) {
    exceptionState.throwDOMException(
        InvalidNodeTypeError,
        "The element provided is not a form control element.");
    return;
  }
  toHTMLFormControlElement(element)->setAutofilled(enabled);
}

Range* Internals::rangeFromLocationAndLength(Element* scope,
                                             int rangeLocation,
                                             int rangeLength) {
  DCHECK(scope);

  // TextIterator depends on Layout information, make sure layout it up to date.
  scope->document().updateStyleAndLayoutIgnorePendingStylesheets();

  return createRange(PlainTextRange(rangeLocation, rangeLocation + rangeLength)
                         .createRange(*scope));
}

unsigned Internals::locationFromRange(Element* scope, const Range* range) {
  DCHECK(scope && range);
  // PlainTextRange depends on Layout information, make sure layout it up to
  // date.
  scope->document().updateStyleAndLayoutIgnorePendingStylesheets();

  return PlainTextRange::create(*scope, *range).start();
}

unsigned Internals::lengthFromRange(Element* scope, const Range* range) {
  DCHECK(scope && range);
  // PlainTextRange depends on Layout information, make sure layout it up to
  // date.
  scope->document().updateStyleAndLayoutIgnorePendingStylesheets();

  return PlainTextRange::create(*scope, *range).length();
}

String Internals::rangeAsText(const Range* range) {
  DCHECK(range);
  // Clean layout is required by plain text extraction.
  range->ownerDocument().updateStyleAndLayoutIgnorePendingStylesheets();

  return range->text();
}

// FIXME: The next four functions are very similar - combine them once
// bestClickableNode/bestContextMenuNode have been combined..

DOMPoint* Internals::touchPositionAdjustedToBestClickableNode(
    long x,
    long y,
    long width,
    long height,
    Document* document,
    ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return 0;
  }

  document->updateStyleAndLayout();

  IntSize radius(width / 2, height / 2);
  IntPoint point(x + radius.width(), y + radius.height());

  EventHandler& eventHandler = document->frame()->eventHandler();
  IntPoint hitTestPoint = document->frame()->view()->rootFrameToContents(point);
  HitTestResult result = eventHandler.hitTestResultAtPoint(
      hitTestPoint, HitTestRequest::ReadOnly | HitTestRequest::Active |
                        HitTestRequest::ListBased,
      LayoutSize(radius));

  Node* targetNode = 0;
  IntPoint adjustedPoint;

  bool foundNode = eventHandler.bestClickableNodeForHitTestResult(
      result, adjustedPoint, targetNode);
  if (foundNode)
    return DOMPoint::create(adjustedPoint.x(), adjustedPoint.y());

  return 0;
}

Node* Internals::touchNodeAdjustedToBestClickableNode(
    long x,
    long y,
    long width,
    long height,
    Document* document,
    ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return 0;
  }

  document->updateStyleAndLayout();

  IntSize radius(width / 2, height / 2);
  IntPoint point(x + radius.width(), y + radius.height());

  EventHandler& eventHandler = document->frame()->eventHandler();
  IntPoint hitTestPoint = document->frame()->view()->rootFrameToContents(point);
  HitTestResult result = eventHandler.hitTestResultAtPoint(
      hitTestPoint, HitTestRequest::ReadOnly | HitTestRequest::Active |
                        HitTestRequest::ListBased,
      LayoutSize(radius));

  Node* targetNode = 0;
  IntPoint adjustedPoint;
  document->frame()->eventHandler().bestClickableNodeForHitTestResult(
      result, adjustedPoint, targetNode);
  return targetNode;
}

DOMPoint* Internals::touchPositionAdjustedToBestContextMenuNode(
    long x,
    long y,
    long width,
    long height,
    Document* document,
    ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return 0;
  }

  document->updateStyleAndLayout();

  IntSize radius(width / 2, height / 2);
  IntPoint point(x + radius.width(), y + radius.height());

  EventHandler& eventHandler = document->frame()->eventHandler();
  IntPoint hitTestPoint = document->frame()->view()->rootFrameToContents(point);
  HitTestResult result = eventHandler.hitTestResultAtPoint(
      hitTestPoint, HitTestRequest::ReadOnly | HitTestRequest::Active |
                        HitTestRequest::ListBased,
      LayoutSize(radius));

  Node* targetNode = 0;
  IntPoint adjustedPoint;

  bool foundNode = eventHandler.bestContextMenuNodeForHitTestResult(
      result, adjustedPoint, targetNode);
  if (foundNode)
    return DOMPoint::create(adjustedPoint.x(), adjustedPoint.y());

  return DOMPoint::create(x, y);
}

Node* Internals::touchNodeAdjustedToBestContextMenuNode(
    long x,
    long y,
    long width,
    long height,
    Document* document,
    ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return 0;
  }

  document->updateStyleAndLayout();

  IntSize radius(width / 2, height / 2);
  IntPoint point(x + radius.width(), y + radius.height());

  EventHandler& eventHandler = document->frame()->eventHandler();
  IntPoint hitTestPoint = document->frame()->view()->rootFrameToContents(point);
  HitTestResult result = eventHandler.hitTestResultAtPoint(
      hitTestPoint, HitTestRequest::ReadOnly | HitTestRequest::Active |
                        HitTestRequest::ListBased,
      LayoutSize(radius));

  Node* targetNode = 0;
  IntPoint adjustedPoint;
  eventHandler.bestContextMenuNodeForHitTestResult(result, adjustedPoint,
                                                   targetNode);
  return targetNode;
}

ClientRect* Internals::bestZoomableAreaForTouchPoint(
    long x,
    long y,
    long width,
    long height,
    Document* document,
    ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return nullptr;
  }

  document->updateStyleAndLayout();

  IntSize radius(width / 2, height / 2);
  IntPoint point(x + radius.width(), y + radius.height());

  Node* targetNode = 0;
  IntRect zoomableArea;
  bool foundNode =
      document->frame()->eventHandler().bestZoomableAreaForTouchPoint(
          point, radius, zoomableArea, targetNode);
  if (foundNode)
    return ClientRect::create(zoomableArea);

  return nullptr;
}

int Internals::lastSpellCheckRequestSequence(Document* document,
                                             ExceptionState& exceptionState) {
  SpellCheckRequester* requester = spellCheckRequester(document);

  if (!requester) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "No spell check requestor can be obtained for the provided document.");
    return -1;
  }

  return requester->lastRequestSequence();
}

int Internals::lastSpellCheckProcessedSequence(Document* document,
                                               ExceptionState& exceptionState) {
  SpellCheckRequester* requester = spellCheckRequester(document);

  if (!requester) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "No spell check requestor can be obtained for the provided document.");
    return -1;
  }

  return requester->lastProcessedSequence();
}

String Internals::idleTimeSpellCheckerState(Document* document,
                                            ExceptionState& exceptionState) {
  static const char* const texts[] = {
#define V(state) #state,
      FOR_EACH_IDLE_SPELL_CHECK_CALLBACK_STATE(V)
#undef V
  };

  if (!document || !document->frame()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "No frame can be obtained from the provided document.");
    return String();
  }

  IdleSpellCheckCallback::State state =
      document->frame()->spellChecker().idleSpellCheckCallback().state();
  const auto& it = std::begin(texts) + static_cast<size_t>(state);
  DCHECK_GE(it, std::begin(texts)) << "Unknown state value";
  DCHECK_LT(it, std::end(texts)) << "Unknown state value";
  return *it;
}

void Internals::runIdleTimeSpellChecker(Document* document,
                                        ExceptionState& exceptionState) {
  if (!document || !document->frame()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "No frame can be obtained from the provided document.");
    return;
  }

  document->frame()
      ->spellChecker()
      .idleSpellCheckCallback()
      .forceInvocationForTesting();
}

Vector<AtomicString> Internals::userPreferredLanguages() const {
  return blink::userPreferredLanguages();
}

// Optimally, the bindings generator would pass a Vector<AtomicString> here but
// this is not supported yet.
void Internals::setUserPreferredLanguages(const Vector<String>& languages) {
  Vector<AtomicString> atomicLanguages;
  for (size_t i = 0; i < languages.size(); ++i)
    atomicLanguages.push_back(AtomicString(languages[i]));
  overrideUserPreferredLanguages(atomicLanguages);
}

unsigned Internals::mediaKeysCount() {
  return InstanceCounters::counterValue(InstanceCounters::MediaKeysCounter);
}

unsigned Internals::mediaKeySessionCount() {
  return InstanceCounters::counterValue(
      InstanceCounters::MediaKeySessionCounter);
}

unsigned Internals::suspendableObjectCount(Document* document) {
  DCHECK(document);
  return document->suspendableObjectCount();
}

static unsigned eventHandlerCount(
    Document& document,
    EventHandlerRegistry::EventHandlerClass handlerClass) {
  if (!document.page())
    return 0;
  EventHandlerRegistry* registry = &document.page()->eventHandlerRegistry();
  unsigned count = 0;
  const EventTargetSet* targets = registry->eventHandlerTargets(handlerClass);
  if (targets) {
    for (const auto& target : *targets)
      count += target.value;
  }
  return count;
}

unsigned Internals::wheelEventHandlerCount(Document* document) {
  DCHECK(document);
  return eventHandlerCount(*document, EventHandlerRegistry::WheelEventBlocking);
}

unsigned Internals::scrollEventHandlerCount(Document* document) {
  DCHECK(document);
  return eventHandlerCount(*document, EventHandlerRegistry::ScrollEvent);
}

unsigned Internals::touchStartOrMoveEventHandlerCount(Document* document) {
  DCHECK(document);
  return eventHandlerCount(
             *document, EventHandlerRegistry::TouchStartOrMoveEventBlocking) +
         eventHandlerCount(*document,
                           EventHandlerRegistry::TouchStartOrMoveEventPassive);
}

unsigned Internals::touchEndOrCancelEventHandlerCount(Document* document) {
  DCHECK(document);
  return eventHandlerCount(
             *document, EventHandlerRegistry::TouchEndOrCancelEventBlocking) +
         eventHandlerCount(*document,
                           EventHandlerRegistry::TouchEndOrCancelEventPassive);
}

static PaintLayer* findLayerForGraphicsLayer(PaintLayer* searchRoot,
                                             GraphicsLayer* graphicsLayer,
                                             IntSize* layerOffset,
                                             String* layerType) {
  *layerOffset = IntSize();
  if (searchRoot->hasCompositedLayerMapping() &&
      graphicsLayer ==
          searchRoot->compositedLayerMapping()->mainGraphicsLayer()) {
    // If the |graphicsLayer| sets the scrollingContent layer as its
    // scroll parent, consider it belongs to the scrolling layer and
    // mark the layer type as "scrolling".
    if (!searchRoot->layoutObject().hasTransformRelatedProperty() &&
        searchRoot->scrollParent() &&
        searchRoot->parent() == searchRoot->scrollParent()) {
      *layerType = "scrolling";
      // For hit-test rect visualization to work, the hit-test rect should
      // be relative to the scrolling layer and in this case the hit-test
      // rect is relative to the element's own GraphicsLayer. So we will have
      // to adjust the rect to be relative to the scrolling layer here.
      // Only when the element's offsetParent == scroller's offsetParent we
      // can compute the element's relative position to the scrolling content
      // in this way.
      if (searchRoot->layoutObject().offsetParent() ==
          searchRoot->parent()->layoutObject().offsetParent()) {
        LayoutBoxModelObject& current = searchRoot->layoutObject();
        LayoutBoxModelObject& parent = searchRoot->parent()->layoutObject();
        layerOffset->setWidth((parent.offsetLeft(parent.offsetParent()) -
                               current.offsetLeft(parent.offsetParent()))
                                  .toInt());
        layerOffset->setHeight((parent.offsetTop(parent.offsetParent()) -
                                current.offsetTop(parent.offsetParent()))
                                   .toInt());
        return searchRoot->parent();
      }
    }

    LayoutRect rect;
    PaintLayer::mapRectInPaintInvalidationContainerToBacking(
        searchRoot->layoutObject(), rect);
    rect.move(searchRoot->compositedLayerMapping()
                  ->contentOffsetInCompositingLayer());

    *layerOffset = IntSize(rect.x().toInt(), rect.y().toInt());
    return searchRoot;
  }

  // If the |graphicsLayer| is a scroller's scrollingContent layer,
  // consider this is a scrolling layer.
  GraphicsLayer* layerForScrolling =
      searchRoot->getScrollableArea()
          ? searchRoot->getScrollableArea()->layerForScrolling()
          : 0;
  if (graphicsLayer == layerForScrolling) {
    *layerType = "scrolling";
    return searchRoot;
  }

  if (searchRoot->compositingState() == PaintsIntoGroupedBacking) {
    GraphicsLayer* squashingLayer =
        searchRoot->groupedMapping()->squashingLayer();
    if (graphicsLayer == squashingLayer) {
      *layerType = "squashing";
      LayoutRect rect;
      PaintLayer::mapRectInPaintInvalidationContainerToBacking(
          searchRoot->layoutObject(), rect);
      *layerOffset = IntSize(rect.x().toInt(), rect.y().toInt());
      return searchRoot;
    }
  }

  GraphicsLayer* layerForHorizontalScrollbar =
      searchRoot->getScrollableArea()
          ? searchRoot->getScrollableArea()->layerForHorizontalScrollbar()
          : 0;
  if (graphicsLayer == layerForHorizontalScrollbar) {
    *layerType = "horizontalScrollbar";
    return searchRoot;
  }

  GraphicsLayer* layerForVerticalScrollbar =
      searchRoot->getScrollableArea()
          ? searchRoot->getScrollableArea()->layerForVerticalScrollbar()
          : 0;
  if (graphicsLayer == layerForVerticalScrollbar) {
    *layerType = "verticalScrollbar";
    return searchRoot;
  }

  GraphicsLayer* layerForScrollCorner =
      searchRoot->getScrollableArea()
          ? searchRoot->getScrollableArea()->layerForScrollCorner()
          : 0;
  if (graphicsLayer == layerForScrollCorner) {
    *layerType = "scrollCorner";
    return searchRoot;
  }

  // Search right to left to increase the chances that we'll choose the top-most
  // layers in a grouped mapping for squashing.
  for (PaintLayer* child = searchRoot->lastChild(); child;
       child = child->previousSibling()) {
    PaintLayer* foundLayer =
        findLayerForGraphicsLayer(child, graphicsLayer, layerOffset, layerType);
    if (foundLayer)
      return foundLayer;
  }

  return 0;
}

// Given a vector of rects, merge those that are adjacent, leaving empty rects
// in the place of no longer used slots. This is intended to simplify the list
// of rects returned by an SkRegion (which have been split apart for sorting
// purposes). No attempt is made to do this efficiently (eg. by relying on the
// sort criteria of SkRegion).
static void mergeRects(WebVector<blink::WebRect>& rects) {
  for (size_t i = 0; i < rects.size(); ++i) {
    if (rects[i].isEmpty())
      continue;
    bool updated;
    do {
      updated = false;
      for (size_t j = i + 1; j < rects.size(); ++j) {
        if (rects[j].isEmpty())
          continue;
        // Try to merge rects[j] into rects[i] along the 4 possible edges.
        if (rects[i].y == rects[j].y && rects[i].height == rects[j].height) {
          if (rects[i].x + rects[i].width == rects[j].x) {
            rects[i].width += rects[j].width;
            rects[j] = blink::WebRect();
            updated = true;
          } else if (rects[i].x == rects[j].x + rects[j].width) {
            rects[i].x = rects[j].x;
            rects[i].width += rects[j].width;
            rects[j] = blink::WebRect();
            updated = true;
          }
        } else if (rects[i].x == rects[j].x &&
                   rects[i].width == rects[j].width) {
          if (rects[i].y + rects[i].height == rects[j].y) {
            rects[i].height += rects[j].height;
            rects[j] = blink::WebRect();
            updated = true;
          } else if (rects[i].y == rects[j].y + rects[j].height) {
            rects[i].y = rects[j].y;
            rects[i].height += rects[j].height;
            rects[j] = blink::WebRect();
            updated = true;
          }
        }
      }
    } while (updated);
  }
}

static void accumulateLayerRectList(PaintLayerCompositor* compositor,
                                    GraphicsLayer* graphicsLayer,
                                    LayerRectList* rects) {
  WebVector<blink::WebRect> layerRects =
      graphicsLayer->platformLayer()->touchEventHandlerRegion();
  if (!layerRects.isEmpty()) {
    mergeRects(layerRects);
    String layerType;
    IntSize layerOffset;
    PaintLayer* paintLayer = findLayerForGraphicsLayer(
        compositor->rootLayer(), graphicsLayer, &layerOffset, &layerType);
    Node* node = paintLayer ? paintLayer->layoutObject().node() : 0;
    for (size_t i = 0; i < layerRects.size(); ++i) {
      if (!layerRects[i].isEmpty()) {
        rects->append(node, layerType, layerOffset.width(),
                      layerOffset.height(), ClientRect::create(layerRects[i]));
      }
    }
  }

  size_t numChildren = graphicsLayer->children().size();
  for (size_t i = 0; i < numChildren; ++i)
    accumulateLayerRectList(compositor, graphicsLayer->children()[i], rects);
}

LayerRectList* Internals::touchEventTargetLayerRects(
    Document* document,
    ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->view() || !document->page() || document != m_document) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return nullptr;
  }

  if (ScrollingCoordinator* scrollingCoordinator =
          document->page()->scrollingCoordinator())
    scrollingCoordinator->updateAfterCompositingChangeIfNeeded();

  LayoutViewItem view = document->layoutViewItem();
  if (!view.isNull()) {
    if (PaintLayerCompositor* compositor = view.compositor()) {
      if (GraphicsLayer* rootLayer = compositor->rootGraphicsLayer()) {
        LayerRectList* rects = LayerRectList::create();
        accumulateLayerRectList(compositor, rootLayer, rects);
        return rects;
      }
    }
  }

  return nullptr;
}

bool Internals::executeCommand(Document* document,
                               const String& name,
                               const String& value,
                               ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return false;
  }

  LocalFrame* frame = document->frame();
  return frame->editor().executeCommand(name, value);
}

AtomicString Internals::htmlNamespace() {
  return HTMLNames::xhtmlNamespaceURI;
}

Vector<AtomicString> Internals::htmlTags() {
  Vector<AtomicString> tags(HTMLNames::HTMLTagsCount);
  std::unique_ptr<const HTMLQualifiedName* []> qualifiedNames =
      HTMLNames::getHTMLTags();
  for (size_t i = 0; i < HTMLNames::HTMLTagsCount; ++i)
    tags[i] = qualifiedNames[i]->localName();
  return tags;
}

AtomicString Internals::svgNamespace() {
  return SVGNames::svgNamespaceURI;
}

Vector<AtomicString> Internals::svgTags() {
  Vector<AtomicString> tags(SVGNames::SVGTagsCount);
  std::unique_ptr<const SVGQualifiedName* []> qualifiedNames =
      SVGNames::getSVGTags();
  for (size_t i = 0; i < SVGNames::SVGTagsCount; ++i)
    tags[i] = qualifiedNames[i]->localName();
  return tags;
}

StaticNodeList* Internals::nodesFromRect(Document* document,
                                         int centerX,
                                         int centerY,
                                         unsigned topPadding,
                                         unsigned rightPadding,
                                         unsigned bottomPadding,
                                         unsigned leftPadding,
                                         bool ignoreClipping,
                                         bool allowChildFrameContent,
                                         ExceptionState& exceptionState) const {
  DCHECK(document);
  if (!document->frame() || !document->frame()->view()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "No view can be obtained from the provided document.");
    return nullptr;
  }

  LocalFrame* frame = document->frame();
  FrameView* frameView = document->view();
  LayoutViewItem layoutViewItem = document->layoutViewItem();

  if (layoutViewItem.isNull())
    return nullptr;

  float zoomFactor = frame->pageZoomFactor();
  LayoutPoint point =
      LayoutPoint(FloatPoint(centerX * zoomFactor + frameView->scrollX(),
                             centerY * zoomFactor + frameView->scrollY()));

  HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly |
                                               HitTestRequest::Active |
                                               HitTestRequest::ListBased;
  if (ignoreClipping)
    hitType |= HitTestRequest::IgnoreClipping;
  if (allowChildFrameContent)
    hitType |= HitTestRequest::AllowChildFrameContent;

  HitTestRequest request(hitType);

  // When ignoreClipping is false, this method returns null for coordinates
  // outside of the viewport.
  if (!request.ignoreClipping() &&
      !frameView->visibleContentRect().intersects(HitTestLocation::rectForPoint(
          point, topPadding, rightPadding, bottomPadding, leftPadding)))
    return nullptr;

  HeapVector<Member<Node>> matches;
  HitTestResult result(request, point, topPadding, rightPadding, bottomPadding,
                       leftPadding);
  layoutViewItem.hitTest(result);
  copyToVector(result.listBasedTestResult(), matches);

  return StaticNodeList::adopt(matches);
}

bool Internals::hasSpellingMarker(Document* document,
                                  int from,
                                  int length,
                                  ExceptionState& exceptionState) {
  if (!document || !document->frame()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "No frame can be obtained from the provided document.");
    return false;
  }

  document->updateStyleAndLayoutIgnorePendingStylesheets();
  return document->frame()->spellChecker().selectionStartHasMarkerFor(
      DocumentMarker::Spelling, from, length);
}

void Internals::setSpellCheckingEnabled(bool enabled,
                                        ExceptionState& exceptionState) {
  if (!frame()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "No frame can be obtained from the provided document.");
    return;
  }

  if (enabled != frame()->spellChecker().isSpellCheckingEnabled())
    frame()->spellChecker().toggleSpellCheckingEnabled();
}

void Internals::replaceMisspelled(Document* document,
                                  const String& replacement,
                                  ExceptionState& exceptionState) {
  if (!document || !document->frame()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "No frame can be obtained from the provided document.");
    return;
  }

  document->updateStyleAndLayoutIgnorePendingStylesheets();
  document->frame()->spellChecker().replaceMisspelledRange(replacement);
}

bool Internals::canHyphenate(const AtomicString& locale) {
  return LayoutLocale::valueOrDefault(LayoutLocale::get(locale))
      .getHyphenation();
}

void Internals::setMockHyphenation(const AtomicString& locale) {
  LayoutLocale::setHyphenationForTesting(locale, adoptRef(new MockHyphenation));
}

bool Internals::isOverwriteModeEnabled(Document* document) {
  DCHECK(document);
  if (!document->frame())
    return false;

  return document->frame()->editor().isOverwriteModeEnabled();
}

void Internals::toggleOverwriteModeEnabled(Document* document) {
  DCHECK(document);
  if (!document->frame())
    return;

  document->frame()->editor().toggleOverwriteModeEnabled();
}

unsigned Internals::numberOfLiveNodes() const {
  return InstanceCounters::counterValue(InstanceCounters::NodeCounter);
}

unsigned Internals::numberOfLiveDocuments() const {
  return InstanceCounters::counterValue(InstanceCounters::DocumentCounter);
}

String Internals::dumpRefCountedInstanceCounts() const {
  return WTF::dumpRefCountedInstanceCounts();
}

bool Internals::hasGrammarMarker(Document* document,
                                 int from,
                                 int length,
                                 ExceptionState& exceptionState) {
  if (!document || !document->frame()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        "No frame can be obtained from the provided document.");
    return false;
  }

  document->updateStyleAndLayoutIgnorePendingStylesheets();
  return document->frame()->spellChecker().selectionStartHasMarkerFor(
      DocumentMarker::Grammar, from, length);
}

unsigned Internals::numberOfScrollableAreas(Document* document) {
  DCHECK(document);
  if (!document->frame())
    return 0;

  unsigned count = 0;
  LocalFrame* frame = document->frame();
  if (frame->view()->scrollableAreas())
    count += frame->view()->scrollableAreas()->size();

  for (Frame* child = frame->tree().firstChild(); child;
       child = child->tree().nextSibling()) {
    if (child->isLocalFrame() && toLocalFrame(child)->view() &&
        toLocalFrame(child)->view()->scrollableAreas())
      count += toLocalFrame(child)->view()->scrollableAreas()->size();
  }

  return count;
}

bool Internals::isPageBoxVisible(Document* document, int pageNumber) {
  DCHECK(document);
  return document->isPageBoxVisible(pageNumber);
}

String Internals::layerTreeAsText(Document* document,
                                  ExceptionState& exceptionState) const {
  return layerTreeAsText(document, 0, exceptionState);
}

String Internals::elementLayerTreeAsText(Element* element,
                                         ExceptionState& exceptionState) const {
  DCHECK(element);
  FrameView* frameView = element->document().view();
  frameView->updateAllLifecyclePhases();

  return elementLayerTreeAsText(element, 0, exceptionState);
}

bool Internals::scrollsWithRespectTo(Element* element1,
                                     Element* element2,
                                     ExceptionState& exceptionState) {
  DCHECK(element1 && element2);
  element1->document().view()->updateAllLifecyclePhases();

  LayoutObject* layoutObject1 = element1->layoutObject();
  LayoutObject* layoutObject2 = element2->layoutObject();
  if (!layoutObject1 || !layoutObject1->isBox()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        layoutObject1
            ? "The first provided element's layoutObject is not a box."
            : "The first provided element has no layoutObject.");
    return false;
  }
  if (!layoutObject2 || !layoutObject2->isBox()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        layoutObject2
            ? "The second provided element's layoutObject is not a box."
            : "The second provided element has no layoutObject.");
    return false;
  }

  PaintLayer* layer1 = toLayoutBox(layoutObject1)->layer();
  PaintLayer* layer2 = toLayoutBox(layoutObject2)->layer();
  if (!layer1 || !layer2) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        String::format(
            "No PaintLayer can be obtained from the %s provided element.",
            layer1 ? "second" : "first"));
    return false;
  }

  return layer1->scrollsWithRespectTo(layer2);
}

String Internals::layerTreeAsText(Document* document,
                                  unsigned flags,
                                  ExceptionState& exceptionState) const {
  DCHECK(document);
  if (!document->frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return String();
  }

  document->view()->updateAllLifecyclePhases();

  return document->frame()->layerTreeAsText(flags);
}

String Internals::elementLayerTreeAsText(Element* element,
                                         unsigned flags,
                                         ExceptionState& exceptionState) const {
  DCHECK(element);
  element->document().updateStyleAndLayout();

  LayoutObject* layoutObject = element->layoutObject();
  if (!layoutObject || !layoutObject->isBox()) {
    exceptionState.throwDOMException(
        InvalidAccessError,
        layoutObject ? "The provided element's layoutObject is not a box."
                     : "The provided element has no layoutObject.");
    return String();
  }

  PaintLayer* layer = toLayoutBox(layoutObject)->layer();
  if (!layer || !layer->hasCompositedLayerMapping() ||
      !layer->compositedLayerMapping()->mainGraphicsLayer()) {
    // Don't raise exception in these cases which may be normally used in tests.
    return String();
  }

  return layer->compositedLayerMapping()->mainGraphicsLayer()->layerTreeAsText(
      flags);
}

String Internals::scrollingStateTreeAsText(Document*) const {
  return String();
}

String Internals::mainThreadScrollingReasons(
    Document* document,
    ExceptionState& exceptionState) const {
  DCHECK(document);
  if (!document->frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return String();
  }

  document->frame()->view()->updateAllLifecyclePhases();

  return document->frame()->view()->mainThreadScrollingReasonsAsText();
}

ClientRectList* Internals::nonFastScrollableRects(
    Document* document,
    ExceptionState& exceptionState) const {
  DCHECK(document);
  if (!document->frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return nullptr;
  }

  Page* page = document->page();
  if (!page)
    return nullptr;

  return page->nonFastScrollableRects(document->frame());
}

void Internals::evictAllResources() const {
  memoryCache()->evictResources();
}

String Internals::counterValue(Element* element) {
  if (!element)
    return String();

  return counterValueForElement(element);
}

int Internals::pageNumber(Element* element,
                          float pageWidth,
                          float pageHeight,
                          ExceptionState& exceptionState) {
  if (!element)
    return 0;

  if (pageWidth <= 0 || pageHeight <= 0) {
    exceptionState.throwDOMException(
        V8TypeError, "Page width and height must be larger than 0.");
    return 0;
  }

  return PrintContext::pageNumberForElement(element,
                                            FloatSize(pageWidth, pageHeight));
}

Vector<String> Internals::iconURLs(Document* document,
                                   int iconTypesMask) const {
  Vector<IconURL> iconURLs = document->iconURLs(iconTypesMask);
  Vector<String> array;

  for (auto& iconURL : iconURLs)
    array.push_back(iconURL.m_iconURL.getString());

  return array;
}

Vector<String> Internals::shortcutIconURLs(Document* document) const {
  return iconURLs(document, Favicon);
}

Vector<String> Internals::allIconURLs(Document* document) const {
  return iconURLs(document, Favicon | TouchIcon | TouchPrecomposedIcon);
}

int Internals::numberOfPages(float pageWidth,
                             float pageHeight,
                             ExceptionState& exceptionState) {
  if (!frame())
    return -1;

  if (pageWidth <= 0 || pageHeight <= 0) {
    exceptionState.throwDOMException(
        V8TypeError, "Page width and height must be larger than 0.");
    return -1;
  }

  return PrintContext::numberOfPages(frame(), FloatSize(pageWidth, pageHeight));
}

String Internals::pageProperty(String propertyName,
                               int pageNumber,
                               ExceptionState& exceptionState) const {
  if (!frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "No frame is available.");
    return String();
  }

  return PrintContext::pageProperty(frame(), propertyName.utf8().data(),
                                    pageNumber);
}

String Internals::pageSizeAndMarginsInPixels(
    int pageNumber,
    int width,
    int height,
    int marginTop,
    int marginRight,
    int marginBottom,
    int marginLeft,
    ExceptionState& exceptionState) const {
  if (!frame()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "No frame is available.");
    return String();
  }

  return PrintContext::pageSizeAndMarginsInPixels(
      frame(), pageNumber, width, height, marginTop, marginRight, marginBottom,
      marginLeft);
}

float Internals::pageScaleFactor(ExceptionState& exceptionState) {
  if (!m_document->page()) {
    exceptionState.throwDOMException(
        InvalidAccessError, "The document's page cannot be retrieved.");
    return 0;
  }
  Page* page = m_document->page();
  return page->visualViewport().pageScale();
}

void Internals::setPageScaleFactor(float scaleFactor,
                                   ExceptionState& exceptionState) {
  if (scaleFactor <= 0)
    return;
  if (!m_document->page()) {
    exceptionState.throwDOMException(
        InvalidAccessError, "The document's page cannot be retrieved.");
    return;
  }
  Page* page = m_document->page();
  page->visualViewport().setScale(scaleFactor);
}

void Internals::setPageScaleFactorLimits(float minScaleFactor,
                                         float maxScaleFactor,
                                         ExceptionState& exceptionState) {
  if (!m_document->page()) {
    exceptionState.throwDOMException(
        InvalidAccessError, "The document's page cannot be retrieved.");
    return;
  }

  Page* page = m_document->page();
  page->setDefaultPageScaleLimits(minScaleFactor, maxScaleFactor);
}

bool Internals::magnifyScaleAroundAnchor(float scaleFactor, float x, float y) {
  if (!frame())
    return false;

  return frame()->page()->visualViewport().magnifyScaleAroundAnchor(
      scaleFactor, FloatPoint(x, y));
}

void Internals::setIsCursorVisible(Document* document,
                                   bool isVisible,
                                   ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->page()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "No context document can be obtained.");
    return;
  }
  document->page()->setIsCursorVisible(isVisible);
}

String Internals::effectivePreload(HTMLMediaElement* mediaElement) {
  DCHECK(mediaElement);
  return mediaElement->effectivePreload();
}

void Internals::mediaPlayerRemoteRouteAvailabilityChanged(
    HTMLMediaElement* mediaElement,
    bool available) {
  DCHECK(mediaElement);
  mediaElement->remoteRouteAvailabilityChanged(
      available ? WebRemotePlaybackAvailability::DeviceAvailable
                : WebRemotePlaybackAvailability::SourceNotSupported);
}

void Internals::mediaPlayerPlayingRemotelyChanged(
    HTMLMediaElement* mediaElement,
    bool remote) {
  DCHECK(mediaElement);
  if (remote)
    mediaElement->connectedToRemoteDevice();
  else
    mediaElement->disconnectedFromRemoteDevice();
}

void Internals::registerURLSchemeAsBypassingContentSecurityPolicy(
    const String& scheme) {
  SchemeRegistry::registerURLSchemeAsBypassingContentSecurityPolicy(scheme);
}

void Internals::registerURLSchemeAsBypassingContentSecurityPolicy(
    const String& scheme,
    const Vector<String>& policyAreas) {
  uint32_t policyAreasEnum = SchemeRegistry::PolicyAreaNone;
  for (const auto& policyArea : policyAreas) {
    if (policyArea == "img")
      policyAreasEnum |= SchemeRegistry::PolicyAreaImage;
    else if (policyArea == "style")
      policyAreasEnum |= SchemeRegistry::PolicyAreaStyle;
  }
  SchemeRegistry::registerURLSchemeAsBypassingContentSecurityPolicy(
      scheme, static_cast<SchemeRegistry::PolicyAreas>(policyAreasEnum));
}

void Internals::removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(
    const String& scheme) {
  SchemeRegistry::removeURLSchemeRegisteredAsBypassingContentSecurityPolicy(
      scheme);
}

TypeConversions* Internals::typeConversions() const {
  return TypeConversions::create();
}

DictionaryTest* Internals::dictionaryTest() const {
  return DictionaryTest::create();
}

RecordTest* Internals::recordTest() const {
  return RecordTest::create();
}

UnionTypesTest* Internals::unionTypesTest() const {
  return UnionTypesTest::create();
}

OriginTrialsTest* Internals::originTrialsTest() const {
  return OriginTrialsTest::create();
}

CallbackFunctionTest* Internals::callbackFunctionTest() const {
  return CallbackFunctionTest::create();
}

Vector<String> Internals::getReferencedFilePaths() const {
  if (!frame())
    return Vector<String>();

  return frame()->loader().currentItem()->getReferencedFilePaths();
}

void Internals::startStoringCompositedLayerDebugInfo(
    Document* document,
    ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->view()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return;
  }

  FrameView* frameView = document->view();
  frameView->setIsStoringCompositedLayerDebugInfo(true);
  frameView->updateAllLifecyclePhases();
}

void Internals::stopStoringCompositedLayerDebugInfo(
    Document* document,
    ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->view()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return;
  }

  FrameView* frameView = document->view();
  frameView->setIsStoringCompositedLayerDebugInfo(false);
  frameView->updateAllLifecyclePhases();
}

void Internals::startTrackingRepaints(Document* document,
                                      ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->view()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return;
  }

  FrameView* frameView = document->view();
  frameView->updateAllLifecyclePhases();
  frameView->setTracksPaintInvalidations(true);
}

void Internals::stopTrackingRepaints(Document* document,
                                     ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->view()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return;
  }

  FrameView* frameView = document->view();
  frameView->updateAllLifecyclePhases();
  frameView->setTracksPaintInvalidations(false);
}

void Internals::updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(
    Node* node,
    ExceptionState& exceptionState) {
  Document* document = nullptr;
  if (!node) {
    document = m_document;
  } else if (node->isDocumentNode()) {
    document = toDocument(node);
  } else if (isHTMLIFrameElement(*node)) {
    document = toHTMLIFrameElement(*node).contentDocument();
  }

  if (!document) {
    exceptionState.throwTypeError(
        "The node provided is neither a document nor an IFrame.");
    return;
  }
  document->updateStyleAndLayoutIgnorePendingStylesheets(
      Document::RunPostLayoutTasksSynchronously);
}

void Internals::forceFullRepaint(Document* document,
                                 ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->view()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return;
  }

  LayoutViewItem layoutViewItem = document->layoutViewItem();
  if (!layoutViewItem.isNull())
    layoutViewItem.invalidatePaintForViewAndCompositedLayers();
}

ClientRectList* Internals::draggableRegions(Document* document,
                                            ExceptionState& exceptionState) {
  return annotatedRegions(document, true, exceptionState);
}

ClientRectList* Internals::nonDraggableRegions(Document* document,
                                               ExceptionState& exceptionState) {
  return annotatedRegions(document, false, exceptionState);
}

ClientRectList* Internals::annotatedRegions(Document* document,
                                            bool draggable,
                                            ExceptionState& exceptionState) {
  DCHECK(document);
  if (!document->view()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return ClientRectList::create();
  }

  document->updateStyleAndLayout();
  document->view()->updateDocumentAnnotatedRegions();
  Vector<AnnotatedRegionValue> regions = document->annotatedRegions();

  Vector<FloatQuad> quads;
  for (size_t i = 0; i < regions.size(); ++i) {
    if (regions[i].draggable == draggable)
      quads.push_back(FloatQuad(FloatRect(regions[i].bounds)));
  }
  return ClientRectList::create(quads);
}

static const char* cursorTypeToString(Cursor::Type cursorType) {
  switch (cursorType) {
    case Cursor::Pointer:
      return "Pointer";
    case Cursor::Cross:
      return "Cross";
    case Cursor::Hand:
      return "Hand";
    case Cursor::IBeam:
      return "IBeam";
    case Cursor::Wait:
      return "Wait";
    case Cursor::Help:
      return "Help";
    case Cursor::EastResize:
      return "EastResize";
    case Cursor::NorthResize:
      return "NorthResize";
    case Cursor::NorthEastResize:
      return "NorthEastResize";
    case Cursor::NorthWestResize:
      return "NorthWestResize";
    case Cursor::SouthResize:
      return "SouthResize";
    case Cursor::SouthEastResize:
      return "SouthEastResize";
    case Cursor::SouthWestResize:
      return "SouthWestResize";
    case Cursor::WestResize:
      return "WestResize";
    case Cursor::NorthSouthResize:
      return "NorthSouthResize";
    case Cursor::EastWestResize:
      return "EastWestResize";
    case Cursor::NorthEastSouthWestResize:
      return "NorthEastSouthWestResize";
    case Cursor::NorthWestSouthEastResize:
      return "NorthWestSouthEastResize";
    case Cursor::ColumnResize:
      return "ColumnResize";
    case Cursor::RowResize:
      return "RowResize";
    case Cursor::MiddlePanning:
      return "MiddlePanning";
    case Cursor::EastPanning:
      return "EastPanning";
    case Cursor::NorthPanning:
      return "NorthPanning";
    case Cursor::NorthEastPanning:
      return "NorthEastPanning";
    case Cursor::NorthWestPanning:
      return "NorthWestPanning";
    case Cursor::SouthPanning:
      return "SouthPanning";
    case Cursor::SouthEastPanning:
      return "SouthEastPanning";
    case Cursor::SouthWestPanning:
      return "SouthWestPanning";
    case Cursor::WestPanning:
      return "WestPanning";
    case Cursor::Move:
      return "Move";
    case Cursor::VerticalText:
      return "VerticalText";
    case Cursor::Cell:
      return "Cell";
    case Cursor::ContextMenu:
      return "ContextMenu";
    case Cursor::Alias:
      return "Alias";
    case Cursor::Progress:
      return "Progress";
    case Cursor::NoDrop:
      return "NoDrop";
    case Cursor::Copy:
      return "Copy";
    case Cursor::None:
      return "None";
    case Cursor::NotAllowed:
      return "NotAllowed";
    case Cursor::ZoomIn:
      return "ZoomIn";
    case Cursor::ZoomOut:
      return "ZoomOut";
    case Cursor::Grab:
      return "Grab";
    case Cursor::Grabbing:
      return "Grabbing";
    case Cursor::Custom:
      return "Custom";
  }

  NOTREACHED();
  return "UNKNOWN";
}

String Internals::getCurrentCursorInfo() {
  if (!frame())
    return String();

  Cursor cursor = frame()->page()->chromeClient().lastSetCursorForTesting();

  StringBuilder result;
  result.append("type=");
  result.append(cursorTypeToString(cursor.getType()));
  result.append(" hotSpot=");
  result.appendNumber(cursor.hotSpot().x());
  result.append(',');
  result.appendNumber(cursor.hotSpot().y());
  if (cursor.getImage()) {
    IntSize size = cursor.getImage()->size();
    result.append(" image=");
    result.appendNumber(size.width());
    result.append('x');
    result.appendNumber(size.height());
  }
  if (cursor.imageScaleFactor() != 1) {
    result.append(" scale=");
    result.appendNumber(cursor.imageScaleFactor(), 8);
  }

  return result.toString();
}

bool Internals::cursorUpdatePending() const {
  if (!frame())
    return false;

  return frame()->eventHandler().cursorUpdatePending();
}

DOMArrayBuffer* Internals::serializeObject(
    PassRefPtr<SerializedScriptValue> value) const {
  String stringValue = value->toWireString();
  DOMArrayBuffer* buffer = DOMArrayBuffer::createUninitializedOrNull(
      stringValue.length(), sizeof(UChar));
  if (buffer) {
    stringValue.copyTo(static_cast<UChar*>(buffer->data()), 0,
                       stringValue.length());
  }
  return buffer;
}

PassRefPtr<SerializedScriptValue> Internals::deserializeBuffer(
    DOMArrayBuffer* buffer) const {
  String value(static_cast<const UChar*>(buffer->data()),
               buffer->byteLength() / sizeof(UChar));
  return SerializedScriptValue::create(value);
}

void Internals::forceReload(bool bypassCache) {
  if (!frame())
    return;

  frame()->reload(bypassCache ? FrameLoadTypeReloadBypassingCache
                              : FrameLoadTypeReloadMainResource,
                  ClientRedirectPolicy::NotClientRedirect);
}

Node* Internals::visibleSelectionAnchorNode() {
  if (!frame())
    return nullptr;
  Position position =
      frame()->selection().computeVisibleSelectionInDOMTreeDeprecated().base();
  return position.isNull() ? nullptr : position.computeContainerNode();
}

unsigned Internals::visibleSelectionAnchorOffset() {
  if (!frame())
    return 0;
  Position position =
      frame()->selection().computeVisibleSelectionInDOMTreeDeprecated().base();
  return position.isNull() ? 0 : position.computeOffsetInContainerNode();
}

Node* Internals::visibleSelectionFocusNode() {
  if (!frame())
    return nullptr;
  Position position = frame()
                          ->selection()
                          .computeVisibleSelectionInDOMTreeDeprecated()
                          .extent();
  return position.isNull() ? nullptr : position.computeContainerNode();
}

unsigned Internals::visibleSelectionFocusOffset() {
  if (!frame())
    return 0;
  Position position = frame()
                          ->selection()
                          .computeVisibleSelectionInDOMTreeDeprecated()
                          .extent();
  return position.isNull() ? 0 : position.computeOffsetInContainerNode();
}

ClientRect* Internals::selectionBounds(ExceptionState& exceptionState) {
  if (!frame()) {
    exceptionState.throwDOMException(
        InvalidAccessError, "The document's frame cannot be retrieved.");
    return nullptr;
  }

  return ClientRect::create(FloatRect(frame()->selection().bounds()));
}

String Internals::markerTextForListItem(Element* element) {
  DCHECK(element);
  return blink::markerTextForListItem(element);
}

String Internals::getImageSourceURL(Element* element) {
  DCHECK(element);
  return element->imageSourceURL();
}

String Internals::selectMenuListText(HTMLSelectElement* select) {
  DCHECK(select);
  LayoutObject* layoutObject = select->layoutObject();
  if (!layoutObject || !layoutObject->isMenuList())
    return String();

  LayoutMenuListItem menuListItem =
      LayoutMenuListItem(toLayoutMenuList(layoutObject));
  return menuListItem.text();
}

bool Internals::isSelectPopupVisible(Node* node) {
  DCHECK(node);
  if (!isHTMLSelectElement(*node))
    return false;
  return toHTMLSelectElement(*node).popupIsVisible();
}

bool Internals::selectPopupItemStyleIsRtl(Node* node, int itemIndex) {
  if (!node || !isHTMLSelectElement(*node))
    return false;

  HTMLSelectElement& select = toHTMLSelectElement(*node);
  if (itemIndex < 0 ||
      static_cast<size_t>(itemIndex) >= select.listItems().size())
    return false;
  const ComputedStyle* itemStyle =
      select.itemComputedStyle(*select.listItems()[itemIndex]);
  return itemStyle && itemStyle->direction() == TextDirection::kRtl;
}

int Internals::selectPopupItemStyleFontHeight(Node* node, int itemIndex) {
  if (!node || !isHTMLSelectElement(*node))
    return false;

  HTMLSelectElement& select = toHTMLSelectElement(*node);
  if (itemIndex < 0 ||
      static_cast<size_t>(itemIndex) >= select.listItems().size())
    return false;
  const ComputedStyle* itemStyle =
      select.itemComputedStyle(*select.listItems()[itemIndex]);

  if (itemStyle) {
    const SimpleFontData* fontData = itemStyle->font().primaryFont();
    DCHECK(fontData);
    return fontData ? fontData->getFontMetrics().height() : 0;
  }
  return 0;
}

void Internals::resetTypeAheadSession(HTMLSelectElement* select) {
  DCHECK(select);
  select->resetTypeAheadSessionForTesting();
}

bool Internals::loseSharedGraphicsContext3D() {
  std::unique_ptr<WebGraphicsContext3DProvider> sharedProvider =
      WTF::wrapUnique(Platform::current()
                          ->createSharedOffscreenGraphicsContext3DProvider());
  if (!sharedProvider)
    return false;
  gpu::gles2::GLES2Interface* sharedGL = sharedProvider->contextGL();
  sharedGL->LoseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_EXT,
                                GL_INNOCENT_CONTEXT_RESET_EXT);
  // To prevent tests that call loseSharedGraphicsContext3D from being
  // flaky, we call finish so that the context is guaranteed to be lost
  // synchronously (i.e. before returning).
  sharedGL->Finish();
  return true;
}

void Internals::forceCompositingUpdate(Document* document,
                                       ExceptionState& exceptionState) {
  DCHECK(document);
  if (document->layoutViewItem().isNull()) {
    exceptionState.throwDOMException(InvalidAccessError,
                                     "The document provided is invalid.");
    return;
  }

  document->frame()->view()->updateAllLifecyclePhases();
}

void Internals::setZoomFactor(float factor) {
  if (!frame())
    return;

  frame()->setPageZoomFactor(factor);
}

void Internals::setShouldRevealPassword(Element* element,
                                        bool reveal,
                                        ExceptionState& exceptionState) {
  DCHECK(element);
  if (!isHTMLInputElement(element)) {
    exceptionState.throwDOMException(InvalidNodeTypeError,
                                     "The element provided is not an INPUT.");
    return;
  }

  return toHTMLInputElement(*element).setShouldRevealPassword(reveal);
}

namespace {

class AddOneFunction : public ScriptFunction {
 public:
  static v8::Local<v8::Function> createFunction(ScriptState* scriptState) {
    AddOneFunction* self = new AddOneFunction(scriptState);
    return self->bindToV8Function();
  }

 private:
  explicit AddOneFunction(ScriptState* scriptState)
      : ScriptFunction(scriptState) {}

  ScriptValue call(ScriptValue value) override {
    v8::Local<v8::Value> v8Value = value.v8Value();
    DCHECK(v8Value->IsNumber());
    int intValue = v8Value.As<v8::Integer>()->Value();
    return ScriptValue(
        getScriptState(),
        v8::Integer::New(getScriptState()->isolate(), intValue + 1));
  }
};

}  // namespace

ScriptPromise Internals::createResolvedPromise(ScriptState* scriptState,
                                               ScriptValue value) {
  ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
  ScriptPromise promise = resolver->promise();
  resolver->resolve(value);
  return promise;
}

ScriptPromise Internals::createRejectedPromise(ScriptState* scriptState,
                                               ScriptValue value) {
  ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
  ScriptPromise promise = resolver->promise();
  resolver->reject(value);
  return promise;
}

ScriptPromise Internals::addOneToPromise(ScriptState* scriptState,
                                         ScriptPromise promise) {
  return promise.then(AddOneFunction::createFunction(scriptState));
}

ScriptPromise Internals::promiseCheck(ScriptState* scriptState,
                                      long arg1,
                                      bool arg2,
                                      const Dictionary& arg3,
                                      const String& arg4,
                                      const Vector<String>& arg5,
                                      ExceptionState& exceptionState) {
  if (arg2)
    return ScriptPromise::cast(scriptState,
                               v8String(scriptState->isolate(), "done"));
  exceptionState.throwDOMException(InvalidStateError,
                                   "Thrown from the native implementation.");
  return ScriptPromise();
}

ScriptPromise Internals::promiseCheckWithoutExceptionState(
    ScriptState* scriptState,
    const Dictionary& arg1,
    const String& arg2,
    const Vector<String>& arg3) {
  return ScriptPromise::cast(scriptState,
                             v8String(scriptState->isolate(), "done"));
}

ScriptPromise Internals::promiseCheckRange(ScriptState* scriptState,
                                           long arg1) {
  return ScriptPromise::cast(scriptState,
                             v8String(scriptState->isolate(), "done"));
}

ScriptPromise Internals::promiseCheckOverload(ScriptState* scriptState,
                                              Location*) {
  return ScriptPromise::cast(scriptState,
                             v8String(scriptState->isolate(), "done"));
}

ScriptPromise Internals::promiseCheckOverload(ScriptState* scriptState,
                                              Document*) {
  return ScriptPromise::cast(scriptState,
                             v8String(scriptState->isolate(), "done"));
}

ScriptPromise Internals::promiseCheckOverload(ScriptState* scriptState,
                                              Location*,
                                              long,
                                              long) {
  return ScriptPromise::cast(scriptState,
                             v8String(scriptState->isolate(), "done"));
}

DEFINE_TRACE(Internals) {
  visitor->trace(m_runtimeFlags);
  visitor->trace(m_document);
}

void Internals::setValueForUser(HTMLInputElement* element,
                                const String& value) {
  element->setValueForUser(value);
}

String Internals::textSurroundingNode(Node* node,
                                      int x,
                                      int y,
                                      unsigned long maxLength) {
  if (!node)
    return String();

  // VisiblePosition and SurroundingText must be created with clean layout.
  node->document().updateStyleAndLayoutIgnorePendingStylesheets();
  DocumentLifecycle::DisallowTransitionScope disallowTransition(
      node->document().lifecycle());

  if (!node->layoutObject())
    return String();
  blink::WebPoint point(x, y);
  SurroundingText surroundingText(
      createVisiblePosition(
          node->layoutObject()->positionForPoint(static_cast<IntPoint>(point)))
          .deepEquivalent()
          .parentAnchoredEquivalent(),
      maxLength);
  return surroundingText.content();
}

void Internals::setFocused(bool focused) {
  if (!frame())
    return;

  frame()->page()->focusController().setFocused(focused);
}

void Internals::setInitialFocus(bool reverse) {
  if (!frame())
    return;

  frame()->document()->clearFocusedElement();
  frame()->page()->focusController().setInitialFocus(
      reverse ? WebFocusTypeBackward : WebFocusTypeForward);
}

bool Internals::ignoreLayoutWithPendingStylesheets(Document* document) {
  DCHECK(document);
  return document->ignoreLayoutWithPendingStylesheets();
}

void Internals::setNetworkConnectionInfoOverride(
    bool onLine,
    const String& type,
    double downlinkMaxMbps,
    ExceptionState& exceptionState) {
  WebConnectionType webtype;
  if (type == "cellular2g") {
    webtype = WebConnectionTypeCellular2G;
  } else if (type == "cellular3g") {
    webtype = WebConnectionTypeCellular3G;
  } else if (type == "cellular4g") {
    webtype = WebConnectionTypeCellular4G;
  } else if (type == "bluetooth") {
    webtype = WebConnectionTypeBluetooth;
  } else if (type == "ethernet") {
    webtype = WebConnectionTypeEthernet;
  } else if (type == "wifi") {
    webtype = WebConnectionTypeWifi;
  } else if (type == "wimax") {
    webtype = WebConnectionTypeWimax;
  } else if (type == "other") {
    webtype = WebConnectionTypeOther;
  } else if (type == "none") {
    webtype = WebConnectionTypeNone;
  } else if (type == "unknown") {
    webtype = WebConnectionTypeUnknown;
  } else {
    exceptionState.throwDOMException(
        NotFoundError,
        ExceptionMessages::failedToEnumerate("connection type", type));
    return;
  }
  networkStateNotifier().setOverride(onLine, webtype, downlinkMaxMbps);
}

void Internals::clearNetworkConnectionInfoOverride() {
  networkStateNotifier().clearOverride();
}

unsigned Internals::countHitRegions(CanvasRenderingContext* context) {
  return context->hitRegionsCount();
}

bool Internals::isInCanvasFontCache(Document* document,
                                    const String& fontString) {
  return document->canvasFontCache()->isInCache(fontString);
}

unsigned Internals::canvasFontCacheMaxFonts() {
  return CanvasFontCache::maxFonts();
}

void Internals::setScrollChain(ScrollState* scrollState,
                               const HeapVector<Member<Element>>& elements,
                               ExceptionState&) {
  std::deque<int> scrollChain;
  for (size_t i = 0; i < elements.size(); ++i)
    scrollChain.push_back(DOMNodeIds::idForNode(elements[i].get()));
  scrollState->setScrollChain(scrollChain);
}

void Internals::forceBlinkGCWithoutV8GC() {
  ThreadState::current()->setGCState(ThreadState::FullGCScheduled);
}

String Internals::selectedHTMLForClipboard() {
  if (!frame())
    return String();

  // Selection normalization and markup generation require clean layout.
  frame()->document()->updateStyleAndLayoutIgnorePendingStylesheets();

  return frame()->selection().selectedHTMLForClipboard();
}

String Internals::selectedTextForClipboard() {
  if (!frame() || !frame()->document())
    return String();

  // Clean layout is required for extracting plain text from selection.
  frame()->document()->updateStyleAndLayoutIgnorePendingStylesheets();

  return frame()->selection().selectedTextForClipboard();
}

void Internals::setVisualViewportOffset(int x, int y) {
  if (!frame())
    return;

  frame()->page()->visualViewport().setLocation(FloatPoint(x, y));
}

int Internals::visualViewportHeight() {
  if (!frame())
    return 0;

  return expandedIntSize(frame()->page()->visualViewport().visibleRect().size())
      .height();
}

int Internals::visualViewportWidth() {
  if (!frame())
    return 0;

  return expandedIntSize(frame()->page()->visualViewport().visibleRect().size())
      .width();
}

float Internals::visualViewportScrollX() {
  if (!frame())
    return 0;

  return frame()->view()->getScrollableArea()->getScrollOffset().width();
}

float Internals::visualViewportScrollY() {
  if (!frame())
    return 0;

  return frame()->view()->getScrollableArea()->getScrollOffset().height();
}

bool Internals::isUseCounted(Document* document, uint32_t feature) {
  if (feature >= UseCounter::NumberOfFeatures)
    return false;
  return UseCounter::isCounted(*document,
                               static_cast<UseCounter::Feature>(feature));
}

bool Internals::isCSSPropertyUseCounted(Document* document,
                                        const String& propertyName) {
  return UseCounter::isCounted(*document, propertyName);
}

bool Internals::isAnimatedCSSPropertyUseCounted(Document* document,
                                                const String& propertyName) {
  return UseCounter::isCountedAnimatedCSS(*document, propertyName);
}

ScriptPromise Internals::observeUseCounter(ScriptState* scriptState,
                                           Document* document,
                                           uint32_t feature) {
  ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
  ScriptPromise promise = resolver->promise();
  if (feature >= UseCounter::NumberOfFeatures) {
    resolver->reject();
    return promise;
  }

  UseCounter::Feature useCounterFeature =
      static_cast<UseCounter::Feature>(feature);
  if (UseCounter::isCounted(*document, useCounterFeature)) {
    resolver->resolve();
    return promise;
  }

  Page* page = document->page();
  if (!page) {
    resolver->reject();
    return promise;
  }

  page->useCounter().addObserver(
      new UseCounterObserverImpl(resolver, useCounterFeature));
  return promise;
}

String Internals::unscopableAttribute() {
  return "unscopableAttribute";
}

String Internals::unscopableMethod() {
  return "unscopableMethod";
}

ClientRectList* Internals::focusRingRects(Element* element) {
  Vector<LayoutRect> rects;
  if (element && element->layoutObject())
    element->layoutObject()->addOutlineRects(
        rects, LayoutPoint(), LayoutObject::IncludeBlockVisualOverflow);
  return ClientRectList::create(rects);
}

ClientRectList* Internals::outlineRects(Element* element) {
  Vector<LayoutRect> rects;
  if (element && element->layoutObject())
    element->layoutObject()->addOutlineRects(
        rects, LayoutPoint(), LayoutObject::DontIncludeBlockVisualOverflow);
  return ClientRectList::create(rects);
}

void Internals::setCapsLockState(bool enabled) {
  KeyboardEventManager::setCurrentCapsLockState(
      enabled ? OverrideCapsLockState::On : OverrideCapsLockState::Off);
}

bool Internals::setScrollbarVisibilityInScrollableArea(Node* node,
                                                       bool visible) {
  if (ScrollableArea* scrollableArea = scrollableAreaForNode(node)) {
    scrollableArea->setScrollbarsHidden(!visible);
    scrollableArea->scrollAnimator().setScrollbarsVisibleForTesting(visible);
    return ScrollbarTheme::theme().usesOverlayScrollbars();
  }
  return false;
}

double Internals::monotonicTimeToZeroBasedDocumentTime(
    double platformTime,
    ExceptionState& exceptionState) {
  return m_document->loader()->timing().monotonicTimeToZeroBasedDocumentTime(
      platformTime);
}

void Internals::setMediaElementNetworkState(HTMLMediaElement* mediaElement,
                                            int state) {
  DCHECK(mediaElement);
  DCHECK(state >= WebMediaPlayer::NetworkState::NetworkStateEmpty);
  DCHECK(state <= WebMediaPlayer::NetworkState::NetworkStateDecodeError);
  mediaElement->setNetworkState(
      static_cast<WebMediaPlayer::NetworkState>(state));
}

String Internals::getScrollAnimationState(Node* node) const {
  if (ScrollableArea* scrollableArea = scrollableAreaForNode(node))
    return scrollableArea->scrollAnimator().runStateAsText();
  return String();
}

String Internals::getProgrammaticScrollAnimationState(Node* node) const {
  if (ScrollableArea* scrollableArea = scrollableAreaForNode(node))
    return scrollableArea->programmaticScrollAnimator().runStateAsText();
  return String();
}

ClientRect* Internals::visualRect(Node* node) {
  if (!node || !node->layoutObject())
    return ClientRect::create();

  return ClientRect::create(FloatRect(node->layoutObject()->visualRect()));
}

void Internals::crash() {
  CHECK(false) << "Intentional crash";
}

void Internals::setIsLowEndDevice(bool isLowEndDevice) {
  MemoryCoordinator::setIsLowEndDeviceForTesting(isLowEndDevice);
}

}  // namespace blink