Remove some of the instrumentation plumbing

cc/resources/one_copy_raster_worker_pool.cc

 // Copyright 2014 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/resources/one_copy_raster_worker_pool.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/debug/trace_event.h"
@@ skipping 36 matching lines @@
 
     // Return raster resource to pool so it can be used by another RasterBuffer
     // instance.
     if (raster_resource_)
       resource_pool_->ReleaseResource(raster_resource_.Pass());
   }
 
   // Overridden from RasterBuffer:
   void Playback(const RasterSource* raster_source,
                 const gfx::Rect& rect,
-                float scale,
-                RenderingStatsInstrumentation* stats) override {
+                float scale) override {
     sequence_ = worker_pool_->PlaybackAndScheduleCopyOnWorkerThread(
-        lock_.Pass(),
-        raster_resource_.Pass(),
-        resource_,
-        raster_source,
-        rect,
-        scale,
-        stats);
+        lock_.Pass(), raster_resource_.Pass(), resource_, raster_source, rect,
+        scale);
   }
 
  private:
   OneCopyRasterWorkerPool* worker_pool_;
   ResourceProvider* resource_provider_;
   ResourcePool* resource_pool_;
   const Resource* resource_;
   scoped_ptr<ScopedResource> raster_resource_;
   scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> lock_;
   CopySequenceNumber sequence_;
@@ skipping 196 matching lines @@
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
 CopySequenceNumber
 OneCopyRasterWorkerPool::PlaybackAndScheduleCopyOnWorkerThread(
     scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> write_lock,
     scoped_ptr<ScopedResource> src,
     const Resource* dst,
     const RasterSource* raster_source,
     const gfx::Rect& rect,
-    float scale,
-    RenderingStatsInstrumentation* stats) {
+    float scale) {
   CopySequenceNumber sequence;
 
   {
     base::AutoLock lock(lock_);
 
     int failed_attempts = 0;
     while ((scheduled_copy_operation_count_ + issued_copy_operation_count_) >=
            kMaxCopyOperations) {
       // Ignore limit when shutdown is set.
       if (shutdown_)
@@ skipping 22 matching lines @@
 
     // There may be more work available, so wake up another worker thread.
     copy_operation_count_cv_.Signal();
 
     {
       base::AutoUnlock unlock(lock_);
 
       gfx::GpuMemoryBuffer* gpu_memory_buffer =
           write_lock->GetGpuMemoryBuffer();
       if (gpu_memory_buffer) {
-        RasterWorkerPool::PlaybackToMemory(gpu_memory_buffer->Map(),
-                                           src->format(),
-                                           src->size(),
-                                           gpu_memory_buffer->GetStride(),
-                                           raster_source,
-                                           rect,
-                                           scale,
-                                           stats);
+        RasterWorkerPool::PlaybackToMemory(
+            gpu_memory_buffer->Map(), src->format(), src->size(),
+            gpu_memory_buffer->GetStride(), raster_source, rect, scale);
         gpu_memory_buffer->Unmap();
       }
     }
 
     // Acquire a sequence number for this copy operation.
     sequence = next_copy_operation_sequence_++;
 
     pending_copy_operations_.push_back(
         make_scoped_ptr(new CopyOperation(write_lock.Pass(), src.Pass(), dst)));
   }
@@ skipping 165 matching lines @@
                             resource_pool_->total_memory_usage_bytes());
   staging_state->SetInteger("pending_copy_count",
                             resource_pool_->total_resource_count() -
                                 resource_pool_->acquired_resource_count());
   staging_state->SetInteger("bytes_pending_copy",
                             resource_pool_->total_memory_usage_bytes() -
                                 resource_pool_->acquired_memory_usage_bytes());
 }
 
 }  // namespace cc