Add impl/comp scrolling instrumentation.

cc/trees/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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 1786 matching lines @@
                                                       device_scale_factor_);
 
   // First find out which layer was hit from the saved list of visible layers
   // in the most recent frame.
   LayerImpl* layer_impl = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       device_viewport_point, active_tree_->RenderSurfaceLayerList());
 
   // Walk up the hierarchy and look for a scrollable layer.
   LayerImpl* potentially_scrolling_layer_impl = 0;
   for (; layer_impl; layer_impl = layer_impl->parent()) {
+    TRACE_EVENT_INSTANT1(
+        "impl-scroll", "LayerTreeHostImpl::ScrollBegin considering layer",
+        TRACE_EVENT_SCOPE_THREAD,
+        "layer_id", layer_impl->id());
+
     // 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) {
       rendering_stats_instrumentation_->IncrementMainThreadScrolls();
+      TRACE_EVENT_INSTANT0(
+          "impl-scroll",
+          "LayerTreeHostImpl::ScrollBegin return ScrollOnMainThread",
+          TRACE_EVENT_SCOPE_THREAD);
+
       UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
       return ScrollOnMainThread;
     }
 
     LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
     if (!scroll_layer_impl)
       continue;
 
+    TRACE_EVENT_INSTANT1(
+        "impl-scroll",
+        "LayerTreeHostImpl::ScrollBegin considering scroll layer",
+        TRACE_EVENT_SCOPE_THREAD,
+        "layer_id", scroll_layer_impl->id());
+
     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) {
       rendering_stats_instrumentation_->IncrementMainThreadScrolls();
+      TRACE_EVENT_INSTANT0(
+          "impl-scroll",
+          "LayerTreeHostImpl::ScrollBegin return ScrollOnMainThread",
+          TRACE_EVENT_SCOPE_THREAD);
+
       UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
       return ScrollOnMainThread;
     }
 
-    if (status == ScrollStarted && !potentially_scrolling_layer_impl)
+    if (status == ScrollStarted && !potentially_scrolling_layer_impl) {
       potentially_scrolling_layer_impl = scroll_layer_impl;
+      TRACE_EVENT_INSTANT1(
+          "impl-scroll",
+          "LayerTreeHostImpl::ScrollBegin scroll layer is the potentially "
+          "scrolling layer",
+          TRACE_EVENT_SCOPE_THREAD,
+          "layer_id", scroll_layer_impl->id());
+    }
   }
 
   // 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_.top_controls_height) {
     potentially_scrolling_layer_impl = RootScrollLayer();
   }
 
   if (potentially_scrolling_layer_impl) {
     active_tree_->SetCurrentlyScrollingLayer(
         potentially_scrolling_layer_impl);
     should_bubble_scrolls_ = (type != NonBubblingGesture);
     wheel_scrolling_ = (type == Wheel);
     rendering_stats_instrumentation_->IncrementImplThreadScrolls();
     client_->RenewTreePriority();
+    TRACE_EVENT_ASYNC_BEGIN0(
+        "impl-scroll",
+        "LayerTreeHostImpl::ScrollBegin",
+        this);
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     return ScrollStarted;
   }
   return ScrollIgnored;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
     LayerImpl* layer_impl,
     float scale_from_viewport_to_screen_space,
     gfx::PointF viewport_point,
@@ skipping 244 matching lines @@
 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
   active_tree_->ClearCurrentlyScrollingLayer();
   did_lock_scrolling_layer_ = false;
   accumulated_root_overscroll_ = gfx::Vector2dF();
   current_fling_velocity_ = gfx::Vector2dF();
 }
 
 void LayerTreeHostImpl::ScrollEnd() {
   if (top_controls_manager_)
     top_controls_manager_->ScrollEnd();
+  TRACE_EVENT_ASYNC_END0(
+      "impl-scroll",
+      "LayerTreeHostImpl::ScrollBegin",
+      this);
   ClearCurrentlyScrollingLayer();
   StartScrollbarAnimation();
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
   if (!active_tree_->CurrentlyScrollingLayer())
     return ScrollIgnored;
 
   if (settings_.ignore_root_layer_flings &&
       active_tree_->CurrentlyScrollingLayer() ==
@@ skipping 65 matching lines @@
   }
 
   for (size_t i = 0; i < layer_impl->children().size(); ++i)
     CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
 }
 
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
   scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
 
   CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
+
+  if (!scroll_info->scrolls.empty()) {
+    TRACE_EVENT_INSTANT0(
+        "impl-scroll",
+        "LayerTreeHostImpl::ProcessScrollDeltas found and set scroll deltas",
+        TRACE_EVENT_SCOPE_THREAD);
+  }
+
   scroll_info->page_scale_delta = active_tree_->page_scale_delta();
   active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
 
   return scroll_info.Pass();
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
   SetViewportDamage(gfx::Rect(device_viewport_size_));
 }
 
@@ skipping 287 matching lines @@
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
 }  // namespace cc