Made PinchViewport a ScrollableArea

Source/core/frame/PinchViewport.cpp

 /*
  * 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 45 matching lines @@
 using blink::WebLayerTreeView;
 using blink::WebScrollbar;
 using blink::WebScrollbarLayer;
 using WebCore::FrameHost;
 using WebCore::GraphicsLayer;
 using WebCore::GraphicsLayerFactory;
 
 namespace WebCore {
 
 PinchViewport::PinchViewport(FrameHost& owner)
-    : m_owner(owner)
+    : m_frameHost(owner)
 {
 }
 
 PinchViewport::~PinchViewport() { }
 
-void PinchViewport::setViewportSize(const WebCore::IntSize& newSize)
+void PinchViewport::setSize(const IntSize& newSize)
 {
+    // TODO: This is currently called from WebViewImpl with the main frame size which
+    // is (or will be) incorrect, address in future patches.
+
     if (!m_innerViewportContainerLayer || !m_innerViewportScrollLayer)
         return;
 
     m_innerViewportContainerLayer->setSize(newSize);
     // The innerviewport scroll layer always has the same size as its clip layer, but
     // the page scale layer lives between them, allowing for non-zero max scroll
     // offset when page scale > 1.
     m_innerViewportScrollLayer->setSize(newSize);
 
     // Need to re-compute sizes for the overlay scrollbars.
     setupScrollbar(WebScrollbar::Horizontal);
     setupScrollbar(WebScrollbar::Vertical);
 }
 
+void PinchViewport::setLocation(const IntPoint& newLocation)
+{
+    // TODO: The update from the LayerTree will occur here before the scale delta is applied.
+    // this means that the clamping below may be incorrect. Once scaling is done in PinchViewport
+    // change it so they happen at the same time.
+
+    // Clamp the location within our extents.
+    IntPoint location(newLocation);
+    location.shrunkTo(maximumScrollPosition());
+    location.expandedTo(minimumScrollPosition());
+
+    m_visibleRect.setLocation(newLocation);
+
+    ScrollingCoordinator* coordinator = m_frameHost.page().scrollingCoordinator();
+    ASSERT(coordinator);
+
+    coordinator->scrollableAreaScrollLayerDidChange(this);
+}
+
 // Modifies the top of the graphics layer tree to add layers needed to support
 // the inner/outer viewport fixed-position model for pinch zoom. When finished,
 // the tree will look like this (with * denoting added layers):
 //
 // *innerViewportContainerLayer (fixed pos container)
 //  +- *pageScaleLayer
 //  |   +- *innerViewportScrollLayer
 //  |       +-- overflowControlsHostLayer (root layer)
 //  |           +-- rootTransformLayer (optional)
 //  |               +-- outerViewportContainerLayer (fixed pos container) [frame container layer in RenderLayerCompositor]
@@ skipping 20 matching lines @@
             && !m_overlayScrollbarVertical
             && !m_pageScaleLayer
             && !m_innerViewportContainerLayer);
 
         m_innerViewportContainerLayer = GraphicsLayer::create(graphicsLayerFactory, this);
         m_pageScaleLayer = GraphicsLayer::create(graphicsLayerFactory, this);
         m_innerViewportScrollLayer = GraphicsLayer::create(graphicsLayerFactory, this);
         m_overlayScrollbarHorizontal = GraphicsLayer::create(graphicsLayerFactory, this);
         m_overlayScrollbarVertical = GraphicsLayer::create(graphicsLayerFactory, this);
 
-        WebCore::ScrollingCoordinator* coordinator = m_owner.page().scrollingCoordinator();
+        WebCore::ScrollingCoordinator* coordinator = m_frameHost.page().scrollingCoordinator();
         ASSERT(coordinator);
         coordinator->setLayerIsContainerForFixedPositionLayers(m_innerViewportScrollLayer.get(), true);
 
         // No need for the inner viewport to clip, since the compositing
         // surface takes care of it -- and clipping here would interfere with
         // dynamically-sized viewports on Android.
         m_innerViewportContainerLayer->setMasksToBounds(false);
 
         m_innerViewportScrollLayer->platformLayer()->setScrollClipLayer(
             m_innerViewportContainerLayer->platformLayer());
         m_innerViewportScrollLayer->platformLayer()->setUserScrollable(true, true);
 
         m_innerViewportContainerLayer->addChild(m_pageScaleLayer.get());
         m_pageScaleLayer->addChild(m_innerViewportScrollLayer.get());
         m_innerViewportContainerLayer->addChild(m_overlayScrollbarHorizontal.get());
         m_innerViewportContainerLayer->addChild(m_overlayScrollbarVertical.get());
 
+        // Ensure this class is set as the scroll layer's ScrollableArea
+        coordinator->scrollableAreaScrollLayerDidChange(this);
+
         // Setup the inner viewport overlay scrollbars.
         setupScrollbar(WebScrollbar::Horizontal);
         setupScrollbar(WebScrollbar::Vertical);
     }
 
     m_innerViewportScrollLayer->removeAllChildren();
     m_innerViewportScrollLayer->addChild(currentLayerTreeRoot);
 
     // We only need to disable the existing (outer viewport) scrollbars
     // if the existing ones are already overlay.
     // FIXME: If we knew in advance before the overflowControlsHostLayer goes
     // away, we would re-enable the drawing of these scrollbars.
     // FIXME: This doesn't seem to work (at least on Android). Commenting out for now until
     // I figure out how to access RenderLayerCompositor from here.
-    // if (GraphicsLayer* scrollbar = m_owner->compositor()->layerForHorizontalScrollbar())
+    // if (GraphicsLayer* scrollbar = m_frameHost->compositor()->layerForHorizontalScrollbar())
     //    scrollbar->setDrawsContent(!page->mainFrame()->view()->hasOverlayScrollbars());
-    // if (GraphicsLayer* scrollbar = m_owner->compositor()->layerForVerticalScrollbar())
+    // if (GraphicsLayer* scrollbar = m_frameHost->compositor()->layerForVerticalScrollbar())
     //    scrollbar->setDrawsContent(!page->mainFrame()->view()->hasOverlayScrollbars());
 }
 
 void PinchViewport::setupScrollbar(WebScrollbar::Orientation orientation)
 {
     bool isHorizontal = orientation == WebScrollbar::Horizontal;
     GraphicsLayer* scrollbarGraphicsLayer = isHorizontal ?
         m_overlayScrollbarHorizontal.get() : m_overlayScrollbarVertical.get();
     OwnPtr<WebScrollbarLayer>& webScrollbarLayer = isHorizontal ?
         m_webOverlayScrollbarHorizontal : m_webOverlayScrollbarVertical;
 
-    const int overlayScrollbarThickness = m_owner.settings().pinchOverlayScrollbarThickness();
+    const int overlayScrollbarThickness = m_frameHost.settings().pinchOverlayScrollbarThickness();
 
     if (!webScrollbarLayer) {
-        WebCore::ScrollingCoordinator* coordinator = m_owner.page().scrollingCoordinator();
+        ScrollingCoordinator* coordinator = m_frameHost.page().scrollingCoordinator();
         ASSERT(coordinator);
-        WebCore::ScrollbarOrientation webcoreOrientation = isHorizontal ? WebCore::HorizontalScrollbar : WebCore::VerticalScrollbar;
+        ScrollbarOrientation webcoreOrientation = isHorizontal ? HorizontalScrollbar : VerticalScrollbar;
         webScrollbarLayer = coordinator->createSolidColorScrollbarLayer(webcoreOrientation, overlayScrollbarThickness, false);
 
         webScrollbarLayer->setClipLayer(m_innerViewportContainerLayer->platformLayer());
         scrollbarGraphicsLayer->setContentsToPlatformLayer(webScrollbarLayer->layer());
         scrollbarGraphicsLayer->setDrawsContent(false);
     }
 
     int xPosition = isHorizontal ? 0 : m_innerViewportContainerLayer->size().width() - overlayScrollbarThickness;
     int yPosition = isHorizontal ? m_innerViewportContainerLayer->size().height() - overlayScrollbarThickness : 0;
     int width = isHorizontal ? m_innerViewportContainerLayer->size().width() - overlayScrollbarThickness : overlayScrollbarThickness;
     int height = isHorizontal ? overlayScrollbarThickness : m_innerViewportContainerLayer->size().height() - overlayScrollbarThickness;
 
     // Use the GraphicsLayer to position the scrollbars.
-    scrollbarGraphicsLayer->setPosition(WebCore::IntPoint(xPosition, yPosition));
-    scrollbarGraphicsLayer->setSize(WebCore::IntSize(width, height));
-    scrollbarGraphicsLayer->setContentsRect(WebCore::IntRect(0, 0, width, height));
+    scrollbarGraphicsLayer->setPosition(IntPoint(xPosition, yPosition));
+    scrollbarGraphicsLayer->setSize(IntSize(width, height));
+    scrollbarGraphicsLayer->setContentsRect(IntRect(0, 0, width, height));
 }
 
-void PinchViewport::registerViewportLayersWithTreeView(WebLayerTreeView* layerTreeView) const
+void PinchViewport::registerLayersWithTreeView(WebLayerTreeView* layerTreeView) const
 {
     ASSERT(layerTreeView);
-    ASSERT(m_owner.page().mainFrame());
-    ASSERT(m_owner.page().mainFrame()->contentRenderer());
+    ASSERT(m_frameHost.page().mainFrame());
+    ASSERT(m_frameHost.page().mainFrame()->contentRenderer());
 
-    WebCore::RenderLayerCompositor* compositor = m_owner.page().mainFrame()->contentRenderer()->compositor();
+    RenderLayerCompositor* compositor = m_frameHost.page().mainFrame()->contentRenderer()->compositor();
     // Get the outer viewport scroll layer.
     WebLayer* scrollLayer = compositor->scrollLayer()->platformLayer();
 
     m_webOverlayScrollbarHorizontal->setScrollLayer(scrollLayer);
     m_webOverlayScrollbarVertical->setScrollLayer(scrollLayer);
 
     ASSERT(compositor);
     layerTreeView->registerViewportLayers(
         m_pageScaleLayer->platformLayer(),
         m_innerViewportScrollLayer->platformLayer(),
         scrollLayer);
 }
 
-void PinchViewport::clearViewportLayersForTreeView(WebLayerTreeView* layerTreeView) const
+void PinchViewport::clearLayersForTreeView(WebLayerTreeView* layerTreeView) const
 {
     ASSERT(layerTreeView);
 
     layerTreeView->clearViewportLayers();
 }
 
+int PinchViewport::scrollSize(ScrollbarOrientation orientation) const
+{
+    IntSize scrollDimensions = maximumScrollPosition() - minimumScrollPosition();
+    return (orientation == HorizontalScrollbar) ? scrollDimensions.width() : scrollDimensions.height();
+}
+
+IntPoint PinchViewport::minimumScrollPosition() const
+{
+    return IntPoint();
+}
+
+IntPoint PinchViewport::maximumScrollPosition() const
+{
+    // TODO: Doesn't take scale into account yet.
+    IntPoint maxScrollPosition(contentsSize() - visibleRect().size());
+    maxScrollPosition.clampNegativeToZero();
+    return maxScrollPosition;
+}
+
+IntRect PinchViewport::scrollableAreaBoundingBox() const
+{
+    // This method should return the bounding box in the parent view's coordinate
+    // space; however, PinchViewport technically isn't a child of any Frames.
+    // Nonetheless, the PinchViewport always occupies the entire main frame so just
+    // return that.
+    LocalFrame* frame = m_frameHost.page().mainFrame();
+
+    if (!frame || !frame->view())
+        return IntRect();
+
+    return frame->view()->frameRect();
+}
+
+IntSize PinchViewport::contentsSize() const
+{
+    LocalFrame* frame = m_frameHost.page().mainFrame();
+
+    if (!frame || !frame->view())
+        return IntSize();
+
+    // TODO: This will be visibleContentSize once page scale is removed from FrameView
+    return frame->view()->unscaledVisibleContentSize(IncludeScrollbars);
+}
+
+void PinchViewport::invalidateScrollbarRect(Scrollbar*, const IntRect&)
+{
+    // Do nothing. Pinch scrollbars live on the compositor thread and will
+    // be updated when the viewport is synced to the CC.
+}
+
+void PinchViewport::setScrollOffset(const IntPoint& offset)
+{
+    setLocation(offset);
+}
+
+GraphicsLayer* PinchViewport::layerForContainer() const OVERRIDE
+{
+    return m_innerViewportContainerLayer.get();
+}
+
+GraphicsLayer* PinchViewport::layerForScrolling() const OVERRIDE
+{
+    return m_innerViewportScrollLayer.get();
+}
+
+GraphicsLayer* PinchViewport::layerForHorizontalScrollbar() const OVERRIDE
+{
+    return m_overlayScrollbarHorizontal.get();
+}
+
+GraphicsLayer* PinchViewport::layerForVerticalScrollbar() const OVERRIDE
+{
+    return m_overlayScrollbarVertical.get();
+}
+
 void PinchViewport::notifyAnimationStarted(const GraphicsLayer*, double monotonicTime)
 {
 }
 
-void PinchViewport::paintContents(const GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& inClip)
+void PinchViewport::paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& inClip)
 {
 }
 
 String PinchViewport::debugName(const GraphicsLayer* graphicsLayer)
 {
     String name;
     if (graphicsLayer == m_innerViewportContainerLayer.get()) {
         name = "Inner Viewport Container Layer";
     } else if (graphicsLayer == m_pageScaleLayer.get()) {
         name =  "Page Scale Layer";
     } else if (graphicsLayer == m_innerViewportScrollLayer.get()) {
         name =  "Inner Viewport Scroll Layer";
     } else if (graphicsLayer == m_overlayScrollbarHorizontal.get()) {
         name =  "Overlay Scrollbar Horizontal Layer";
     } else if (graphicsLayer == m_overlayScrollbarVertical.get()) {
         name =  "Overlay Scrollbar Vertical Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore