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"
@@ skipping 1341 matching lines @@
 
   // Walk up the hierarchy and look for a scrollable layer.
   LayerImpl* potentially_scrolling_layer_impl = 0;
   for (; layer_impl; layer_impl = layer_impl->parent()) {
     // The content layer can also block attempts to scroll outside the main
     // thread.
     ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
     if (status == ScrollOnMainThread) {
       num_main_thread_scrolls_++;
       UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
+      active_tree()->DidBeginScroll();
       return ScrollOnMainThread;
     }
 
     LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
     if (!scroll_layer_impl)
       continue;
 
     status = scroll_layer_impl->TryScroll(device_viewport_point, type);
 
     // If any layer wants to divert the scroll event to the main thread, abort.
     if (status == ScrollOnMainThread) {
       num_main_thread_scrolls_++;
       UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
+      active_tree()->DidBeginScroll();
       return ScrollOnMainThread;
     }
 
     if (status == ScrollStarted && !potentially_scrolling_layer_impl)
       potentially_scrolling_layer_impl = scroll_layer_impl;
   }
 
   // When hiding top controls is enabled and the controls are hidden or
   // overlaying the content, force scrolls to be enabled on the root layer to
   // allow bringing the top controls back into view.
   if (!potentially_scrolling_layer_impl && top_controls_manager_ &&
       top_controls_manager_->content_top_offset() !=
       settings_.topControlsHeight) {
     potentially_scrolling_layer_impl = RootScrollLayer();
   }
 
   if (potentially_scrolling_layer_impl) {
     active_tree_->set_currently_scrolling_layer(
         potentially_scrolling_layer_impl);
     should_bubble_scrolls_ = (type != NonBubblingGesture);
     wheel_scrolling_ = (type == Wheel);
     num_impl_thread_scrolls_++;
     client_->RenewTreePriority();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
+    active_tree()->DidBeginScroll();
     return ScrollStarted;
   }
   return ScrollIgnored;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
     LayerImpl* layer_impl,
     float scale_from_viewport_to_screen_space,
     gfx::PointF viewport_point,
     gfx::Vector2dF viewport_delta) {
@@ skipping 137 matching lines @@
 
     // Allow further movement only on an axis perpendicular to the direction in
     // which the layer moved.
     gfx::Vector2dF perpendicular_axis(-applied_delta.y(), applied_delta.x());
     pending_delta = MathUtil::projectVector(pending_delta, perpendicular_axis);
 
     if (gfx::ToFlooredVector2d(pending_delta).IsZero())
       break;
   }
 
+  active_tree()->DidUpdateScroll();
   if (did_scroll) {
     client_->SetNeedsCommitOnImplThread();
     client_->SetNeedsRedrawOnImplThread();
     client_->RenewTreePriority();
   }
   return did_scroll;
 }
 
 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
   active_tree_->ClearCurrentlyScrollingLayer();
   did_lock_scrolling_layer_ = false;
 }
 
 void LayerTreeHostImpl::ScrollEnd() {
   if (top_controls_manager_)
     top_controls_manager_->ScrollEnd();
   ClearCurrentlyScrollingLayer();
+  active_tree()->DidEndScroll();
 }
 
 void LayerTreeHostImpl::PinchGestureBegin() {
   pinch_gesture_active_ = true;
   previous_pinch_anchor_ = gfx::Point();
   client_->RenewTreePriority();
 }
 
 void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
                                            gfx::Point anchor) {
@@ skipping 358 matching lines @@
     tile_manager_->SetRecordRenderingStats(debug_state_.recordRenderingStats());
 }
 
 void LayerTreeHostImpl::SavePaintTime(const base::TimeDelta& total_paint_time,
                                       int commit_number) {
   DCHECK(debug_state_.continuousPainting);
   paint_time_counter_->SavePaintTime(total_paint_time, commit_number);
 }
 
 }  // namespace cc