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 1741 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,
+          "layerId", layer_impl->id());

[danakj, 2013/07/29 17:16:08]

layer_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,
+        "layerId", scroll_layer_impl->id());

[danakj, 2013/07/29 17:16:08]

layer_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,
+          "layerId", scroll_layer_impl->id());

[danakj, 2013/07/29 17:16:08]

layer_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_INSTANT0(
+          "impl-scroll", "LayerTreeHostImpl::ScrollBegin: start impl-scroll.",

[enne (OOO), 2013/07/29 17:46:31]

Would it make sense to do something with trace event async begin and step for
scrolls like we do with the pending tree in LTHI?

+          TRACE_EVENT_SCOPE_THREAD);
     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 322 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 249 matching lines @@
   if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
     return;
   if (debug_state_.continuous_painting != new_debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = new_debug_state;
   SetFullRootLayerDamage();
 }
 
 }  // namespace cc