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/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "cc/animation_registrar.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.h"
+#include "cc/pinch_zoom_scrollbar_geometry.h"
+#include "cc/pinch_zoom_scrollbar_painter.h"
 #include "cc/prioritized_resource_manager.h"
+#include "cc/scrollbar_layer.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/switches.h"
 #include "cc/thread.h"
 #include "cc/thread_proxy.h"
 #include "cc/top_controls_manager.h"
 #include "cc/tree_synchronizer.h"
 
 namespace {
 static int numLayerTreeInstances;
 }
@@ skipping 283 matching lines @@
     hostImpl->setDeviceScaleFactor(deviceScaleFactor());
     hostImpl->setDebugState(m_debugState);
 
     DCHECK(!syncTree->ViewportSizeInvalid());
 
     if (newImplTreeHasNoEvictedResources) {
         if (syncTree->ContentsTexturesPurged())
             syncTree->ResetContentsTexturesPurged();
     }
 
+    syncTree->SetPinchZoomHorizontalLayerId(
+        m_pinchZoomScrollbarHorizontal ? m_pinchZoomScrollbarHorizontal->id() :
+                                         Layer::INVALID_ID);
+    syncTree->SetPinchZoomVerticalLayerId(
+        m_pinchZoomScrollbarVertical ? m_pinchZoomScrollbarVertical->id() :
+                                       Layer::INVALID_ID);
+
     if (!m_settings.implSidePainting) {
         // If we're not in impl-side painting, the tree is immediately
         // considered active.
         syncTree->DidBecomeActive();
     }
 
     if (m_debugState.continuousPainting)
         hostImpl->savePaintTime(m_renderingStats.totalPaintTime, commitNumber());
 
     m_commitNumber++;
 }
 
+void LayerTreeHost::setPinchZoomScrollbarsBoundsAndPosition()
+{
+    if (!m_pinchZoomScrollbarHorizontal || !m_pinchZoomScrollbarVertical)
+        return;
+
+    gfx::Size size = layoutViewportSize();
+    int trackWidth = PinchZoomScrollbarGeometry::kTrackWidth;
+
+    m_pinchZoomScrollbarHorizontal->SetBounds(gfx::Size(size.width() - trackWidth, trackWidth));
+    m_pinchZoomScrollbarHorizontal->SetPosition(gfx::PointF(0, size.height() - trackWidth));
+
+    m_pinchZoomScrollbarVertical->SetBounds(gfx::Size(trackWidth, size.height() - trackWidth));
+    m_pinchZoomScrollbarVertical->SetPosition(gfx::PointF(size.width() - trackWidth, 0));
+}
+
+static scoped_refptr<ScrollbarLayer> CreatePinchZoomScrollbar(
+    WebKit::WebScrollbar::Orientation orientation, LayerTreeHost* owner)
+{
+    scoped_refptr<ScrollbarLayer> scrollbarLayer = ScrollbarLayer::Create(
+        make_scoped_ptr(
+            new PinchZoomScrollbar(orientation, owner)).PassAs<WebKit::WebScrollbar>(),
+        scoped_ptr<ScrollbarThemePainter>(new PinchZoomScrollbarPainter).Pass(),
+        scoped_ptr<WebKit::WebScrollbarThemeGeometry>(
+            new PinchZoomScrollbarGeometry).Pass(),
+        Layer::PINCH_ZOOM_ROOT_SCROLL_LAYER_ID);
+    scrollbarLayer->SetIsDrawable(true);
+    scrollbarLayer->SetOpacity(0.f);
+    return scrollbarLayer;
+}
+
+void LayerTreeHost::createAndAddPinchZoomScrollbars()
+{
+    bool needsPropertiesUpdated = false;
+
+    if (!m_pinchZoomScrollbarHorizontal || !m_pinchZoomScrollbarVertical) {
+        m_pinchZoomScrollbarHorizontal = CreatePinchZoomScrollbar(WebKit::WebScrollbar::Horizontal, this);
+        m_pinchZoomScrollbarVertical = CreatePinchZoomScrollbar( WebKit::WebScrollbar::Vertical, this);
+        needsPropertiesUpdated = true;
+    }
+
+    DCHECK(m_pinchZoomScrollbarHorizontal && m_pinchZoomScrollbarVertical);
+
+    if (!m_pinchZoomScrollbarHorizontal->parent())
+        m_rootLayer->AddChild(m_pinchZoomScrollbarHorizontal);
+
+    if (!m_pinchZoomScrollbarVertical->parent())
+        m_rootLayer->AddChild(m_pinchZoomScrollbarVertical);
+
+    if (needsPropertiesUpdated)
+        setPinchZoomScrollbarsBoundsAndPosition();
+}
+
 void LayerTreeHost::willCommit()
 {
     m_client->willCommit();
+
+    if (m_settings.usePinchZoomScrollbars)
+        createAndAddPinchZoomScrollbars();
 }
 
 void LayerTreeHost::updateHudLayer()
 {
     if (m_debugState.showHudInfo()) {
         if (!m_hudLayer)
             m_hudLayer = HeadsUpDisplayLayer::Create();
 
         if (m_rootLayer && !m_hudLayer->parent())
             m_rootLayer->AddChild(m_hudLayer);
@@ skipping 118 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_pinchZoomScrollbarHorizontal)
+        m_pinchZoomScrollbarHorizontal->RemoveFromParent();
+
+    if (m_pinchZoomScrollbarVertical)
+        m_pinchZoomScrollbarVertical->RemoveFromParent();
+
     setNeedsFullTreeSync();
 }
 
 void LayerTreeHost::setDebugState(const LayerTreeDebugState& debugState)
 {
     LayerTreeDebugState newDebugState = LayerTreeDebugState::unite(m_settings.initialDebugState, debugState);
 
     if (LayerTreeDebugState::equal(m_debugState, newDebugState))
         return;
 
     m_debugState = newDebugState;
     setNeedsCommit();
 }
 
 void LayerTreeHost::setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize)
 {
     if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
         return;
 
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
 
+    setPinchZoomScrollbarsBoundsAndPosition();
     setNeedsCommit();
 }
 
 void LayerTreeHost::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
 {
     if (pageScaleFactor == m_pageScaleFactor && minPageScaleFactor == m_minPageScaleFactor && maxPageScaleFactor == m_maxPageScaleFactor)
         return;
 
     m_pageScaleFactor = pageScaleFactor;
     m_minPageScaleFactor = minPageScaleFactor;
@@ skipping 73 matching lines @@
 
     for (size_t i = 0; i < layer->children().size(); ++i) {
         Layer* found = findFirstScrollableLayer(layer->children()[i].get());
         if (found)
             return found;
     }
 
     return 0;
 }
 
+const Layer* LayerTreeHost::rootScrollLayer() const
+{
+    return findFirstScrollableLayer(m_rootLayer.get());
+}
+
 void LayerTreeHost::updateLayers(Layer* rootLayer, ResourceUpdateQueue& queue)
 {
     TRACE_EVENT0("cc", "LayerTreeHost::updateLayers");
 
     LayerList updateList;
 
     {
         Layer* rootScroll = findFirstScrollableLayer(rootLayer);
         if (rootScroll)
             rootScroll->SetImplTransform(m_implTransform);
@@ skipping 302 matching lines @@
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::capturePicture()
 {
     return m_proxy->CapturePicture();
 }
 
 }  // namespace cc