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/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "cc/animation_registrar.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.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 288 matching lines @@
     hostImpl->savePaintTime(m_renderingStats.totalPaintTime);
 
     if (newImplTreeHasNoEvictedResources) {
         if (syncTree->ContentsTexturesPurged())
             syncTree->ResetContentsTexturesPurged();
     }
 
     m_commitNumber++;
 }
 
+void LayerTreeHost::setPinchZoomScrollbarPropertiesIfNeeded()
+{
+    gfx::Size size = layoutViewportSize();
+    int trackWidth = PinchZoomScrollbar::kTrackWidth;
+    Layer* rootScrollLayer = this->rootScrollLayer();
+    int rootScrollLayerId = rootScrollLayer ? rootScrollLayer->id() : 0;
+    if (m_pinchZoomScrollbarHorizontal) {
+        m_pinchZoomScrollbarHorizontal->setBounds(gfx::Size(size.width() - trackWidth, trackWidth));
+        m_pinchZoomScrollbarHorizontal->setPosition(gfx::PointF(0, size.height() - trackWidth));
+        m_pinchZoomScrollbarHorizontal->setIsDrawable(true);
+        m_pinchZoomScrollbarHorizontal->setOpacity(0.5);
+        m_pinchZoomScrollbarHorizontal->setNeedsDisplay();
+        m_pinchZoomScrollbarHorizontal->setScrollLayerId(rootScrollLayerId);
+    }
+    if (m_pinchZoomScrollbarVertical) {
+        m_pinchZoomScrollbarVertical->setBounds(gfx::Size(10, size.height() - 10));
+        m_pinchZoomScrollbarVertical->setPosition(gfx::PointF(size.width() - 10, 0));
+        m_pinchZoomScrollbarVertical->setIsDrawable(true);
+        m_pinchZoomScrollbarVertical->setOpacity(0.5);
+        m_pinchZoomScrollbarVertical->setNeedsDisplay();
+        m_pinchZoomScrollbarVertical->setScrollLayerId(rootScrollLayerId);
+    }
+}
+
 void LayerTreeHost::willCommit()
 {
     m_client->willCommit();
 
     if (m_debugState.showHudInfo()) {
         if (!m_hudLayer)
             m_hudLayer = HeadsUpDisplayLayer::create();
 
         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;
     }
+
+    // Setup pinch-zoom scrollbars if required.
+    if (m_settings.pageScalePinchZoomEnabled && rootScrollLayer() &&
+        !ScrollbarLayer::defaultUsesOverlayScrollbars()) {
+        if (!m_pinchZoomScrollbarHorizontal)
+            m_pinchZoomScrollbarHorizontal = ScrollbarLayer::create(
+                make_scoped_ptr(
+                    new PinchZoomScrollbar(
+                        WebKit::WebScrollbar::Horizontal, this)).PassAs<WebKit::WebScrollbar>(),
+                make_scoped_ptr(new PinchZoomScrollbarPainter).PassAs<ScrollbarThemePainter>(),
+                0);
+
+        DCHECK(m_pinchZoomScrollbarHorizontal);
+        if (!m_pinchZoomScrollbarHorizontal->parent())
+            m_rootLayer->addChild(m_pinchZoomScrollbarHorizontal);
+
+        if (!m_pinchZoomScrollbarVertical)
+            m_pinchZoomScrollbarVertical = ScrollbarLayer::create(
+                make_scoped_ptr(
+                    new PinchZoomScrollbar(
+                        WebKit::WebScrollbar::Vertical, this)).PassAs<WebKit::WebScrollbar>(),
+                make_scoped_ptr(new PinchZoomScrollbarPainter).PassAs<ScrollbarThemePainter>(),
+                0);
+
+       DCHECK(m_pinchZoomScrollbarVertical);
+       if (!m_pinchZoomScrollbarVertical->parent())
+            m_rootLayer->addChild(m_pinchZoomScrollbarVertical);
+
+       setPinchZoomScrollbarPropertiesIfNeeded();
+    }
 }
 
 void LayerTreeHost::commitComplete()
 {
     m_client->didCommit();
 }
 
 scoped_ptr<OutputSurface> LayerTreeHost::createOutputSurface()
 {
     return m_client->createOutputSurface();
@@ skipping 122 matching lines @@
 }
 
 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;
 
+    setPinchZoomScrollbarPropertiesIfNeeded();
     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;
 }
 
+Layer* LayerTreeHost::rootScrollLayer() const
+{
+    return findFirstScrollableLayer(m_rootLayer.get());
+}
+
 void LayerTreeHost::updateLayers(Layer* rootLayer, ResourceUpdateQueue& queue)
 {
     TRACE_EVENT0("cc", "LayerTreeHost::updateLayers");
 
     LayerList updateList;
 
     {
         if (m_settings.pageScalePinchZoomEnabled) {
             Layer* rootScroll = findFirstScrollableLayer(rootLayer);
             if (rootScroll)
@@ skipping 271 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