/*
 * Copyright (C) 2011, 2012 Google 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:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (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 "web/WebViewImpl.h"

#include "core/CSSValueKeywords.h"
#include "core/HTMLNames.h"
#include "core/InputTypeNames.h"
#include "core/clipboard/DataObject.h"
#include "core/dom/Document.h"
#include "core/dom/Fullscreen.h"
#include "core/dom/LayoutTreeBuilderTraversal.h"
#include "core/dom/Text.h"
#include "core/editing/EditingUtilities.h"
#include "core/editing/Editor.h"
#include "core/editing/FrameSelection.h"
#include "core/editing/InputMethodController.h"
#include "core/editing/iterators/TextIterator.h"
#include "core/editing/markers/DocumentMarkerController.h"
#include "core/editing/serializers/HTMLInterchange.h"
#include "core/editing/serializers/Serialization.h"
#include "core/events/KeyboardEvent.h"
#include "core/events/UIEventWithKeyState.h"
#include "core/events/WheelEvent.h"
#include "core/fetch/UniqueIdentifier.h"
#include "core/frame/EventHandlerRegistry.h"
#include "core/frame/FrameHost.h"
#include "core/frame/FrameView.h"
#include "core/frame/LocalFrame.h"
#include "core/frame/PageScaleConstraintsSet.h"
#include "core/frame/RemoteFrame.h"
#include "core/frame/Settings.h"
#include "core/frame/SmartClip.h"
#include "core/frame/TopControls.h"
#include "core/frame/UseCounter.h"
#include "core/frame/VisualViewport.h"
#include "core/html/HTMLInputElement.h"
#include "core/html/HTMLMediaElement.h"
#include "core/html/HTMLPlugInElement.h"
#include "core/html/HTMLTextAreaElement.h"
#include "core/input/EventHandler.h"
#include "core/input/TouchActionUtil.h"
#include "core/layout/LayoutPart.h"
#include "core/layout/TextAutosizer.h"
#include "core/layout/api/LayoutViewItem.h"
#include "core/layout/compositing/PaintLayerCompositor.h"
#include "core/loader/FrameLoadRequest.h"
#include "core/loader/FrameLoader.h"
#include "core/loader/FrameLoaderClient.h"
#include "core/loader/FrameLoaderStateMachine.h"
#include "core/page/ContextMenuController.h"
#include "core/page/ContextMenuProvider.h"
#include "core/page/DragController.h"
#include "core/page/DragData.h"
#include "core/page/DragSession.h"
#include "core/page/FocusController.h"
#include "core/page/FrameTree.h"
#include "core/page/Page.h"
#include "core/page/PagePopupClient.h"
#include "core/page/PointerLockController.h"
#include "core/page/ScopedPageLoadDeferrer.h"
#include "core/page/TouchDisambiguation.h"
#include "core/page/scrolling/TopDocumentRootScrollerController.h"
#include "core/paint/PaintLayer.h"
#include "core/timing/DOMWindowPerformance.h"
#include "core/timing/Performance.h"
#include "modules/accessibility/AXObject.h"
#include "modules/accessibility/AXObjectCacheImpl.h"
#include "modules/credentialmanager/CredentialManagerClient.h"
#include "modules/encryptedmedia/MediaKeysController.h"
#include "modules/storage/StorageNamespaceController.h"
#include "modules/webgl/WebGLRenderingContext.h"
#include "platform/ContextMenu.h"
#include "platform/ContextMenuItem.h"
#include "platform/Cursor.h"
#include "platform/Histogram.h"
#include "platform/KeyboardCodes.h"
#include "platform/PlatformGestureEvent.h"
#include "platform/PlatformMouseEvent.h"
#include "platform/RuntimeEnabledFeatures.h"
#include "platform/TraceEvent.h"
#include "platform/UserGestureIndicator.h"
#include "platform/exported/WebActiveGestureAnimation.h"
#include "platform/fonts/FontCache.h"
#include "platform/geometry/FloatRect.h"
#include "platform/graphics/Color.h"
#include "platform/graphics/CompositorMutatorClient.h"
#include "platform/graphics/FirstPaintInvalidationTracking.h"
#include "platform/graphics/GraphicsContext.h"
#include "platform/graphics/Image.h"
#include "platform/graphics/ImageBuffer.h"
#include "platform/graphics/gpu/DrawingBuffer.h"
#include "platform/graphics/paint/DrawingRecorder.h"
#include "platform/image-decoders/ImageDecoder.h"
#include "platform/scroll/ScrollbarTheme.h"
#include "platform/weborigin/SchemeRegistry.h"
#include "public/platform/Platform.h"
#include "public/platform/WebCompositeAndReadbackAsyncCallback.h"
#include "public/platform/WebCompositorSupport.h"
#include "public/platform/WebDragData.h"
#include "public/platform/WebFloatPoint.h"
#include "public/platform/WebGestureCurve.h"
#include "public/platform/WebImage.h"
#include "public/platform/WebLayerTreeView.h"
#include "public/platform/WebScheduler.h"
#include "public/platform/WebURLRequest.h"
#include "public/platform/WebVector.h"
#include "public/platform/WebViewScheduler.h"
#include "public/web/WebAXObject.h"
#include "public/web/WebActiveWheelFlingParameters.h"
#include "public/web/WebAutofillClient.h"
#include "public/web/WebConsoleMessage.h"
#include "public/web/WebElement.h"
#include "public/web/WebFrame.h"
#include "public/web/WebFrameClient.h"
#include "public/web/WebFrameWidget.h"
#include "public/web/WebHitTestResult.h"
#include "public/web/WebInputElement.h"
#include "public/web/WebMeaningfulLayout.h"
#include "public/web/WebMediaPlayerAction.h"
#include "public/web/WebNode.h"
#include "public/web/WebPlugin.h"
#include "public/web/WebPluginAction.h"
#include "public/web/WebRange.h"
#include "public/web/WebScopedUserGesture.h"
#include "public/web/WebSelection.h"
#include "public/web/WebTextInputInfo.h"
#include "public/web/WebViewClient.h"
#include "public/web/WebWindowFeatures.h"
#include "web/CompositionUnderlineVectorBuilder.h"
#include "web/CompositorMutatorImpl.h"
#include "web/CompositorProxyClientImpl.h"
#include "web/ContextFeaturesClientImpl.h"
#include "web/ContextMenuAllowedScope.h"
#include "web/DatabaseClientImpl.h"
#include "web/DedicatedWorkerMessagingProxyProviderImpl.h"
#include "web/DevToolsEmulator.h"
#include "web/FullscreenController.h"
#include "web/InspectorOverlay.h"
#include "web/LinkHighlightImpl.h"
#include "web/PageOverlay.h"
#include "web/PrerendererClientImpl.h"
#include "web/ResizeViewportAnchor.h"
#include "web/RotationViewportAnchor.h"
#include "web/SpeechRecognitionClientProxy.h"
#include "web/StorageQuotaClientImpl.h"
#include "web/ValidationMessageClientImpl.h"
#include "web/WebDevToolsAgentImpl.h"
#include "web/WebInputEventConversion.h"
#include "web/WebLocalFrameImpl.h"
#include "web/WebPagePopupImpl.h"
#include "web/WebPluginContainerImpl.h"
#include "web/WebRemoteFrameImpl.h"
#include "web/WebSettingsImpl.h"
#include "wtf/AutoReset.h"
#include "wtf/CurrentTime.h"
#include "wtf/PtrUtil.h"
#include "wtf/RefPtr.h"
#include <memory>

#if USE(DEFAULT_RENDER_THEME)
#include "core/layout/LayoutThemeDefault.h"
#endif

// Get rid of WTF's pow define so we can use std::pow.
#undef pow
#include <cmath>  // for std::pow

// The following constants control parameters for automated scaling of webpages
// (such as due to a double tap gesture or find in page etc.). These are
// experimentally determined.
static const int touchPointPadding = 32;
static const int nonUserInitiatedPointPadding = 11;
static const float minScaleDifference = 0.01f;
static const float doubleTapZoomContentDefaultMargin = 5;
static const float doubleTapZoomContentMinimumMargin = 2;
static const double doubleTapZoomAnimationDurationInSeconds = 0.25;
static const float doubleTapZoomAlreadyLegibleRatio = 1.2f;

static const double multipleTargetsZoomAnimationDurationInSeconds = 0.25;
static const double findInPageAnimationDurationInSeconds = 0;

// Constants for viewport anchoring on resize.
static const float viewportAnchorCoordX = 0.5f;
static const float viewportAnchorCoordY = 0;

// Constants for zooming in on a focused text field.
static const double scrollAndScaleAnimationDurationInSeconds = 0.2;
static const int minReadableCaretHeight = 16;
static const int minReadableCaretHeightForTextArea = 13;
static const float minScaleChangeToTriggerZoom = 1.5f;
static const float leftBoxRatio = 0.3f;
static const int caretPadding = 10;

namespace blink {

// Change the text zoom level by kTextSizeMultiplierRatio each time the user
// zooms text in or out (ie., change by 20%).  The min and max values limit
// text zoom to half and 3x the original text size.  These three values match
// those in Apple's port in WebKit/WebKit/WebView/WebView.mm
const double WebView::textSizeMultiplierRatio = 1.2;
const double WebView::minTextSizeMultiplier = 0.5;
const double WebView::maxTextSizeMultiplier = 3.0;

// Used to defer all page activity in cases where the embedder wishes to run
// a nested event loop. Using a stack enables nesting of message loop
// invocations.
static Vector<std::unique_ptr<ScopedPageLoadDeferrer>>&
pageLoadDeferrerStack() {
  DEFINE_STATIC_LOCAL(Vector<std::unique_ptr<ScopedPageLoadDeferrer>>,
                      deferrerStack, ());
  return deferrerStack;
}

// Ensure that the WebDragOperation enum values stay in sync with the original
// DragOperation constants.
#define STATIC_ASSERT_ENUM(a, b)                            \
  static_assert(static_cast<int>(a) == static_cast<int>(b), \
                "mismatching enum : " #a)
STATIC_ASSERT_ENUM(DragOperationNone, WebDragOperationNone);
STATIC_ASSERT_ENUM(DragOperationCopy, WebDragOperationCopy);
STATIC_ASSERT_ENUM(DragOperationLink, WebDragOperationLink);
STATIC_ASSERT_ENUM(DragOperationGeneric, WebDragOperationGeneric);
STATIC_ASSERT_ENUM(DragOperationPrivate, WebDragOperationPrivate);
STATIC_ASSERT_ENUM(DragOperationMove, WebDragOperationMove);
STATIC_ASSERT_ENUM(DragOperationDelete, WebDragOperationDelete);
STATIC_ASSERT_ENUM(DragOperationEvery, WebDragOperationEvery);

static bool shouldUseExternalPopupMenus = false;

namespace {

class UserGestureNotifier {
 public:
  // If a UserGestureIndicator is created for a user gesture since the last
  // page load and *userGestureObserved is false, the UserGestureNotifier
  // will notify the client and set *userGestureObserved to true.
  UserGestureNotifier(WebAutofillClient*, bool* userGestureObserved);
  ~UserGestureNotifier();

 private:
  WebAutofillClient* const m_client;
  bool* const m_userGestureObserved;
};

UserGestureNotifier::UserGestureNotifier(WebAutofillClient* client,
                                         bool* userGestureObserved)
    : m_client(client), m_userGestureObserved(userGestureObserved) {
  DCHECK(m_userGestureObserved);
}

UserGestureNotifier::~UserGestureNotifier() {
  if (!*m_userGestureObserved &&
      UserGestureIndicator::processedUserGestureSinceLoad()) {
    *m_userGestureObserved = true;
    if (m_client)
      m_client->firstUserGestureObserved();
  }
}

class EmptyEventListener final : public EventListener {
 public:
  static EmptyEventListener* create() { return new EmptyEventListener(); }

  bool operator==(const EventListener& other) const override {
    return this == &other;
  }

 private:
  EmptyEventListener() : EventListener(CPPEventListenerType) {}

  void handleEvent(ExecutionContext* executionContext, Event*) override {}
};

class ColorOverlay final : public PageOverlay::Delegate {
 public:
  explicit ColorOverlay(WebColor color) : m_color(color) {}

 private:
  void paintPageOverlay(const PageOverlay& pageOverlay,
                        GraphicsContext& graphicsContext,
                        const WebSize& size) const override {
    if (DrawingRecorder::useCachedDrawingIfPossible(
            graphicsContext, pageOverlay, DisplayItem::kPageOverlay))
      return;
    FloatRect rect(0, 0, size.width, size.height);
    DrawingRecorder drawingRecorder(graphicsContext, pageOverlay,
                                    DisplayItem::kPageOverlay, rect);
    graphicsContext.fillRect(rect, m_color);
  }

  WebColor m_color;
};

}  // namespace

// WebView ----------------------------------------------------------------

WebView* WebView::create(WebViewClient* client,
                         WebPageVisibilityState visibilityState) {
  // Pass the WebViewImpl's self-reference to the caller.
  return WebViewImpl::create(client, visibilityState);
}

WebViewImpl* WebViewImpl::create(WebViewClient* client,
                                 WebPageVisibilityState visibilityState) {
  // Pass the WebViewImpl's self-reference to the caller.
  return adoptRef(new WebViewImpl(client, visibilityState)).leakRef();
}

void WebView::setUseExternalPopupMenus(bool useExternalPopupMenus) {
  shouldUseExternalPopupMenus = useExternalPopupMenus;
}

void WebView::updateVisitedLinkState(unsigned long long linkHash) {
  Page::visitedStateChanged(linkHash);
}

void WebView::resetVisitedLinkState(bool invalidateVisitedLinkHashes) {
  Page::allVisitedStateChanged(invalidateVisitedLinkHashes);
}

void WebView::willEnterModalLoop() {
  pageLoadDeferrerStack().append(wrapUnique(new ScopedPageLoadDeferrer()));
}

void WebView::didExitModalLoop() {
  DCHECK(pageLoadDeferrerStack().size());
  pageLoadDeferrerStack().removeLast();
}

void WebViewImpl::setMainFrame(WebFrame* frame) {
  frame->toImplBase()->initializeCoreFrame(&page()->frameHost(), 0, nullAtom,
                                           nullAtom);
}

void WebViewImpl::setCredentialManagerClient(
    WebCredentialManagerClient* webCredentialManagerClient) {
  DCHECK(m_page);
  provideCredentialManagerClientTo(
      *m_page, new CredentialManagerClient(webCredentialManagerClient));
}

void WebViewImpl::setPrerendererClient(
    WebPrerendererClient* prerendererClient) {
  DCHECK(m_page);
  providePrerendererClientTo(*m_page,
                             new PrerendererClientImpl(prerendererClient));
}

void WebViewImpl::setSpellCheckClient(WebSpellCheckClient* spellCheckClient) {
  m_spellCheckClient = spellCheckClient;
}

// static
HashSet<WebViewImpl*>& WebViewImpl::allInstances() {
  DEFINE_STATIC_LOCAL(HashSet<WebViewImpl*>, allInstances, ());
  return allInstances;
}

WebViewImpl::WebViewImpl(WebViewClient* client,
                         WebPageVisibilityState visibilityState)
    : m_client(client),
      m_spellCheckClient(nullptr),
      m_chromeClientImpl(ChromeClientImpl::create(this)),
      m_contextMenuClientImpl(this),
      m_editorClientImpl(this),
      m_spellCheckerClientImpl(this),
      m_storageClientImpl(this),
      m_shouldAutoResize(false),
      m_zoomLevel(0),
      m_minimumZoomLevel(zoomFactorToZoomLevel(minTextSizeMultiplier)),
      m_maximumZoomLevel(zoomFactorToZoomLevel(maxTextSizeMultiplier)),
      m_zoomFactorForDeviceScaleFactor(0.f),
      m_maximumLegibleScale(1),
      m_doubleTapZoomPageScaleFactor(0),
      m_doubleTapZoomPending(false),
      m_enableFakePageScaleAnimationForTesting(false),
      m_fakePageScaleAnimationPageScaleFactor(0),
      m_fakePageScaleAnimationUseAnchor(false),
      m_doingDragAndDrop(false),
      m_ignoreInputEvents(false),
      m_compositorDeviceScaleFactorOverride(0),
      m_suppressNextKeypressEvent(false),
      m_imeAcceptEvents(true),
      m_operationsAllowed(WebDragOperationNone),
      m_dragOperation(WebDragOperationNone),
      m_devToolsEmulator(nullptr),
      m_isTransparent(false),
      m_tabsToLinks(false),
      m_layerTreeView(nullptr),
      m_rootLayer(nullptr),
      m_rootGraphicsLayer(nullptr),
      m_visualViewportContainerLayer(nullptr),
      m_matchesHeuristicsForGpuRasterization(false),
      m_flingModifier(0),
      m_flingSourceDevice(WebGestureDeviceUninitialized),
      m_fullscreenController(FullscreenController::create(this)),
      m_baseBackgroundColor(Color::white),
      m_backgroundColorOverride(Color::transparent),
      m_zoomFactorOverride(0),
      m_userGestureObserved(false),
      m_shouldDispatchFirstVisuallyNonEmptyLayout(false),
      m_shouldDispatchFirstLayoutAfterFinishedParsing(false),
      m_shouldDispatchFirstLayoutAfterFinishedLoading(false),
      m_displayMode(WebDisplayModeBrowser),
      m_elasticOverscroll(FloatSize()),
      m_mutator(nullptr),
      m_scheduler(wrapUnique(Platform::current()
                                 ->currentThread()
                                 ->scheduler()
                                 ->createWebViewScheduler(this)
                                 .release())),
      m_lastFrameTimeMonotonic(0),
      m_overrideCompositorVisibility(false) {
  Page::PageClients pageClients;
  pageClients.chromeClient = m_chromeClientImpl.get();
  pageClients.contextMenuClient = &m_contextMenuClientImpl;
  pageClients.editorClient = &m_editorClientImpl;
  pageClients.spellCheckerClient = &m_spellCheckerClientImpl;

  m_page = Page::createOrdinary(pageClients);
  MediaKeysController::provideMediaKeysTo(*m_page, &m_mediaKeysClientImpl);
  provideSpeechRecognitionTo(
      *m_page, SpeechRecognitionClientProxy::create(
                   client ? client->speechRecognizer() : nullptr));
  provideContextFeaturesTo(*m_page, ContextFeaturesClientImpl::create());
  provideDatabaseClientTo(*m_page, DatabaseClientImpl::create());

  provideStorageQuotaClientTo(*m_page, StorageQuotaClientImpl::create());
  m_page->setValidationMessageClient(
      ValidationMessageClientImpl::create(*this));
  provideDedicatedWorkerMessagingProxyProviderTo(
      *m_page, DedicatedWorkerMessagingProxyProviderImpl::create());
  StorageNamespaceController::provideStorageNamespaceTo(*m_page,
                                                        &m_storageClientImpl);

  setVisibilityState(visibilityState, true);

  initializeLayerTreeView();

  m_devToolsEmulator = DevToolsEmulator::create(this);

  allInstances().add(this);

  m_pageImportanceSignals.setObserver(client);
  m_resizeViewportAnchor = new ResizeViewportAnchor(*m_page);
}

WebViewImpl::~WebViewImpl() {
  DCHECK(!m_page);

  // Each highlight uses m_owningWebViewImpl->m_linkHighlightsTimeline
  // in destructor. m_linkHighlightsTimeline might be destroyed earlier
  // than m_linkHighlights.
  DCHECK(m_linkHighlights.isEmpty());
}

WebDevToolsAgentImpl* WebViewImpl::mainFrameDevToolsAgentImpl() {
  WebLocalFrameImpl* mainFrame = mainFrameImpl();
  return mainFrame ? mainFrame->devToolsAgentImpl() : nullptr;
}

InspectorOverlay* WebViewImpl::inspectorOverlay() {
  if (WebDevToolsAgentImpl* devtools = mainFrameDevToolsAgentImpl())
    return devtools->overlay();
  return nullptr;
}

WebLocalFrameImpl* WebViewImpl::mainFrameImpl() const {
  return m_page && m_page->mainFrame() && m_page->mainFrame()->isLocalFrame()
             ? WebLocalFrameImpl::fromFrame(m_page->deprecatedLocalMainFrame())
             : nullptr;
}

bool WebViewImpl::tabKeyCyclesThroughElements() const {
  DCHECK(m_page);
  return m_page->tabKeyCyclesThroughElements();
}

void WebViewImpl::setTabKeyCyclesThroughElements(bool value) {
  if (m_page)
    m_page->setTabKeyCyclesThroughElements(value);
}

void WebViewImpl::handleMouseLeave(LocalFrame& mainFrame,
                                   const WebMouseEvent& event) {
  m_client->setMouseOverURL(WebURL());
  PageWidgetEventHandler::handleMouseLeave(mainFrame, event);
}

void WebViewImpl::handleMouseDown(LocalFrame& mainFrame,
                                  const WebMouseEvent& event) {
  // If there is a popup open, close it as the user is clicking on the page
  // (outside of the popup). We also save it so we can prevent a click on an
  // element from immediately reopening the same popup.
  RefPtr<WebPagePopupImpl> pagePopup;
  if (event.button == WebMouseEvent::Button::Left) {
    pagePopup = m_pagePopup;
    hidePopups();
    DCHECK(!m_pagePopup);
  }

  // Take capture on a mouse down on a plugin so we can send it mouse events.
  // If the hit node is a plugin but a scrollbar is over it don't start mouse
  // capture because it will interfere with the scrollbar receiving events.
  IntPoint point(event.x, event.y);
  if (event.button == WebMouseEvent::Button::Left &&
      m_page->mainFrame()->isLocalFrame()) {
    point =
        m_page->deprecatedLocalMainFrame()->view()->rootFrameToContents(point);
    HitTestResult result(
        m_page->deprecatedLocalMainFrame()->eventHandler().hitTestResultAtPoint(
            point));
    result.setToShadowHostIfInUserAgentShadowRoot();
    Node* hitNode = result.innerNodeOrImageMapImage();

    if (!result.scrollbar() && hitNode && hitNode->layoutObject() &&
        hitNode->layoutObject()->isEmbeddedObject()) {
      m_mouseCaptureNode = hitNode;
      TRACE_EVENT_ASYNC_BEGIN0("input", "capturing mouse", this);
    }
  }

  PageWidgetEventHandler::handleMouseDown(mainFrame, event);

  if (event.button == WebMouseEvent::Button::Left && m_mouseCaptureNode)
    m_mouseCaptureGestureToken =
        mainFrame.eventHandler().takeLastMouseDownGestureToken();

  if (m_pagePopup && pagePopup &&
      m_pagePopup->hasSamePopupClient(pagePopup.get())) {
    // That click triggered a page popup that is the same as the one we just
    // closed.  It needs to be closed.
    cancelPagePopup();
  }

  // Dispatch the contextmenu event regardless of if the click was swallowed.
  if (!page()->settings().showContextMenuOnMouseUp()) {
#if OS(MACOSX)
    if (event.button == WebMouseEvent::Button::Right ||
        (event.button == WebMouseEvent::Button::Left &&
         event.modifiers & WebMouseEvent::ControlKey))
      mouseContextMenu(event);
#else
    if (event.button == WebMouseEvent::Button::Right)
      mouseContextMenu(event);
#endif
  }
}

void WebViewImpl::setDisplayMode(WebDisplayMode mode) {
  m_displayMode = mode;
  if (!mainFrameImpl() || !mainFrameImpl()->frameView())
    return;

  mainFrameImpl()->frameView()->setDisplayMode(mode);
}

void WebViewImpl::mouseContextMenu(const WebMouseEvent& event) {
  if (!mainFrameImpl() || !mainFrameImpl()->frameView())
    return;

  m_page->contextMenuController().clearContextMenu();

  PlatformMouseEventBuilder pme(mainFrameImpl()->frameView(), event);

  // Find the right target frame. See issue 1186900.
  HitTestResult result = hitTestResultForRootFramePos(pme.position());
  Frame* targetFrame;
  if (result.innerNodeOrImageMapImage())
    targetFrame = result.innerNodeOrImageMapImage()->document().frame();
  else
    targetFrame = m_page->focusController().focusedOrMainFrame();

  if (!targetFrame->isLocalFrame())
    return;

  LocalFrame* targetLocalFrame = toLocalFrame(targetFrame);

#if OS(WIN)
  targetLocalFrame->view()->setCursor(pointerCursor());
#endif

  {
    ContextMenuAllowedScope scope;
    targetLocalFrame->eventHandler().sendContextMenuEvent(pme, nullptr);
  }
  // Actually showing the context menu is handled by the ContextMenuClient
  // implementation...
}

void WebViewImpl::handleMouseUp(LocalFrame& mainFrame,
                                const WebMouseEvent& event) {
  PageWidgetEventHandler::handleMouseUp(mainFrame, event);

  if (page()->settings().showContextMenuOnMouseUp()) {
    // Dispatch the contextmenu event regardless of if the click was swallowed.
    // On Mac/Linux, we handle it on mouse down, not up.
    if (event.button == WebMouseEvent::Button::Right)
      mouseContextMenu(event);
  }
}

WebInputEventResult WebViewImpl::handleMouseWheel(
    LocalFrame& mainFrame,
    const WebMouseWheelEvent& event) {
  // Halt an in-progress fling on a wheel tick.
  if (!event.hasPreciseScrollingDeltas)
    endActiveFlingAnimation();

  hidePopups();
  return PageWidgetEventHandler::handleMouseWheel(mainFrame, event);
}

WebGestureEvent WebViewImpl::createGestureScrollEventFromFling(
    WebInputEvent::Type type,
    WebGestureDevice sourceDevice) const {
  WebGestureEvent gestureEvent;
  gestureEvent.type = type;
  gestureEvent.sourceDevice = sourceDevice;
  gestureEvent.timeStampSeconds = WTF::monotonicallyIncreasingTime();
  gestureEvent.x = m_positionOnFlingStart.x;
  gestureEvent.y = m_positionOnFlingStart.y;
  gestureEvent.globalX = m_globalPositionOnFlingStart.x;
  gestureEvent.globalY = m_globalPositionOnFlingStart.y;
  gestureEvent.modifiers = m_flingModifier;
  return gestureEvent;
}

bool WebViewImpl::scrollBy(const WebFloatSize& delta,
                           const WebFloatSize& velocity) {
  DCHECK_NE(m_flingSourceDevice, WebGestureDeviceUninitialized);
  if (!m_page || !m_page->mainFrame() || !m_page->mainFrame()->isLocalFrame() ||
      !m_page->deprecatedLocalMainFrame()->view())
    return false;

  if (m_flingSourceDevice == WebGestureDeviceTouchpad) {
    WebMouseWheelEvent syntheticWheel;
    const float tickDivisor = WheelEvent::TickMultiplier;

    syntheticWheel.type = WebInputEvent::MouseWheel;
    syntheticWheel.timeStampSeconds = WTF::monotonicallyIncreasingTime();
    syntheticWheel.deltaX = delta.width;
    syntheticWheel.deltaY = delta.height;
    syntheticWheel.wheelTicksX = delta.width / tickDivisor;
    syntheticWheel.wheelTicksY = delta.height / tickDivisor;
    syntheticWheel.hasPreciseScrollingDeltas = true;
    syntheticWheel.x = m_positionOnFlingStart.x;
    syntheticWheel.y = m_positionOnFlingStart.y;
    syntheticWheel.globalX = m_globalPositionOnFlingStart.x;
    syntheticWheel.globalY = m_globalPositionOnFlingStart.y;
    syntheticWheel.modifiers = m_flingModifier;

    if (handleMouseWheel(*m_page->deprecatedLocalMainFrame(), syntheticWheel) !=
        WebInputEventResult::NotHandled)
      return true;

    // TODO(dtapuska): Remove these GSB/GSE sequences when trackpad latching is
    // implemented; see crbug.com/526463.
    WebGestureEvent syntheticScrollBegin = createGestureScrollEventFromFling(
        WebInputEvent::GestureScrollBegin, WebGestureDeviceTouchpad);
    syntheticScrollBegin.data.scrollBegin.deltaXHint = delta.width;
    syntheticScrollBegin.data.scrollBegin.deltaYHint = delta.height;
    syntheticScrollBegin.data.scrollBegin.inertialPhase =
        WebGestureEvent::MomentumPhase;
    handleGestureEvent(syntheticScrollBegin);

    WebGestureEvent syntheticScrollUpdate = createGestureScrollEventFromFling(
        WebInputEvent::GestureScrollUpdate, WebGestureDeviceTouchpad);
    syntheticScrollUpdate.data.scrollUpdate.deltaX = delta.width;
    syntheticScrollUpdate.data.scrollUpdate.deltaY = delta.height;
    syntheticScrollUpdate.data.scrollUpdate.velocityX = velocity.width;
    syntheticScrollUpdate.data.scrollUpdate.velocityY = velocity.height;
    syntheticScrollUpdate.data.scrollUpdate.inertialPhase =
        WebGestureEvent::MomentumPhase;
    bool scrollUpdateHandled = handleGestureEvent(syntheticScrollUpdate) !=
                               WebInputEventResult::NotHandled;

    WebGestureEvent syntheticScrollEnd = createGestureScrollEventFromFling(
        WebInputEvent::GestureScrollEnd, WebGestureDeviceTouchpad);
    syntheticScrollEnd.data.scrollEnd.inertialPhase =
        WebGestureEvent::MomentumPhase;
    handleGestureEvent(syntheticScrollEnd);
    return scrollUpdateHandled;
  } else {
    WebGestureEvent syntheticGestureEvent = createGestureScrollEventFromFling(
        WebInputEvent::GestureScrollUpdate, WebGestureDeviceTouchscreen);
    syntheticGestureEvent.data.scrollUpdate.preventPropagation = true;
    syntheticGestureEvent.data.scrollUpdate.deltaX = delta.width;
    syntheticGestureEvent.data.scrollUpdate.deltaY = delta.height;
    syntheticGestureEvent.data.scrollUpdate.velocityX = velocity.width;
    syntheticGestureEvent.data.scrollUpdate.velocityY = velocity.height;
    syntheticGestureEvent.data.scrollUpdate.inertialPhase =
        WebGestureEvent::MomentumPhase;

    return handleGestureEvent(syntheticGestureEvent) !=
           WebInputEventResult::NotHandled;
  }
}

WebInputEventResult WebViewImpl::handleGestureEvent(
    const WebGestureEvent& event) {
  if (!m_client)
    return WebInputEventResult::NotHandled;

  WebInputEventResult eventResult = WebInputEventResult::NotHandled;
  bool eventCancelled = false;  // for disambiguation

  // Special handling for slow-path fling gestures.
  switch (event.type) {
    case WebInputEvent::GestureFlingStart: {
      if (mainFrameImpl()
              ->frame()
              ->eventHandler()
              .isScrollbarHandlingGestures())
        break;
      endActiveFlingAnimation();
      m_client->cancelScheduledContentIntents();
      m_positionOnFlingStart = WebPoint(event.x, event.y);
      m_globalPositionOnFlingStart = WebPoint(event.globalX, event.globalY);
      m_flingModifier = event.modifiers;
      m_flingSourceDevice = event.sourceDevice;
      DCHECK_NE(m_flingSourceDevice, WebGestureDeviceUninitialized);
      std::unique_ptr<WebGestureCurve> flingCurve =
          wrapUnique(Platform::current()->createFlingAnimationCurve(
              event.sourceDevice,
              WebFloatPoint(event.data.flingStart.velocityX,
                            event.data.flingStart.velocityY),
              WebSize()));
      DCHECK(flingCurve);
      m_gestureAnimation = WebActiveGestureAnimation::createAtAnimationStart(
          std::move(flingCurve), this);
      mainFrameImpl()->frameWidget()->scheduleAnimation();
      eventResult = WebInputEventResult::HandledSystem;

      // Plugins may need to see GestureFlingStart to balance
      // GestureScrollBegin (since the former replaces GestureScrollEnd when
      // transitioning to a fling).
      PlatformGestureEventBuilder platformEvent(mainFrameImpl()->frameView(),
                                                event);
      // TODO(dtapuska): Why isn't the response used?
      mainFrameImpl()->frame()->eventHandler().handleGestureScrollEvent(
          platformEvent);

      m_client->didHandleGestureEvent(event, eventCancelled);
      return WebInputEventResult::HandledSystem;
    }
    case WebInputEvent::GestureFlingCancel:
      if (endActiveFlingAnimation())
        eventResult = WebInputEventResult::HandledSuppressed;

      m_client->didHandleGestureEvent(event, eventCancelled);
      return eventResult;
    default:
      break;
  }

  PlatformGestureEventBuilder platformEvent(mainFrameImpl()->frameView(),
                                            event);

  // Special handling for double tap and scroll events as we don't want to
  // hit test for them.
  switch (event.type) {
    case WebInputEvent::GestureDoubleTap:
      if (m_webSettings->doubleTapToZoomEnabled() &&
          minimumPageScaleFactor() != maximumPageScaleFactor()) {
        m_client->cancelScheduledContentIntents();
        animateDoubleTapZoom(platformEvent.position());
      }
      // GestureDoubleTap is currently only used by Android for zooming. For
      // WebCore, GestureTap with tap count = 2 is used instead. So we drop
      // GestureDoubleTap here.
      eventResult = WebInputEventResult::HandledSystem;
      m_client->didHandleGestureEvent(event, eventCancelled);
      return eventResult;
    case WebInputEvent::GestureScrollBegin:
      m_client->cancelScheduledContentIntents();
    case WebInputEvent::GestureScrollEnd:
    case WebInputEvent::GestureScrollUpdate:
    case WebInputEvent::GestureFlingStart:
      // Scrolling-related gesture events invoke EventHandler recursively for
      // each frame down the chain, doing a single-frame hit-test per frame.
      // This matches handleWheelEvent.  Perhaps we could simplify things by
      // rewriting scroll handling to work inner frame out, and then unify with
      // other gesture events.
      eventResult =
          mainFrameImpl()->frame()->eventHandler().handleGestureScrollEvent(
              platformEvent);
      m_client->didHandleGestureEvent(event, eventCancelled);
      return eventResult;
    case WebInputEvent::GesturePinchBegin:
    case WebInputEvent::GesturePinchEnd:
    case WebInputEvent::GesturePinchUpdate:
      return WebInputEventResult::NotHandled;
    default:
      break;
  }

  // Hit test across all frames and do touch adjustment as necessary for the
  // event type.
  GestureEventWithHitTestResults targetedEvent =
      m_page->deprecatedLocalMainFrame()->eventHandler().targetGestureEvent(
          platformEvent);

  // Handle link highlighting outside the main switch to avoid getting lost in
  // the complicated set of cases handled below.
  switch (event.type) {
    case WebInputEvent::GestureShowPress:
      // Queue a highlight animation, then hand off to regular handler.
      enableTapHighlightAtPoint(targetedEvent);
      break;
    case WebInputEvent::GestureTapCancel:
    case WebInputEvent::GestureTap:
    case WebInputEvent::GestureLongPress:
      for (size_t i = 0; i < m_linkHighlights.size(); ++i)
        m_linkHighlights[i]->startHighlightAnimationIfNeeded();
      break;
    default:
      break;
  }

  switch (event.type) {
    case WebInputEvent::GestureTap: {
      // If there is a popup open, close it as the user is clicking on the page
      // (outside of the popup). We also save it so we can prevent a tap on an
      // element from immediately reopening the same popup.
      RefPtr<WebPagePopupImpl> pagePopup = m_pagePopup;
      hidePopups();
      DCHECK(!m_pagePopup);

      m_client->cancelScheduledContentIntents();
      if (detectContentOnTouch(targetedEvent)) {
        eventResult = WebInputEventResult::HandledSystem;
        break;
      }

      // Don't trigger a disambiguation popup on sites designed for mobile
      // devices.  Instead, assume that the page has been designed with big
      // enough buttons and links.  Don't trigger a disambiguation popup when
      // screencasting, since it's implemented outside of compositor pipeline
      // and is not being screencasted itself. This leads to bad user
      // experience.
      WebDevToolsAgentImpl* devTools = mainFrameDevToolsAgentImpl();
      VisualViewport& visualViewport = page()->frameHost().visualViewport();
      bool screencastEnabled = devTools && devTools->screencastEnabled();
      if (event.data.tap.width > 0 &&
          !visualViewport.shouldDisableDesktopWorkarounds() &&
          !screencastEnabled) {
        IntRect boundingBox(visualViewport.viewportToRootFrame(
            IntRect(event.x - event.data.tap.width / 2,
                    event.y - event.data.tap.height / 2, event.data.tap.width,
                    event.data.tap.height)));

        // TODO(bokan): We shouldn't pass details of the VisualViewport offset
        // to render_view_impl.  crbug.com/459591
        WebSize visualViewportOffset =
            flooredIntSize(visualViewport.location());

        if (m_webSettings->multiTargetTapNotificationEnabled()) {
          Vector<IntRect> goodTargets;
          HeapVector<Member<Node>> highlightNodes;
          findGoodTouchTargets(boundingBox, mainFrameImpl()->frame(),
                               goodTargets, highlightNodes);
          // FIXME: replace touch adjustment code when numberOfGoodTargets == 1?
          // Single candidate case is currently handled by:
          // https://bugs.webkit.org/show_bug.cgi?id=85101
          if (goodTargets.size() >= 2 && m_client &&
              m_client->didTapMultipleTargets(visualViewportOffset, boundingBox,
                                              goodTargets)) {
            enableTapHighlights(highlightNodes);
            for (size_t i = 0; i < m_linkHighlights.size(); ++i)
              m_linkHighlights[i]->startHighlightAnimationIfNeeded();
            eventResult = WebInputEventResult::HandledSystem;
            eventCancelled = true;
            break;
          }
        }
      }

      eventResult = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(
          targetedEvent);

      if (m_pagePopup && pagePopup &&
          m_pagePopup->hasSamePopupClient(pagePopup.get())) {
        // The tap triggered a page popup that is the same as the one we just
        // closed.  It needs to be closed.
        cancelPagePopup();
      }
      break;
    }
    case WebInputEvent::GestureTwoFingerTap:
    case WebInputEvent::GestureLongPress:
    case WebInputEvent::GestureLongTap: {
      if (!mainFrameImpl() || !mainFrameImpl()->frameView())
        break;

      m_client->cancelScheduledContentIntents();
      m_page->contextMenuController().clearContextMenu();
      {
        ContextMenuAllowedScope scope;
        eventResult =
            mainFrameImpl()->frame()->eventHandler().handleGestureEvent(
                targetedEvent);
      }

      break;
    }
    case WebInputEvent::GestureShowPress:
      m_client->cancelScheduledContentIntents();
    case WebInputEvent::GestureTapDown:
    case WebInputEvent::GestureTapCancel:
    case WebInputEvent::GestureTapUnconfirmed: {
      eventResult = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(
          targetedEvent);
      break;
    }
    default:
      NOTREACHED();
  }
  m_client->didHandleGestureEvent(event, eventCancelled);
  return eventResult;
}

WebInputEventResult WebViewImpl::handleSyntheticWheelFromTouchpadPinchEvent(
    const WebGestureEvent& pinchEvent) {
  DCHECK_EQ(pinchEvent.type, WebInputEvent::GesturePinchUpdate);

  // For pinch gesture events, match typical trackpad behavior on Windows by
  // sending fake wheel events with the ctrl modifier set when we see trackpad
  // pinch gestures.  Ideally we'd someday get a platform 'pinch' event and
  // send that instead.
  WebMouseWheelEvent wheelEvent;
  wheelEvent.type = WebInputEvent::MouseWheel;
  wheelEvent.timeStampSeconds = pinchEvent.timeStampSeconds;
  wheelEvent.windowX = wheelEvent.x = pinchEvent.x;
  wheelEvent.windowY = wheelEvent.y = pinchEvent.y;
  wheelEvent.globalX = pinchEvent.globalX;
  wheelEvent.globalY = pinchEvent.globalY;
  wheelEvent.modifiers = pinchEvent.modifiers | WebInputEvent::ControlKey;
  wheelEvent.deltaX = 0;

  // The function to convert scales to deltaY values is designed to be
  // compatible with websites existing use of wheel events, and with existing
  // Windows trackpad behavior.  In particular, we want:
  //  - deltas should accumulate via addition: f(s1*s2)==f(s1)+f(s2)
  //  - deltas should invert via negation: f(1/s) == -f(s)
  //  - zoom in should be positive: f(s) > 0 iff s > 1
  //  - magnitude roughly matches wheels: f(2) > 25 && f(2) < 100
  //  - a formula that's relatively easy to use from JavaScript
  // Note that 'wheel' event deltaY values have their sign inverted.  So to
  // convert a wheel deltaY back to a scale use Math.exp(-deltaY/100).
  DCHECK_GT(pinchEvent.data.pinchUpdate.scale, 0);
  wheelEvent.deltaY = 100.0f * log(pinchEvent.data.pinchUpdate.scale);
  wheelEvent.hasPreciseScrollingDeltas = true;
  wheelEvent.wheelTicksX = 0;
  wheelEvent.wheelTicksY = pinchEvent.data.pinchUpdate.scale > 1 ? 1 : -1;

  return handleInputEvent(wheelEvent);
}

void WebViewImpl::transferActiveWheelFlingAnimation(
    const WebActiveWheelFlingParameters& parameters) {
  TRACE_EVENT0("blink", "WebViewImpl::transferActiveWheelFlingAnimation");
  DCHECK(!m_gestureAnimation);
  m_positionOnFlingStart = parameters.point;
  m_globalPositionOnFlingStart = parameters.globalPoint;
  m_flingModifier = parameters.modifiers;
  std::unique_ptr<WebGestureCurve> curve =
      wrapUnique(Platform::current()->createFlingAnimationCurve(
          parameters.sourceDevice, WebFloatPoint(parameters.delta),
          parameters.cumulativeScroll));
  DCHECK(curve);
  m_gestureAnimation = WebActiveGestureAnimation::createWithTimeOffset(
      std::move(curve), this, parameters.startTime);
  DCHECK_NE(parameters.sourceDevice, WebGestureDeviceUninitialized);
  m_flingSourceDevice = parameters.sourceDevice;
  mainFrameImpl()->frameWidget()->scheduleAnimation();
}

bool WebViewImpl::endActiveFlingAnimation() {
  if (m_gestureAnimation) {
    m_gestureAnimation.reset();
    m_flingSourceDevice = WebGestureDeviceUninitialized;
    if (m_layerTreeView)
      m_layerTreeView->didStopFlinging();
    return true;
  }
  return false;
}

bool WebViewImpl::startPageScaleAnimation(const IntPoint& targetPosition,
                                          bool useAnchor,
                                          float newScale,
                                          double durationInSeconds) {
  VisualViewport& visualViewport = page()->frameHost().visualViewport();
  WebPoint clampedPoint = targetPosition;
  if (!useAnchor) {
    clampedPoint =
        visualViewport.clampDocumentOffsetAtScale(targetPosition, newScale);
    if (!durationInSeconds) {
      setPageScaleFactor(newScale);

      FrameView* view = mainFrameImpl()->frameView();
      if (view && view->getScrollableArea())
        view->getScrollableArea()->setScrollPosition(
            DoublePoint(clampedPoint.x, clampedPoint.y), ProgrammaticScroll);

      return false;
    }
  }
  if (useAnchor && newScale == pageScaleFactor())
    return false;

  if (m_enableFakePageScaleAnimationForTesting) {
    m_fakePageScaleAnimationTargetPosition = targetPosition;
    m_fakePageScaleAnimationUseAnchor = useAnchor;
    m_fakePageScaleAnimationPageScaleFactor = newScale;
  } else {
    if (!m_layerTreeView)
      return false;
    m_layerTreeView->startPageScaleAnimation(targetPosition, useAnchor,
                                             newScale, durationInSeconds);
  }
  return true;
}

void WebViewImpl::enableFakePageScaleAnimationForTesting(bool enable) {
  m_enableFakePageScaleAnimationForTesting = enable;
}

void WebViewImpl::setShowFPSCounter(bool show) {
  if (m_layerTreeView) {
    TRACE_EVENT0("blink", "WebViewImpl::setShowFPSCounter");
    m_layerTreeView->setShowFPSCounter(show);
  }
}

void WebViewImpl::setShowPaintRects(bool show) {
  if (m_layerTreeView) {
    TRACE_EVENT0("blink", "WebViewImpl::setShowPaintRects");
    m_layerTreeView->setShowPaintRects(show);
  }
  setFirstPaintInvalidationTrackingEnabledForShowPaintRects(show);
}

void WebViewImpl::setShowDebugBorders(bool show) {
  if (m_layerTreeView)
    m_layerTreeView->setShowDebugBorders(show);
}

void WebViewImpl::setShowScrollBottleneckRects(bool show) {
  if (m_layerTreeView)
    m_layerTreeView->setShowScrollBottleneckRects(show);
}

void WebViewImpl::acceptLanguagesChanged() {
  if (m_client)
    FontCache::acceptLanguagesChanged(m_client->acceptLanguages());

  if (!page())
    return;

  page()->acceptLanguagesChanged();
}

void WebViewImpl::ReportIntervention(const WebString& message) {
  if (!mainFrame())
    return;
  WebConsoleMessage consoleMessage(WebConsoleMessage::LevelWarning, message);
  mainFrame()->addMessageToConsole(consoleMessage);
}

WebInputEventResult WebViewImpl::handleKeyEvent(const WebKeyboardEvent& event) {
  DCHECK((event.type == WebInputEvent::RawKeyDown) ||
         (event.type == WebInputEvent::KeyDown) ||
         (event.type == WebInputEvent::KeyUp));
  TRACE_EVENT2("input", "WebViewImpl::handleKeyEvent", "type",
               WebInputEvent::GetName(event.type), "text",
               String(event.text).utf8());

  // Halt an in-progress fling on a key event.
  endActiveFlingAnimation();

  // Please refer to the comments explaining the m_suppressNextKeypressEvent
  // member.
  // The m_suppressNextKeypressEvent is set if the KeyDown is handled by
  // Webkit. A keyDown event is typically associated with a keyPress(char)
  // event and a keyUp event. We reset this flag here as this is a new keyDown
  // event.
  m_suppressNextKeypressEvent = false;

  // If there is a popup, it should be the one processing the event, not the
  // page.
  if (m_pagePopup) {
    m_pagePopup->handleKeyEvent(event);
    // We need to ignore the next Char event after this otherwise pressing
    // enter when selecting an item in the popup will go to the page.
    if (WebInputEvent::RawKeyDown == event.type)
      m_suppressNextKeypressEvent = true;
    return WebInputEventResult::HandledSystem;
  }

  Frame* focusedFrame = focusedCoreFrame();
  if (focusedFrame && focusedFrame->isRemoteFrame()) {
    WebRemoteFrameImpl* webFrame =
        WebRemoteFrameImpl::fromFrame(*toRemoteFrame(focusedFrame));
    webFrame->client()->forwardInputEvent(&event);
    return WebInputEventResult::HandledSystem;
  }

  if (!focusedFrame || !focusedFrame->isLocalFrame())
    return WebInputEventResult::NotHandled;

  LocalFrame* frame = toLocalFrame(focusedFrame);

  WebInputEventResult result = frame->eventHandler().keyEvent(event);
  if (result != WebInputEventResult::NotHandled) {
    if (WebInputEvent::RawKeyDown == event.type) {
      // Suppress the next keypress event unless the focused node is a plugin
      // node.  (Flash needs these keypress events to handle non-US keyboards.)
      Element* element = focusedElement();
      if (element && element->layoutObject() &&
          element->layoutObject()->isEmbeddedObject()) {
        if (event.windowsKeyCode == VKEY_TAB) {
          // If the plugin supports keyboard focus then we should not send a tab
          // keypress event.
          Widget* widget = toLayoutPart(element->layoutObject())->widget();
          if (widget && widget->isPluginContainer()) {
            WebPluginContainerImpl* plugin = toWebPluginContainerImpl(widget);
            if (plugin && plugin->supportsKeyboardFocus())
              m_suppressNextKeypressEvent = true;
          }
        }
      } else {
        m_suppressNextKeypressEvent = true;
      }
    }
    return result;
  }

#if !OS(MACOSX)
  const WebInputEvent::Type contextMenuKeyTriggeringEventType =
#if OS(WIN)
      WebInputEvent::KeyUp;
#else
      WebInputEvent::RawKeyDown;
#endif
  const WebInputEvent::Type shiftF10TriggeringEventType =
      WebInputEvent::RawKeyDown;

  bool isUnmodifiedMenuKey =
      !(event.modifiers & WebInputEvent::InputModifiers) &&
      event.windowsKeyCode == VKEY_APPS;
  bool isShiftF10 = (event.modifiers & WebInputEvent::InputModifiers) ==
                        WebInputEvent::ShiftKey &&
                    event.windowsKeyCode == VKEY_F10;
  if ((isUnmodifiedMenuKey &&
       event.type == contextMenuKeyTriggeringEventType) ||
      (isShiftF10 && event.type == shiftF10TriggeringEventType)) {
    sendContextMenuEvent(event);
    return WebInputEventResult::HandledSystem;
  }
#endif  // !OS(MACOSX)

  if (keyEventDefault(event))
    return WebInputEventResult::HandledSystem;
  return WebInputEventResult::NotHandled;
}

WebInputEventResult WebViewImpl::handleCharEvent(
    const WebKeyboardEvent& event) {
  DCHECK_EQ(event.type, WebInputEvent::Char);
  TRACE_EVENT1("input", "WebViewImpl::handleCharEvent", "text",
               String(event.text).utf8());

  // Please refer to the comments explaining the m_suppressNextKeypressEvent
  // member.  The m_suppressNextKeypressEvent is set if the KeyDown is
  // handled by Webkit. A keyDown event is typically associated with a
  // keyPress(char) event and a keyUp event. We reset this flag here as it
  // only applies to the current keyPress event.
  bool suppress = m_suppressNextKeypressEvent;
  m_suppressNextKeypressEvent = false;

  // If there is a popup, it should be the one processing the event, not the
  // page.
  if (m_pagePopup)
    return m_pagePopup->handleKeyEvent(event);

  LocalFrame* frame = toLocalFrame(focusedCoreFrame());
  if (!frame)
    return suppress ? WebInputEventResult::HandledSuppressed
                    : WebInputEventResult::NotHandled;

  EventHandler& handler = frame->eventHandler();

  if (!event.isCharacterKey())
    return WebInputEventResult::HandledSuppressed;

  // Accesskeys are triggered by char events and can't be suppressed.
  if (handler.handleAccessKey(event))
    return WebInputEventResult::HandledSystem;

  // Safari 3.1 does not pass off windows system key messages (WM_SYSCHAR) to
  // the eventHandler::keyEvent. We mimic this behavior on all platforms since
  // for now we are converting other platform's key events to windows key
  // events.
  if (event.isSystemKey)
    return WebInputEventResult::NotHandled;

  if (suppress)
    return WebInputEventResult::HandledSuppressed;

  WebInputEventResult result = handler.keyEvent(event);
  if (result != WebInputEventResult::NotHandled)
    return result;
  if (keyEventDefault(event))
    return WebInputEventResult::HandledSystem;

  return WebInputEventResult::NotHandled;
}

WebRect WebViewImpl::computeBlockBound(const WebPoint& pointInRootFrame,
                                       bool ignoreClipping) {
  if (!mainFrameImpl())
    return WebRect();

  // Use the point-based hit test to find the node.
  IntPoint point = mainFrameImpl()->frameView()->rootFrameToContents(
      IntPoint(pointInRootFrame.x, pointInRootFrame.y));
  HitTestRequest::HitTestRequestType hitType =
      HitTestRequest::ReadOnly | HitTestRequest::Active |
      (ignoreClipping ? HitTestRequest::IgnoreClipping : 0);
  HitTestResult result =
      mainFrameImpl()->frame()->eventHandler().hitTestResultAtPoint(point,
                                                                    hitType);
  result.setToShadowHostIfInUserAgentShadowRoot();

  Node* node = result.innerNodeOrImageMapImage();
  if (!node)
    return WebRect();

  // Find the block type node based on the hit node.
  // FIXME: This wants to walk flat tree with
  // LayoutTreeBuilderTraversal::parent().
  while (node && (!node->layoutObject() || node->layoutObject()->isInline()))
    node = LayoutTreeBuilderTraversal::parent(*node);

  // Return the bounding box in the root frame's coordinate space.
  if (node) {
    IntRect pointInRootFrame = node->Node::pixelSnappedBoundingBox();
    LocalFrame* frame = node->document().frame();
    return frame->view()->contentsToRootFrame(pointInRootFrame);
  }
  return WebRect();
}

WebRect WebViewImpl::widenRectWithinPageBounds(const WebRect& source,
                                               int targetMargin,
                                               int minimumMargin) {
  WebSize maxSize;
  if (mainFrame())
    maxSize = mainFrame()->contentsSize();
  IntSize scrollOffset;
  if (mainFrame())
    scrollOffset = mainFrame()->scrollOffset();
  int leftMargin = targetMargin;
  int rightMargin = targetMargin;

  const int absoluteSourceX = source.x + scrollOffset.width();
  if (leftMargin > absoluteSourceX) {
    leftMargin = absoluteSourceX;
    rightMargin = std::max(leftMargin, minimumMargin);
  }

  const int maximumRightMargin =
      maxSize.width - (source.width + absoluteSourceX);
  if (rightMargin > maximumRightMargin) {
    rightMargin = maximumRightMargin;
    leftMargin = std::min(leftMargin, std::max(rightMargin, minimumMargin));
  }

  const int newWidth = source.width + leftMargin + rightMargin;
  const int newX = source.x - leftMargin;

  DCHECK_GE(newWidth, 0);
  DCHECK_LE(scrollOffset.width() + newX + newWidth, maxSize.width);

  return WebRect(newX, source.y, newWidth, source.height);
}

float WebViewImpl::maximumLegiblePageScale() const {
  // Pages should be as legible as on desktop when at dpi scale, so no
  // need to zoom in further when automatically determining zoom level
  // (after double tap, find in page, etc), though the user should still
  // be allowed to manually pinch zoom in further if they desire.
  if (page())
    return m_maximumLegibleScale *
           page()->settings().accessibilityFontScaleFactor();
  return m_maximumLegibleScale;
}

void WebViewImpl::computeScaleAndScrollForBlockRect(
    const WebPoint& hitPointInRootFrame,
    const WebRect& blockRectInRootFrame,
    float padding,
    float defaultScaleWhenAlreadyLegible,
    float& scale,
    WebPoint& scroll) {
  scale = pageScaleFactor();
  scroll.x = scroll.y = 0;

  WebRect rect = blockRectInRootFrame;

  if (!rect.isEmpty()) {
    float defaultMargin = doubleTapZoomContentDefaultMargin;
    float minimumMargin = doubleTapZoomContentMinimumMargin;
    // We want the margins to have the same physical size, which means we
    // need to express them in post-scale size. To do that we'd need to know
    // the scale we're scaling to, but that depends on the margins. Instead
    // we express them as a fraction of the target rectangle: this will be
    // correct if we end up fully zooming to it, and won't matter if we
    // don't.
    rect = widenRectWithinPageBounds(
        rect, static_cast<int>(defaultMargin * rect.width / m_size.width),
        static_cast<int>(minimumMargin * rect.width / m_size.width));
    // Fit block to screen, respecting limits.
    scale = static_cast<float>(m_size.width) / rect.width;
    scale = std::min(scale, maximumLegiblePageScale());
    if (pageScaleFactor() < defaultScaleWhenAlreadyLegible)
      scale = std::max(scale, defaultScaleWhenAlreadyLegible);
    scale = clampPageScaleFactorToLimits(scale);
  }

  // FIXME: If this is being called for auto zoom during find in page,
  // then if the user manually zooms in it'd be nice to preserve the
  // relative increase in zoom they caused (if they zoom out then it's ok
  // to zoom them back in again). This isn't compatible with our current
  // double-tap zoom strategy (fitting the containing block to the screen)
  // though.

  float screenWidth = m_size.width / scale;
  float screenHeight = m_size.height / scale;

  // Scroll to vertically align the block.
  if (rect.height < screenHeight) {
    // Vertically center short blocks.
    rect.y -= 0.5 * (screenHeight - rect.height);
  } else {
    // Ensure position we're zooming to (+ padding) isn't off the bottom of
    // the screen.
    rect.y =
        std::max<float>(rect.y, hitPointInRootFrame.y + padding - screenHeight);
  }  // Otherwise top align the block.

  // Do the same thing for horizontal alignment.
  if (rect.width < screenWidth)
    rect.x -= 0.5 * (screenWidth - rect.width);
  else
    rect.x =
        std::max<float>(rect.x, hitPointInRootFrame.x + padding - screenWidth);
  scroll.x = rect.x;
  scroll.y = rect.y;

  scale = clampPageScaleFactorToLimits(scale);
  scroll = mainFrameImpl()->frameView()->rootFrameToContents(scroll);
  scroll = page()->frameHost().visualViewport().clampDocumentOffsetAtScale(
      scroll, scale);
}

static Node* findCursorDefiningAncestor(Node* node, LocalFrame* frame) {
  // Go up the tree to find the node that defines a mouse cursor style
  while (node) {
    if (node->layoutObject()) {
      ECursor cursor = node->layoutObject()->style()->cursor();
      if (cursor != CURSOR_AUTO ||
          frame->eventHandler().useHandCursor(node, node->isLink()))
        break;
    }
    node = LayoutTreeBuilderTraversal::parent(*node);
  }

  return node;
}

static bool showsHandCursor(Node* node, LocalFrame* frame) {
  if (!node || !node->layoutObject())
    return false;

  ECursor cursor = node->layoutObject()->style()->cursor();
  return cursor == CURSOR_POINTER ||
         (cursor == CURSOR_AUTO &&
          frame->eventHandler().useHandCursor(node, node->isLink()));
}

Node* WebViewImpl::bestTapNode(
    const GestureEventWithHitTestResults& targetedTapEvent) {
  TRACE_EVENT0("input", "WebViewImpl::bestTapNode");

  if (!m_page || !m_page->mainFrame())
    return nullptr;

  Node* bestTouchNode = targetedTapEvent.hitTestResult().innerNode();
  if (!bestTouchNode)
    return nullptr;

  // We might hit something like an image map that has no layoutObject on it
  // Walk up the tree until we have a node with an attached layoutObject
  while (!bestTouchNode->layoutObject()) {
    bestTouchNode = LayoutTreeBuilderTraversal::parent(*bestTouchNode);
    if (!bestTouchNode)
      return nullptr;
  }

  // Editable nodes should not be highlighted (e.g., <input>)
  if (hasEditableStyle(*bestTouchNode))
    return nullptr;

  Node* cursorDefiningAncestor = findCursorDefiningAncestor(
      bestTouchNode, m_page->deprecatedLocalMainFrame());
  // We show a highlight on tap only when the current node shows a hand cursor
  if (!cursorDefiningAncestor ||
      !showsHandCursor(cursorDefiningAncestor,
                       m_page->deprecatedLocalMainFrame())) {
    return nullptr;
  }

  // We should pick the largest enclosing node with hand cursor set. We do this
  // by first jumping up to cursorDefiningAncestor (which is already known to
  // have hand cursor set). Then we locate the next cursor-defining ancestor up
  // in the the tree and repeat the jumps as long as the node has hand cursor
  // set.
  do {
    bestTouchNode = cursorDefiningAncestor;
    cursorDefiningAncestor = findCursorDefiningAncestor(
        LayoutTreeBuilderTraversal::parent(*bestTouchNode),
        m_page->deprecatedLocalMainFrame());
  } while (cursorDefiningAncestor &&
           showsHandCursor(cursorDefiningAncestor,
                           m_page->deprecatedLocalMainFrame()));

  return bestTouchNode;
}

void WebViewImpl::enableTapHighlightAtPoint(
    const GestureEventWithHitTestResults& targetedTapEvent) {
  Node* touchNode = bestTapNode(targetedTapEvent);

  HeapVector<Member<Node>> highlightNodes;
  highlightNodes.append(touchNode);

  enableTapHighlights(highlightNodes);
}

void WebViewImpl::enableTapHighlights(
    HeapVector<Member<Node>>& highlightNodes) {
  if (highlightNodes.isEmpty())
    return;

  // Always clear any existing highlight when this is invoked, even if we
  // don't get a new target to highlight.
  m_linkHighlights.clear();

  for (size_t i = 0; i < highlightNodes.size(); ++i) {
    Node* node = highlightNodes[i];

    if (!node || !node->layoutObject())
      continue;

    Color highlightColor = node->layoutObject()->style()->tapHighlightColor();
    // Safari documentation for -webkit-tap-highlight-color says if the
    // specified color has 0 alpha, then tap highlighting is disabled.
    // http://developer.apple.com/library/safari/#documentation/appleapplications/reference/safaricssref/articles/standardcssproperties.html
    if (!highlightColor.alpha())
      continue;

    m_linkHighlights.append(LinkHighlightImpl::create(node, this));
  }

  updateAllLifecyclePhases();
}

void WebViewImpl::animateDoubleTapZoom(const IntPoint& pointInRootFrame) {
  if (!mainFrameImpl())
    return;

  WebRect blockBounds = computeBlockBound(pointInRootFrame, false);
  float scale;
  WebPoint scroll;

  computeScaleAndScrollForBlockRect(
      pointInRootFrame, blockBounds, touchPointPadding,
      minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio, scale,
      scroll);

  bool stillAtPreviousDoubleTapScale =
      (pageScaleFactor() == m_doubleTapZoomPageScaleFactor &&
       m_doubleTapZoomPageScaleFactor != minimumPageScaleFactor()) ||
      m_doubleTapZoomPending;

  bool scaleUnchanged = fabs(pageScaleFactor() - scale) < minScaleDifference;
  bool shouldZoomOut =
      blockBounds.isEmpty() || scaleUnchanged || stillAtPreviousDoubleTapScale;

  bool isAnimating;

  if (shouldZoomOut) {
    scale = minimumPageScaleFactor();
    IntPoint targetPosition =
        mainFrameImpl()->frameView()->rootFrameToContents(pointInRootFrame);
    isAnimating = startPageScaleAnimation(
        targetPosition, true, scale, doubleTapZoomAnimationDurationInSeconds);
  } else {
    isAnimating = startPageScaleAnimation(
        scroll, false, scale, doubleTapZoomAnimationDurationInSeconds);
  }

  // TODO(dglazkov): The only reason why we're using isAnimating and not just
  // checking for m_layerTreeView->hasPendingPageScaleAnimation() is because of
  // fake page scale animation plumbing for testing, which doesn't actually
  // initiate a page scale animation.
  if (isAnimating) {
    m_doubleTapZoomPageScaleFactor = scale;
    m_doubleTapZoomPending = true;
  }
}

void WebViewImpl::zoomToFindInPageRect(const WebRect& rectInRootFrame) {
  if (!mainFrameImpl())
    return;

  WebRect blockBounds = computeBlockBound(
      WebPoint(rectInRootFrame.x + rectInRootFrame.width / 2,
               rectInRootFrame.y + rectInRootFrame.height / 2),
      true);

  if (blockBounds.isEmpty()) {
    // Keep current scale (no need to scroll as x,y will normally already
    // be visible). FIXME: Revisit this if it isn't always true.
    return;
  }

  float scale;
  WebPoint scroll;

  computeScaleAndScrollForBlockRect(
      WebPoint(rectInRootFrame.x, rectInRootFrame.y), blockBounds,
      nonUserInitiatedPointPadding, minimumPageScaleFactor(), scale, scroll);

  startPageScaleAnimation(scroll, false, scale,
                          findInPageAnimationDurationInSeconds);
}

bool WebViewImpl::zoomToMultipleTargetsRect(const WebRect& rectInRootFrame) {
  if (!mainFrameImpl())
    return false;

  float scale;
  WebPoint scroll;

  computeScaleAndScrollForBlockRect(
      WebPoint(rectInRootFrame.x, rectInRootFrame.y), rectInRootFrame,
      nonUserInitiatedPointPadding, minimumPageScaleFactor(), scale, scroll);

  if (scale <= pageScaleFactor())
    return false;

  startPageScaleAnimation(scroll, false, scale,
                          multipleTargetsZoomAnimationDurationInSeconds);
  return true;
}

void WebViewImpl::hasTouchEventHandlers(bool hasTouchHandlers) {
  if (m_client)
    m_client->hasTouchEventHandlers(hasTouchHandlers);
}

bool WebViewImpl::hasTouchEventHandlersAt(const WebPoint& point) {
  // FIXME: Implement this. Note that the point must be divided by
  // pageScaleFactor.
  return true;
}

#if !OS(MACOSX)
// Mac has no way to open a context menu based on a keyboard event.
WebInputEventResult WebViewImpl::sendContextMenuEvent(
    const WebKeyboardEvent& event) {
  // The contextMenuController() holds onto the last context menu that was
  // popped up on the page until a new one is created. We need to clear
  // this menu before propagating the event through the DOM so that we can
  // detect if we create a new menu for this event, since we won't create
  // a new menu if the DOM swallows the event and the defaultEventHandler does
  // not run.
  page()->contextMenuController().clearContextMenu();

  {
    ContextMenuAllowedScope scope;
    Frame* focusedFrame = page()->focusController().focusedOrMainFrame();
    if (!focusedFrame->isLocalFrame())
      return WebInputEventResult::NotHandled;
    // Firefox reveal focus based on "keydown" event but not "contextmenu"
    // event, we match FF.
    if (Element* focusedElement =
            toLocalFrame(focusedFrame)->document()->focusedElement())
      focusedElement->scrollIntoViewIfNeeded();
    return toLocalFrame(focusedFrame)
        ->eventHandler()
        .sendContextMenuEventForKey(nullptr);
  }
}
#endif

void WebViewImpl::showContextMenuAtPoint(float x,
                                         float y,
                                         ContextMenuProvider* menuProvider) {
  if (!page()->mainFrame()->isLocalFrame())
    return;
  {
    ContextMenuAllowedScope scope;
    page()->contextMenuController().clearContextMenu();
    page()->contextMenuController().showContextMenuAtPoint(
        page()->deprecatedLocalMainFrame(), x, y, menuProvider);
  }
}

void WebViewImpl::showContextMenuForElement(WebElement element) {
  if (!page())
    return;

  page()->contextMenuController().clearContextMenu();
  {
    ContextMenuAllowedScope scope;
    if (LocalFrame* focusedFrame =
            toLocalFrame(page()->focusController().focusedOrMainFrame()))
      focusedFrame->eventHandler().sendContextMenuEventForKey(
          element.unwrap<Element>());
  }
}

bool WebViewImpl::keyEventDefault(const WebKeyboardEvent& event) {
  LocalFrame* frame = toLocalFrame(focusedCoreFrame());
  if (!frame)
    return false;

  switch (event.type) {
    case WebInputEvent::Char:
      if (event.windowsKeyCode == VKEY_SPACE) {
        int keyCode = ((event.modifiers & WebInputEvent::ShiftKey) ? VKEY_PRIOR
                                                                   : VKEY_NEXT);
        return scrollViewWithKeyboard(keyCode, event.modifiers);
      }
      break;
    case WebInputEvent::RawKeyDown:
      if (event.modifiers == WebInputEvent::ControlKey) {
        switch (event.windowsKeyCode) {
#if !OS(MACOSX)
          case 'A':
            focusedFrame()->executeCommand(WebString::fromUTF8("SelectAll"));
            return true;
          case VKEY_INSERT:
          case 'C':
            focusedFrame()->executeCommand(WebString::fromUTF8("Copy"));
            return true;
#endif
          // Match FF behavior in the sense that Ctrl+home/end are the only Ctrl
          // key combinations which affect scrolling. Safari is buggy in the
          // sense that it scrolls the page for all Ctrl+scrolling key
          // combinations. For e.g. Ctrl+pgup/pgdn/up/down, etc.
          case VKEY_HOME:
          case VKEY_END:
            break;
          default:
            return false;
        }
      }
      if (!event.isSystemKey && !(event.modifiers & WebInputEvent::ShiftKey))
        return scrollViewWithKeyboard(event.windowsKeyCode, event.modifiers);
      break;
    default:
      break;
  }
  return false;
}

bool WebViewImpl::scrollViewWithKeyboard(int keyCode, int modifiers) {
  ScrollDirectionPhysical scrollDirectionPhysical;
  ScrollGranularity scrollGranularity;
#if OS(MACOSX)
  // Alt-Up/Down should be PageUp/Down on Mac.
  if (modifiers & WebMouseEvent::AltKey) {
    if (keyCode == VKEY_UP)
      keyCode = VKEY_PRIOR;
    else if (keyCode == VKEY_DOWN)
      keyCode = VKEY_NEXT;
  }
#endif
  if (!mapKeyCodeForScroll(keyCode, &scrollDirectionPhysical,
                           &scrollGranularity))
    return false;

  if (LocalFrame* frame = toLocalFrame(focusedCoreFrame()))
    return frame->eventHandler().bubblingScroll(
        toScrollDirection(scrollDirectionPhysical), scrollGranularity);
  return false;
}

bool WebViewImpl::mapKeyCodeForScroll(int keyCode,
                                      ScrollDirectionPhysical* scrollDirection,
                                      ScrollGranularity* scrollGranularity) {
  switch (keyCode) {
    case VKEY_LEFT:
      *scrollDirection = ScrollLeft;
      *scrollGranularity = ScrollByLine;
      break;
    case VKEY_RIGHT:
      *scrollDirection = ScrollRight;
      *scrollGranularity = ScrollByLine;
      break;
    case VKEY_UP:
      *scrollDirection = ScrollUp;
      *scrollGranularity = ScrollByLine;
      break;
    case VKEY_DOWN:
      *scrollDirection = ScrollDown;
      *scrollGranularity = ScrollByLine;
      break;
    case VKEY_HOME:
      *scrollDirection = ScrollUp;
      *scrollGranularity = ScrollByDocument;
      break;
    case VKEY_END:
      *scrollDirection = ScrollDown;
      *scrollGranularity = ScrollByDocument;
      break;
    case VKEY_PRIOR:  // page up
      *scrollDirection = ScrollUp;
      *scrollGranularity = ScrollByPage;
      break;
    case VKEY_NEXT:  // page down
      *scrollDirection = ScrollDown;
      *scrollGranularity = ScrollByPage;
      break;
    default:
      return false;
  }

  return true;
}

PagePopup* WebViewImpl::openPagePopup(PagePopupClient* client) {
  DCHECK(client);
  if (hasOpenedPopup())
    hidePopups();
  DCHECK(!m_pagePopup);

  WebWidget* popupWidget = m_client->createPopupMenu(WebPopupTypePage);
  // createPopupMenu returns nullptr if this renderer process is about to die.
  if (!popupWidget)
    return nullptr;
  m_pagePopup = toWebPagePopupImpl(popupWidget);
  if (!m_pagePopup->initialize(this, client)) {
    m_pagePopup->closePopup();
    m_pagePopup = nullptr;
  }
  enablePopupMouseWheelEventListener();
  return m_pagePopup.get();
}

void WebViewImpl::closePagePopup(PagePopup* popup) {
  DCHECK(popup);
  WebPagePopupImpl* popupImpl = toWebPagePopupImpl(popup);
  DCHECK_EQ(m_pagePopup.get(), popupImpl);
  if (m_pagePopup.get() != popupImpl)
    return;
  m_pagePopup->closePopup();
}

void WebViewImpl::cleanupPagePopup() {
  m_pagePopup = nullptr;
  disablePopupMouseWheelEventListener();
}

void WebViewImpl::cancelPagePopup() {
  if (m_pagePopup)
    m_pagePopup->cancel();
}

void WebViewImpl::enablePopupMouseWheelEventListener() {
  // TODO(kenrb): Popup coordination for out-of-process iframes needs to be
  // added. Because of the early return here a select element
  // popup can remain visible even when the element underneath it is
  // scrolled to a new position. This is part of a larger set of issues with
  // popups.
  // See https://crbug.com/566130
  if (!mainFrameImpl())
    return;
  DCHECK(!m_popupMouseWheelEventListener);
  Document* document = mainFrameImpl()->frame()->document();
  DCHECK(document);
  // We register an empty event listener, EmptyEventListener, so that mouse
  // wheel events get sent to the WebView.
  m_popupMouseWheelEventListener = EmptyEventListener::create();
  document->addEventListener(EventTypeNames::mousewheel,
                             m_popupMouseWheelEventListener, false);
}

void WebViewImpl::disablePopupMouseWheelEventListener() {
  // TODO(kenrb): Concerns the same as in enablePopupMouseWheelEventListener.
  // See https://crbug.com/566130
  if (!mainFrameImpl())
    return;
  DCHECK(m_popupMouseWheelEventListener);
  Document* document = mainFrameImpl()->frame()->document();
  DCHECK(document);
  // Document may have already removed the event listener, for instance, due
  // to a navigation, but remove it anyway.
  document->removeEventListener(EventTypeNames::mousewheel,
                                m_popupMouseWheelEventListener.release(),
                                false);
}

LocalDOMWindow* WebViewImpl::pagePopupWindow() const {
  return m_pagePopup ? m_pagePopup->window() : nullptr;
}

Frame* WebViewImpl::focusedCoreFrame() const {
  return m_page ? m_page->focusController().focusedOrMainFrame() : nullptr;
}

WebViewImpl* WebViewImpl::fromPage(Page* page) {
  return page ? static_cast<WebViewImpl*>(page->chromeClient().webView())
              : nullptr;
}

// WebWidget ------------------------------------------------------------------

void WebViewImpl::close() {
  WebDevToolsAgentImpl::webViewImplClosed(this);
  DCHECK(allInstances().contains(this));
  allInstances().remove(this);

  if (m_page) {
    // Initiate shutdown for the entire frameset.  This will cause a lot of
    // notifications to be sent.
    m_page->willBeDestroyed();
    m_page.clear();
  }

  // Reset the delegate to prevent notifications being sent as we're being
  // deleted.
  m_client = nullptr;

  deref();  // Balances ref() acquired in WebView::create
}

WebSize WebViewImpl::size() {
  return m_size;
}

void WebViewImpl::resizeVisualViewport(const WebSize& newSize) {
  page()->frameHost().visualViewport().setSize(newSize);
  page()->frameHost().visualViewport().clampToBoundaries();
}

void WebViewImpl::performResize() {
  // We'll keep the initial containing block size from changing when the top
  // controls hide so that the ICB will always be the same size as the
  // viewport with the top controls shown.
  IntSize ICBSize = m_size;
  if (RuntimeEnabledFeatures::inertTopControlsEnabled() &&
      !topControls().shrinkViewport())
    ICBSize.expand(0, -topControls().height());

  pageScaleConstraintsSet().didChangeInitialContainingBlockSize(ICBSize);

  updatePageDefinedViewportConstraints(
      mainFrameImpl()->frame()->document()->viewportDescription());
  updateMainFrameLayoutSize();

  page()->frameHost().visualViewport().setSize(m_size);

  if (mainFrameImpl()->frameView()) {
    if (!mainFrameImpl()->frameView()->needsLayout())
      postLayoutResize(mainFrameImpl());
  }
}

void WebViewImpl::updateTopControlsState(WebTopControlsState constraint,
                                         WebTopControlsState current,
                                         bool animate) {
  topControls().updateConstraintsAndState(constraint, current, animate);

  if (m_layerTreeView)
    m_layerTreeView->updateTopControlsState(constraint, current, animate);
}

void WebViewImpl::didUpdateTopControls() {
  if (m_layerTreeView) {
    m_layerTreeView->setTopControlsShownRatio(topControls().shownRatio());
    m_layerTreeView->setTopControlsHeight(topControls().height(),
                                          topControls().shrinkViewport());
  }

  WebLocalFrameImpl* mainFrame = mainFrameImpl();
  if (!mainFrame)
    return;

  FrameView* view = mainFrame->frameView();
  if (!view)
    return;

  VisualViewport& visualViewport = page()->frameHost().visualViewport();

  {
    // This object will save the current visual viewport offset w.r.t. the
    // document and restore it when the object goes out of scope. It's
    // needed since the top controls adjustment will change the maximum
    // scroll offset and we may need to reposition them to keep the user's
    // apparent position unchanged.
    ResizeViewportAnchor::ResizeScope resizeScope(*m_resizeViewportAnchor);

    float topControlsViewportAdjustment =
        topControls().layoutHeight() - topControls().contentOffset();
    visualViewport.setTopControlsAdjustment(topControlsViewportAdjustment);

    // Since the FrameView is sized to be the visual viewport at minimum
    // scale, its adjustment must also be scaled by the minimum scale.
    view->setTopControlsViewportAdjustment(topControlsViewportAdjustment /
                                           minimumPageScaleFactor());
  }
}

TopControls& WebViewImpl::topControls() {
  return page()->frameHost().topControls();
}

void WebViewImpl::resizeViewWhileAnchored(FrameView* view,
                                          float topControlsHeight,
                                          bool topControlsShrinkLayout) {
  DCHECK(mainFrameImpl());

  topControls().setHeight(topControlsHeight, topControlsShrinkLayout);

  {
    // Avoids unnecessary invalidations while various bits of state in
    // TextAutosizer are updated.
    TextAutosizer::DeferUpdatePageInfo deferUpdatePageInfo(page());
    performResize();
  }

  m_fullscreenController->updateSize();

  // Update lifecyle phases immediately to recalculate the minimum scale limit
  // for rotation anchoring, and to make sure that no lifecycle states are
  // stale if this WebView is embedded in another one.
  updateAllLifecyclePhases();
}

void WebViewImpl::resizeWithTopControls(const WebSize& newSize,
                                        float topControlsHeight,
                                        bool topControlsShrinkLayout) {
  if (m_shouldAutoResize)
    return;

  if (m_size == newSize && topControls().height() == topControlsHeight &&
      topControls().shrinkViewport() == topControlsShrinkLayout)
    return;

  if (page()->mainFrame() && !page()->mainFrame()->isLocalFrame()) {
    // Viewport resize for a remote main frame does not require any
    // particular action, but the state needs to reflect the correct size
    // so that it can be used for initalization if the main frame gets
    // swapped to a LocalFrame at a later time.
    m_size = newSize;
    pageScaleConstraintsSet().didChangeInitialContainingBlockSize(m_size);
    page()->frameHost().visualViewport().setSize(m_size);
    return;
  }

  WebLocalFrameImpl* mainFrame = mainFrameImpl();
  if (!mainFrame)
    return;

  FrameView* view = mainFrame->frameView();
  if (!view)
    return;

  VisualViewport& visualViewport = page()->frameHost().visualViewport();

  bool isRotation =
      page()->settings().mainFrameResizesAreOrientationChanges() &&
      m_size.width && contentsSize().width() && newSize.width != m_size.width &&
      !m_fullscreenController->isFullscreen();
  m_size = newSize;

  FloatSize viewportAnchorCoords(viewportAnchorCoordX, viewportAnchorCoordY);
  if (isRotation) {
    RotationViewportAnchor anchor(*view, visualViewport, viewportAnchorCoords,
                                  pageScaleConstraintsSet());
    resizeViewWhileAnchored(view, topControlsHeight, topControlsShrinkLayout);
  } else {
    ResizeViewportAnchor::ResizeScope resizeScope(*m_resizeViewportAnchor);
    resizeViewWhileAnchored(view, topControlsHeight, topControlsShrinkLayout);
  }
  sendResizeEventAndRepaint();
}

void WebViewImpl::resize(const WebSize& newSize) {
  if (m_shouldAutoResize || m_size == newSize)
    return;

  resizeWithTopControls(newSize, topControls().height(),
                        topControls().shrinkViewport());
}

void WebViewImpl::didEnterFullscreen() {
  m_fullscreenController->didEnterFullscreen();
}

void WebViewImpl::didExitFullscreen() {
  m_fullscreenController->didExitFullscreen();
}

void WebViewImpl::didUpdateFullscreenSize() {
  m_fullscreenController->updateSize();
}

void WebViewImpl::beginFrame(double lastFrameTimeMonotonic) {
  TRACE_EVENT1("blink", "WebViewImpl::beginFrame", "frameTime",
               lastFrameTimeMonotonic);
  DCHECK(lastFrameTimeMonotonic);

  // Create synthetic wheel events as necessary for fling.
  if (m_gestureAnimation) {
    if (m_gestureAnimation->animate(lastFrameTimeMonotonic))
      mainFrameImpl()->frameWidget()->scheduleAnimation();
    else {
      DCHECK_NE(m_flingSourceDevice, WebGestureDeviceUninitialized);
      WebGestureDevice lastFlingSourceDevice = m_flingSourceDevice;
      endActiveFlingAnimation();

      PlatformGestureEvent endScrollEvent(
          PlatformEvent::GestureScrollEnd, m_positionOnFlingStart,
          m_globalPositionOnFlingStart, IntSize(), 0,
          PlatformEvent::NoModifiers,
          lastFlingSourceDevice == WebGestureDeviceTouchpad
              ? PlatformGestureSourceTouchpad
              : PlatformGestureSourceTouchscreen);
      endScrollEvent.setScrollGestureData(0, 0, ScrollByPrecisePixel, 0, 0,
                                          ScrollInertialPhaseMomentum, false,
                                          -1 /* null plugin id */);

      mainFrameImpl()->frame()->eventHandler().handleGestureScrollEnd(
          endScrollEvent);
    }
  }

  if (!mainFrameImpl())
    return;

  m_lastFrameTimeMonotonic = lastFrameTimeMonotonic;

  DocumentLifecycle::AllowThrottlingScope throttlingScope(
      mainFrameImpl()->frame()->document()->lifecycle());
  PageWidgetDelegate::animate(*m_page, lastFrameTimeMonotonic);
}

void WebViewImpl::updateAllLifecyclePhases() {
  TRACE_EVENT0("blink", "WebViewImpl::updateAllLifecyclePhases");
  if (!mainFrameImpl())
    return;

  DocumentLifecycle::AllowThrottlingScope throttlingScope(
      mainFrameImpl()->frame()->document()->lifecycle());
  updateLayerTreeBackgroundColor();

  PageWidgetDelegate::updateAllLifecyclePhases(*m_page,
                                               *mainFrameImpl()->frame());

  if (InspectorOverlay* overlay = inspectorOverlay()) {
    overlay->updateAllLifecyclePhases();
    // TODO(chrishtr): integrate paint into the overlay's lifecycle.
    if (overlay->pageOverlay() && overlay->pageOverlay()->graphicsLayer())
      overlay->pageOverlay()->graphicsLayer()->paint(nullptr);
  }
  if (m_pageColorOverlay)
    m_pageColorOverlay->graphicsLayer()->paint(nullptr);

  // TODO(chrishtr): link highlights don't currently paint themselves, it's
  // still driven by cc.  Fix this.
  for (size_t i = 0; i < m_linkHighlights.size(); ++i)
    m_linkHighlights[i]->updateGeometry();

  if (FrameView* view = mainFrameImpl()->frameView()) {
    LocalFrame* frame = mainFrameImpl()->frame();
    WebWidgetClient* client =
        WebLocalFrameImpl::fromFrame(frame)->frameWidget()->client();

    if (m_shouldDispatchFirstVisuallyNonEmptyLayout &&
        view->isVisuallyNonEmpty()) {
      m_shouldDispatchFirstVisuallyNonEmptyLayout = false;
      // TODO(esprehn): Move users of this callback to something
      // better, the heuristic for "visually non-empty" is bad.
      client->didMeaningfulLayout(WebMeaningfulLayout::VisuallyNonEmpty);
    }

    if (m_shouldDispatchFirstLayoutAfterFinishedParsing &&
        frame->document()->hasFinishedParsing()) {
      m_shouldDispatchFirstLayoutAfterFinishedParsing = false;
      client->didMeaningfulLayout(WebMeaningfulLayout::FinishedParsing);
    }

    if (m_shouldDispatchFirstLayoutAfterFinishedLoading &&
        frame->document()->isLoadCompleted()) {
      m_shouldDispatchFirstLayoutAfterFinishedLoading = false;
      client->didMeaningfulLayout(WebMeaningfulLayout::FinishedLoading);
    }
  }
}

void WebViewImpl::paint(WebCanvas* canvas, const WebRect& rect) {
  // This should only be used when compositing is not being used for this
  // WebView, and it is painting into the recording of its parent.
  DCHECK(!isAcceleratedCompositingActive());

  double paintStart = currentTime();
  PageWidgetDelegate::paint(*m_page, canvas, rect,
                            *m_page->deprecatedLocalMainFrame());
  double paintEnd = currentTime();
  double pixelsPerSec = (rect.width * rect.height) / (paintEnd - paintStart);
  DEFINE_STATIC_LOCAL(CustomCountHistogram, softwarePaintDurationHistogram,
                      ("Renderer4.SoftwarePaintDurationMS", 0, 120, 30));
  softwarePaintDurationHistogram.count((paintEnd - paintStart) * 1000);
  DEFINE_STATIC_LOCAL(CustomCountHistogram, softwarePaintRateHistogram,
                      ("Renderer4.SoftwarePaintMegapixPerSecond", 10, 210, 30));
  softwarePaintRateHistogram.count(pixelsPerSec / 1000000);
}

#if OS(ANDROID)
void WebViewImpl::paintIgnoringCompositing(WebCanvas* canvas,
                                           const WebRect& rect) {
  // This is called on a composited WebViewImpl, but we will ignore it,
  // producing all possible content of the WebViewImpl into the WebCanvas.
  DCHECK(isAcceleratedCompositingActive());
  PageWidgetDelegate::paintIgnoringCompositing(
      *m_page, canvas, rect, *m_page->deprecatedLocalMainFrame());
}
#endif

void WebViewImpl::layoutAndPaintAsync(
    WebLayoutAndPaintAsyncCallback* callback) {
  m_layerTreeView->layoutAndPaintAsync(callback);
}

void WebViewImpl::compositeAndReadbackAsync(
    WebCompositeAndReadbackAsyncCallback* callback) {
  m_layerTreeView->compositeAndReadbackAsync(callback);
}

void WebViewImpl::themeChanged() {
  if (!page())
    return;
  if (!page()->mainFrame()->isLocalFrame())
    return;
  FrameView* view = page()->deprecatedLocalMainFrame()->view();

  WebRect damagedRect(0, 0, m_size.width, m_size.height);
  view->invalidateRect(damagedRect);
}

void WebViewImpl::enterFullscreenForElement(Element* element) {
  m_fullscreenController->enterFullscreenForElement(element);
}

void WebViewImpl::exitFullscreenForElement(Element* element) {
  m_fullscreenController->exitFullscreenForElement(element);
}

bool WebViewImpl::hasHorizontalScrollbar() {
  return mainFrameImpl()->frameView()->horizontalScrollbar();
}

bool WebViewImpl::hasVerticalScrollbar() {
  return mainFrameImpl()->frameView()->verticalScrollbar();
}

const WebInputEvent* WebViewImpl::m_currentInputEvent = nullptr;

WebInputEventResult WebViewImpl::handleInputEvent(
    const WebInputEvent& inputEvent) {
  // TODO(dcheng): The fact that this is getting called when there is no local
  // main frame is problematic and probably indicates a bug in the input event
  // routing code.
  if (!mainFrameImpl())
    return WebInputEventResult::NotHandled;

  WebAutofillClient* autofillClient = mainFrameImpl()->autofillClient();
  UserGestureNotifier notifier(autofillClient, &m_userGestureObserved);
  // On the first input event since page load, |notifier| instructs the
  // autofill client to unblock values of password input fields of any forms
  // on the page. There is a single input event, GestureTap, which can both
  // be the first event after page load, and cause a form submission. In that
  // case, the form submission happens before the autofill client is told
  // to unblock the password values, and so the password values are not
  // submitted. To avoid that, GestureTap is handled explicitly:
  if (inputEvent.type == WebInputEvent::GestureTap && autofillClient) {
    m_userGestureObserved = true;
    autofillClient->firstUserGestureObserved();
  }

  page()->frameHost().visualViewport().startTrackingPinchStats();

  TRACE_EVENT1("input,rail", "WebViewImpl::handleInputEvent", "type",
               WebInputEvent::GetName(inputEvent.type));
  // If we've started a drag and drop operation, ignore input events until
  // we're done.
  if (m_doingDragAndDrop)
    return WebInputEventResult::HandledSuppressed;

  if (m_devToolsEmulator->handleInputEvent(inputEvent))
    return WebInputEventResult::HandledSuppressed;

  if (InspectorOverlay* overlay = inspectorOverlay()) {
    if (overlay->handleInputEvent(inputEvent))
      return WebInputEventResult::HandledSuppressed;
  }

  // Report the event to be NOT processed by WebKit, so that the browser can
  // handle it appropriately.
  if (m_ignoreInputEvents)
    return WebInputEventResult::NotHandled;

  AutoReset<const WebInputEvent*> currentEventChange(&m_currentInputEvent,
                                                     &inputEvent);
  UIEventWithKeyState::clearNewTabModifierSetFromIsolatedWorld();

  bool isPointerLocked = false;
  if (WebFrameWidgetBase* widget = mainFrameImpl()->frameWidget()) {
    if (WebWidgetClient* client = widget->client())
      isPointerLocked = client->isPointerLocked();
  }

  if (isPointerLocked && WebInputEvent::isMouseEventType(inputEvent.type)) {
    pointerLockMouseEvent(inputEvent);
    return WebInputEventResult::HandledSystem;
  }

  if (m_mouseCaptureNode && WebInputEvent::isMouseEventType(inputEvent.type)) {
    TRACE_EVENT1("input", "captured mouse event", "type", inputEvent.type);
    // Save m_mouseCaptureNode since mouseCaptureLost() will clear it.
    Node* node = m_mouseCaptureNode;

    // Not all platforms call mouseCaptureLost() directly.
    if (inputEvent.type == WebInputEvent::MouseUp)
      mouseCaptureLost();

    std::unique_ptr<UserGestureIndicator> gestureIndicator;

    AtomicString eventType;
    switch (inputEvent.type) {
      case WebInputEvent::MouseMove:
        eventType = EventTypeNames::mousemove;
        break;
      case WebInputEvent::MouseLeave:
        eventType = EventTypeNames::mouseout;
        break;
      case WebInputEvent::MouseDown:
        eventType = EventTypeNames::mousedown;
        gestureIndicator = wrapUnique(
            new UserGestureIndicator(DefinitelyProcessingNewUserGesture));
        m_mouseCaptureGestureToken = gestureIndicator->currentToken();
        break;
      case WebInputEvent::MouseUp:
        eventType = EventTypeNames::mouseup;
        gestureIndicator = wrapUnique(
            new UserGestureIndicator(m_mouseCaptureGestureToken.release()));
        break;
      default:
        NOTREACHED();
    }

    node->dispatchMouseEvent(
        PlatformMouseEventBuilder(
            mainFrameImpl()->frameView(),
            static_cast<const WebMouseEvent&>(inputEvent)),
        eventType, static_cast<const WebMouseEvent&>(inputEvent).clickCount);
    return WebInputEventResult::HandledSystem;
  }

  // FIXME: This should take in the intended frame, not the local frame root.
  WebInputEventResult result = PageWidgetDelegate::handleInputEvent(
      *this, inputEvent, mainFrameImpl()->frame());
  if (result != WebInputEventResult::NotHandled)
    return result;

  // Unhandled pinch events should adjust the scale.
  if (inputEvent.type == WebInputEvent::GesturePinchUpdate) {
    const WebGestureEvent& pinchEvent =
        static_cast<const WebGestureEvent&>(inputEvent);

    // For touchpad gestures synthesize a Windows-like wheel event
    // to send to any handlers that may exist. Not necessary for touchscreen
    // as touch events would have already been sent for the gesture.
    if (pinchEvent.sourceDevice == WebGestureDeviceTouchpad) {
      result = handleSyntheticWheelFromTouchpadPinchEvent(pinchEvent);
      if (result != WebInputEventResult::NotHandled)
        return result;
    }

    if (pinchEvent.data.pinchUpdate.zoomDisabled)
      return WebInputEventResult::NotHandled;

    if (page()->frameHost().visualViewport().magnifyScaleAroundAnchor(
            pinchEvent.data.pinchUpdate.scale,
            FloatPoint(pinchEvent.x, pinchEvent.y)))
      return WebInputEventResult::HandledSystem;
  }

  return WebInputEventResult::NotHandled;
}

void WebViewImpl::setCursorVisibilityState(bool isVisible) {
  if (m_page)
    m_page->setIsCursorVisible(isVisible);
}

void WebViewImpl::mouseCaptureLost() {
  TRACE_EVENT_ASYNC_END0("input", "capturing mouse", this);
  m_mouseCaptureNode = nullptr;
}

void WebViewImpl::setFocus(bool enable) {
  m_page->focusController().setFocused(enable);
  if (enable) {
    m_page->focusController().setActive(true);
    LocalFrame* focusedFrame = m_page->focusController().focusedFrame();
    if (focusedFrame) {
      Element* element = focusedFrame->document()->focusedElement();
      if (element && focusedFrame->selection().selection().isNone()) {
        // If the selection was cleared while the WebView was not
        // focused, then the focus element shows with a focus ring but
        // no caret and does respond to keyboard inputs.
        focusedFrame->document()->updateStyleAndLayoutTree();
        if (element->isTextFormControl()) {
          element->updateFocusAppearance(SelectionBehaviorOnFocus::Restore);
        } else if (hasEditableStyle(*element)) {
          // updateFocusAppearance() selects all the text of
          // contentseditable DIVs. So we set the selection explicitly
          // instead. Note that this has the side effect of moving the
          // caret back to the beginning of the text.
          Position position(element, 0);
          focusedFrame->selection().setSelection(
              createVisibleSelection(position, SelDefaultAffinity));
        }
      }
    }
    m_imeAcceptEvents = true;
  } else {
    hidePopups();

    // Clear focus on the currently focused frame if any.
    if (!m_page)
      return;

    LocalFrame* frame =
        m_page->mainFrame() && m_page->mainFrame()->isLocalFrame()
            ? m_page->deprecatedLocalMainFrame()
            : nullptr;
    if (!frame)
      return;

    LocalFrame* focusedFrame = focusedLocalFrameInWidget();
    if (focusedFrame) {
      // Finish an ongoing composition to delete the composition node.
      if (focusedFrame->inputMethodController().hasComposition()) {
        WebAutofillClient* autofillClient =
            WebLocalFrameImpl::fromFrame(focusedFrame)->autofillClient();

        if (autofillClient)
          autofillClient->setIgnoreTextChanges(true);

        // TODO(xiaochengh): The use of
        // updateStyleAndLayoutIgnorePendingStylesheets
        // needs to be audited.  See http://crbug.com/590369 for more details.
        focusedFrame->document()
            ->updateStyleAndLayoutIgnorePendingStylesheets();

        focusedFrame->inputMethodController().finishComposingText(
            InputMethodController::KeepSelection);

        if (autofillClient)
          autofillClient->setIgnoreTextChanges(false);
      }
      m_imeAcceptEvents = false;
    }
  }
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
bool WebViewImpl::setComposition(
    const WebString& text,
    const WebVector<WebCompositionUnderline>& underlines,
    int selectionStart,
    int selectionEnd) {
  LocalFrame* focused = focusedLocalFrameAvailableForIme();
  if (!focused)
    return false;

  if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused))
    return plugin->setComposition(text, underlines, selectionStart,
                                  selectionEnd);

  // The input focus has been moved to another WebWidget object.
  // We should use this |editor| object only to complete the ongoing
  // composition.
  InputMethodController& inputMethodController =
      focused->inputMethodController();
  if (!focused->editor().canEdit() && !inputMethodController.hasComposition())
    return false;

  // We should verify the parent node of this IME composition node are
  // editable because JavaScript may delete a parent node of the composition
  // node. In this case, WebKit crashes while deleting texts from the parent
  // node, which doesn't exist any longer.
  const EphemeralRange range =
      inputMethodController.compositionEphemeralRange();
  if (range.isNotNull()) {
    Node* node = range.startPosition().computeContainerNode();
    focused->document()->updateStyleAndLayoutTree();
    if (!node || !hasEditableStyle(*node))
      return false;
  }

  // A keypress event is canceled. If an ongoing composition exists, then the
  // keydown event should have arisen from a handled key (e.g., backspace).
  // In this case we ignore the cancellation and continue; otherwise (no
  // ongoing composition) we exit and signal success only for attempts to
  // clear the composition.
  if (m_suppressNextKeypressEvent && !inputMethodController.hasComposition())
    return text.isEmpty();

  UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);

  // When the range of composition underlines overlap with the range between
  // selectionStart and selectionEnd, WebKit somehow won't paint the selection
  // at all (see InlineTextBox::paint() function in InlineTextBox.cpp).
  // But the selection range actually takes effect.
  inputMethodController.setComposition(
      String(text), CompositionUnderlineVectorBuilder(underlines),
      selectionStart, selectionEnd);

  return text.isEmpty() || inputMethodController.hasComposition();
}

// TODO(ekaramad):These methods are almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
bool WebViewImpl::finishComposingText(
    ConfirmCompositionBehavior selectionBehavior) {
  LocalFrame* focused = focusedLocalFrameAvailableForIme();
  if (!focused)
    return false;

  if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused))
    return plugin->finishComposingText(selectionBehavior);

  return focused->inputMethodController().finishComposingText(
      selectionBehavior == KeepSelection
          ? InputMethodController::KeepSelection
          : InputMethodController::DoNotKeepSelection);
}

bool WebViewImpl::commitText(const WebString& text, int relativeCaretPosition) {
  UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);

  LocalFrame* focused = focusedLocalFrameAvailableForIme();
  if (!focused)
    return false;

  if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused))
    return plugin->commitText(text, relativeCaretPosition);

  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
  // needs to be audited.  See http://crbug.com/590369 for more details.
  focused->document()->updateStyleAndLayoutIgnorePendingStylesheets();

  return focused->inputMethodController().commitText(text,
                                                     relativeCaretPosition);
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
WebRange WebViewImpl::compositionRange() {
  LocalFrame* focused = focusedLocalFrameAvailableForIme();
  if (!focused)
    return WebRange();

  const EphemeralRange range =
      focused->inputMethodController().compositionEphemeralRange();
  if (range.isNull())
    return WebRange();

  Element* editable =
      focused->selection().rootEditableElementOrDocumentElement();
  DCHECK(editable);

  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
  // needs to be audited.  See http://crbug.com/590369 for more details.
  editable->document().updateStyleAndLayoutIgnorePendingStylesheets();

  return PlainTextRange::create(*editable, range);
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
WebTextInputInfo WebViewImpl::textInputInfo() {
  WebTextInputInfo info;

  LocalFrame* focused = focusedLocalFrameInWidget();
  if (!focused)
    return info;

  FrameSelection& selection = focused->selection();
  if (!selection.isAvailable()) {
    // plugins/mouse-capture-inside-shadow.html reaches here.
    return info;
  }
  Element* element = selection.selection().rootEditableElement();
  if (!element)
    return info;

  info.inputMode = inputModeOfFocusedElement();

  info.type = textInputType();
  info.flags = textInputFlags();
  if (info.type == WebTextInputTypeNone)
    return info;

  if (!focused->editor().canEdit())
    return info;

  // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets
  // needs to be audited.  see http://crbug.com/590369 for more details.
  focused->document()->updateStyleAndLayoutIgnorePendingStylesheets();

  DocumentLifecycle::DisallowTransitionScope disallowTransition(
      focused->document()->lifecycle());

  // Emits an object replacement character for each replaced element so that
  // it is exposed to IME and thus could be deleted by IME on android.
  info.value = plainText(EphemeralRange::rangeOfContents(*element),
                         TextIteratorEmitsObjectReplacementCharacter);

  if (info.value.isEmpty())
    return info;

  EphemeralRange firstRange = firstEphemeralRangeOf(selection.selection());
  if (firstRange.isNotNull()) {
    PlainTextRange plainTextRange(PlainTextRange::create(*element, firstRange));
    if (plainTextRange.isNotNull()) {
      info.selectionStart = plainTextRange.start();
      info.selectionEnd = plainTextRange.end();
    }
  }

  EphemeralRange range =
      focused->inputMethodController().compositionEphemeralRange();
  if (range.isNotNull()) {
    PlainTextRange plainTextRange(PlainTextRange::create(*element, range));
    if (plainTextRange.isNotNull()) {
      info.compositionStart = plainTextRange.start();
      info.compositionEnd = plainTextRange.end();
    }
  }

  return info;
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
WebTextInputType WebViewImpl::textInputType() {
  LocalFrame* focusedFrame = focusedLocalFrameInWidget();
  if (!focusedFrame)
    return WebTextInputTypeNone;

  if (!focusedFrame->selection().isAvailable()) {
    // "mouse-capture-inside-shadow.html" reaches here.
    return WebTextInputTypeNone;
  }

  // It's important to preserve the equivalence of textInputInfo().type and
  // textInputType(), so perform the same rootEditableElement() existence check
  // here for consistency.
  if (!focusedFrame->selection().selection().rootEditableElement())
    return WebTextInputTypeNone;

  Document* document = focusedFrame->document();
  if (!document)
    return WebTextInputTypeNone;

  Element* element = document->focusedElement();
  if (!element)
    return WebTextInputTypeNone;

  if (isHTMLInputElement(*element)) {
    HTMLInputElement& input = toHTMLInputElement(*element);
    const AtomicString& type = input.type();

    if (input.isDisabledOrReadOnly())
      return WebTextInputTypeNone;

    if (type == InputTypeNames::password)
      return WebTextInputTypePassword;
    if (type == InputTypeNames::search)
      return WebTextInputTypeSearch;
    if (type == InputTypeNames::email)
      return WebTextInputTypeEmail;
    if (type == InputTypeNames::number)
      return WebTextInputTypeNumber;
    if (type == InputTypeNames::tel)
      return WebTextInputTypeTelephone;
    if (type == InputTypeNames::url)
      return WebTextInputTypeURL;
    if (type == InputTypeNames::text)
      return WebTextInputTypeText;

    return WebTextInputTypeNone;
  }

  if (isHTMLTextAreaElement(*element)) {
    if (toHTMLTextAreaElement(*element).isDisabledOrReadOnly())
      return WebTextInputTypeNone;
    return WebTextInputTypeTextArea;
  }

  if (element->isHTMLElement()) {
    if (toHTMLElement(element)->isDateTimeFieldElement())
      return WebTextInputTypeDateTimeField;
  }

  document->updateStyleAndLayoutTree();
  if (hasEditableStyle(*element))
    return WebTextInputTypeContentEditable;

  return WebTextInputTypeNone;
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
int WebViewImpl::textInputFlags() {
  Element* element = focusedElement();
  if (!element)
    return WebTextInputFlagNone;

  DEFINE_STATIC_LOCAL(AtomicString, autocompleteString, ("autocomplete"));
  DEFINE_STATIC_LOCAL(AtomicString, autocorrectString, ("autocorrect"));
  int flags = 0;

  const AtomicString& autocomplete = element->getAttribute(autocompleteString);
  if (autocomplete == "on")
    flags |= WebTextInputFlagAutocompleteOn;
  else if (autocomplete == "off")
    flags |= WebTextInputFlagAutocompleteOff;

  const AtomicString& autocorrect = element->getAttribute(autocorrectString);
  if (autocorrect == "on")
    flags |= WebTextInputFlagAutocorrectOn;
  else if (autocorrect == "off")
    flags |= WebTextInputFlagAutocorrectOff;

  SpellcheckAttributeState spellcheck = element->spellcheckAttributeState();
  if (spellcheck == SpellcheckAttributeTrue)
    flags |= WebTextInputFlagSpellcheckOn;
  else if (spellcheck == SpellcheckAttributeFalse)
    flags |= WebTextInputFlagSpellcheckOff;

  if (isHTMLTextFormControlElement(element)) {
    HTMLTextFormControlElement* formElement =
        static_cast<HTMLTextFormControlElement*>(element);
    if (formElement->supportsAutocapitalize()) {
      DEFINE_STATIC_LOCAL(const AtomicString, none, ("none"));
      DEFINE_STATIC_LOCAL(const AtomicString, characters, ("characters"));
      DEFINE_STATIC_LOCAL(const AtomicString, words, ("words"));
      DEFINE_STATIC_LOCAL(const AtomicString, sentences, ("sentences"));

      const AtomicString& autocapitalize = formElement->autocapitalize();
      if (autocapitalize == none)
        flags |= WebTextInputFlagAutocapitalizeNone;
      else if (autocapitalize == characters)
        flags |= WebTextInputFlagAutocapitalizeCharacters;
      else if (autocapitalize == words)
        flags |= WebTextInputFlagAutocapitalizeWords;
      else if (autocapitalize == sentences)
        flags |= WebTextInputFlagAutocapitalizeSentences;
      else
        NOTREACHED();
    }
  }

  return flags;
}

WebString WebViewImpl::inputModeOfFocusedElement() {
  if (!RuntimeEnabledFeatures::inputModeAttributeEnabled())
    return WebString();

  Element* element = focusedElement();
  if (!element)
    return WebString();

  if (isHTMLInputElement(*element)) {
    const HTMLInputElement& input = toHTMLInputElement(*element);
    if (input.supportsInputModeAttribute())
      return input.fastGetAttribute(HTMLNames::inputmodeAttr).lower();
    return WebString();
  }
  if (isHTMLTextAreaElement(*element)) {
    const HTMLTextAreaElement& textarea = toHTMLTextAreaElement(*element);
    return textarea.fastGetAttribute(HTMLNames::inputmodeAttr).lower();
  }

  return WebString();
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
bool WebViewImpl::selectionBounds(WebRect& anchor, WebRect& focus) const {
  const Frame* frame = focusedCoreFrame();
  if (!frame || !frame->isLocalFrame())
    return false;

  const LocalFrame* localFrame = toLocalFrame(frame);
  if (!localFrame)
    return false;
  FrameSelection& selection = localFrame->selection();
  if (!selection.isAvailable() || selection.isNone()) {
    // plugins/mouse-capture-inside-shadow.html reaches here.
    return false;
  }

  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
  // needs to be audited.  See http://crbug.com/590369 for more details.
  localFrame->document()->updateStyleAndLayoutIgnorePendingStylesheets();

  DocumentLifecycle::DisallowTransitionScope disallowTransition(
      localFrame->document()->lifecycle());

  if (selection.isCaret()) {
    anchor = focus = selection.absoluteCaretBounds();
  } else {
    const EphemeralRange selectedRange =
        selection.selection().toNormalizedEphemeralRange();
    if (selectedRange.isNull())
      return false;
    anchor = localFrame->editor().firstRectForRange(
        EphemeralRange(selectedRange.startPosition()));
    focus = localFrame->editor().firstRectForRange(
        EphemeralRange(selectedRange.endPosition()));
  }

  anchor = localFrame->view()->contentsToViewport(anchor);
  focus = localFrame->view()->contentsToViewport(focus);

  if (!selection.selection().isBaseFirst())
    std::swap(anchor, focus);
  return true;
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
WebPlugin* WebViewImpl::focusedPluginIfInputMethodSupported(LocalFrame* frame) {
  WebPluginContainerImpl* container =
      WebLocalFrameImpl::currentPluginContainer(frame);
  if (container && container->supportsInputMethod())
    return container->plugin();
  return nullptr;
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
bool WebViewImpl::selectionTextDirection(WebTextDirection& start,
                                         WebTextDirection& end) const {
  const LocalFrame* frame = focusedLocalFrameInWidget();
  if (!frame)
    return false;

  const FrameSelection& selection = frame->selection();
  if (!selection.isAvailable()) {
    // plugins/mouse-capture-inside-shadow.html reaches here.
    return false;
  }
  if (selection.selection().toNormalizedEphemeralRange().isNull())
    return false;
  start =
      toWebTextDirection(primaryDirectionOf(*selection.start().anchorNode()));
  end = toWebTextDirection(primaryDirectionOf(*selection.end().anchorNode()));
  return true;
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
bool WebViewImpl::isSelectionAnchorFirst() const {
  const LocalFrame* frame = focusedLocalFrameInWidget();
  if (!frame)
    return false;

  FrameSelection& selection = frame->selection();
  if (!selection.isAvailable()) {
    // plugins/mouse-capture-inside-shadow.html reaches here.
    return false;
  }
  return selection.selection().isBaseFirst();
}

WebColor WebViewImpl::backgroundColor() const {
  if (isTransparent())
    return Color::transparent;
  if (!m_page)
    return m_baseBackgroundColor;
  if (!m_page->mainFrame())
    return m_baseBackgroundColor;
  if (!m_page->mainFrame()->isLocalFrame())
    return m_baseBackgroundColor;
  FrameView* view = m_page->deprecatedLocalMainFrame()->view();
  return view->documentBackgroundColor().rgb();
}

WebPagePopup* WebViewImpl::pagePopup() const {
  return m_pagePopup.get();
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
WebRange WebViewImpl::caretOrSelectionRange() {
  const LocalFrame* focused = focusedLocalFrameInWidget();
  if (!focused)
    return WebRange();

  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
  // needs to be audited.  See http://crbug.com/590369 for more details.
  focused->document()->updateStyleAndLayoutIgnorePendingStylesheets();

  return focused->inputMethodController().getSelectionOffsets();
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
void WebViewImpl::setTextDirection(WebTextDirection direction) {
  // The Editor::setBaseWritingDirection() function checks if we can change
  // the text direction of the selected node and updates its DOM "dir"
  // attribute and its CSS "direction" property.
  // So, we just call the function as Safari does.
  const LocalFrame* focused = focusedLocalFrameInWidget();
  if (!focused)
    return;

  Editor& editor = focused->editor();
  if (!editor.canEdit())
    return;

  switch (direction) {
    case WebTextDirectionDefault:
      editor.setBaseWritingDirection(NaturalWritingDirection);
      break;

    case WebTextDirectionLeftToRight:
      editor.setBaseWritingDirection(LeftToRightWritingDirection);
      break;

    case WebTextDirectionRightToLeft:
      editor.setBaseWritingDirection(RightToLeftWritingDirection);
      break;

    default:
      NOTIMPLEMENTED();
      break;
  }
}

bool WebViewImpl::isAcceleratedCompositingActive() const {
  return m_rootLayer;
}

void WebViewImpl::willCloseLayerTreeView() {
  if (m_linkHighlightsTimeline) {
    m_linkHighlights.clear();
    detachCompositorAnimationTimeline(m_linkHighlightsTimeline.get());
    m_linkHighlightsTimeline.reset();
  }

  if (m_layerTreeView)
    page()->willCloseLayerTreeView(*m_layerTreeView);

  setRootLayer(nullptr);

  m_mutator = nullptr;
  m_layerTreeView = nullptr;
}

void WebViewImpl::didAcquirePointerLock() {
  if (page())
    page()->pointerLockController().didAcquirePointerLock();
}

void WebViewImpl::didNotAcquirePointerLock() {
  if (page())
    page()->pointerLockController().didNotAcquirePointerLock();
}

void WebViewImpl::didLosePointerLock() {
  m_pointerLockGestureToken.clear();
  if (page())
    page()->pointerLockController().didLosePointerLock();
}

void WebViewImpl::didChangeWindowResizerRect() {
  if (mainFrameImpl()->frameView())
    mainFrameImpl()->frameView()->windowResizerRectChanged();
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
bool WebViewImpl::getCompositionCharacterBounds(WebVector<WebRect>& bounds) {
  WebRange range = compositionRange();
  if (range.isEmpty())
    return false;

  WebLocalFrame* frame = focusedFrame();

  // Only consider frames whose local root is the main frame. For other
  // local frames which have different local roots, the corresponding
  // WebFrameWidget will handle this task.
  if (frame->localRoot() != mainFrameImpl())
    return false;

  size_t characterCount = range.length();
  size_t offset = range.startOffset();
  WebVector<WebRect> result(characterCount);
  WebRect webrect;
  for (size_t i = 0; i < characterCount; ++i) {
    if (!frame->firstRectForCharacterRange(offset + i, 1, webrect)) {
      DLOG(ERROR) << "Could not retrieve character rectangle at " << i;
      return false;
    }
    result[i] = webrect;
  }
  bounds.swap(result);
  return true;
}

// TODO(ekaramad):This method is almost duplicated in WebFrameWidgetImpl as
// well. This code needs to be refactored  (http://crbug.com/629721).
void WebViewImpl::applyReplacementRange(const WebRange& range) {
  if (WebLocalFrame* frame = focusedFrame())
    frame->selectRange(range);
}

// WebView --------------------------------------------------------------------

WebSettingsImpl* WebViewImpl::settingsImpl() {
  if (!m_webSettings)
    m_webSettings = wrapUnique(
        new WebSettingsImpl(&m_page->settings(), m_devToolsEmulator.get()));
  DCHECK(m_webSettings);
  return m_webSettings.get();
}

WebSettings* WebViewImpl::settings() {
  return settingsImpl();
}

WebString WebViewImpl::pageEncoding() const {
  if (!m_page)
    return WebString();

  if (!m_page->mainFrame()->isLocalFrame())
    return WebString();

  // FIXME: Is this check needed?
  if (!m_page->deprecatedLocalMainFrame()->document()->loader())
    return WebString();

  return m_page->deprecatedLocalMainFrame()->document()->encodingName();
}

WebFrame* WebViewImpl::mainFrame() {
  return WebFrame::fromFrame(m_page ? m_page->mainFrame() : nullptr);
}

WebFrame* WebViewImpl::findFrameByName(const WebString& name,
                                       WebFrame* relativeToFrame) {
  // FIXME: Either this should only deal with WebLocalFrames or it should move
  // to WebFrame.
  if (!relativeToFrame)
    relativeToFrame = mainFrame();
  Frame* frame = toWebLocalFrameImpl(relativeToFrame)->frame();
  frame = frame->tree().find(name);
  if (!frame || !frame->isLocalFrame())
    return nullptr;
  return WebLocalFrameImpl::fromFrame(toLocalFrame(frame));
}

WebLocalFrame* WebViewImpl::focusedFrame() {
  Frame* frame = focusedCoreFrame();
  // TODO(yabinh): focusedCoreFrame() should always return a local frame, and
  // the following check should be unnecessary.
  // See crbug.com/625068
  if (!frame || !frame->isLocalFrame())
    return nullptr;
  return WebLocalFrameImpl::fromFrame(toLocalFrame(frame));
}

void WebViewImpl::setFocusedFrame(WebFrame* frame) {
  if (!frame) {
    // Clears the focused frame if any.
    Frame* focusedFrame = focusedCoreFrame();
    if (focusedFrame && focusedFrame->isLocalFrame())
      toLocalFrame(focusedFrame)->selection().setFocused(false);
    return;
  }
  LocalFrame* coreFrame = toWebLocalFrameImpl(frame)->frame();
  coreFrame->page()->focusController().setFocusedFrame(coreFrame);
}

void WebViewImpl::focusDocumentView(WebFrame* frame) {
  // This is currently only used when replicating focus changes for
  // cross-process frames, and |notifyEmbedder| is disabled to avoid sending
  // duplicate frameFocused updates from FocusController to the browser
  // process, which already knows the latest focused frame.
  page()->focusController().focusDocumentView(frame->toImplBase()->frame(),
                                              false /* notifyEmbedder */);
}

void WebViewImpl::unfocusDocumentView() {
  page()->focusController().focusDocumentView(nullptr /* frame */,
                                              false /* notifyEmbedder */);
}

void WebViewImpl::setInitialFocus(bool reverse) {
  if (!m_page)
    return;
  Frame* frame = page()->focusController().focusedOrMainFrame();
  if (frame->isLocalFrame()) {
    if (Document* document = toLocalFrame(frame)->document())
      document->clearFocusedElement();
  }
  page()->focusController().setInitialFocus(reverse ? WebFocusTypeBackward
                                                    : WebFocusTypeForward);
}

void WebViewImpl::clearFocusedElement() {
  Frame* frame = focusedCoreFrame();
  if (!frame || !frame->isLocalFrame())
    return;

  LocalFrame* localFrame = toLocalFrame(frame);

  Document* document = localFrame->document();
  if (!document)
    return;

  Element* oldFocusedElement = document->focusedElement();
  document->clearFocusedElement();
  if (!oldFocusedElement)
    return;

  // If a text field has focus, we need to make sure the selection controller
  // knows to remove selection from it. Otherwise, the text field is still
  // processing keyboard events even though focus has been moved to the page and
  // keystrokes get eaten as a result.
  document->updateStyleAndLayoutTree();
  if (hasEditableStyle(*oldFocusedElement) ||
      oldFocusedElement->isTextFormControl())
    localFrame->selection().clear();
}

// TODO(dglazkov): Remove and replace with Node:hasEditableStyle.
// http://crbug.com/612560
static bool isElementEditable(const Element* element) {
  element->document().updateStyleAndLayoutTree();
  if (hasEditableStyle(*element))
    return true;

  if (element->isTextFormControl()) {
    const HTMLTextFormControlElement* input =
        toHTMLTextFormControlElement(element);
    if (!input->isDisabledOrReadOnly())
      return true;
  }

  return equalIgnoringASCIICase(element->getAttribute(HTMLNames::roleAttr),
                                "textbox");
}

bool WebViewImpl::scrollFocusedEditableElementIntoRect(
    const WebRect& rectInViewport) {
  LocalFrame* frame = page()->mainFrame() && page()->mainFrame()->isLocalFrame()
                          ? page()->deprecatedLocalMainFrame()
                          : nullptr;
  Element* element = focusedElement();
  if (!frame || !frame->view() || !element)
    return false;

  if (!isElementEditable(element))
    return false;

  element->document().updateStyleAndLayoutIgnorePendingStylesheets();

  bool zoomInToLegibleScale =
      m_webSettings->autoZoomFocusedNodeToLegibleScale() &&
      !page()->frameHost().visualViewport().shouldDisableDesktopWorkarounds();

  if (zoomInToLegibleScale) {
    // When deciding whether to zoom in on a focused text box, we should decide
    // not to zoom in if the user won't be able to zoom out. e.g if the textbox
    // is within a touch-action: none container the user can't zoom back out.
    TouchAction action = TouchActionUtil::computeEffectiveTouchAction(*element);
    if (!(action & TouchActionPinchZoom))
      zoomInToLegibleScale = false;
  }

  float scale;
  IntPoint scroll;
  bool needAnimation;
  computeScaleAndScrollForFocusedNode(element, zoomInToLegibleScale, scale,
                                      scroll, needAnimation);
  if (needAnimation)
    startPageScaleAnimation(scroll, false, scale,
                            scrollAndScaleAnimationDurationInSeconds);

  return true;
}

void WebViewImpl::smoothScroll(int targetX, int targetY, long durationMs) {
  IntPoint targetPosition(targetX, targetY);
  startPageScaleAnimation(targetPosition, false, pageScaleFactor(),
                          (double)durationMs / 1000);
}

void WebViewImpl::computeScaleAndScrollForFocusedNode(Node* focusedNode,
                                                      bool zoomInToLegibleScale,
                                                      float& newScale,
                                                      IntPoint& newScroll,
                                                      bool& needAnimation) {
  VisualViewport& visualViewport = page()->frameHost().visualViewport();

  WebRect caretInViewport, unusedEnd;
  selectionBounds(caretInViewport, unusedEnd);

  // 'caretInDocument' is rect encompassing the blinking cursor relative to the
  // root document.
  IntRect caretInDocument = mainFrameImpl()->frameView()->frameToContents(
      visualViewport.viewportToRootFrame(caretInViewport));
  IntRect textboxRectInDocument = mainFrameImpl()->frameView()->frameToContents(
      focusedNode->document().view()->contentsToRootFrame(
          pixelSnappedIntRect(focusedNode->Node::boundingBox())));

  if (!zoomInToLegibleScale) {
    newScale = pageScaleFactor();
  } else {
    // Pick a scale which is reasonably readable. This is the scale at which
    // the caret height will become minReadableCaretHeightForNode (adjusted
    // for dpi and font scale factor).
    const int minReadableCaretHeightForNode =
        textboxRectInDocument.height() >= 2 * caretInDocument.height()
            ? minReadableCaretHeightForTextArea
            : minReadableCaretHeight;
    newScale = clampPageScaleFactorToLimits(maximumLegiblePageScale() *
                                            minReadableCaretHeightForNode /
                                            caretInDocument.height());
    newScale = std::max(newScale, pageScaleFactor());
  }
  const float deltaScale = newScale / pageScaleFactor();

  needAnimation = false;

  // If we are at less than the target zoom level, zoom in.
  if (deltaScale > minScaleChangeToTriggerZoom)
    needAnimation = true;
  else
    newScale = pageScaleFactor();

  // If the caret is offscreen, then animate.
  if (!visualViewport.visibleRectInDocument().contains(caretInDocument))
    needAnimation = true;

  // If the box is partially offscreen and it's possible to bring it fully
  // onscreen, then animate.
  if (visualViewport.visibleRect().width() >= textboxRectInDocument.width() &&
      visualViewport.visibleRect().height() >= textboxRectInDocument.height() &&
      !visualViewport.visibleRectInDocument().contains(textboxRectInDocument))
    needAnimation = true;

  if (!needAnimation)
    return;

  FloatSize targetViewportSize(visualViewport.size());
  targetViewportSize.scale(1 / newScale);

  if (textboxRectInDocument.width() <= targetViewportSize.width()) {
    // Field is narrower than screen. Try to leave padding on left so field's
    // label is visible, but it's more important to ensure entire field is
    // onscreen.
    int idealLeftPadding = targetViewportSize.width() * leftBoxRatio;
    int maxLeftPaddingKeepingBoxOnscreen =
        targetViewportSize.width() - textboxRectInDocument.width();
    newScroll.setX(
        textboxRectInDocument.x() -
        std::min<int>(idealLeftPadding, maxLeftPaddingKeepingBoxOnscreen));
  } else {
    // Field is wider than screen. Try to left-align field, unless caret would
    // be offscreen, in which case right-align the caret.
    newScroll.setX(std::max<int>(textboxRectInDocument.x(),
                                 caretInDocument.x() + caretInDocument.width() +
                                     caretPadding -
                                     targetViewportSize.width()));
  }
  if (textboxRectInDocument.height() <= targetViewportSize.height()) {
    // Field is shorter than screen. Vertically center it.
    newScroll.setY(
        textboxRectInDocument.y() -
        (targetViewportSize.height() - textboxRectInDocument.height()) / 2);
  } else {
    // Field is taller than screen. Try to top align field, unless caret would
    // be offscreen, in which case bottom-align the caret.
    newScroll.setY(std::max<int>(textboxRectInDocument.y(),
                                 caretInDocument.y() +
                                     caretInDocument.height() + caretPadding -
                                     targetViewportSize.height()));
  }
}

void WebViewImpl::advanceFocus(bool reverse) {
  page()->focusController().advanceFocus(reverse ? WebFocusTypeBackward
                                                 : WebFocusTypeForward);
}

void WebViewImpl::advanceFocusAcrossFrames(WebFocusType type,
                                           WebRemoteFrame* from,
                                           WebLocalFrame* to) {
  // TODO(alexmos): Pass in proper with sourceCapabilities.
  page()->focusController().advanceFocusAcrossFrames(
      type, toWebRemoteFrameImpl(from)->frame(),
      toWebLocalFrameImpl(to)->frame());
}

double WebViewImpl::zoomLevel() {
  return m_zoomLevel;
}

void WebViewImpl::propagateZoomFactorToLocalFrameRoots(Frame* frame,
                                                       float zoomFactor) {
  if (frame->isLocalRoot()) {
    LocalFrame* localFrame = toLocalFrame(frame);
    if (!WebLocalFrameImpl::pluginContainerFromFrame(localFrame))
      localFrame->setPageZoomFactor(zoomFactor);
  }

  for (Frame* child = frame->tree().firstChild(); child;
       child = child->tree().nextSibling())
    propagateZoomFactorToLocalFrameRoots(child, zoomFactor);
}

double WebViewImpl::setZoomLevel(double zoomLevel) {
  if (zoomLevel < m_minimumZoomLevel)
    m_zoomLevel = m_minimumZoomLevel;
  else if (zoomLevel > m_maximumZoomLevel)
    m_zoomLevel = m_maximumZoomLevel;
  else
    m_zoomLevel = zoomLevel;

  float zoomFactor =
      m_zoomFactorOverride
          ? m_zoomFactorOverride
          : static_cast<float>(zoomLevelToZoomFactor(m_zoomLevel));
  if (m_zoomFactorForDeviceScaleFactor) {
    if (m_compositorDeviceScaleFactorOverride) {
      // Adjust the page's DSF so that DevicePixelRatio becomes
      // m_zoomFactorForDeviceScaleFactor.
      page()->setDeviceScaleFactor(m_zoomFactorForDeviceScaleFactor /
                                   m_compositorDeviceScaleFactorOverride);
      zoomFactor *= m_compositorDeviceScaleFactorOverride;
    } else {
      page()->setDeviceScaleFactor(1.f);
      zoomFactor *= m_zoomFactorForDeviceScaleFactor;
    }
  }
  propagateZoomFactorToLocalFrameRoots(m_page->mainFrame(), zoomFactor);

  return m_zoomLevel;
}

void WebViewImpl::zoomLimitsChanged(double minimumZoomLevel,
                                    double maximumZoomLevel) {
  m_minimumZoomLevel = minimumZoomLevel;
  m_maximumZoomLevel = maximumZoomLevel;
  m_client->zoomLimitsChanged(m_minimumZoomLevel, m_maximumZoomLevel);
}

float WebViewImpl::textZoomFactor() {
  return mainFrameImpl()->frame()->textZoomFactor();
}

float WebViewImpl::setTextZoomFactor(float textZoomFactor) {
  LocalFrame* frame = mainFrameImpl()->frame();
  if (WebLocalFrameImpl::pluginContainerFromFrame(frame))
    return 1;

  frame->setTextZoomFactor(textZoomFactor);

  return textZoomFactor;
}

double WebView::zoomLevelToZoomFactor(double zoomLevel) {
  return pow(textSizeMultiplierRatio, zoomLevel);
}

double WebView::zoomFactorToZoomLevel(double factor) {
  // Since factor = 1.2^level, level = log(factor) / log(1.2)
  return log(factor) / log(textSizeMultiplierRatio);
}

float WebViewImpl::pageScaleFactor() const {
  if (!page())
    return 1;

  return page()->frameHost().visualViewport().scale();
}

float WebViewImpl::clampPageScaleFactorToLimits(float scaleFactor) const {
  return pageScaleConstraintsSet().finalConstraints().clampToConstraints(
      scaleFactor);
}

void WebViewImpl::setVisualViewportOffset(const WebFloatPoint& offset) {
  DCHECK(page());
  page()->frameHost().visualViewport().setLocation(offset);
}

WebFloatPoint WebViewImpl::visualViewportOffset() const {
  DCHECK(page());
  return page()->frameHost().visualViewport().visibleRect().location();
}

WebFloatSize WebViewImpl::visualViewportSize() const {
  DCHECK(page());
  return page()->frameHost().visualViewport().visibleRect().size();
}

void WebViewImpl::scrollAndRescaleViewports(
    float scaleFactor,
    const IntPoint& mainFrameOrigin,
    const FloatPoint& visualViewportOrigin) {
  if (!page())
    return;

  if (!mainFrameImpl())
    return;

  FrameView* view = mainFrameImpl()->frameView();
  if (!view)
    return;

  // Order is important: visual viewport location is clamped based on
  // main frame scroll position and visual viewport scale.

  view->setScrollPosition(mainFrameOrigin, ProgrammaticScroll);

  setPageScaleFactor(scaleFactor);

  page()->frameHost().visualViewport().setLocation(visualViewportOrigin);
}

void WebViewImpl::setPageScaleFactorAndLocation(float scaleFactor,
                                                const FloatPoint& location) {
  DCHECK(page());

  page()->frameHost().visualViewport().setScaleAndLocation(
      clampPageScaleFactorToLimits(scaleFactor), location);
}

void WebViewImpl::setPageScaleFactor(float scaleFactor) {
  DCHECK(page());

  scaleFactor = clampPageScaleFactorToLimits(scaleFactor);
  if (scaleFactor == pageScaleFactor())
    return;

  page()->frameHost().visualViewport().setScale(scaleFactor);
}

void WebViewImpl::setDeviceScaleFactor(float scaleFactor) {
  if (!page())
    return;

  page()->setDeviceScaleFactor(scaleFactor);

  if (m_layerTreeView)
    updateLayerTreeDeviceScaleFactor();
}

void WebViewImpl::setZoomFactorForDeviceScaleFactor(
    float zoomFactorForDeviceScaleFactor) {
  m_zoomFactorForDeviceScaleFactor = zoomFactorForDeviceScaleFactor;
  if (!m_layerTreeView)
    return;
  setZoomLevel(m_zoomLevel);
}

void WebViewImpl::setDeviceColorProfile(const WebVector<char>& colorProfile) {
  Vector<char> deviceProfile;
  deviceProfile.append(colorProfile.data(), colorProfile.size());
  ImageDecoder::setTargetColorProfile(deviceProfile);
}

void WebViewImpl::enableAutoResizeMode(const WebSize& minSize,
                                       const WebSize& maxSize) {
  m_shouldAutoResize = true;
  m_minAutoSize = minSize;
  m_maxAutoSize = maxSize;
  configureAutoResizeMode();
}

void WebViewImpl::disableAutoResizeMode() {
  m_shouldAutoResize = false;
  configureAutoResizeMode();
}

void WebViewImpl::setDefaultPageScaleLimits(float minScale, float maxScale) {
  return page()->frameHost().setDefaultPageScaleLimits(minScale, maxScale);
}

void WebViewImpl::setInitialPageScaleOverride(
    float initialPageScaleFactorOverride) {
  PageScaleConstraints constraints =
      pageScaleConstraintsSet().userAgentConstraints();
  constraints.initialScale = initialPageScaleFactorOverride;

  if (constraints == pageScaleConstraintsSet().userAgentConstraints())
    return;

  pageScaleConstraintsSet().setNeedsReset(true);
  page()->frameHost().setUserAgentPageScaleConstraints(constraints);
}

void WebViewImpl::setMaximumLegibleScale(float maximumLegibleScale) {
  m_maximumLegibleScale = maximumLegibleScale;
}

void WebViewImpl::setIgnoreViewportTagScaleLimits(bool ignore) {
  PageScaleConstraints constraints =
      pageScaleConstraintsSet().userAgentConstraints();
  if (ignore) {
    constraints.minimumScale =
        pageScaleConstraintsSet().defaultConstraints().minimumScale;
    constraints.maximumScale =
        pageScaleConstraintsSet().defaultConstraints().maximumScale;
  } else {
    constraints.minimumScale = -1;
    constraints.maximumScale = -1;
  }
  page()->frameHost().setUserAgentPageScaleConstraints(constraints);
}

IntSize WebViewImpl::mainFrameSize() {
  // The frame size should match the viewport size at minimum scale, since the
  // viewport must always be contained by the frame.
  FloatSize frameSize(m_size);
  frameSize.scale(1 / minimumPageScaleFactor());
  return expandedIntSize(frameSize);
}

PageScaleConstraintsSet& WebViewImpl::pageScaleConstraintsSet() const {
  return page()->frameHost().pageScaleConstraintsSet();
}

void WebViewImpl::refreshPageScaleFactorAfterLayout() {
  if (!mainFrame() || !page() || !page()->mainFrame() ||
      !page()->mainFrame()->isLocalFrame() ||
      !page()->deprecatedLocalMainFrame()->view())
    return;
  FrameView* view = page()->deprecatedLocalMainFrame()->view();

  updatePageDefinedViewportConstraints(
      mainFrameImpl()->frame()->document()->viewportDescription());
  pageScaleConstraintsSet().computeFinalConstraints();

  int verticalScrollbarWidth = 0;
  if (view->verticalScrollbar() &&
      !view->verticalScrollbar()->isOverlayScrollbar())
    verticalScrollbarWidth = view->verticalScrollbar()->width();
  pageScaleConstraintsSet().adjustFinalConstraintsToContentsSize(
      contentsSize(), verticalScrollbarWidth,
      settings()->shrinksViewportContentToFit());

  float newPageScaleFactor = pageScaleFactor();
  if (pageScaleConstraintsSet().needsReset() &&
      pageScaleConstraintsSet().finalConstraints().initialScale != -1) {
    newPageScaleFactor =
        pageScaleConstraintsSet().finalConstraints().initialScale;
    pageScaleConstraintsSet().setNeedsReset(false);
  }
  setPageScaleFactor(newPageScaleFactor);

  updateLayerTreeViewport();

  // Changes to page-scale during layout may require an additional frame.
  // We can't update the lifecycle here because we may be in the middle of
  // layout in the caller of this method.
  // TODO(chrishtr): clean all this up. All layout should happen in one
  // lifecycle run (crbug.com/578239).
  if (mainFrameImpl()->frameView()->needsLayout())
    mainFrameImpl()->frameWidget()->scheduleAnimation();
}

void WebViewImpl::updatePageDefinedViewportConstraints(
    const ViewportDescription& description) {
  if (!page() || (!m_size.width && !m_size.height) ||
      !page()->mainFrame()->isLocalFrame())
    return;

  if (!settings()->viewportEnabled()) {
    pageScaleConstraintsSet().clearPageDefinedConstraints();
    updateMainFrameLayoutSize();

    // If we don't support mobile viewports, allow GPU rasterization.
    m_matchesHeuristicsForGpuRasterization = true;
    if (m_layerTreeView)
      m_layerTreeView->heuristicsForGpuRasterizationUpdated(
          m_matchesHeuristicsForGpuRasterization);
    return;
  }

  Document* document = page()->deprecatedLocalMainFrame()->document();

  m_matchesHeuristicsForGpuRasterization =
      description.matchesHeuristicsForGpuRasterization();
  if (m_layerTreeView)
    m_layerTreeView->heuristicsForGpuRasterizationUpdated(
        m_matchesHeuristicsForGpuRasterization);

  Length defaultMinWidth = document->viewportDefaultMinWidth();
  if (defaultMinWidth.isAuto())
    defaultMinWidth = Length(ExtendToZoom);

  ViewportDescription adjustedDescription = description;
  if (settingsImpl()->viewportMetaLayoutSizeQuirk() &&
      adjustedDescription.type == ViewportDescription::ViewportMeta) {
    const int legacyWidthSnappingMagicNumber = 320;
    if (adjustedDescription.maxWidth.isFixed() &&
        adjustedDescription.maxWidth.value() <= legacyWidthSnappingMagicNumber)
      adjustedDescription.maxWidth = Length(DeviceWidth);
    if (adjustedDescription.maxHeight.isFixed() &&
        adjustedDescription.maxHeight.value() <= m_size.height)
      adjustedDescription.maxHeight = Length(DeviceHeight);
    adjustedDescription.minWidth = adjustedDescription.maxWidth;
    adjustedDescription.minHeight = adjustedDescription.maxHeight;
  }

  float oldInitialScale =
      pageScaleConstraintsSet().pageDefinedConstraints().initialScale;
  pageScaleConstraintsSet().updatePageDefinedConstraints(adjustedDescription,
                                                         defaultMinWidth);

  if (settingsImpl()->clobberUserAgentInitialScaleQuirk() &&
      pageScaleConstraintsSet().userAgentConstraints().initialScale != -1 &&
      pageScaleConstraintsSet().userAgentConstraints().initialScale *
              deviceScaleFactor() <=
          1) {
    if (description.maxWidth == Length(DeviceWidth) ||
        (description.maxWidth.type() == Auto &&
         pageScaleConstraintsSet().pageDefinedConstraints().initialScale ==
             1.0f))
      setInitialPageScaleOverride(-1);
  }

  Settings& pageSettings = page()->settings();
  pageScaleConstraintsSet().adjustForAndroidWebViewQuirks(
      adjustedDescription, defaultMinWidth.intValue(), deviceScaleFactor(),
      settingsImpl()->supportDeprecatedTargetDensityDPI(),
      pageSettings.wideViewportQuirkEnabled(), pageSettings.useWideViewport(),
      pageSettings.loadWithOverviewMode(),
      settingsImpl()->viewportMetaNonUserScalableQuirk());
  float newInitialScale =
      pageScaleConstraintsSet().pageDefinedConstraints().initialScale;
  if (oldInitialScale != newInitialScale && newInitialScale != -1) {
    pageScaleConstraintsSet().setNeedsReset(true);
    if (mainFrameImpl() && mainFrameImpl()->frameView())
      mainFrameImpl()->frameView()->setNeedsLayout();
  }

  if (LocalFrame* frame = page()->deprecatedLocalMainFrame()) {
    if (TextAutosizer* textAutosizer = frame->document()->textAutosizer())
      textAutosizer->updatePageInfoInAllFrames();
  }

  updateMainFrameLayoutSize();
}

void WebViewImpl::updateMainFrameLayoutSize() {
  if (m_shouldAutoResize || !mainFrameImpl())
    return;

  FrameView* view = mainFrameImpl()->frameView();
  if (!view)
    return;

  WebSize layoutSize = m_size;

  if (settings()->viewportEnabled())
    layoutSize = pageScaleConstraintsSet().layoutSize();

  if (page()->settings().forceZeroLayoutHeight())
    layoutSize.height = 0;

  view->setLayoutSize(layoutSize);
}

IntSize WebViewImpl::contentsSize() const {
  if (!page()->mainFrame()->isLocalFrame())
    return IntSize();
  LayoutViewItem root = page()->deprecatedLocalMainFrame()->contentLayoutItem();
  if (root.isNull())
    return IntSize();
  return root.documentRect().size();
}

WebSize WebViewImpl::contentsPreferredMinimumSize() {
  if (mainFrameImpl())
    mainFrameImpl()
        ->frame()
        ->view()
        ->updateLifecycleToCompositingCleanPlusScrolling();

  Document* document = m_page->mainFrame()->isLocalFrame()
                           ? m_page->deprecatedLocalMainFrame()->document()
                           : nullptr;
  if (!document || document->layoutViewItem().isNull() ||
      !document->documentElement() || !document->documentElement()->layoutBox())
    return WebSize();

  int widthScaled = document->layoutViewItem()
                        .minPreferredLogicalWidth()
                        .round();  // Already accounts for zoom.
  int heightScaled =
      document->documentElement()->layoutBox()->scrollHeight().round();
  return IntSize(widthScaled, heightScaled);
}

float WebViewImpl::defaultMinimumPageScaleFactor() const {
  return pageScaleConstraintsSet().defaultConstraints().minimumScale;
}

float WebViewImpl::defaultMaximumPageScaleFactor() const {
  return pageScaleConstraintsSet().defaultConstraints().maximumScale;
}

float WebViewImpl::minimumPageScaleFactor() const {
  return pageScaleConstraintsSet().finalConstraints().minimumScale;
}

float WebViewImpl::maximumPageScaleFactor() const {
  return pageScaleConstraintsSet().finalConstraints().maximumScale;
}

void WebViewImpl::resetScaleStateImmediately() {
  pageScaleConstraintsSet().setNeedsReset(true);
}

void WebViewImpl::resetScrollAndScaleState() {
  page()->frameHost().visualViewport().reset();

  if (!page()->mainFrame()->isLocalFrame())
    return;

  if (FrameView* frameView = toLocalFrame(page()->mainFrame())->view()) {
    ScrollableArea* scrollableArea = frameView->layoutViewportScrollableArea();

    if (scrollableArea->scrollPositionDouble() != DoublePoint::zero())
      scrollableArea->setScrollPosition(DoublePoint::zero(),
                                        ProgrammaticScroll);
  }

  pageScaleConstraintsSet().setNeedsReset(true);
}

void WebViewImpl::performMediaPlayerAction(const WebMediaPlayerAction& action,
                                           const WebPoint& location) {
  HitTestResult result = hitTestResultForViewportPos(location);
  Node* node = result.innerNode();
  if (!isHTMLVideoElement(*node) && !isHTMLAudioElement(*node))
    return;

  HTMLMediaElement* mediaElement = toHTMLMediaElement(node);
  switch (action.type) {
    case WebMediaPlayerAction::Play:
      if (action.enable)
        mediaElement->play();
      else
        mediaElement->pause();
      break;
    case WebMediaPlayerAction::Mute:
      mediaElement->setMuted(action.enable);
      break;
    case WebMediaPlayerAction::Loop:
      mediaElement->setLoop(action.enable);
      break;
    case WebMediaPlayerAction::Controls:
      mediaElement->setBooleanAttribute(HTMLNames::controlsAttr, action.enable);
      break;
    default:
      NOTREACHED();
  }
}

void WebViewImpl::performPluginAction(const WebPluginAction& action,
                                      const WebPoint& location) {
  // FIXME: Location is probably in viewport coordinates
  HitTestResult result = hitTestResultForRootFramePos(location);
  Node* node = result.innerNode();
  if (!isHTMLObjectElement(*node) && !isHTMLEmbedElement(*node))
    return;

  LayoutObject* object = node->layoutObject();
  if (object && object->isLayoutPart()) {
    Widget* widget = toLayoutPart(object)->widget();
    if (widget && widget->isPluginContainer()) {
      WebPluginContainerImpl* plugin = toWebPluginContainerImpl(widget);
      switch (action.type) {
        case WebPluginAction::Rotate90Clockwise:
          plugin->plugin()->rotateView(WebPlugin::RotationType90Clockwise);
          break;
        case WebPluginAction::Rotate90Counterclockwise:
          plugin->plugin()->rotateView(
              WebPlugin::RotationType90Counterclockwise);
          break;
        default:
          NOTREACHED();
      }
    }
  }
}

WebHitTestResult WebViewImpl::hitTestResultAt(const WebPoint& point) {
  return coreHitTestResultAt(point);
}

HitTestResult WebViewImpl::coreHitTestResultAt(
    const WebPoint& pointInViewport) {
  DocumentLifecycle::AllowThrottlingScope throttlingScope(
      mainFrameImpl()->frame()->document()->lifecycle());
  FrameView* view = mainFrameImpl()->frameView();
  IntPoint pointInRootFrame =
      view->contentsToFrame(view->viewportToContents(pointInViewport));
  return hitTestResultForRootFramePos(pointInRootFrame);
}

void WebViewImpl::dragSourceEndedAt(const WebPoint& clientPoint,
                                    const WebPoint& screenPoint,
                                    WebDragOperation operation) {
  PlatformMouseEvent pme(
      clientPoint, screenPoint, WebPointerProperties::Button::Left,
      PlatformEvent::MouseMoved, 0, PlatformEvent::NoModifiers,
      PlatformMouseEvent::RealOrIndistinguishable,
      WTF::monotonicallyIncreasingTime());
  m_page->deprecatedLocalMainFrame()->eventHandler().dragSourceEndedAt(
      pme, static_cast<DragOperation>(operation));
}

void WebViewImpl::dragSourceSystemDragEnded() {
  // It's possible for us to get this callback while not doing a drag if
  // it's from a previous page that got unloaded.
  if (m_doingDragAndDrop) {
    m_page->dragController().dragEnded();
    m_doingDragAndDrop = false;
  }
}

WebDragOperation WebViewImpl::dragTargetDragEnter(
    const WebDragData& webDragData,
    const WebPoint& clientPoint,
    const WebPoint& screenPoint,
    WebDragOperationsMask operationsAllowed,
    int modifiers) {
  DCHECK(!m_currentDragData);

  m_currentDragData = DataObject::create(webDragData);
  m_operationsAllowed = operationsAllowed;

  return dragTargetDragEnterOrOver(clientPoint, screenPoint, DragEnter,
                                   modifiers);
}

WebDragOperation WebViewImpl::dragTargetDragOver(
    const WebPoint& clientPoint,
    const WebPoint& screenPoint,
    WebDragOperationsMask operationsAllowed,
    int modifiers) {
  m_operationsAllowed = operationsAllowed;

  return dragTargetDragEnterOrOver(clientPoint, screenPoint, DragOver,
                                   modifiers);
}

void WebViewImpl::dragTargetDragLeave() {
  DCHECK(m_currentDragData);

  DragData dragData(m_currentDragData.get(), IntPoint(), IntPoint(),
                    static_cast<DragOperation>(m_operationsAllowed));

  m_page->dragController().dragExited(&dragData);

  // FIXME: why is the drag scroll timer not stopped here?

  m_dragOperation = WebDragOperationNone;
  m_currentDragData = nullptr;
}

void WebViewImpl::dragTargetDrop(const WebDragData& webDragData,
                                 const WebPoint& clientPoint,
                                 const WebPoint& screenPoint,
                                 int modifiers) {
  DCHECK(m_currentDragData);
  m_currentDragData = DataObject::create(webDragData);

  WebAutofillClient* autofillClient =
      mainFrameImpl() ? mainFrameImpl()->autofillClient() : 0;
  UserGestureNotifier notifier(autofillClient, &m_userGestureObserved);

  // If this webview transitions from the "drop accepting" state to the "not
  // accepting" state, then our IPC message reply indicating that may be in-
  // flight, or else delayed by javascript processing in this webview.  If a
  // drop happens before our IPC reply has reached the browser process, then
  // the browser forwards the drop to this webview.  So only allow a drop to
  // proceed if our webview m_dragOperation state is not DragOperationNone.

  if (m_dragOperation ==
      WebDragOperationNone) {  // IPC RACE CONDITION: do not allow this drop.
    dragTargetDragLeave();
    return;
  }

  m_currentDragData->setModifiers(modifiers);
  DragData dragData(m_currentDragData.get(), clientPoint, screenPoint,
                    static_cast<DragOperation>(m_operationsAllowed));

  UserGestureIndicator gesture(DefinitelyProcessingNewUserGesture);
  m_page->dragController().performDrag(&dragData);

  m_dragOperation = WebDragOperationNone;
  m_currentDragData = nullptr;
}

void WebViewImpl::spellingMarkers(WebVector<uint32_t>* markers) {
  Vector<uint32_t> result;
  for (Frame* frame = m_page->mainFrame(); frame;
       frame = frame->tree().traverseNext()) {
    if (!frame->isLocalFrame())
      continue;
    const DocumentMarkerVector& documentMarkers =
        toLocalFrame(frame)->document()->markers().markers();
    for (size_t i = 0; i < documentMarkers.size(); ++i)
      result.append(documentMarkers[i]->hash());
  }
  markers->assign(result);
}

void WebViewImpl::removeSpellingMarkersUnderWords(
    const WebVector<WebString>& words) {
  Vector<String> convertedWords;
  convertedWords.append(words.data(), words.size());

  for (Frame* frame = m_page->mainFrame(); frame;
       frame = frame->tree().traverseNext()) {
    if (frame->isLocalFrame())
      toLocalFrame(frame)->removeSpellingMarkersUnderWords(convertedWords);
  }
}

WebDragOperation WebViewImpl::dragTargetDragEnterOrOver(
    const WebPoint& clientPoint,
    const WebPoint& screenPoint,
    DragAction dragAction,
    int modifiers) {
  DCHECK(m_currentDragData);

  m_currentDragData->setModifiers(modifiers);
  DragData dragData(m_currentDragData.get(), clientPoint, screenPoint,
                    static_cast<DragOperation>(m_operationsAllowed));

  DragSession dragSession;
  if (dragAction == DragEnter)
    dragSession = m_page->dragController().dragEntered(&dragData);
  else
    dragSession = m_page->dragController().dragUpdated(&dragData);

  DragOperation dropEffect = dragSession.operation;

  // Mask the drop effect operation against the drag source's allowed
  // operations.
  if (!(dropEffect & dragData.draggingSourceOperationMask()))
    dropEffect = DragOperationNone;

  m_dragOperation = static_cast<WebDragOperation>(dropEffect);

  return m_dragOperation;
}

void WebViewImpl::sendResizeEventAndRepaint() {
  // FIXME: This is wrong. The FrameView is responsible sending a resizeEvent
  // as part of layout. Layout is also responsible for sending invalidations
  // to the embedder. This method and all callers may be wrong. -- eseidel.
  if (mainFrameImpl()->frameView()) {
    // Enqueues the resize event.
    mainFrameImpl()->frame()->document()->enqueueResizeEvent();
  }

  if (m_client) {
    if (m_layerTreeView) {
      updateLayerTreeViewport();
    } else {
      WebRect damagedRect(0, 0, m_size.width, m_size.height);
      m_client->widgetClient()->didInvalidateRect(damagedRect);
    }
  }
}

void WebViewImpl::configureAutoResizeMode() {
  if (!mainFrameImpl() || !mainFrameImpl()->frame() ||
      !mainFrameImpl()->frame()->view())
    return;

  if (m_shouldAutoResize)
    mainFrameImpl()->frame()->view()->enableAutoSizeMode(m_minAutoSize,
                                                         m_maxAutoSize);
  else
    mainFrameImpl()->frame()->view()->disableAutoSizeMode();
}

unsigned long WebViewImpl::createUniqueIdentifierForRequest() {
  return createUniqueIdentifier();
}

void WebViewImpl::setCompositorDeviceScaleFactorOverride(
    float deviceScaleFactor) {
  if (m_compositorDeviceScaleFactorOverride == deviceScaleFactor)
    return;
  m_compositorDeviceScaleFactorOverride = deviceScaleFactor;
  if (m_zoomFactorForDeviceScaleFactor) {
    setZoomLevel(zoomLevel());
    return;
  }
  if (page() && m_layerTreeView)
    updateLayerTreeDeviceScaleFactor();
}

void WebViewImpl::setRootLayerTransform(const TransformationMatrix& transform) {
  if (transform == m_rootLayerTransform)
    return;
  m_rootLayerTransform = transform;
  updateRootLayerTransform();
}

TransformationMatrix WebViewImpl::getRootLayerTransformForTesting() const {
  return m_rootLayerTransform;
}

void WebViewImpl::enableDeviceEmulation(
    const WebDeviceEmulationParams& params) {
  m_devToolsEmulator->enableDeviceEmulation(params);
}

void WebViewImpl::disableDeviceEmulation() {
  m_devToolsEmulator->disableDeviceEmulation();
}

WebAXObject WebViewImpl::accessibilityObject() {
  if (!mainFrameImpl())
    return WebAXObject();

  Document* document = mainFrameImpl()->frame()->document();
  return WebAXObject(toAXObjectCacheImpl(document->axObjectCache())->root());
}

void WebViewImpl::performCustomContextMenuAction(unsigned action) {
  if (!m_page)
    return;
  ContextMenu* menu = m_page->contextMenuController().contextMenu();
  if (!menu)
    return;
  const ContextMenuItem* item = menu->itemWithAction(
      static_cast<ContextMenuAction>(ContextMenuItemBaseCustomTag + action));
  if (item)
    m_page->contextMenuController().contextMenuItemSelected(item);
  m_page->contextMenuController().clearContextMenu();
}

void WebViewImpl::showContextMenu() {
  if (!page())
    return;

  page()->contextMenuController().clearContextMenu();
  {
    ContextMenuAllowedScope scope;
    if (LocalFrame* focusedFrame =
            toLocalFrame(page()->focusController().focusedOrMainFrame()))
      focusedFrame->eventHandler().sendContextMenuEventForKey(nullptr);
  }
}

void WebViewImpl::didCloseContextMenu() {
  LocalFrame* frame = m_page->focusController().focusedFrame();
  if (frame)
    frame->selection().setCaretBlinkingSuspended(false);
}

void WebViewImpl::extractSmartClipData(WebRect rectInViewport,
                                       WebString& clipText,
                                       WebString& clipHtml,
                                       WebRect& clipRectInViewport) {
  LocalFrame* localFrame = toLocalFrame(focusedCoreFrame());
  if (!localFrame)
    return;
  SmartClipData clipData = SmartClip(localFrame).dataForRect(rectInViewport);
  clipText = clipData.clipData();
  clipRectInViewport = clipData.rectInViewport();

  WebLocalFrameImpl* frame = mainFrameImpl();
  if (!frame)
    return;
  WebPoint startPoint(rectInViewport.x, rectInViewport.y);
  WebPoint endPoint(rectInViewport.x + rectInViewport.width,
                    rectInViewport.y + rectInViewport.height);
  VisiblePosition startVisiblePosition =
      frame->visiblePositionForViewportPoint(startPoint);
  VisiblePosition endVisiblePosition =
      frame->visiblePositionForViewportPoint(endPoint);

  Position startPosition = startVisiblePosition.deepEquivalent();
  Position endPosition = endVisiblePosition.deepEquivalent();

  // document() will return null if -webkit-user-select is set to none.
  if (!startPosition.document() || !endPosition.document())
    return;

  if (startPosition.compareTo(endPosition) <= 0) {
    clipHtml =
        createMarkup(startPosition, endPosition, AnnotateForInterchange,
                     ConvertBlocksToInlines::NotConvert, ResolveNonLocalURLs);
  } else {
    clipHtml =
        createMarkup(endPosition, startPosition, AnnotateForInterchange,
                     ConvertBlocksToInlines::NotConvert, ResolveNonLocalURLs);
  }
}

void WebViewImpl::hidePopups() {
  cancelPagePopup();
}

void WebViewImpl::setIsTransparent(bool isTransparent) {
  // Set any existing frames to be transparent.
  Frame* frame = m_page->mainFrame();
  while (frame) {
    if (frame->isLocalFrame())
      toLocalFrame(frame)->view()->setTransparent(isTransparent);
    frame = frame->tree().traverseNext();
  }

  // Future frames check this to know whether to be transparent.
  m_isTransparent = isTransparent;

  if (m_layerTreeView)
    m_layerTreeView->setHasTransparentBackground(this->isTransparent());
}

bool WebViewImpl::isTransparent() const {
  return m_isTransparent;
}

void WebViewImpl::setBaseBackgroundColor(WebColor color) {
  if (m_baseBackgroundColor == color)
    return;

  m_baseBackgroundColor = color;

  if (m_page->mainFrame() && m_page->mainFrame()->isLocalFrame())
    m_page->deprecatedLocalMainFrame()->view()->setBaseBackgroundColor(color);
}

void WebViewImpl::setIsActive(bool active) {
  if (page())
    page()->focusController().setActive(active);
}

bool WebViewImpl::isActive() const {
  return page() ? page()->focusController().isActive() : false;
}

void WebViewImpl::setDomainRelaxationForbidden(bool forbidden,
                                               const WebString& scheme) {
  SchemeRegistry::setDomainRelaxationForbiddenForURLScheme(forbidden,
                                                           String(scheme));
}

void WebViewImpl::setWindowFeatures(const WebWindowFeatures& features) {
  m_page->chromeClient().setWindowFeatures(features);
}

void WebViewImpl::setOpenedByDOM() {
  m_page->setOpenedByDOM();
}

void WebViewImpl::setSelectionColors(unsigned activeBackgroundColor,
                                     unsigned activeForegroundColor,
                                     unsigned inactiveBackgroundColor,
                                     unsigned inactiveForegroundColor) {
#if USE(DEFAULT_RENDER_THEME)
  LayoutThemeDefault::setSelectionColors(
      activeBackgroundColor, activeForegroundColor, inactiveBackgroundColor,
      inactiveForegroundColor);
  LayoutTheme::theme().platformColorsDidChange();
#endif
}

void WebViewImpl::didCommitLoad(bool isNewNavigation,
                                bool isNavigationWithinPage) {
  if (!isNavigationWithinPage) {
    m_shouldDispatchFirstVisuallyNonEmptyLayout = true;
    m_shouldDispatchFirstLayoutAfterFinishedParsing = true;
    m_shouldDispatchFirstLayoutAfterFinishedLoading = true;

    if (isNewNavigation) {
      pageScaleConstraintsSet().setNeedsReset(true);
      m_pageImportanceSignals.onCommitLoad();
    }
  }

  // Give the visual viewport's scroll layer its initial size.
  page()->frameHost().visualViewport().mainFrameDidChangeSize();

  // Make sure link highlight from previous page is cleared.
  m_linkHighlights.clear();
  endActiveFlingAnimation();
  m_userGestureObserved = false;
}

void WebViewImpl::postLayoutResize(WebLocalFrameImpl* webframe) {
  FrameView* view = webframe->frame()->view();
  if (webframe == mainFrame())
    m_resizeViewportAnchor->resizeFrameView(mainFrameSize());
  else
    view->resize(webframe->frameView()->size());
}

void WebViewImpl::layoutUpdated(WebLocalFrameImpl* webframe) {
  LocalFrame* frame = webframe->frame();
  if (!m_client || !frame->isLocalRoot())
    return;

  if (m_shouldAutoResize) {
    WebSize frameSize = frame->view()->frameRect().size();
    if (frameSize != m_size) {
      m_size = frameSize;

      page()->frameHost().visualViewport().setSize(m_size);
      pageScaleConstraintsSet().didChangeInitialContainingBlockSize(m_size);

      m_client->didAutoResize(m_size);
      sendResizeEventAndRepaint();
    }
  }

  if (pageScaleConstraintsSet().constraintsDirty())
    refreshPageScaleFactorAfterLayout();

  FrameView* view = webframe->frame()->view();

  postLayoutResize(webframe);

  // Relayout immediately to avoid violating the rule that needsLayout()
  // isn't set at the end of a layout.
  if (view->needsLayout())
    view->layout();

  updatePageOverlays();

  m_fullscreenController->didUpdateLayout();
  m_client->didUpdateLayout();
}

void WebViewImpl::didChangeContentsSize() {
  pageScaleConstraintsSet().didChangeContentsSize(contentsSize(),
                                                  pageScaleFactor());
}

void WebViewImpl::pageScaleFactorChanged() {
  pageScaleConstraintsSet().setNeedsReset(false);
  updateLayerTreeViewport();
  m_client->pageScaleFactorChanged();
  m_devToolsEmulator->mainFrameScrollOrScaleChanged();
}

void WebViewImpl::mainFrameScrollOffsetChanged() {
  m_devToolsEmulator->mainFrameScrollOrScaleChanged();
}

bool WebViewImpl::useExternalPopupMenus() {
  return shouldUseExternalPopupMenus;
}

void WebViewImpl::startDragging(LocalFrame* frame,
                                const WebDragData& dragData,
                                WebDragOperationsMask mask,
                                const WebImage& dragImage,
                                const WebPoint& dragImageOffset) {
  if (!m_client)
    return;
  DCHECK(!m_doingDragAndDrop);
  m_doingDragAndDrop = true;
  m_client->startDragging(WebLocalFrameImpl::fromFrame(frame), dragData, mask,
                          dragImage, dragImageOffset);
}

void WebViewImpl::setIgnoreInputEvents(bool newValue) {
  DCHECK_NE(m_ignoreInputEvents, newValue);
  m_ignoreInputEvents = newValue;
}

void WebViewImpl::setBackgroundColorOverride(WebColor color) {
  m_backgroundColorOverride = color;
  updateLayerTreeBackgroundColor();
}

void WebViewImpl::setZoomFactorOverride(float zoomFactor) {
  m_zoomFactorOverride = zoomFactor;
  setZoomLevel(zoomLevel());
}

void WebViewImpl::setPageOverlayColor(WebColor color) {
  if (m_pageColorOverlay)
    m_pageColorOverlay.reset();

  if (color == Color::transparent)
    return;

  m_pageColorOverlay =
      PageOverlay::create(this, wrapUnique(new ColorOverlay(color)));
  m_pageColorOverlay->update();
}

WebPageImportanceSignals* WebViewImpl::pageImportanceSignals() {
  return &m_pageImportanceSignals;
}

Element* WebViewImpl::focusedElement() const {
  LocalFrame* frame = m_page->focusController().focusedFrame();
  if (!frame)
    return nullptr;

  Document* document = frame->document();
  if (!document)
    return nullptr;

  return document->focusedElement();
}

HitTestResult WebViewImpl::hitTestResultForViewportPos(
    const IntPoint& posInViewport) {
  IntPoint rootFramePoint(
      m_page->frameHost().visualViewport().viewportToRootFrame(posInViewport));
  return hitTestResultForRootFramePos(rootFramePoint);
}

HitTestResult WebViewImpl::hitTestResultForRootFramePos(
    const IntPoint& posInRootFrame) {
  if (!m_page->mainFrame()->isLocalFrame())
    return HitTestResult();
  IntPoint docPoint(
      m_page->deprecatedLocalMainFrame()->view()->rootFrameToContents(
          posInRootFrame));
  HitTestResult result =
      m_page->deprecatedLocalMainFrame()->eventHandler().hitTestResultAtPoint(
          docPoint, HitTestRequest::ReadOnly | HitTestRequest::Active);
  result.setToShadowHostIfInUserAgentShadowRoot();
  return result;
}

WebHitTestResult WebViewImpl::hitTestResultForTap(
    const WebPoint& tapPointWindowPos,
    const WebSize& tapArea) {
  if (!m_page->mainFrame()->isLocalFrame())
    return HitTestResult();

  WebGestureEvent tapEvent;
  tapEvent.x = tapPointWindowPos.x;
  tapEvent.y = tapPointWindowPos.y;
  tapEvent.type = WebInputEvent::GestureTap;
  // GestureTap is only ever from a touchscreen.
  tapEvent.sourceDevice = WebGestureDeviceTouchscreen;
  tapEvent.data.tap.tapCount = 1;
  tapEvent.data.tap.width = tapArea.width;
  tapEvent.data.tap.height = tapArea.height;

  PlatformGestureEventBuilder platformEvent(mainFrameImpl()->frameView(),
                                            tapEvent);

  HitTestResult result =
      m_page->deprecatedLocalMainFrame()
          ->eventHandler()
          .hitTestResultForGestureEvent(
              platformEvent, HitTestRequest::ReadOnly | HitTestRequest::Active)
          .hitTestResult();

  result.setToShadowHostIfInUserAgentShadowRoot();
  return result;
}

void WebViewImpl::setTabsToLinks(bool enable) {
  m_tabsToLinks = enable;
}

bool WebViewImpl::tabsToLinks() const {
  return m_tabsToLinks;
}

void WebViewImpl::registerViewportLayersWithCompositor() {
  DCHECK(m_layerTreeView);

  if (!page()->mainFrame() || !page()->mainFrame()->isLocalFrame())
    return;

  Document* document = page()->deprecatedLocalMainFrame()->document();

  DCHECK(document);

  // Get the outer viewport scroll layer.
  GraphicsLayer* layoutViewportScrollLayer =
      page()->frameHost().globalRootScrollerController().rootScrollerLayer();
  WebLayer* layoutViewportWebLayer =
      layoutViewportScrollLayer ? layoutViewportScrollLayer->platformLayer()
                                : nullptr;

  VisualViewport& visualViewport = page()->frameHost().visualViewport();

  // TODO(bokan): This was moved here from when registerViewportLayers was a
  // part of VisualViewport and maybe doesn't belong here. See comment inside
  // the mehtod.
  visualViewport.setScrollLayerOnScrollbars(layoutViewportWebLayer);

  m_layerTreeView->registerViewportLayers(
      visualViewport.overscrollElasticityLayer()->platformLayer(),
      visualViewport.pageScaleLayer()->platformLayer(),
      visualViewport.scrollLayer()->platformLayer(), layoutViewportWebLayer);
}

void WebViewImpl::setRootGraphicsLayer(GraphicsLayer* graphicsLayer) {
  if (!m_layerTreeView)
    return;

  // In SPv2, setRootLayer is used instead.
  DCHECK(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());

  VisualViewport& visualViewport = page()->frameHost().visualViewport();
  visualViewport.attachToLayerTree(graphicsLayer);
  if (graphicsLayer) {
    m_rootGraphicsLayer = visualViewport.rootGraphicsLayer();
    m_visualViewportContainerLayer = visualViewport.containerLayer();
    m_rootLayer = m_rootGraphicsLayer->platformLayer();
    updateRootLayerTransform();
    m_layerTreeView->setRootLayer(*m_rootLayer);
    // We register viewport layers here since there may not be a layer
    // tree view prior to this point.
    registerViewportLayersWithCompositor();

    // TODO(enne): Work around page visibility changes not being
    // propagated to the WebView in some circumstances.  This needs to
    // be refreshed here when setting a new root layer to avoid being
    // stuck in a presumed incorrectly invisible state.
    m_layerTreeView->setVisible(page()->isPageVisible());
  } else {
    m_rootGraphicsLayer = nullptr;
    m_visualViewportContainerLayer = nullptr;
    m_rootLayer = nullptr;
    // This means that we're transitioning to a new page. Suppress
    // commits until Blink generates invalidations so we don't
    // attempt to paint too early in the next page load.
    m_layerTreeView->setDeferCommits(true);
    m_layerTreeView->clearRootLayer();
    m_layerTreeView->clearViewportLayers();
    if (WebDevToolsAgentImpl* devTools = mainFrameDevToolsAgentImpl())
      devTools->rootLayerCleared();
  }
}

void WebViewImpl::setRootLayer(WebLayer* layer) {
  if (!m_layerTreeView)
    return;

  if (layer) {
    m_rootLayer = layer;
    m_layerTreeView->setRootLayer(*m_rootLayer);
    m_layerTreeView->setVisible(page()->isPageVisible());
  } else {
    m_rootLayer = nullptr;
    // This means that we're transitioning to a new page. Suppress
    // commits until Blink generates invalidations so we don't
    // attempt to paint too early in the next page load.
    m_layerTreeView->setDeferCommits(true);
    m_layerTreeView->clearRootLayer();
    m_layerTreeView->clearViewportLayers();
    if (WebDevToolsAgentImpl* devTools = mainFrameDevToolsAgentImpl())
      devTools->rootLayerCleared();
  }
}

void WebViewImpl::invalidateRect(const IntRect& rect) {
  if (m_layerTreeView) {
    updateLayerTreeViewport();
  } else if (m_client) {
    // This is only for WebViewPlugin.
    m_client->widgetClient()->didInvalidateRect(rect);
  }
}

PaintLayerCompositor* WebViewImpl::compositor() const {
  WebLocalFrameImpl* frame = mainFrameImpl();
  if (!frame)
    return nullptr;

  Document* document = frame->frame()->document();
  if (!document || document->layoutViewItem().isNull())
    return nullptr;

  return document->layoutViewItem().compositor();
}

GraphicsLayer* WebViewImpl::rootGraphicsLayer() {
  return m_rootGraphicsLayer;
}

void WebViewImpl::scheduleAnimationForWidget() {
  if (m_layerTreeView) {
    m_layerTreeView->setNeedsBeginFrame();
    return;
  }
  if (m_client)
    m_client->widgetClient()->scheduleAnimation();
}

void WebViewImpl::attachCompositorAnimationTimeline(
    CompositorAnimationTimeline* timeline) {
  if (m_layerTreeView)
    m_layerTreeView->attachCompositorAnimationTimeline(
        timeline->animationTimeline());
}

void WebViewImpl::detachCompositorAnimationTimeline(
    CompositorAnimationTimeline* timeline) {
  if (m_layerTreeView)
    m_layerTreeView->detachCompositorAnimationTimeline(
        timeline->animationTimeline());
}

void WebViewImpl::initializeLayerTreeView() {
  if (m_client) {
    m_client->initializeLayerTreeView();
    m_layerTreeView = m_client->widgetClient()->layerTreeView();
  }

  if (WebDevToolsAgentImpl* devTools = mainFrameDevToolsAgentImpl())
    devTools->layerTreeViewChanged(m_layerTreeView);

  m_page->settings().setAcceleratedCompositingEnabled(m_layerTreeView);
  if (m_layerTreeView)
    m_page->layerTreeViewInitialized(*m_layerTreeView);

  // FIXME: only unittests, click to play, Android printing, and printing (for
  // headers and footers) make this assert necessary. We should make them not
  // hit this code and then delete allowsBrokenNullLayerTreeView.
  DCHECK(m_layerTreeView || !m_client ||
         m_client->widgetClient()->allowsBrokenNullLayerTreeView());

  if (Platform::current()->isThreadedAnimationEnabled() && m_layerTreeView) {
    m_linkHighlightsTimeline = CompositorAnimationTimeline::create();
    attachCompositorAnimationTimeline(m_linkHighlightsTimeline.get());
  }
}

void WebViewImpl::applyViewportDeltas(
    const WebFloatSize& visualViewportDelta,
    // TODO(bokan): This parameter is to be removed but requires adjusting many
    // callsites.
    const WebFloatSize&,
    const WebFloatSize& elasticOverscrollDelta,
    float pageScaleDelta,
    float topControlsShownRatioDelta) {
  VisualViewport& visualViewport = page()->frameHost().visualViewport();

  // Store the desired offsets the visual viewport before setting the top
  // controls ratio since doing so will change the bounds and move the
  // viewports to keep the offsets valid. The compositor may have already
  // done that so we don't want to double apply the deltas here.
  FloatPoint visualViewportOffset = visualViewport.visibleRect().location();
  visualViewportOffset.move(visualViewportDelta.width,
                            visualViewportDelta.height);

  topControls().setShownRatio(topControls().shownRatio() +
                              topControlsShownRatioDelta);

  setPageScaleFactorAndLocation(pageScaleFactor() * pageScaleDelta,
                                visualViewportOffset);

  if (pageScaleDelta != 1) {
    m_doubleTapZoomPending = false;
    visualViewport.userDidChangeScale();
  }

  m_elasticOverscroll += elasticOverscrollDelta;

  if (mainFrameImpl() && mainFrameImpl()->frameView())
    mainFrameImpl()->frameView()->didUpdateElasticOverscroll();
}

void WebViewImpl::updateLayerTreeViewport() {
  if (!page() || !m_layerTreeView)
    return;

  m_layerTreeView->setPageScaleFactorAndLimits(
      pageScaleFactor(), minimumPageScaleFactor(), maximumPageScaleFactor());
}

void WebViewImpl::updateLayerTreeBackgroundColor() {
  if (!m_layerTreeView)
    return;

  m_layerTreeView->setBackgroundColor(alphaChannel(m_backgroundColorOverride)
                                          ? m_backgroundColorOverride
                                          : backgroundColor());
}

void WebViewImpl::updateLayerTreeDeviceScaleFactor() {
  DCHECK(page());
  DCHECK(m_layerTreeView);

  float deviceScaleFactor = m_compositorDeviceScaleFactorOverride
                                ? m_compositorDeviceScaleFactorOverride
                                : page()->deviceScaleFactor();
  m_layerTreeView->setDeviceScaleFactor(deviceScaleFactor);
}

void WebViewImpl::updateRootLayerTransform() {
  if (m_visualViewportContainerLayer)
    m_visualViewportContainerLayer->setTransform(m_rootLayerTransform);
}

bool WebViewImpl::detectContentOnTouch(
    const GestureEventWithHitTestResults& targetedEvent) {
  if (!m_page->mainFrame()->isLocalFrame())
    return false;

  // Need a local copy of the hit test as
  // setToShadowHostIfInUserAgentShadowRoot() will modify it.
  HitTestResult touchHit = targetedEvent.hitTestResult();
  touchHit.setToShadowHostIfInUserAgentShadowRoot();

  if (touchHit.isContentEditable())
    return false;

  Node* node = touchHit.innerNode();
  if (!node || !node->isTextNode())
    return false;

  // Ignore when tapping on links or nodes listening to click events, unless
  // the click event is on the body element, in which case it's unlikely that
  // the original node itself was intended to be clickable.
  for (; node && !isHTMLBodyElement(*node);
       node = LayoutTreeBuilderTraversal::parent(*node)) {
    if (node->isLink() || node->willRespondToTouchEvents() ||
        node->willRespondToMouseClickEvents())
      return false;
  }

  WebURL intent = m_client->detectContentIntentAt(touchHit);
  if (!intent.isValid())
    return false;

  // This code is called directly after hit test code, with no user code
  // running in between, thus it is assumed that the frame pointer is non-null.
  bool isMainFrame = node ? node->document().frame()->isMainFrame() : true;
  m_client->scheduleContentIntent(intent, isMainFrame);
  return true;
}

WebViewScheduler* WebViewImpl::scheduler() const {
  return m_scheduler.get();
}

void WebViewImpl::setVisibilityState(WebPageVisibilityState visibilityState,
                                     bool isInitialState) {
  DCHECK(visibilityState == WebPageVisibilityStateVisible ||
         visibilityState == WebPageVisibilityStateHidden ||
         visibilityState == WebPageVisibilityStatePrerender);

  if (page())
    m_page->setVisibilityState(
        static_cast<PageVisibilityState>(static_cast<int>(visibilityState)),
        isInitialState);

  bool visible = visibilityState == WebPageVisibilityStateVisible;
  if (m_layerTreeView && !m_overrideCompositorVisibility)
    m_layerTreeView->setVisible(visible);
  m_scheduler->setPageVisible(visible);
}

void WebViewImpl::setCompositorVisibility(bool isVisible) {
  if (!isVisible)
    m_overrideCompositorVisibility = true;
  else
    m_overrideCompositorVisibility = false;
  if (m_layerTreeView)
    m_layerTreeView->setVisible(isVisible);
}

void WebViewImpl::pointerLockMouseEvent(const WebInputEvent& event) {
  std::unique_ptr<UserGestureIndicator> gestureIndicator;
  AtomicString eventType;
  switch (event.type) {
    case WebInputEvent::MouseDown:
      eventType = EventTypeNames::mousedown;
      gestureIndicator = wrapUnique(
          new UserGestureIndicator(DefinitelyProcessingNewUserGesture));
      m_pointerLockGestureToken = gestureIndicator->currentToken();
      break;
    case WebInputEvent::MouseUp:
      eventType = EventTypeNames::mouseup;
      gestureIndicator = wrapUnique(
          new UserGestureIndicator(m_pointerLockGestureToken.release()));
      break;
    case WebInputEvent::MouseMove:
      eventType = EventTypeNames::mousemove;
      break;
    default:
      NOTREACHED();
  }

  const WebMouseEvent& mouseEvent = static_cast<const WebMouseEvent&>(event);

  if (page())
    page()->pointerLockController().dispatchLockedMouseEvent(
        PlatformMouseEventBuilder(mainFrameImpl()->frameView(), mouseEvent),
        eventType);
}

void WebViewImpl::forceNextWebGLContextCreationToFail() {
  WebGLRenderingContext::forceNextWebGLContextCreationToFail();
}

void WebViewImpl::forceNextDrawingBufferCreationToFail() {
  DrawingBuffer::forceNextDrawingBufferCreationToFail();
}

CompositorProxyClient* WebViewImpl::createCompositorProxyClient() {
  if (!m_mutator) {
    std::unique_ptr<CompositorMutatorClient> mutatorClient =
        CompositorMutatorImpl::createClient();
    m_mutator = static_cast<CompositorMutatorImpl*>(mutatorClient->mutator());
    m_layerTreeView->setMutatorClient(std::move(mutatorClient));
  }
  return new CompositorProxyClientImpl(m_mutator);
}

void WebViewImpl::updatePageOverlays() {
  if (m_pageColorOverlay)
    m_pageColorOverlay->update();
  if (InspectorOverlay* overlay = inspectorOverlay()) {
    PageOverlay* inspectorPageOverlay = overlay->pageOverlay();
    if (inspectorPageOverlay)
      inspectorPageOverlay->update();
  }
}

float WebViewImpl::deviceScaleFactor() const {
  // TODO(oshima): Investigate if this should return the ScreenInfo's scale
  // factor rather than page's scale factor, which can be 1 in use-zoom-for-dsf
  // mode.
  if (!page())
    return 1;

  return page()->deviceScaleFactor();
}

LocalFrame* WebViewImpl::focusedLocalFrameInWidget() const {
  if (!mainFrameImpl())
    return nullptr;

  LocalFrame* focusedFrame = toLocalFrame(focusedCoreFrame());
  if (focusedFrame->localFrameRoot() != mainFrameImpl()->frame())
    return nullptr;
  return focusedFrame;
}

LocalFrame* WebViewImpl::focusedLocalFrameAvailableForIme() const {
  return m_imeAcceptEvents ? focusedLocalFrameInWidget() : nullptr;
}

}  // namespace blink