cc: Add some tracing below LayerTreeHost::PushProperties.

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1144 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
     scoped_ptr<CopyOutputRequest> request,
     scoped_ptr<CopyOutputResult> result) {
   main_thread_task_runner->PostTask(FROM_HERE,
                                     base::Bind(&RunCopyCallbackOnMainThread,
                                                base::Passed(&request),
                                                base::Passed(&result)));
 }
 
 void Layer::PushPropertiesTo(LayerImpl* layer) {
+  TRACE_EVENT0("cc", "Layer::PushPropertiesTo");
   DCHECK(layer_tree_host_);
 
   // If we did not SavePaintProperties() for the layer this frame, then push the
   // real property values, not the paint property values.
   bool use_paint_properties = paint_properties_.source_frame_number ==
                               layer_tree_host_->source_frame_number();
 
   layer->SetTransformOrigin(transform_origin_);
   layer->SetBackgroundColor(background_color_);
   layer->SetBounds(use_paint_properties ? paint_properties_.bounds
@@ skipping 102 matching lines @@
   // When a scroll offset animation is interrupted the new scroll position on
   // the pending tree will clobber any impl-side scrolling occuring on the
   // active tree. To do so, avoid scrolling the pending tree along with it
   // instead of trying to undo that scrolling later.
   if (ScrollOffsetAnimationWasInterrupted())
     layer->PushScrollOffsetFromMainThreadAndClobberActiveValue(scroll_offset_);
   else
     layer->PushScrollOffsetFromMainThread(scroll_offset_);
   layer->SetScrollCompensationAdjustment(ScrollCompensationAdjustment());
 
-  // Wrap the copy_requests_ in a PostTask to the main thread.
-  std::vector<scoped_ptr<CopyOutputRequest>> main_thread_copy_requests;
-  for (auto it = copy_requests_.begin(); it != copy_requests_.end(); ++it) {
-    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
-        layer_tree_host()->task_runner_provider()->MainThreadTaskRunner();
-    scoped_ptr<CopyOutputRequest> original_request = std::move(*it);
-    const CopyOutputRequest& original_request_ref = *original_request;
-    scoped_ptr<CopyOutputRequest> main_thread_request =
-        CopyOutputRequest::CreateRelayRequest(
-            original_request_ref,
-            base::Bind(&PostCopyCallbackToMainThread,
-                       main_thread_task_runner,
-                       base::Passed(&original_request)));
-    main_thread_copy_requests.push_back(std::move(main_thread_request));
+  {
+    TRACE_EVENT0("cc", "Layer::PushPropertiesTo::CopyOutputRequests");
+    // Wrap the copy_requests_ in a PostTask to the main thread.
+    std::vector<scoped_ptr<CopyOutputRequest>> main_thread_copy_requests;
+    for (auto it = copy_requests_.begin(); it != copy_requests_.end(); ++it) {
+      scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
+          layer_tree_host()->task_runner_provider()->MainThreadTaskRunner();
+      scoped_ptr<CopyOutputRequest> original_request = std::move(*it);
+      const CopyOutputRequest& original_request_ref = *original_request;
+      scoped_ptr<CopyOutputRequest> main_thread_request =
+          CopyOutputRequest::CreateRelayRequest(
+              original_request_ref,
+              base::Bind(&PostCopyCallbackToMainThread, main_thread_task_runner,
+                         base::Passed(&original_request)));
+      main_thread_copy_requests.push_back(std::move(main_thread_request));
+    }
+    if (!copy_requests_.empty() && layer_tree_host_)
+      layer_tree_host_->property_trees()->needs_rebuild = true;
+
+    copy_requests_.clear();
+    layer->PassCopyRequests(&main_thread_copy_requests);
   }
-  if (!copy_requests_.empty() && layer_tree_host_)
-    layer_tree_host_->property_trees()->needs_rebuild = true;
-
-  copy_requests_.clear();
-  layer->PassCopyRequests(&main_thread_copy_requests);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
 
   layer->SetStackingOrderChanged(stacking_order_changed_);
 
@@ skipping 699 matching lines @@
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return ScreenSpaceTransformFromPropertyTrees(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc