Add impl/comp scrolling instrumentation.

cc/layers/layer_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/layers/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/scrollbar_animation_controller.h"
@@ skipping 236 matching lines @@
   return 0;
 }
 
 void LayerImpl::SetSentScrollDelta(gfx::Vector2d sent_scroll_delta) {
   // Pending tree never has sent scroll deltas
   DCHECK(layer_tree_impl()->IsActiveTree());
 
   if (sent_scroll_delta_ == sent_scroll_delta)
     return;
 
+  TRACE_EVENT2("impl-scroll",
+               "LayerImpl::SetSentScrollDelta",
+               "scrollX", sent_scroll_delta.x(),

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

scroll_x?

+               "scrollY", sent_scroll_delta.y());

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

scroll_y?

+
   sent_scroll_delta_ = sent_scroll_delta;
 }
 
 gfx::Vector2dF LayerImpl::ScrollBy(gfx::Vector2dF scroll) {
+  TRACE_EVENT2("impl-scroll",
+               "LayerImpl::ScrollBy",
+               "scrollX", scroll.x(),

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

same.

consider making a base::Value containing the data and passing that to the event,
instead of passing values directly, so we can add more things in the future more
easily.

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

Even better, add a MathUtil::AsValue for gfx::Vector2d.

+               "scrollY", scroll.y());
   gfx::Vector2dF min_delta = -scroll_offset_;
   gfx::Vector2dF max_delta = max_scroll_offset_ - scroll_offset_;
   // Clamp new_delta so that position + delta stays within scroll bounds.
   gfx::Vector2dF new_delta = (ScrollDelta() + scroll);
   new_delta.SetToMax(min_delta);
   new_delta.SetToMin(max_delta);
   gfx::Vector2dF unscrolled = ScrollDelta() + scroll - new_delta;
 
   SetScrollDelta(new_delta);
   return unscrolled;
 }
 
 InputHandler::ScrollStatus LayerImpl::TryScroll(
     gfx::PointF screen_space_point,
     InputHandler::ScrollInputType type) const {
   if (should_scroll_on_main_thread()) {
-    TRACE_EVENT0("cc", "LayerImpl::TryScroll: Failed ShouldScrollOnMainThread");
+    TRACE_EVENT_INSTANT0("cc,impl-scroll",

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

Should we drop these from the "cc" category then?

+        "LayerImpl::TryScroll: Failed ShouldScrollOnMainThread",
+        TRACE_EVENT_SCOPE_THREAD);
     return InputHandler::ScrollOnMainThread;
   }
 
   if (!screen_space_transform().IsInvertible()) {
-    TRACE_EVENT0("cc", "LayerImpl::TryScroll: Ignored NonInvertibleTransform");
+    TRACE_EVENT_INSTANT0("cc,impl-scroll",

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

i think "impl" as a name is something to avoid and not as
discoverable/understandable to people in general. what about just calling these
"scroll[ing?]"? wdyt?

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

Do you think there'll ever be a blink scrolling trace? What about cc-scroll?

+        "LayerImpl::TryScroll: Ignored NonInvertibleTransform",
+        TRACE_EVENT_SCOPE_THREAD);
     return InputHandler::ScrollIgnored;
   }
 
   if (!non_fast_scrollable_region().IsEmpty()) {
     bool clipped = false;
     gfx::Transform inverse_screen_space_transform(
         gfx::Transform::kSkipInitialization);
     if (!screen_space_transform().GetInverse(&inverse_screen_space_transform)) {
       // TODO(shawnsingh): We shouldn't be applying a projection if screen space
       // transform is uninvertible here. Perhaps we should be returning
       // ScrollOnMainThread in this case?
     }
 
     gfx::PointF hit_test_point_in_content_space =
         MathUtil::ProjectPoint(inverse_screen_space_transform,
                                screen_space_point,
                                &clipped);
     gfx::PointF hit_test_point_in_layer_space =
         gfx::ScalePoint(hit_test_point_in_content_space,
                         1.f / contents_scale_x(),
                         1.f / contents_scale_y());
     if (!clipped &&
         non_fast_scrollable_region().Contains(
             gfx::ToRoundedPoint(hit_test_point_in_layer_space))) {
-      TRACE_EVENT0("cc",
-                   "LayerImpl::tryScroll: Failed NonFastScrollableRegion");
+      TRACE_EVENT_INSTANT0("cc,impl-scroll",
+        "LayerImpl::TryScroll: Failed NonFastScrollableRegion",
+        TRACE_EVENT_SCOPE_THREAD);
       return InputHandler::ScrollOnMainThread;
     }
   }
 
   if (type == InputHandler::Wheel && have_wheel_event_handlers()) {
-    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed WheelEventHandlers");
+    TRACE_EVENT_INSTANT0("cc,impl-scroll",
+        "LayerImpl::TryScroll: Failed WheelEventHandlers",
+        TRACE_EVENT_SCOPE_THREAD);
     return InputHandler::ScrollOnMainThread;
   }
 
   if (!scrollable()) {
-    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored not scrollable");
+    TRACE_EVENT_INSTANT0("cc,impl-scroll",
+        "LayerImpl::TryScroll: Ignored not scrollable",
+        TRACE_EVENT_SCOPE_THREAD);
     return InputHandler::ScrollIgnored;
   }
 
   if (max_scroll_offset_.x() <= 0 && max_scroll_offset_.y() <= 0) {
-    TRACE_EVENT0("cc",
-                 "LayerImpl::tryScroll: Ignored. Technically scrollable,"
-                 " but has no affordance in either direction.");
+    TRACE_EVENT_INSTANT0("cc,impl-scroll",
+        "LayerImpl::TryScroll: Ignored. Technically scrollable,"
+        " but has no affordance in either direction.",
+        TRACE_EVENT_SCOPE_THREAD);
     return InputHandler::ScrollIgnored;
   }
 
+  TRACE_EVENT_INSTANT1("cc,impl-scroll",
+      "LayerImpl::TryScroll: Started",
+      TRACE_EVENT_SCOPE_THREAD,
+      "layerId", id());

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

layer_id?

+
   return InputHandler::ScrollStarted;
 }
 
 bool LayerImpl::DrawCheckerboardForMissingTiles() const {
   return draw_checkerboard_for_missing_tiles_ &&
       !layer_tree_impl()->settings().background_color_instead_of_checkerboard;
 }
 
 gfx::Rect LayerImpl::LayerRectToContentRect(
     const gfx::RectF& layer_rect) const {
@@ skipping 527 matching lines @@
 gfx::Vector2dF LayerImpl::ScrollDelta() const {
   if (scroll_offset_delegate_)
     return scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
   return scroll_delta_;
 }
 
 void LayerImpl::SetScrollDelta(gfx::Vector2dF scroll_delta) {
   if (ScrollDelta() == scroll_delta)
     return;
 
+  TRACE_EVENT2("impl-scroll",
+               "LayerImpl::SetScrollDelta",
+               "scroll_delta.x", scroll_delta.x(),
+               "scroll_delta.y", scroll_delta.y());
+
   if (layer_tree_impl()->IsActiveTree()) {
     LayerImpl* pending_twin = layer_tree_impl()->FindPendingTreeLayerById(id());
     if (pending_twin) {
       // The pending twin can't mirror the scroll delta of the active
       // layer.  Although the delta - sent scroll delta difference is
       // identical for both twins, the sent scroll delta for the pending
       // layer is zero, as anything that has been sent has been baked
       // into the layer's position/scroll offset as a part of commit.
       DCHECK(pending_twin->sent_scroll_delta().IsZero());
       pending_twin->SetScrollDelta(scroll_delta - sent_scroll_delta());
@@ skipping 212 matching lines @@
   state->Set("compositing_reasons",
              CompositingReasonsAsValue(compositing_reasons_).release());
 
   bool clipped;
   gfx::QuadF layer_quad = MathUtil::MapQuad(
       screen_space_transform(),
       gfx::QuadF(gfx::Rect(content_bounds())),
       &clipped);
   state->Set("layer_quad", MathUtil::AsValue(layer_quad).release());
 
+#ifndef NDEBUG

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

Why only in not NDEBUG?

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

Layers only get their names set in debug builds.  You're welcome to land this,
but there's some work in progress being done to pull names from Blink but only
when tracing is on, rather than always pushing names from Blink only for debug
builds.

See: https://codereview.chromium.org/18473002/ or
https://codereview.chromium.org/16903005/.

+  state->SetString("debug_name", debug_name_);
+#endif
 
   scoped_ptr<base::ListValue> children_list(new base::ListValue());
   for (size_t i = 0; i < children_.size(); ++i)
     children_list->Append(children_[i]->AsValue().release());
   state->Set("children", children_list.release());
   if (mask_layer_)
     state->Set("mask_layer", mask_layer_->AsValue().release());
   if (replica_layer_)
     state->Set("replica_layer", replica_layer_->AsValue().release());
 }
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
 
 scoped_ptr<base::Value> LayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   AsValueInto(state.get());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc