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 3132 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());

[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)
 {
     if (!page())
         return;
 
     if (!mainFrameImpl())
         return;
 
@@ skipping 114 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());

[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);
 }
 
 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 682 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