Adds scroll position/scale emulation to DevTools.

third_party/WebKit/Source/web/WebViewImpl.cpp

Index: third_party/WebKit/Source/web/WebViewImpl.cpp
diff --git a/third_party/WebKit/Source/web/WebViewImpl.cpp b/third_party/WebKit/Source/web/WebViewImpl.cpp
index 3e92e32a2f867341300bb60c550f5729a13a1c55..223cd590395ca5442e8b0b2b76a7b764a080d6f0 100644
--- a/third_party/WebKit/Source/web/WebViewImpl.cpp
+++ b/third_party/WebKit/Source/web/WebViewImpl.cpp
@@ -56,6 +56,7 @@
 #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"
@@ -3208,6 +3209,58 @@ WebFloatSize WebViewImpl::visualViewportSize() const
     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());

[bokan, 2016/07/01 21:05:12]

Give the ScrollAndScaleEmulator a ref to the frameHost and move all this code
(and the disableThreadedScrolling) and it's dual in the "clear" method inside
it.

[Eric Seckler, 2016/07/04 14:33:08]

Done. At the moment, I don't keep a reference to the page as member in the
emulator, but pass it in only for the methods as needed. (Primarily because I am
not sure about its lifetime.) Does that make sense, or can I safely store it? If
so, which of Blink's reference types would be the most sensible one? :)

[bokan, 2016/07/04 22:44:08]

I would actually move the ScrollAndScaleEmulator object to be owned by
FrameHost. FrameHost is basically the same as Page but was split off for OOPIF
refactorings (Page will eventually disappear from Blink) and you can get a
pointer to Page from FrameHost and vice-versa. That way you don't have to worry
about lifetime issues and I think it makes more sense conceptually.

You can then store a back-pointer to FrameHost (as a Member<>) without worrying
about it being GC'd from under you.

+    }
+}
+
+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());

[bokan, 2016/07/01 21:05:12]

This will clear existing UA constraints. You should save the current UA
constraints when creating the override and restore to those instead (like you do
with the threaded scrolling flag).

[Eric Seckler, 2016/07/04 14:33:08]

Done.

+
+    // TODO(eseckler): For some reason, we seem to need this enforce the cleared
+    // constraints. Adding it in setScrollAndScaleOverride() makes the override
+    // ineffective, though.

[bokan, 2016/07/01 21:05:13]

I think you it doesn't work in the setter because it'll then skip
refreshPageScaleFactorAfterLayout in WebViewImpl::layoutUpdated.

I'm not sure why you'd need computeFinalConstraints here though...do you mean
that without it pinching in and out doesn't change from the overridden scale?
could you dig into it a little? setUserAgentPageScaleConstraints should
setNeedsLayout which should then eventually reach WebViewImpl::layoutUpdated
with dirty constraints. resetScrollAndScaleState below should also set the scale
(without respecting limits) to 1 as well as call setNeedsReset(true) which means
that layoutUpdated will reset to the minimum page scale. Not sure where this is
going wrong or why you'd need computeFinalConstraints here.

[Eric Seckler, 2016/07/04 14:33:08]

What I'm seeing is that the scale factor is not reset to 1 when the overrides
are cleared (without the call to computeFinalConstraints()). Instead, it stays
at the overridden value, but can be changed by e.g. pinch-zooming.

I now also know where this is coming from.
DevToolsEmulator::disableDeviceEmulation() is called in the process of handling
the "clearDeviceMetricsOverride" devtools command. There,
WebViewImpl::setPageScaleFactor() is called, which clamps to the old constraints
if computeFinalConstraints() is not called first.

I'm now fixing this by setting the page scale on the visual viewport directly
(circumventing clamping) from DevToolsEmulator. It also seems that the
DevToolsEmulator only modifies page scales when mobile emulation is active.
Thus, I also moved the call to setPageScaleFactor() from
disableDeviceEmulation() to disableMobileEmulation() and updated its test. Let
me know if this is reasonable :)

[bokan, 2016/07/04 22:44:08]

Thanks for tracking it down. See my reply in DevToolsEmulator.cpp.

+    page()->frameHost().pageScaleConstraintsSet().computeFinalConstraints();
+
+    m_scrollAndScaleEmulator.clear();
+    resetScrollAndScaleState();
+}
+
 void WebViewImpl::scrollAndRescaleViewports(float scaleFactor,
     const IntPoint& mainFrameOrigin,
     const FloatPoint& visualViewportOrigin)
@@ -3342,10 +3395,22 @@ void WebViewImpl::setIgnoreViewportTagScaleLimits(bool ignore)
 
 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);
+
+    // The frame size should match the viewport size at minimum scale, since the
+    // 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());

[bokan, 2016/07/01 21:05:13]

I'd add a method to the scrollAndScaleEmulator that calculate the frame size to
use that if we have an Emulator. You can then move all this in there. Also, it's
probably cleaner to just copy the PageScaleConstraintsSet, remove the UA
constraint, and calculate the minimum from that rather than operating on the
live constraints set.

[Eric Seckler, 2016/07/04 14:33:08]

Done.

+        pageScaleConstraintsSet().computeFinalConstraints();
+    }
     frameSize.scale(1 / minimumPageScaleFactor());
+    if (m_scrollAndScaleEmulator) {
+        pageScaleConstraintsSet().setUserAgentConstraints(m_scrollAndScaleEmulator->pageScaleConstraints());
+        pageScaleConstraintsSet().computeFinalConstraints();
+    }
+
     return expandedIntSize(frameSize);
 }
 
@@ -3834,10 +3899,12 @@ void WebViewImpl::setRootLayerTransform(const WebSize& rootLayerOffset, float ro
 void WebViewImpl::enableDeviceEmulation(const WebDeviceEmulationParams& params)
 {
     m_devToolsEmulator->enableDeviceEmulation(params);
+    setScrollAndScaleOverride(params);
 }
 
 void WebViewImpl::disableDeviceEmulation()
 {
+    clearScrollAndScaleOverride();
     m_devToolsEmulator->disableDeviceEmulation();
 }