Adds scroll position/scale emulation to DevTools.

third_party/WebKit/Source/web/WebViewImpl.cpp

 /*
  * 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
@@ skipping 38 matching lines @@
 #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/ScrollAndScaleEmulator.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"
@@ skipping 3131 matching lines @@
     DCHECK(page());
     return page()->frameHost().visualViewport().visibleRect().location();
 }
 
 WebFloatSize WebViewImpl::visualViewportSize() const
 {
     DCHECK(page());
     return page()->frameHost().visualViewport().visibleRect().size();
 }
 
+void WebViewImpl::setScrollAndScaleOverride(const WebDeviceEmulationParams& params)
+{
+    if (!page() || !mainFrameImpl())
+        return;
+
+    FrameView * view = mainFrameImpl()->frameView();
+    if (!view)
+        return;
+
+    if (!m_scrollAndScaleEmulator) {
+        m_scrollAndScaleEmulator = ScrollAndScaleEmulator::create();
+
+        // Force main thread scrolling, because we do not apply scroll position
+        // overrides in the compositor thread.
+        m_scrollAndScaleEmulator->disableThreadedScrolling(page());
+    }
+
+    bool hasChanged = m_scrollAndScaleEmulator->update(
+        static_cast<IntPoint>(params.scrollPosition),
+        static_cast<FloatPoint>(params.visualViewportPosition),
+        params.visualViewportScale);
+    if (hasChanged) {
+        view->setScrollAndScaleEmulator(m_scrollAndScaleEmulator);
+        page()->frameHost().visualViewport().setScrollAndScaleEmulator(m_scrollAndScaleEmulator);
+        page()->frameHost().setUserAgentPageScaleConstraints(m_scrollAndScaleEmulator->pageScaleConstraints());
+    }
+}
+
+void WebViewImpl::clearScrollAndScaleOverride()
+{
+    if (!m_scrollAndScaleEmulator || !page() || !mainFrameImpl())
+        return;
+
+    FrameView * view = mainFrameImpl()->frameView();
+    if (!view)
+        return;
+
+    m_scrollAndScaleEmulator->restoreThreadedScrolling(page());
+
+    view->setScrollAndScaleEmulator(nullptr);
+    page()->frameHost().visualViewport().setScrollAndScaleEmulator(nullptr);
+    page()->frameHost().setUserAgentPageScaleConstraints(PageScaleConstraints());
+
+    // TODO(eseckler): For some reason, we seem to need this enforce the cleared
+    // constraints. Adding it in setScrollAndScaleOverride() makes the override
+    // ineffective, though.
+    page()->frameHost().pageScaleConstraintsSet().computeFinalConstraints();

[Eric Seckler, 2016/06/30 20:01:28]

Not sure why this line is necessary here (otherwise the cleared constraints
don't have any visible effect). Weirdly, it hurts to add it at the same place in
setScrollAndScaleOverride(), in which case the scale override doesn't have any
visible effect.

+
+    m_scrollAndScaleEmulator.clear();
+    resetScrollAndScaleState();
+}
+
 void WebViewImpl::scrollAndRescaleViewports(float scaleFactor,
     const IntPoint& mainFrameOrigin,
     const FloatPoint& visualViewportOrigin)
 {
     if (!page())
         return;
 
     if (!mainFrameImpl())
         return;
 
@@ skipping 113 matching lines @@
         constraints.maximumScale = pageScaleConstraintsSet().defaultConstraints().maximumScale;
     } else {
         constraints.minimumScale = -1;
         constraints.maximumScale = -1;
     }
     page()->frameHost().setUserAgentPageScaleConstraints(constraints);
 }
 
 IntSize WebViewImpl::mainFrameSize()
 {
+    FloatSize frameSize(m_size);
+
     // 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);
+    // viewport must always be contained by the frame. ScrollAndScaleEmulator
+    // overrides the minimum scale in the userAgentConstraints. These overrides
+    // should be ignored for this calculation.
+    if (m_scrollAndScaleEmulator) {
+        pageScaleConstraintsSet().setUserAgentConstraints(PageScaleConstraints());
+        pageScaleConstraintsSet().computeFinalConstraints();
+    }
     frameSize.scale(1 / minimumPageScaleFactor());
+    if (m_scrollAndScaleEmulator) {
+        pageScaleConstraintsSet().setUserAgentConstraints(m_scrollAndScaleEmulator->pageScaleConstraints());
+        pageScaleConstraintsSet().computeFinalConstraints();
+    }
+
     return expandedIntSize(frameSize);
 }
 
 PageScaleConstraintsSet& WebViewImpl::pageScaleConstraintsSet() const
 {
     return page()->frameHost().pageScaleConstraintsSet();
 }
 
 void WebViewImpl::refreshPageScaleFactorAfterLayout()
 {
@@ skipping 468 matching lines @@
     m_rootLayerScale = rootLayerScale;
     m_rootLayerOffset = rootLayerOffset;
     if (mainFrameImpl())
         mainFrameImpl()->setInputEventsTransformForEmulation(m_rootLayerOffset, m_rootLayerScale);
     updateRootLayerTransform();
 }
 
 void WebViewImpl::enableDeviceEmulation(const WebDeviceEmulationParams& params)
 {
     m_devToolsEmulator->enableDeviceEmulation(params);
+    setScrollAndScaleOverride(params);
 }
 
 void WebViewImpl::disableDeviceEmulation()
 {
+    clearScrollAndScaleOverride();
     m_devToolsEmulator->disableDeviceEmulation();
 }
 
 WebAXObject WebViewImpl::accessibilityObject()
 {
     if (!mainFrameImpl())
         return WebAXObject();
 
     Document* document = mainFrameImpl()->frame()->document();
     return WebAXObject(toAXObjectCacheImpl(document->axObjectCache())->root());
@@ skipping 672 matching lines @@
 {
     // 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();
 }
 
 } // namespace blink