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

cc/layer_tree_host.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.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "cc/font_atlas.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/overdraw_metrics.h"
+#include "cc/pinch_zoom_scrollbar_layer.h"
+#include "cc/scrollbar_layer_impl.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/switches.h"
 #include "cc/thread.h"
 #include "cc/thread_proxy.h"
 #include "cc/tree_synchronizer.h"
 
 using namespace std;
 
 namespace {
 static int numLayerTreeInstances;
@@ skipping 51 matching lines @@
     , m_visible(true)
     , m_pageScaleFactor(1)
     , m_minPageScaleFactor(1)
     , m_maxPageScaleFactor(1)
     , m_triggerIdleUpdates(true)
     , m_backgroundColor(SK_ColorWHITE)
     , m_hasTransparentBackground(false)
     , m_partialTextureUpdateRequests(0)
 {
     numLayerTreeInstances++;
+
+    if (m_settings.pageScalePinchZoomEnabled) {
+        m_pinchZoomScrollbarVertical = PinchZoomScrollbarLayer::create();
+        m_pinchZoomScrollbarHorizontal = PinchZoomScrollbarLayer::create();
+    }
 }
 
 bool LayerTreeHost::initialize(scoped_ptr<Thread> implThread)
 {
     if (implThread)
         return initializeProxy(ThreadProxy::create(this, implThread.Pass()));
     else
         return initializeProxy(SingleThreadProxy::create(this));
 }
 
@@ skipping 168 matching lines @@
         TRACE_EVENT0("cc", "LayerTreeHost::pushPropertiesRecursive");
         pushPropertiesRecursive(rootLayer(), hostImpl->rootLayer());
     }
     m_needsFullTreeSync = false;
 
     if (m_rootLayer && m_hudLayer)
         hostImpl->activeTree()->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(LayerTreeHostCommon::findLayerInSubtree(hostImpl->rootLayer(), m_hudLayer->id())));
     else
         hostImpl->activeTree()->set_hud_layer(0);
 
+    if (m_rootLayer && m_pinchZoomScrollbarVertical)
+        hostImpl->activeTree()->set_pinch_zoom_scrollbar_vertical(static_cast<ScrollbarLayerImpl*>(LayerTreeHostCommon::findLayerInSubtree(hostImpl->rootLayer(), m_pinchZoomScrollbarVertical->id())));
+    else
+        hostImpl->activeTree()->set_pinch_zoom_scrollbar_vertical(0);
+
+    if (m_rootLayer && m_pinchZoomScrollbarHorizontal)
+        hostImpl->activeTree()->set_pinch_zoom_scrollbar_horizontal(static_cast<ScrollbarLayerImpl*>(LayerTreeHostCommon::findLayerInSubtree(hostImpl->rootLayer(), m_pinchZoomScrollbarHorizontal->id())));
+    else
+        hostImpl->activeTree()->set_pinch_zoom_scrollbar_horizontal(0);
+
     // We may have added an animation during the tree sync. This will cause both layer tree hosts
     // to visit their controllers.
     if (rootLayer() && m_needsAnimateLayers)
         hostImpl->setNeedsAnimateLayers();
 
     hostImpl->activeTree()->set_source_frame_number(commitNumber());
     hostImpl->setViewportSize(layoutViewportSize(), deviceViewportSize());
     hostImpl->setDeviceScaleFactor(deviceScaleFactor());
     hostImpl->setPageScaleFactorAndLimits(m_pageScaleFactor, m_minPageScaleFactor, m_maxPageScaleFactor);
     hostImpl->setBackgroundColor(m_backgroundColor);
@@ skipping 13 matching lines @@
 
         if (m_debugState.hudNeedsFont() && !m_hudLayer->hasFontAtlas())
             m_hudLayer->setFontAtlas(m_client->createFontAtlas());
 
         if (m_rootLayer && !m_hudLayer->parent())
             m_rootLayer->addChild(m_hudLayer);
     } else if (m_hudLayer) {
         m_hudLayer->removeFromParent();
         m_hudLayer = 0;
     }
+
+    if (m_settings.pageScalePinchZoomEnabled && m_rootLayer) {
+        DCHECK(m_pinchZoomScrollbarVertical);
+        if (m_pinchZoomScrollbarVertical && !m_pinchZoomScrollbarVertical->parent())
+            m_rootLayer->addChild(m_pinchZoomScrollbarVertical);
+
+        DCHECK(m_pinchZoomScrollbarHorizontal);
+        if (m_pinchZoomScrollbarHorizontal && !m_pinchZoomScrollbarHorizontal->parent())
+            m_rootLayer->addChild(m_pinchZoomScrollbarHorizontal);
+    }
 }
 
 void LayerTreeHost::commitComplete()
 {
     m_client->didCommit();
 }
 
 scoped_ptr<OutputSurface> LayerTreeHost::createOutputSurface()
 {
     return m_client->createOutputSurface();
@@ skipping 105 matching lines @@
 
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(0);
     m_rootLayer = rootLayer;
     if (m_rootLayer)
         m_rootLayer->setLayerTreeHost(this);
 
     if (m_hudLayer)
         m_hudLayer->removeFromParent();
 
+    if (m_pinchZoomScrollbarVertical)
+        m_pinchZoomScrollbarVertical->removeFromParent();
+
+    if (m_pinchZoomScrollbarHorizontal)
+        m_pinchZoomScrollbarHorizontal->removeFromParent();
+
     setNeedsFullTreeSync();
 }
 
 void LayerTreeHost::setDebugState(const LayerTreeDebugState& debugState)
 {
     LayerTreeDebugState newDebugState = LayerTreeDebugState::unite(m_settings.initialDebugState, debugState);
 
     if (LayerTreeDebugState::equal(m_debugState, newDebugState))
         return;
 
@@ skipping 110 matching lines @@
 }
 
 void LayerTreeHost::updateLayers(Layer* rootLayer, ResourceUpdateQueue& queue)
 {
     TRACE_EVENT0("cc", "LayerTreeHost::updateLayers");
 
     LayerList updateList;
 
     {
         if (m_settings.pageScalePinchZoomEnabled) {
-            Layer* rootScroll = findFirstScrollableLayer(rootLayer);
-            if (rootScroll)
-                rootScroll->setImplTransform(m_implTransform);
+            const LayerList& children = m_rootLayer->children();
+            for (size_t i = 0; i < children.size(); ++i) {
+                Layer* layer = children[i].get();
+                if (layer != m_pinchZoomScrollbarVertical.get()
+                    && layer != m_pinchZoomScrollbarHorizontal.get())
+                layer->setImplTransform(m_implTransform);
+            }
         }
 
         TRACE_EVENT0("cc", "LayerTreeHost::updateLayers::calcDrawEtc");
         LayerTreeHostCommon::calculateDrawProperties(rootLayer, deviceViewportSize(), m_deviceScaleFactor, m_pageScaleFactor, rendererCapabilities().maxTextureSize, updateList);
     }
 
     // Reset partial texture update requests.
     m_partialTextureUpdateRequests = 0;
 
     bool needMoreUpdates = paintLayerContents(updateList, queue);
@@ skipping 283 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 }  // namespace cc