Add graphics layers for pinch virtual viewport.

Source/core/rendering/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 300 matching lines @@
 void RenderLayerCompositor::didChangeVisibleRect()
 {
     GraphicsLayer* rootLayer = rootGraphicsLayer();
     if (!rootLayer)
         return;
 
     FrameView* frameView = m_renderView ? m_renderView->frameView() : 0;
     if (!frameView)
         return;
 
-    IntRect visibleRect = m_clipLayer ? IntRect(IntPoint(), frameView->contentsSize()) : frameView->visibleContentRect();
+    IntRect visibleRect = m_innerViewportClipLayer ? IntRect(IntPoint(), frameView->contentsSize()) : frameView->visibleContentRect();
     if (rootLayer->visibleRectChangeRequiresFlush(visibleRect)) {
         if (Page* page = this->page())
             page->chrome().client()->scheduleCompositingLayerFlush();
     }
 }
 
 bool RenderLayerCompositor::hasAnyAdditionalCompositedLayers(const RenderLayer* rootLayer) const
 {
     return m_compositedLayerCount > (rootLayer->isComposited() ? 1 : 0);
 }
@@ skipping 778 matching lines @@
 }
 
 void RenderLayerCompositor::frameViewDidChangeLocation(const IntPoint& contentsOffset)
 {
     if (m_overflowControlsHostLayer)
         m_overflowControlsHostLayer->setPosition(contentsOffset);
 }
 
 void RenderLayerCompositor::frameViewDidChangeSize()
 {
-    if (m_clipLayer) {
+    if (m_innerViewportClipLayer) {
         FrameView* frameView = m_renderView->frameView();
-        m_clipLayer->setSize(frameView->unscaledVisibleContentSize());
+        FloatSize unscaledVisibleContentSize = frameView->unscaledVisibleContentSize();
+        m_innerViewportClipLayer->setSize(frameView->frameRect().size());
+        if (m_outerViewportClipLayer) {
+            FloatSize visibleContentSize(unscaledVisibleContentSize);
+            visibleContentSize.scale(frameView->visibleContentScaleFactor());
+            m_outerViewportClipLayer->setSize(visibleContentSize);
+        }
 
         frameViewDidScroll();
         updateOverflowControlsLayers();
 
 #if ENABLE(RUBBER_BANDING)
         if (m_layerForOverhangAreas)
             m_layerForOverhangAreas->setSize(frameView->frameRect().size());
 #endif
     }
 }
 
 void RenderLayerCompositor::frameViewDidScroll()
 {
     FrameView* frameView = m_renderView->frameView();
     IntPoint scrollPosition = frameView->scrollPosition();
 
-    if (!m_scrollLayer)
+    if (!m_innerViewportScrollLayer)
         return;
 
     // If there's a scrolling coordinator that manages scrolling for this frame view,
     // it will also manage updating the scroll layer position.
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator()) {
         if (scrollingCoordinator->coordinatesScrollingForFrameView(frameView))
             return;
         if (Settings* settings = m_renderView->document()->settings()) {
             if (settings->compositedScrollingForFramesEnabled())
                 scrollingCoordinator->scrollableAreaScrollLayerDidChange(frameView);
         }
     }
 
-    m_scrollLayer->setPosition(FloatPoint(-scrollPosition.x(), -scrollPosition.y()));
+    m_innerViewportScrollLayer->setPosition(FloatPoint(-scrollPosition.x(), -scrollPosition.y()));
 
     if (GraphicsLayer* fixedBackgroundLayer = fixedRootBackgroundLayer())
         fixedBackgroundLayer->setPosition(IntPoint(frameView->scrollOffsetForFixedPosition()));
 }
 
 void RenderLayerCompositor::frameViewDidLayout()
 {
 }
 
 void RenderLayerCompositor::rootFixedBackgroundsChanged()
@@ skipping 244 matching lines @@
 
 GraphicsLayer* RenderLayerCompositor::rootGraphicsLayer() const
 {
     if (m_overflowControlsHostLayer)
         return m_overflowControlsHostLayer.get();
     return m_rootContentLayer.get();
 }
 
 GraphicsLayer* RenderLayerCompositor::scrollLayer() const
 {
-    return m_scrollLayer.get();
+    return m_innerViewportScrollLayer.get();
 }
 
 void RenderLayerCompositor::setIsInWindow(bool isInWindow)
 {
     if (!inCompositingMode())
         return;
 
     if (isInWindow) {
         if (m_rootLayerAttachment != RootLayerUnattached)
             return;
@@ skipping 27 matching lines @@
     clearBackingForLayerIncludingDescendants(m_renderView->layer());
 }
 
 void RenderLayerCompositor::updateRootLayerPosition()
 {
     if (m_rootContentLayer) {
         const IntRect& documentRect = m_renderView->documentRect();
         m_rootContentLayer->setSize(documentRect.size());
         m_rootContentLayer->setPosition(documentRect.location());
     }
-    if (m_clipLayer) {
+    if (m_innerViewportClipLayer) {
         FrameView* frameView = m_renderView->frameView();
-        m_clipLayer->setSize(frameView->unscaledVisibleContentSize());
+        m_innerViewportClipLayer->setSize(frameView->frameRect().size());
+        if (m_outerViewportClipLayer)
+            m_outerViewportClipLayer->setSize(frameView->unscaledVisibleContentSize());
     }
 
 #if ENABLE(RUBBER_BANDING)
     if (m_contentShadowLayer) {
         m_contentShadowLayer->setPosition(m_rootContentLayer->position());
 
         FloatSize rootContentLayerSize = m_rootContentLayer->size();
         if (m_contentShadowLayer->size() != rootContentLayerSize) {
             m_contentShadowLayer->setSize(rootContentLayerSize);
             ScrollbarTheme::theme()->setUpContentShadowLayer(m_contentShadowLayer.get());
@@ skipping 717 matching lines @@
             m_layerForTopOverhangArea = nullptr;
         }
         return 0;
     }
 
     if (!m_layerForTopOverhangArea) {
         m_layerForTopOverhangArea = GraphicsLayer::create(graphicsLayerFactory(), this);
 #ifndef NDEBUG
         m_layerForTopOverhangArea->setName("top overhang area");
 #endif
-        m_scrollLayer->addChildBelow(m_layerForTopOverhangArea.get(), m_rootContentLayer.get());
+        // FIXME: When the pinch virtual viewport is enabled, do we really want

[enne (OOO), 2013/05/30 21:03:31]

This is wrong, but this patch doesn't make it any more wrong.  Can you remove
the question marks and more definitively say that this is wrong were there to be
page scale?

On the upside, the overhang layers are only for Mac, where we never have non-1
page scale.

[wjmaclean, 2013/05/31 18:21:10]

Yes. Even better, it can be immortalized with a DCHECK to warn if the condition
is ever violated.
SGTM!

+        // to be applying the page scale to the bottom overhang layer? Will it hurt anything?
+        if (!m_outerViewportScrollLayer)
+            m_innerViewportScrollLayer->addChildBelow(m_layerForTopOverhangArea.get(), m_rootContentLayer.get());
+        else
+            m_outerViewportScrollLayer->addChildBelow(m_layerForTopOverhangArea.get(), m_rootContentLayer.get());
     }
 
     return m_layerForTopOverhangArea.get();
 }
 
 GraphicsLayer* RenderLayerCompositor::updateLayerForBottomOverhangArea(bool wantsLayer)
 {
     if (!isMainFrame())
         return 0;
 
     if (!wantsLayer) {
         if (m_layerForBottomOverhangArea) {
             m_layerForBottomOverhangArea->removeFromParent();
             m_layerForBottomOverhangArea = nullptr;
         }
         return 0;
     }
 
     if (!m_layerForBottomOverhangArea) {
         m_layerForBottomOverhangArea = GraphicsLayer::create(graphicsLayerFactory(), this);
 #ifndef NDEBUG
         m_layerForBottomOverhangArea->setName("bottom overhang area");
 #endif
-        m_scrollLayer->addChildBelow(m_layerForBottomOverhangArea.get(), m_rootContentLayer.get());
+        // FIXME: When the pinch virtual viewport is enabled, do we really want
+        // to be applying the page scale to the bottom overhang layer? Will it hurt anything?
+        if (!m_outerViewportScrollLayer)
+            m_innerViewportScrollLayer->addChildBelow(m_layerForBottomOverhangArea.get(), m_rootContentLayer.get());
+        else
+            m_outerViewportScrollLayer->addChildBelow(m_layerForBottomOverhangArea.get(), m_rootContentLayer.get());
     }
 
     m_layerForBottomOverhangArea->setPosition(FloatPoint(0, m_rootContentLayer->size().height()));
     return m_layerForBottomOverhangArea.get();
 }
 
 #endif
 
 bool RenderLayerCompositor::viewHasTransparentBackground(Color* backgroundColor) const
 {
     FrameView* frameView = m_renderView->frameView();
     if (frameView->isTransparent()) {
         if (backgroundColor)
             *backgroundColor = Color(); // Return an invalid color.
         return true;
     }
 
     Color documentBackgroundColor = frameView->documentBackgroundColor();
     if (!documentBackgroundColor.isValid())
         documentBackgroundColor = Color::white;
 
     if (backgroundColor)
         *backgroundColor = documentBackgroundColor;
         
     return documentBackgroundColor.hasAlpha();
 }
 
 void RenderLayerCompositor::updateOverflowControlsLayers()
 {
+    GraphicsLayer* hostLayerForOverflowControls = m_outerViewportClipLayer ?
+        m_innerViewportScrollLayer.get() : m_innerViewportClipLayer.get();
 #if ENABLE(RUBBER_BANDING)
     if (requiresOverhangAreasLayer()) {
         if (!m_layerForOverhangAreas) {
             m_layerForOverhangAreas = GraphicsLayer::create(graphicsLayerFactory(), this);
 #ifndef NDEBUG
             m_layerForOverhangAreas->setName("overhang areas");
 #endif
             m_layerForOverhangAreas->setDrawsContent(false);
             m_layerForOverhangAreas->setSize(m_renderView->frameView()->frameRect().size());
 
             // We want the overhang areas layer to be positioned below the frame contents,
             // so insert it below the clip layer.
-            m_overflowControlsHostLayer->addChildBelow(m_layerForOverhangAreas.get(), m_clipLayer.get());
+            m_overflowControlsHostLayer->addChildBelow(m_layerForOverhangAreas.get(), m_innerViewportClipLayer.get());
         }
     } else if (m_layerForOverhangAreas) {
         m_layerForOverhangAreas->removeFromParent();
         m_layerForOverhangAreas = nullptr;
     }
 
     if (requiresContentShadowLayer()) {
         if (!m_contentShadowLayer) {
             m_contentShadowLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
 #ifndef NDEBUG
             m_contentShadowLayer->setName("content shadow");
 #endif
             m_contentShadowLayer->setSize(m_rootContentLayer->size());
             m_contentShadowLayer->setPosition(m_rootContentLayer->position());
             ScrollbarTheme::theme()->setUpContentShadowLayer(m_contentShadowLayer.get());
 
-            m_scrollLayer->addChildBelow(m_contentShadowLayer.get(), m_rootContentLayer.get());
+            if (!m_outerViewportScrollLayer)
+                m_innerViewportScrollLayer->addChildBelow(m_contentShadowLayer.get(), m_rootContentLayer.get());
+            else
+                m_outerViewportScrollLayer->addChildBelow(m_contentShadowLayer.get(), m_rootContentLayer.get());
         }
     } else if (m_contentShadowLayer) {
         m_contentShadowLayer->removeFromParent();
         m_contentShadowLayer = nullptr;
     }
 #endif
 
     if (requiresHorizontalScrollbarLayer()) {
         if (!m_layerForHorizontalScrollbar) {
             m_layerForHorizontalScrollbar = GraphicsLayer::create(graphicsLayerFactory(), this);
             m_layerForHorizontalScrollbar->setShowDebugBorder(m_showDebugBorders);
 #ifndef NDEBUG
             m_layerForHorizontalScrollbar->setName("horizontal scrollbar");
 #endif
-            m_overflowControlsHostLayer->addChild(m_layerForHorizontalScrollbar.get());
+            hostLayerForOverflowControls->addChild(m_layerForHorizontalScrollbar.get());
 
             if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
                 scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_renderView->frameView(), HorizontalScrollbar);
         }
     } else if (m_layerForHorizontalScrollbar) {
         m_layerForHorizontalScrollbar->removeFromParent();
         m_layerForHorizontalScrollbar = nullptr;
 
         if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
             scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_renderView->frameView(), HorizontalScrollbar);
     }
 
     if (requiresVerticalScrollbarLayer()) {
         if (!m_layerForVerticalScrollbar) {
             m_layerForVerticalScrollbar = GraphicsLayer::create(graphicsLayerFactory(), this);
             m_layerForVerticalScrollbar->setShowDebugBorder(m_showDebugBorders);
 #ifndef NDEBUG
             m_layerForVerticalScrollbar->setName("vertical scrollbar");
 #endif
-            m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get());
+            hostLayerForOverflowControls->addChild(m_layerForVerticalScrollbar.get());
 
             if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
                 scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_renderView->frameView(), VerticalScrollbar);
         }
     } else if (m_layerForVerticalScrollbar) {
         m_layerForVerticalScrollbar->removeFromParent();
         m_layerForVerticalScrollbar = nullptr;
 
         if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
             scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_renderView->frameView(), VerticalScrollbar);
     }
 
     if (requiresScrollCornerLayer()) {
         if (!m_layerForScrollCorner) {
             m_layerForScrollCorner = GraphicsLayer::create(graphicsLayerFactory(), this);
             m_layerForScrollCorner->setShowDebugBorder(m_showDebugBorders);
 #ifndef NDEBUG
             m_layerForScrollCorner->setName("scroll corner");
 #endif
-            m_overflowControlsHostLayer->addChild(m_layerForScrollCorner.get());
+            hostLayerForOverflowControls->addChild(m_layerForScrollCorner.get());
         }
     } else if (m_layerForScrollCorner) {
         m_layerForScrollCorner->removeFromParent();
         m_layerForScrollCorner = nullptr;
     }
 
     m_renderView->frameView()->positionScrollbarLayers();
 }
 
 void RenderLayerCompositor::ensureRootLayer()
 {
     RootLayerAttachment expectedAttachment = isMainFrame() ? RootLayerAttachedViaChromeClient : RootLayerAttachedViaEnclosingFrame;
     if (expectedAttachment == m_rootLayerAttachment)
          return;
 
     if (!m_rootContentLayer) {
         m_rootContentLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
 #ifndef NDEBUG
         m_rootContentLayer->setName("content root");
 #endif
         IntRect overflowRect = m_renderView->pixelSnappedLayoutOverflowRect();
         m_rootContentLayer->setSize(FloatSize(overflowRect.maxX(), overflowRect.maxY()));
         m_rootContentLayer->setPosition(FloatPoint());
 
         // Need to clip to prevent transformed content showing outside this frame
         m_rootContentLayer->setMasksToBounds(true);
     }
 
     if (!m_overflowControlsHostLayer) {
-        ASSERT(!m_scrollLayer);
-        ASSERT(!m_clipLayer);
+        ASSERT(!m_innerViewportScrollLayer);
+        ASSERT(!m_innerViewportClipLayer);
 
         // Create a layer to host the clipping layer and the overflow controls layers.
         m_overflowControlsHostLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
 #ifndef NDEBUG
         m_overflowControlsHostLayer->setName("overflow controls host");
 #endif
 
         // Create a clipping layer if this is an iframe

[enne (OOO), 2013/05/30 21:03:31]

Is this comment true?

[wjmaclean, 2013/05/31 18:21:10]

Hmm, not sure. The line below got changed in a search-and-replace operation, so
I never really looked at it. I'll give this some thought though ...

-        m_clipLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
+        m_innerViewportClipLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
 #ifndef NDEBUG
-        m_clipLayer->setName("frame clipping");
+        m_innerViewportClipLayer->setName("inner viewport clipping");
 #endif
-        m_clipLayer->setMasksToBounds(true);
+        m_innerViewportClipLayer->setMasksToBounds(true);
 
-        m_scrollLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
+        m_innerViewportScrollLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
 #ifndef NDEBUG
-        m_scrollLayer->setName("frame scrolling");
+        m_innerViewportScrollLayer->setName("inner viewport scrolling");
 #endif
         if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
-            scrollingCoordinator->setLayerIsContainerForFixedPositionLayers(m_scrollLayer.get(), true);
+            scrollingCoordinator->setLayerIsContainerForFixedPositionLayers(m_innerViewportScrollLayer.get(), true);
+        // Hook them up
+        if (isMainFrame() && m_renderView->document()->settings()->pinchVirtualViewportEnabled()) {
+            // When using the pinch virtual viewport, the layer hierarchy looks like this:

[enne (OOO), 2013/05/30 21:03:31]

Can you add overhang layers too?

[wjmaclean, 2013/05/31 18:21:10]

Will do.

+            //
+            //  overflowControlsHostLayer
+            //      innerViewportClipLayer (fixed pos container)
+            //          pageScaleLayer
+            //              innerViewportScrollLayer
+            //                  outerViewportClipLayer (fixed pos container)
+            //                      outerViewportScrollLayer
+            //                  horizontal ScrollbarLayer (non-overlay)
+            //                  verticalScrollbarLayer (non-overlay)
+            //                  scroll corner (non-overlay)
+            //          horizontalScrollbarLayer (overlay)
+            //          verticalScrollbarLayer (overlay)
+            //
+            m_outerViewportClipLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
+            m_outerViewportClipLayer->setMasksToBounds(true);
 
-        // Hook them up
-        m_overflowControlsHostLayer->addChild(m_clipLayer.get());
-        m_clipLayer->addChild(m_scrollLayer.get());
-        m_scrollLayer->addChild(m_rootContentLayer.get());
+            m_outerViewportScrollLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
+            if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
+                scrollingCoordinator->setLayerIsContainerForFixedPositionLayers(m_outerViewportScrollLayer.get(), true);
+
+            m_pageScaleLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
+
+#ifndef NDEBUG
+            m_pageScaleLayer->setName("page scale layer");
+            m_outerViewportClipLayer->setName("outer viewport clip");
+            m_outerViewportScrollLayer->setName("outer viewport scrolling");
+#endif
+
+            m_overflowControlsHostLayer->addChild(m_innerViewportClipLayer.get());
+            m_innerViewportClipLayer->addChild(m_pageScaleLayer.get());
+            m_pageScaleLayer->addChild(m_innerViewportScrollLayer.get());
+            m_innerViewportScrollLayer->addChild(m_outerViewportClipLayer.get());
+            m_outerViewportClipLayer->addChild(m_outerViewportScrollLayer.get());
+            m_outerViewportScrollLayer->addChild(m_rootContentLayer.get());
+        } else {
+            // When not using the pinch virtual viewport, the layer hierarchy looks like this:
+            //
+            //  overflowControlsHostLayer
+            //      innerViewportClipLayer (fixed pos container)
+            //          innerViewportScrollLayer
+            //          horizontalScrollbarLayer (overlay/non-overlay)
+            //          verticalScrollbarLayer (overlay/non-overlay)
+            //
+            m_overflowControlsHostLayer->addChild(m_innerViewportClipLayer.get());
+            m_innerViewportClipLayer->addChild(m_innerViewportScrollLayer.get());
+            m_innerViewportScrollLayer->addChild(m_rootContentLayer.get());
+        }
 
         frameViewDidChangeSize();
         frameViewDidScroll();
     }
 
     // Check to see if we have to change the attachment
     if (m_rootLayerAttachment != RootLayerUnattached)
         detachRootLayer();
 
     attachRootLayer(expectedAttachment);
@@ skipping 31 matching lines @@
             m_renderView->frameView()->invalidateScrollbar(verticalScrollbar, IntRect(IntPoint(0, 0), verticalScrollbar->frameRect().size()));
     }
 
     if (m_layerForScrollCorner) {
         m_layerForScrollCorner = nullptr;
         m_renderView->frameView()->invalidateScrollCorner(m_renderView->frameView()->scrollCornerRect());
     }
 
     if (m_overflowControlsHostLayer) {
         m_overflowControlsHostLayer = nullptr;
-        m_clipLayer = nullptr;
-        m_scrollLayer = nullptr;
+        m_innerViewportClipLayer = nullptr;
+        m_innerViewportScrollLayer = nullptr;
+        m_outerViewportClipLayer = nullptr;
+        m_outerViewportScrollLayer = nullptr;
+        m_pageScaleLayer = nullptr;
     }
-    ASSERT(!m_scrollLayer);
+    ASSERT(!m_innerViewportScrollLayer);
     m_rootContentLayer = nullptr;
 }
 
 void RenderLayerCompositor::attachRootLayer(RootLayerAttachment attachment)
 {
     if (!m_rootContentLayer)
         return;
 
     switch (attachment) {
         case RootLayerUnattached:
@@ skipping 259 matching lines @@
         return frame->page();
     
     return 0;
 }
 
 void RenderLayerCompositor::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Rendering);
     info.addWeakPointer(m_renderView);
     info.addMember(m_rootContentLayer, "rootContentLayer");
-    info.addMember(m_clipLayer, "clipLayer");
-    info.addMember(m_scrollLayer, "scrollLayer");
+    info.addMember(m_innerViewportClipLayer, "innerViewportClipLayer");
+    info.addMember(m_innerViewportScrollLayer, "innerViewportScrollLayer");
+    info.addMember(m_outerViewportClipLayer, "outerViewportClipLayer");
+    info.addMember(m_outerViewportScrollLayer, "outerViewportScrollLayer");
+    info.addMember(m_pageScaleLayer, "pageScaleLayer");
     info.addMember(m_viewportConstrainedLayers, "viewportConstrainedLayers");
     info.addMember(m_overflowControlsHostLayer, "overflowControlsHostLayer");
     info.addMember(m_layerForHorizontalScrollbar, "layerForHorizontalScrollbar");
     info.addMember(m_layerForVerticalScrollbar, "layerForVerticalScrollbar");
     info.addMember(m_layerForScrollCorner, "layerForScrollCorner");
 #if ENABLE(RUBBER_BANDING)
     info.addMember(m_layerForOverhangAreas, "layerForOverhangAreas");
     info.addMember(m_contentShadowLayer, "contentShadowLayer");
     info.addMember(m_layerForTopOverhangArea, "layerForTopOverhangArea");
     info.addMember(m_layerForBottomOverhangArea, "layerForBottomOverhangArea");
 #endif
 }
 
 } // namespace WebCore