cc: Switch RenderingStats collection in Layer::Update() to RenderingStatsInstrumentation

cc/trees/layer_tree_host_unittest.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 "base/synchronization/lock.h"
 #include "cc/animation/timing_function.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
@@ skipping 545 matching lines @@
  public:
   static scoped_refptr<ContentLayerWithUpdateTracking> Create(
       ContentLayerClient* client) {
     return make_scoped_refptr(new ContentLayerWithUpdateTracking(client));
   }
 
   int PaintContentsCount() { return paint_contents_count_; }
   void ResetPaintContentsCount() { paint_contents_count_ = 0; }
 
   virtual void Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker* occlusion,
-                      RenderingStats* stats) OVERRIDE {
-    ContentLayer::Update(queue, occlusion, stats);
+                      const OcclusionTracker* occlusion) OVERRIDE {
+    ContentLayer::Update(queue, occlusion);
     paint_contents_count_++;
   }
 
  private:
   explicit ContentLayerWithUpdateTracking(ContentLayerClient* client)
       : ContentLayer(client), paint_contents_count_(0) {
     SetAnchorPoint(gfx::PointF(0.f, 0.f));
     SetBounds(gfx::Size(10, 10));
     SetIsDrawable(true);
   }
@@ skipping 644 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit);
 
 class EvictionTestLayer : public Layer {
  public:
   static scoped_refptr<EvictionTestLayer> Create() {
     return make_scoped_refptr(new EvictionTestLayer());
   }
 
   virtual void Update(ResourceUpdateQueue*,
-                      const OcclusionTracker*,
-                      RenderingStats*) OVERRIDE;
+                      const OcclusionTracker*) OVERRIDE;
   virtual bool DrawsContent() const OVERRIDE { return true; }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
       OVERRIDE;
   virtual void PushPropertiesTo(LayerImpl* impl) OVERRIDE;
   virtual void SetTexturePriorities(const PriorityCalculator&) OVERRIDE;
 
   bool HaveBackingTexture() const {
     return texture_.get() ? texture_->have_backing_texture() : false;
   }
@@ skipping 39 matching lines @@
 };
 
 void EvictionTestLayer::SetTexturePriorities(const PriorityCalculator&) {
   CreateTextureIfNeeded();
   if (!texture_.get())
     return;
   texture_->set_request_priority(PriorityCalculator::UIPriority(true));
 }
 
 void EvictionTestLayer::Update(ResourceUpdateQueue* queue,
-                               const OcclusionTracker*,
-                               RenderingStats*) {
+                               const OcclusionTracker*) {
   CreateTextureIfNeeded();
   if (!texture_.get())
     return;
 
   gfx::Rect full_rect(0, 0, 10, 10);
   ResourceUpdate upload = ResourceUpdate::Create(
       texture_.get(), &bitmap_, full_rect, full_rect, gfx::Vector2d());
   queue->AppendFullUpload(upload);
 }
 
@@ skipping 882 matching lines @@
   }
 
  private:
   base::TimeTicks frame_time_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestVSyncNotification);
 
 }  // namespace
 }  // namespace cc