cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

cc/layer_tree_host.h

 // 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.
 
 #ifndef CC_LAYER_TREE_HOST_H_
 #define CC_LAYER_TREE_HOST_H_
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "cc/animation_events.h"
 #include "cc/cc_export.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_settings.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/output_surface.h"
 #include "cc/proxy.h"
 #include "cc/rate_limiter.h"
-#include "cc/rendering_stats.h"
 #include "cc/scoped_ptr_vector.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/rect.h"
 
 #if defined(COMPILER_GCC)
 namespace BASE_HASH_NAMESPACE {
 template <>
 struct hash<WebKit::WebGraphicsContext3D*> {
   size_t operator()(WebKit::WebGraphicsContext3D* ptr) const {
     return hash<size_t>()(reinterpret_cast<size_t>(ptr));
   }
 };
 }  // namespace BASE_HASH_NAMESPACE
 #endif  // COMPILER
 
 namespace cc {
 
 class AnimationRegistrar;
 class HeadsUpDisplayLayer;
 class Layer;
 class LayerTreeHostImpl;
 class LayerTreeHostImplClient;
 class PrioritizedResourceManager;
 class PrioritizedResource;
 class Region;
+class RenderingStatsInstrumentation;
 class ResourceProvider;
 class ResourceUpdateQueue;
 class TopControlsManager;
+struct RenderingStats;
 struct ScrollAndScaleSet;
 
 // Provides information on an Impl's rendering capabilities back to the
 // LayerTreeHost.
 struct CC_EXPORT RendererCapabilities {
   RendererCapabilities();
   ~RendererCapabilities();
 
   unsigned best_texture_format;
   bool using_partial_swap;
@@ skipping 71 matching lines @@
 
   void SetDeferCommits(bool defer_commits);
 
   // Test only hook
   virtual void DidDeferCommit();
 
   int commit_number() const { return commit_number_; }
 
   void CollectRenderingStats(RenderingStats* stats) const;
 
+  RenderingStatsInstrumentation* rendering_stats_instrumentation() const {
+    return rendering_stats_instrumentation_.get();
+  }
+
   const RendererCapabilities& GetRendererCapabilities() const;
 
   void SetNeedsAnimate();
   virtual void SetNeedsCommit();
   virtual void SetNeedsFullTreeSync();
   void SetNeedsRedraw();
   bool CommitRequested() const;
 
   void SetAnimationEvents(scoped_ptr<AnimationEventsVector> events,
                           base::Time wall_clock_time);
@@ skipping 78 matching lines @@
 
  private:
   typedef std::vector<scoped_refptr<Layer> > LayerList;
 
   bool InitializeProxy(scoped_ptr<Proxy> proxy);
   void InitializeRenderer();
 
   bool PaintLayerContents(const LayerList& render_surface_layer_list,
                           ResourceUpdateQueue* quue);
   bool PaintMasksForRenderSurface(Layer* render_surface_layer,
-                                  ResourceUpdateQueue* queue);
+                                  ResourceUpdateQueue* queue,
+                                  RenderingStats* stats);
 
   void UpdateLayers(Layer* root_layer, ResourceUpdateQueue* queue);
   void UpdateHudLayer();
   void TriggerPrepaint();
 
   void PrioritizeTextures(const LayerList& render_surface_layer_list,
                           OverdrawMetrics* metrics); 
   void SetPrioritiesForSurfaces(size_t surface_memory_bytes);
   void SetPrioritiesForLayers(const LayerList& update_list);
   size_t CalculateMemoryForRenderSurfaces(const LayerList& update_list);
 
   void AnimateLayers(base::TimeTicks monotonic_time);
   bool AnimateLayersRecursive(Layer* current, base::TimeTicks time);
   void SetAnimationEventsRecursive(const AnimationEventsVector& events,
                                    Layer* layer,
                                    base::Time wall_clock_time);
 
   bool animating_;
   bool needs_full_tree_sync_;
   bool needs_filter_context_;
 
   base::CancelableClosure prepaint_callback_;
 
   LayerTreeHostClient* client_;
   scoped_ptr<Proxy> proxy_;
 
   int commit_number_;
-  RenderingStats rendering_stats_;
+  scoped_ptr<RenderingStatsInstrumentation> rendering_stats_instrumentation_;
 
   bool renderer_initialized_;
   bool output_surface_lost_;
   int num_failed_recreate_attempts_;
 
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<HeadsUpDisplayLayer> hud_layer_;
 
   scoped_ptr<PrioritizedResourceManager> contents_texture_manager_;
   scoped_ptr<PrioritizedResource> surface_memory_placeholder_;
@@ skipping 25 matching lines @@
   size_t partial_texture_update_requests_;
 
   scoped_ptr<AnimationRegistrar> animation_registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYER_TREE_HOST_H_