cc: Add main frame timing info to frame timing tracker.

cc/trees/layer_tree_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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 16 matching lines @@
 #include "cc/layers/scrollbar_layer_impl_base.h"
 #include "cc/resources/ui_resource_request.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
+namespace {
+
+template <typename Lambda>
+void ProcessLayersRecursive(LayerImpl* current, const Lambda& lambda) {

[enne (OOO), 2015/03/06 00:00:57]

This isn't needed anymore, yeah?

[vmpstr, 2015/03/06 00:59:53]

Whoops, removed.

+  DCHECK(current);
+  lambda(current);
+  if (current->mask_layer())
+    ProcessLayersRecursive(current->mask_layer(), lambda);
+  if (current->replica_layer())
+    ProcessLayersRecursive(current->replica_layer(), lambda);
+  for (size_t i = 0; i < current->children().size(); ++i)
+    ProcessLayersRecursive(current->children()[i], lambda);
+}
+
+}  // namespace
 
 // This class exists to split the LayerScrollOffsetDelegate between the
 // InnerViewportScrollLayer and the OuterViewportScrollLayer in a manner
 // that never requires the embedder or LayerImpl to know about.
 class LayerScrollOffsetDelegateProxy : public LayerImpl::ScrollOffsetDelegate {
  public:
   LayerScrollOffsetDelegateProxy(LayerImpl* layer,
                                  LayerScrollOffsetDelegate* delegate,
                                  LayerTreeImpl* layer_tree)
       : layer_(layer), delegate_(delegate), layer_tree_impl_(layer_tree) {}
@@ skipping 81 matching lines @@
 }
 
 void LayerTreeImpl::RecreateResources() {
   if (root_layer_) {
     LayerTreeHostCommon::CallFunctionForSubtree(
         root_layer_.get(),
         [](LayerImpl* layer) { layer->RecreateResources(); });
   }
 }
 
+void LayerTreeImpl::GatherFrameTimingRequestIds(
+    std::vector<int64_t>* request_ids) {
+  if (!root_layer_)
+    return;
+
+  // TODO(vmpstr): Early out if there are no requests on any of the layers. For
+  // that, we need to inform LayerTreeImpl whenever there are requests when we
+  // get them.
+  LayerTreeHostCommon::CallFunctionForSubtree(
+      root_layer_.get(), [request_ids](LayerImpl* layer) {
+        layer->GatherFrameTimingRequestIds(request_ids);
+      });
+}
+
 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
   if (inner_viewport_scroll_layer_)
     inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
   if (outer_viewport_scroll_layer_)
     outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL);
   inner_viewport_scroll_delegate_proxy_ = nullptr;
   outer_viewport_scroll_delegate_proxy_ = nullptr;
 
   root_layer_ = layer.Pass();
   currently_scrolling_layer_ = NULL;
@@ skipping 1488 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc