Implement pinch-zoom scaling for main-frame scrollbars and pinch-zoom overlay scrollbars.

cc/layer_tree_host_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "base/json/json_writer.h"
 #include "cc/append_quads_data.h"
 #include "cc/damage_tracker.h"
 #include "cc/debug_rect_history.h"
 #include "cc/delay_based_time_source.h"
 #include "cc/delegating_renderer.h"
 #include "cc/frame_rate_counter.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/page_scale_animation.h"
+#include "cc/pinch_zoom_scrollbars_manager.h"
 #include "cc/prioritized_resource_manager.h"
 #include "cc/quad_culler.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/rendering_stats.h"
 #include "cc/scrollbar_animation_controller.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/shared_quad_state.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/software_renderer.h"
 #include "cc/solid_color_draw_quad.h"
@@ skipping 336 matching lines @@
     // damage rect. The root damage rect is then used to scissor each surface.
 
     for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         LayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex];
         RenderSurfaceImpl* renderSurface = renderSurfaceLayer->renderSurface();
         DCHECK(renderSurface);
         renderSurface->damageTracker()->updateDamageTrackingState(renderSurface->layerList(), renderSurfaceLayer->id(), renderSurface->surfacePropertyChangedOnlyFromDescendant(), renderSurface->contentRect(), renderSurfaceLayer->maskLayer(), renderSurfaceLayer->filters(), renderSurfaceLayer->filter().get());
     }
 }
 
-void LayerTreeHostImpl::updateRootScrollLayerImplTransform()
+void LayerTreeHostImpl::updateImplTransformOnRootChildren()
 {
     if (rootScrollLayer()) {
-        rootScrollLayer()->setImplTransform(implTransform());
+        for (size_t i = 0; i < rootLayer()->children().size(); ++i) {
+            LayerImpl* layerImpl = rootLayer()->children()[i];
+            if (layerImpl != static_cast<LayerImpl*>(activeTree()->pinch_zoom_scrollbar_vertical())
+                && layerImpl != static_cast<LayerImpl*>(activeTree()->pinch_zoom_scrollbar_horizontal()))
+                layerImpl->setImplTransform(implTransform());
+        }
+    }
+    // TODO(wjmaclean): make sure this is revised to work with multiple LayerTreeImpls.

[enne (OOO), 2012/12/13 17:43:38]

Whoa, why is the PinchZoomScrollbarsManager on the tree and not the host? It
seems to me that the layers from the main thread side have no state, so there's
no reason to have them on the pending tree.

Also, if you create them here and don't sync, then you don't need to do anything
on the layer side.  You can just create them here and hand them to the manager. 
(Or remove them from the previous tree and insert them in the next active tree
during tree swap.)

[wjmaclean, 2012/12/13 18:26:50]

OK, I will re-do with the manager on LTHI. I considered both options, but as I
was unaware of how the tree-swap mechanics would look I wasn't sure how easily
I'd be able to do the remove/insert.

+    PinchZoomScrollbarsManager* pinchZoomScrollbars = activeTree()->pinch_zoom_scrollbars_manager();
+    if (pinchZoomScrollbars) {
+        pinchZoomScrollbars->setPinchZoomViewportPosition(m_pinchZoomViewport.zoomedViewportOffset(), m_pinchZoomViewport.totalPageScaleFactor());
+        if (rootScrollLayer())
+            pinchZoomScrollbars->setRootScrollLayerOffset(
+                rootScrollLayer()->scrollOffset(), rootScrollLayer()->maxScrollOffset());
+        else
+            pinchZoomScrollbars->setRootScrollLayerOffset(gfx::Vector2d(), gfx::Vector2d());
     }
 }
 
 void LayerTreeHostImpl::updateDrawProperties()
 {
     if (!needsUpdateDrawProperties())
         return;
 
     m_renderSurfaceLayerList.clear();
     m_needsUpdateDrawProperties = false;
 
     if (!rootLayer())
         return;
 
     calculateRenderSurfaceLayerList(m_renderSurfaceLayerList);
 }
 
 void LayerTreeHostImpl::calculateRenderSurfaceLayerList(LayerList& renderSurfaceLayerList)
 {
     DCHECK(renderSurfaceLayerList.empty());
     DCHECK(rootLayer());
     DCHECK(m_renderer); // For maxTextureSize.
     {
-        updateRootScrollLayerImplTransform();
+        updateImplTransformOnRootChildren();
 
         TRACE_EVENT0("cc", "LayerTreeHostImpl::calcDrawEtc");
         float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
         LayerTreeHostCommon::calculateDrawProperties(rootLayer(), deviceViewportSize(), m_deviceScaleFactor, pageScaleFactor, rendererCapabilities().maxTextureSize, renderSurfaceLayerList);
     }
 }
 
 void LayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<RenderPass> renderPass)
 {
     RenderPass* pass = renderPass.get();
@@ skipping 127 matching lines @@
 
         AppendQuadsData appendQuadsData(targetRenderPass->id);
 
         if (it.representsContributingRenderSurface()) {
             RenderPass::Id contributingRenderPassId = it->renderSurface()->renderPassId();
             RenderPass* contributingRenderPass = frame.renderPassesById.get(contributingRenderPassId);
             appendQuadsForRenderSurfaceLayer(targetRenderPass, *it, contributingRenderPass, occlusionTracker, appendQuadsData);
         } else if (it.representsItself() && !it->visibleContentRect().IsEmpty()) {
             bool hasOcclusionFromOutsideTargetSurface;
             bool implDrawTransformIsUnknown = false;
+
             if (occlusionTracker.occluded(it->renderTarget(), it->visibleContentRect(), it->drawTransform(), implDrawTransformIsUnknown, it->drawableContentRect(), &hasOcclusionFromOutsideTargetSurface))
                 appendQuadsData.hadOcclusionFromOutsideTargetSurface |= hasOcclusionFromOutsideTargetSurface;
             else {
                 DCHECK_EQ(this->activeTree(), it->layerTreeImpl());
                 it->willDraw(m_resourceProvider.get());
                 frame.willDrawLayers.push_back(*it);
 
                 if (it->hasContributingDelegatedRenderPasses()) {
                     RenderPass::Id contributingRenderPassId = it->firstContributingRenderPassId();
                     while (frame.renderPassesById.contains(contributingRenderPassId)) {
@@ skipping 309 matching lines @@
     m_fpsCounter->markBeginningOfFrame(base::TimeTicks::Now());
 
     if (m_debugState.showHudRects())
         m_debugRectHistory->saveDebugRectsForCurrentFrame(rootLayer(), *frame.renderSurfaceLayerList, frame.occludingScreenSpaceRects, frame.nonOccludingScreenSpaceRects, m_debugState);
 
     // Because the contents of the HUD depend on everything else in the frame, the contents
     // of its texture are updated as the last thing before the frame is drawn.
     if (m_activeTree->hud_layer())
         m_activeTree->hud_layer()->updateHudTexture(m_resourceProvider.get());
 
+    PinchZoomScrollbarsManager* pinchZoomScrollbars = activeTree()->pinch_zoom_scrollbars_manager();

[enne (OOO), 2012/12/13 17:43:38]

I would like nearly all the changes in this file to go away.  This adds way too
much complexity to the already overwhelming LTHI.  We already have abstractions
for updating layers.  You could give the manager an LTHI pointer or the layers
themselves could ask for their LTHI and then get the right device scale /
viewport / etc.

The pinch zoom scrollbar manager doesn't need to be special cased any time one
of these values changed.  You should just look them up when you need them.

[wjmaclean, 2012/12/13 18:26:50]

OK, I'll look into doing this. I had hoped this would minimize the number of
calls required to transfer the information.
OK.

+    if (pinchZoomScrollbars && m_pinchZoomViewport.pageScaleFactor() != 1)
+        pinchZoomScrollbars->updateThumbTextures(m_resourceProvider.get());
+
     m_renderer->drawFrame(frame.renderPasses, frame.renderPassesById);
 
     // The render passes should be consumed by the renderer.
     DCHECK(frame.renderPasses.empty());
     DCHECK(frame.renderPassesById.empty());
 
     // The next frame should start by assuming nothing has changed, and changes are noted as they occur.
     for (unsigned int i = 0; i < frame.renderSurfaceLayerList->size(); i++)
         (*frame.renderSurfaceLayerList)[i]->renderSurface()->damageTracker()->didDrawDamagedArea();
     rootLayer()->resetAllChangeTrackingForSubtree();
@@ skipping 181 matching lines @@
 }
 
 void LayerTreeHostImpl::setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize)
 {
     if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
         return;
 
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
 
-    m_pinchZoomViewport.setLayoutViewportSize(layoutViewportSize);
+    m_pinchZoomViewport.setLayoutViewportSize(m_layoutViewportSize);
+    // TODO(wjmaclean): make sure this is revised to work with multiple LayerTreeImpls.
+    PinchZoomScrollbarsManager* pinchZoomScrollbars = activeTree()->pinch_zoom_scrollbars_manager();
+    if (pinchZoomScrollbars)
+        pinchZoomScrollbars->setPinchZoomViewportBounds(layoutViewportSize);
 
     updateMaxScrollOffset();
 
     if (m_renderer)
         m_renderer->viewportChanged();
 
     m_client->onCanDrawStateChanged(canDraw());
 }
 
 static void adjustScrollsForPageScaleChange(LayerImpl* layerImpl, float pageScaleChange)
@@ skipping 11 matching lines @@
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
         adjustScrollsForPageScaleChange(layerImpl->children()[i], pageScaleChange);
 }
 
 void LayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor)
 {
     if (deviceScaleFactor == m_deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
     m_pinchZoomViewport.setDeviceScaleFactor(m_deviceScaleFactor);
+    // TODO(wjmaclean): make sure this is revised to work with multiple LayerTreeImpls.
+    PinchZoomScrollbarsManager* pinchZoomScrollbars = activeTree()->pinch_zoom_scrollbars_manager();
+    if (pinchZoomScrollbars)
+        pinchZoomScrollbars->setDeviceScaleFactor(m_deviceScaleFactor);
 
     updateMaxScrollOffset();
 }
 
 float LayerTreeHostImpl::pageScaleFactor() const
 {
     return m_pinchZoomViewport.pageScaleFactor();
 }
 
 void LayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
@@ skipping 26 matching lines @@
 
     gfx::SizeF viewBounds = m_deviceViewportSize;
     if (LayerImpl* clipLayer = rootScrollLayer()->parent()) {
         // Compensate for non-overlay scrollbars.
         if (clipLayer->masksToBounds())
             viewBounds = gfx::ScaleSize(clipLayer->bounds(), m_deviceScaleFactor);
     }
 
     gfx::Size contentBounds = contentSize();
     if (m_settings.pageScalePinchZoomEnabled) {
+        // TODO(wjmaclean): make sure this is revised to work with multiple LayerTreeImpls.
+        PinchZoomScrollbarsManager* pinchZoomScrollbars = activeTree()->pinch_zoom_scrollbars_manager();
+        if (pinchZoomScrollbars) {
+            if (!rootScrollLayer() || rootScrollLayer()->children().isEmpty())
+                pinchZoomScrollbars->setContentBounds(m_layoutViewportSize);
+            else
+                pinchZoomScrollbars->setContentBounds(contentSize());
+        }
         // Pinch with pageScale scrolls entirely in layout space.  contentSize
         // returns the bounds including the page scale factor, so calculate the
         // pre page-scale layout size here.
         float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
         contentBounds.set_width(contentBounds.width() / pageScaleFactor);
         contentBounds.set_height(contentBounds.height() / pageScaleFactor);
     } else {
         viewBounds.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
     }
 
@@ skipping 78 matching lines @@
     }
 
     if (potentiallyScrollingLayerImpl) {
         m_activeTree->set_currently_scrolling_layer(potentiallyScrollingLayerImpl);
         // Gesture events need to be transformed from viewport coordinates to local layer coordinates
         // so that the scrolling contents exactly follow the user's finger. In contrast, wheel
         // events are already in local layer coordinates so we can just apply them directly.
         m_scrollDeltaIsInViewportSpace = (type == Gesture);
         m_numImplThreadScrolls++;
         setNeedsUpdateDrawProperties();
+
+        PinchZoomScrollbarsManager* pinchZoomScrollbars = activeTree()->pinch_zoom_scrollbars_manager();
+        if (type == Gesture && pinchZoomScrollbars)
+            pinchZoomScrollbars->setEnabled(m_pinchZoomViewport.totalPageScaleFactor() != 1);
+
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
 static gfx::Vector2dF scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport, LayerImpl& layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
     DCHECK(layerImpl.screenSpaceTransform().IsInvertible());
@@ skipping 106 matching lines @@
     return didScroll;
 }
 
 void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
 {
     m_activeTree->ClearCurrentlyScrollingLayer();
 }
 
 void LayerTreeHostImpl::scrollEnd()
 {
+    PinchZoomScrollbarsManager* pinchZoomScrollbars = activeTree()->pinch_zoom_scrollbars_manager();
+    if (pinchZoomScrollbars) {
+        pinchZoomScrollbars->setEnabled(false);
+        m_client->setNeedsRedrawOnImplThread();
+    }
     clearCurrentlyScrollingLayer();
 }
 
 void LayerTreeHostImpl::pinchGestureBegin()
 {
     m_pinchGestureActive = true;
     m_previousPinchAnchor = gfx::Point();
 
     if (rootScrollLayer() && rootScrollLayer()->scrollbarAnimationController())
         rootScrollLayer()->scrollbarAnimationController()->didPinchGestureBegin();
@@ skipping 21 matching lines @@
         // Compute the application of the delta with respect to the current page zoom of the page.
         move.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
     }
 
     gfx::Vector2dF scrollOverflow = m_settings.pageScalePinchZoomEnabled ? m_pinchZoomViewport.applyScroll(move) : move;
     rootScrollLayer()->scrollBy(scrollOverflow);
 
     if (rootScrollLayer()->scrollbarAnimationController())
         rootScrollLayer()->scrollbarAnimationController()->didPinchGestureUpdate();
 
+    PinchZoomScrollbarsManager* pinchZoomScrollbars = activeTree()->pinch_zoom_scrollbars_manager();
+    if (pinchZoomScrollbars)
+        pinchZoomScrollbars->setEnabled(m_pinchZoomViewport.totalPageScaleFactor() != 1);
+
     m_client->setNeedsCommitOnImplThread();
     m_client->setNeedsRedrawOnImplThread();
     setNeedsUpdateDrawProperties();
 }
 
 void LayerTreeHostImpl::pinchGestureEnd()
 {
     m_pinchGestureActive = false;
 
     if (rootScrollLayer() && rootScrollLayer()->scrollbarAnimationController())
         rootScrollLayer()->scrollbarAnimationController()->didPinchGestureEnd();
 
+    PinchZoomScrollbarsManager* pinchZoomScrollbars = activeTree()->pinch_zoom_scrollbars_manager();
+    if (pinchZoomScrollbars)
+        pinchZoomScrollbars->setEnabled(false);
+
     m_client->setNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::computeDoubleTapZoomDeltas(ScrollAndScaleSet* scrollInfo)
 {
     gfx::Vector2dF scaledScrollOffset = m_pageScaleAnimation->targetScrollOffset();
     if (!m_settings.pageScalePinchZoomEnabled)
         scaledScrollOffset.Scale(m_pinchZoomViewport.pageScaleFactor());
     makeScrollAndScaleSet(scrollInfo, ToFlooredVector2d(scaledScrollOffset), m_pageScaleAnimation->targetPageScaleFactor());
 }
@@ skipping 267 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc