Adds scroll position/scale emulation to DevTools.

third_party/WebKit/Source/core/frame/VisualViewport.h

 /*
  * Copyright (C) 2013 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 37 matching lines @@
 }
 
 namespace blink {
 
 class FrameHost;
 class GraphicsContext;
 class GraphicsLayer;
 class IntRect;
 class IntSize;
 class LocalFrame;
+class ScrollAndScaleEmulator;
 
 // Represents the visual viewport the user is currently seeing the page through. This
 // class corresponds to the InnerViewport on the compositor. It is a ScrollableArea; it's
 // offset is set through the GraphicsLayer <-> CC sync mechanisms. Its contents is the page's
 // main FrameView, which corresponds to the outer viewport. The inner viewport is always contained
 // in the outer viewport and can pan within it.
 class CORE_EXPORT VisualViewport final
     : public GarbageCollectedFinalized<VisualViewport>
     , public GraphicsLayerClient
     , public ScrollableArea {
@@ skipping 25 matching lines @@
     void initializeScrollbars();
 
     // Sets the location of the visual viewport relative to the outer viewport. The
     // coordinates are in partial CSS pixels.
     void setLocation(const FloatPoint&);
     // FIXME: This should be called moveBy
     void move(const FloatPoint&);
     void move(const FloatSize&);
     FloatPoint location() const { return m_offset; }
 
+    // Override the scroll location and scale with values from the emulator. Passing |nullptr| clears override.
+    void setScrollAndScaleEmulator(ScrollAndScaleEmulator*);
+
     // Sets the size of the inner viewport when unscaled in CSS pixels.
     void setSize(const IntSize&);
     IntSize size() const { return m_size; }
 
     // Gets the scaled size, i.e. the viewport in root view space.
     FloatSize visibleSize() const;
 
     // Resets the viewport to initial state.
     void reset();
 
@@ skipping 61 matching lines @@
     IntRect visibleContentRect(IncludeScrollbarsInRect = ExcludeScrollbars) const override;
     bool shouldUseIntegerScrollOffset() const override;
     LayoutRect visualRectForScrollbarParts() const override { ASSERT_NOT_REACHED(); return LayoutRect(); }
     bool isActive() const override { return false; }
     int scrollSize(ScrollbarOrientation) const override;
     bool isScrollCornerVisible() const override { return false; }
     IntRect scrollCornerRect() const override { return IntRect(); }
     IntPoint scrollPosition() const override { return flooredIntPoint(m_offset); }
     DoublePoint scrollPositionDouble() const override { return m_offset; }
     IntPoint minimumScrollPosition() const override;
+    DoublePoint minimumScrollPositionDouble() const override;
     IntPoint maximumScrollPosition() const override;
     DoublePoint maximumScrollPositionDouble() const override;
     int visibleHeight() const override { return visibleRect().height(); }
     int visibleWidth() const override { return visibleRect().width(); }
     IntSize contentsSize() const override;
     bool scrollbarsCanBeActive() const override { return false; }
     IntRect scrollableAreaBoundingBox() const override;
     bool userInputScrollable(ScrollbarOrientation) const override { return true; }
     bool shouldPlaceVerticalScrollbarOnLeft() const override { return false; }
     bool scrollAnimatorEnabled() const override;
@@ skipping 34 matching lines @@
 
     // GraphicsLayerClient implementation.
     bool needsRepaint(const GraphicsLayer&) const { ASSERT_NOT_REACHED(); return true; }
     IntRect computeInterestRect(const GraphicsLayer*, const IntRect&) const;
     void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect&) const override;
     String debugName(const GraphicsLayer*) const override;
 
     void setupScrollbar(WebScrollbar::Orientation);
     FloatPoint clampOffsetToBoundaries(const FloatPoint&);
 
+    // Calculate the physical minimum/maximum scroll positions without any overrides applied.
+    DoublePoint calculateMinimumScrollPositionDouble() const;
+    DoublePoint calculateMaximumScrollPositionDouble() const;
+
     LocalFrame* mainFrame() const;
 
     FrameHost& frameHost() const
     {
         ASSERT(m_frameHost);
         return *m_frameHost;
     }
 
     Member<FrameHost> m_frameHost;
     std::unique_ptr<GraphicsLayer> m_rootTransformLayer;
     std::unique_ptr<GraphicsLayer> m_innerViewportContainerLayer;
     std::unique_ptr<GraphicsLayer> m_overscrollElasticityLayer;
     std::unique_ptr<GraphicsLayer> m_pageScaleLayer;
     std::unique_ptr<GraphicsLayer> m_innerViewportScrollLayer;
     std::unique_ptr<GraphicsLayer> m_overlayScrollbarHorizontal;
     std::unique_ptr<GraphicsLayer> m_overlayScrollbarVertical;
     std::unique_ptr<WebScrollbarLayer> m_webOverlayScrollbarHorizontal;
     std::unique_ptr<WebScrollbarLayer> m_webOverlayScrollbarVertical;
 
     // Offset of the visual viewport from the main frame's origin, in CSS pixels.
     FloatPoint m_offset;
     float m_scale;
     IntSize m_size;
     float m_topControlsAdjustment;
     float m_maxPageScale;
     bool m_trackPinchZoomStatsForPage;
+
+    Member<ScrollAndScaleEmulator> m_scrollAndScaleEmulator;
 };
 
 } // namespace blink
 
 #endif // VisualViewport_h