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() : -1);
+    syncTree->SetPinchZoomVerticalLayerId(
+        m_pinchZoomScrollbarVertical ? m_pinchZoomScrollbarVertical->id() : -1);
+
     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_pinchZoomScrollbarHorizontal->setNeedsDisplay();
+
+    m_pinchZoomScrollbarVertical->setBounds(gfx::Size(trackWidth, size.height() - trackWidth));
+    m_pinchZoomScrollbarVertical->setPosition(gfx::PointF(size.width() - trackWidth, 0));
+    m_pinchZoomScrollbarVertical->setNeedsDisplay();
+}
+
+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>(),

[jamesr, 2013/03/02 03:19:14]

doing make_scoped_ptr(...).PassAs<T> is just extra typing. The point of
make_scoped_ptr() is to infer the type, but if you have to just override that
with PassAs<> it's not saving you anything. scoped_ptr<T>(...).Pass() is shorter

[wjmaclean, 2013/03/04 15:53:10]

Done.

+        make_scoped_ptr(new PinchZoomScrollbarPainter).PassAs<ScrollbarThemePainter>(),
+        make_scoped_ptr(new PinchZoomScrollbarGeometry).PassAs<WebKit::WebScrollbarThemeGeometry>(),
+        -1);
+        scrollbarLayer->setIsDrawable(true);
+        scrollbarLayer->setOpacity(0.01); //PinchZoomScrollbar::kDefaultOpacity);

[jamesr, 2013/03/02 03:19:14]

This doesn't make sense. If it's drawable, why is the opacity so low?  Why not
just make it not drawable?  Why the reference to the constant in a comment?

[wjmaclean, 2013/03/04 15:53:10]

If I make it not drawable, then later when we use an impl-side animation to fade
in/out, nothing happens because the scrollbar textures have never been painted
in the first paint. I don't think the animation framework can do this, and since
we're starting the animation on the impl-thread I don't have access. Calling
setDrawsContent(true) on the impl-thread isn't enough.

A better value here is 0 for opacity. The value in comments was left over from
an experiment and has been removed.

+        return scrollbarLayer;
+}
+
+void LayerTreeHost::createAndAddPinchZoomScrollbars()
+{
+    bool needsPropertiesUpdated = false;
+
+    if (!m_pinchZoomScrollbarHorizontal) {
+        m_pinchZoomScrollbarHorizontal = CreatePinchZoomScrollbar(WebKit::WebScrollbar::Horizontal, this);
+        needsPropertiesUpdated = true;
+    }
+
+    if (!m_pinchZoomScrollbarVertical) {
+        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_debugState.showHudInfo()) {
         if (!m_hudLayer)
             m_hudLayer = HeadsUpDisplayLayer::create();
 
         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.usePinchZoomScrollbars)
+        createAndAddPinchZoomScrollbars();
 }
 
 void LayerTreeHost::commitComplete()
 {
     m_client->didCommit();
 }
 
 scoped_ptr<OutputSurface> LayerTreeHost::createOutputSurface()
 {
     return m_client->createOutputSurface();
@@ skipping 126 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;
 
+    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;
 }
 
+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 271 matching lines @@
     }
 }
 
 void LayerTreeHost::setAnimationEventsRecursive(const AnimationEventsVector& events, Layer* layer, base::Time wallClockTime)
 {
     if (!layer)
         return;
 
     for (size_t eventIndex = 0; eventIndex < events.size(); ++eventIndex) {
         if (layer->id() == events[eventIndex].layerId) {
-            if (events[eventIndex].type == AnimationEvent::Started)
+            switch (events[eventIndex].type) {
+            case AnimationEvent::Started :
                 layer->notifyAnimationStarted(events[eventIndex], wallClockTime.ToDoubleT());
-            else
+                break;
+            case AnimationEvent::Finished :
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
+                break;
+
+            case AnimationEvent::PropertyUpdate :
+                layer->notifyAnimationPropertyUpdate(events[eventIndex]);
+                break;
+
+            default:
+                NOTREACHED();
+            }
         }
     }
 
     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