[DRAFT] Animations: Profile hash look-ups for external mutators

cc/trees/layer_tree_host.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.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 398 matching lines @@
 
 void LayerTreeHost::CommitComplete() {
   source_frame_number_++;
   client_->DidCommit();
   if (did_complete_scale_animation_) {
     client_->DidCompletePageScaleAnimation();
     did_complete_scale_animation_ = false;
   }
 }
 
+void LayerTreeHost::DidCommitAndDrawFrame() {
+  client_->DidCommitAndDrawFrame();
+  if (animation_host_)
+    animation_host_->ReportAndClearStatsOnFrameEnd();
+}
+
 void LayerTreeHost::SetOutputSurface(scoped_ptr<OutputSurface> surface) {
   TRACE_EVENT0("cc", "LayerTreeHost::SetOutputSurface");
   DCHECK(output_surface_lost_);
   DCHECK(surface);
 
   proxy_->SetOutputSurface(surface.Pass());
 }
 
 void LayerTreeHost::RequestNewOutputSurface() {
   client_->RequestNewOutputSurface();
@@ skipping 750 matching lines @@
 }
 
 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled)
     return;
 
   AnimationEventsVector events;
   if (animation_host_) {
     if (animation_host_->AnimateLayers(monotonic_time))
       animation_host_->UpdateAnimationState(true, &events);
+    ReportAndClearStatsAfterAnimateLayers();
   } else if (animation_registrar_) {
     if (animation_registrar_->AnimateLayers(monotonic_time))
       animation_registrar_->UpdateAnimationState(true, &events);
   }
 
   if (!events.empty())
     property_trees_.needs_rebuild = true;
 }
 
 UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
@@ skipping 124 matching lines @@
     const BeginFrameArgs& args) const {
   client_->SendBeginFramesToChildren(args);
 }
 
 void LayerTreeHost::SetAuthoritativeVSyncInterval(
     const base::TimeDelta& interval) {
   proxy_->SetAuthoritativeVSyncInterval(interval);
 }
 
 Layer* LayerTreeHost::LayerById(int id) const {
+  base::TimeTicks start_time = base::TimeTicks::Now();
   LayerIdMap::const_iterator iter = layer_id_map_.find(id);
+  find_layer_by_id_stats_ += base::TimeTicks::Now() - start_time;
   return iter != layer_id_map_.end() ? iter->second : NULL;
 }
 
 void LayerTreeHost::RegisterLayer(Layer* layer) {
   DCHECK(!LayerById(layer->id()));
   layer_id_map_[layer->id()] = layer;
   if (animation_host_)
     animation_host_->RegisterLayer(layer->id(), true);
 }
 
@@ skipping 106 matching lines @@
 bool LayerTreeHost::HasAnyAnimation(const Layer* layer) const {
   return animation_host_ ? animation_host_->HasAnyAnimation(layer->id())
                          : false;
 }
 
 bool LayerTreeHost::HasActiveAnimation(const Layer* layer) const {
   return animation_host_ ? animation_host_->HasActiveAnimation(layer->id())
                          : false;
 }
 
+void LayerTreeHost::ReportAndClearStatsAfterAnimateLayers() {
+  LOCAL_HISTOGRAM_CUSTOM_COUNTS("Mutators.FindLayerById",
+                                find_layer_by_id_stats_.InMicroseconds(), 1,
+                                1000, 10);
+  find_layer_by_id_stats_ = base::TimeDelta();
+}
+
 }  // namespace cc