cc:: Add RenderingStatsInstrumentation to manage collection of RenderingStats

cc/layer_tree_host_impl.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_IMPL_H_
 #define CC_LAYER_TREE_HOST_IMPL_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "cc/animation_events.h"
 #include "cc/animation_registrar.h"
 #include "cc/cc_export.h"
 #include "cc/input_handler.h"
 #include "cc/output_surface_client.h"
 #include "cc/render_pass.h"
 #include "cc/render_pass_sink.h"
 #include "cc/renderer.h"
+#include "cc/rendering_stats_instrumentation.h"
 #include "cc/tile_manager.h"
 #include "cc/top_controls_manager_client.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"
 
 namespace cc {
 
 class CompletionEvent;
 class CompositorFrameMetadata;
 class DebugRectHistory;
 class FrameRateCounter;
 class LayerImpl;
 class LayerTreeHostImplTimeSourceAdapter;
 class LayerTreeImpl;
 class PageScaleAnimation;
 class PaintTimeCounter;
 class MemoryHistory;
 class RenderPassDrawQuad;
 class ResourceProvider;
 class TopControlsManager;
 struct RendererCapabilities;
-struct RenderingStats;
 
 // LayerTreeHost->Proxy callback interface.
 class LayerTreeHostImplClient {
  public:
   virtual void DidLoseOutputSurfaceOnImplThread() = 0;
   virtual void OnSwapBuffersCompleteOnImplThread() = 0;
   virtual void OnVSyncParametersChanged(base::TimeTicks timebase,
                                         base::TimeDelta interval) = 0;
   virtual void OnCanDrawStateChanged(bool can_draw) = 0;
   virtual void OnHasPendingTreeStateChanged(bool has_pending_tree) = 0;
@@ skipping 20 matching lines @@
                                     public RendererClient,
                                     public TileManagerClient,
                                     public OutputSurfaceClient,
                                     public TopControlsManagerClient {
   typedef std::vector<LayerImpl*> LayerList;
 
  public:
   static scoped_ptr<LayerTreeHostImpl> Create(
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* client,
-      Proxy* proxy);
+      Proxy* proxy,
+      RenderingStatsInstrumentation* rendering_stats_instrumentation);
   virtual ~LayerTreeHostImpl();
 
   // InputHandlerClient implementation
   virtual InputHandlerClient::ScrollStatus ScrollBegin(
       gfx::Point viewport_point,
       InputHandlerClient::ScrollInputType type) OVERRIDE;
   virtual bool ScrollBy(gfx::Point viewport_point,
                         gfx::Vector2dF scroll_delta) OVERRIDE;
   virtual void ScrollEnd() OVERRIDE;
   virtual void PinchGestureBegin() OVERRIDE;
@@ skipping 130 matching lines @@
 
   void StartPageScaleAnimation(gfx::Vector2d target_offset,
                                bool use_anchor,
                                float scale,
                                base::TimeDelta duration);
 
   bool needs_animate_layers() const {
     return !animation_registrar_->active_animation_controllers().empty();
   }
 
-  void CollectRenderingStats(RenderingStats* stats) const;
-
   void SendManagedMemoryStats(
       size_t memory_visible_bytes,
       size_t memory_visible_and_nearby_bytes,
       size_t memoryUseBytes);
 
   FrameRateCounter* fps_counter() {
     return fps_counter_.get();
   }
   PaintTimeCounter* paint_time_counter() {
     return paint_time_counter_.get();
@@ skipping 69 matching lines @@
   void BeginNextFrame();
   base::TimeTicks CurrentFrameTime();
 
   scoped_ptr<base::Value> AsValue() const;
   scoped_ptr<base::Value> ActivationStateAsValue() const;
   scoped_ptr<base::Value> FrameStateAsValue() const;
 
   bool page_scale_animation_active() const { return !!page_scale_animation_; }
 
  protected:
-  LayerTreeHostImpl(const LayerTreeSettings& settings,
-                    LayerTreeHostImplClient* client,
-                    Proxy* proxy);
+  LayerTreeHostImpl(
+      const LayerTreeSettings& settings,
+      LayerTreeHostImplClient* client,
+      Proxy* proxy,
+      RenderingStatsInstrumentation* rendering_stats_instrumentation);
   void ActivatePendingTree();
 
   // Virtual for testing.
   virtual void AnimateLayers(base::TimeTicks monotonic_time,
                              base::Time wall_clock_time);
   virtual void UpdateAnimationState();
 
   // Virtual for testing.
   virtual base::TimeDelta LowFrequencyAnimationInterval() const;
 
@@ skipping 93 matching lines @@
   int64 cumulative_num_missing_tiles_;
 
   size_t last_sent_memory_visible_bytes_;
   size_t last_sent_memory_visible_and_nearby_bytes_;
   size_t last_sent_memory_use_bytes_;
 
   base::TimeTicks current_frame_time_;
 
   scoped_ptr<AnimationRegistrar> animation_registrar_;
 
+  RenderingStatsInstrumentation* rendering_stats_instrumentation_;
+
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYER_TREE_HOST_IMPL_H_