cc: Remove unused metrics from RenderingStats.

cc/resources/raster_worker_pool.cc

 // Copyright 2013 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/raster_worker_pool.h"
 
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "cc/debug/benchmark_instrumentation.h"
@@ skipping 37 matching lines @@
   }
 };
 
 class RasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
  public:
   RasterWorkerPoolTaskImpl(const Resource* resource,
                            PicturePileImpl* picture_pile,
                            gfx::Rect content_rect,
                            float contents_scale,
                            RasterMode raster_mode,
-                           bool is_tile_in_pending_tree_now_bin,
                            TileResolution tile_resolution,
                            int layer_id,
                            const void* tile_id,
                            int source_frame_number,
                            RenderingStatsInstrumentation* rendering_stats,
                            const RasterWorkerPool::RasterTask::Reply& reply,
                            TaskVector* dependencies)
       : internal::RasterWorkerPoolTask(resource, dependencies),
         picture_pile_(picture_pile),
         content_rect_(content_rect),
         contents_scale_(contents_scale),
         raster_mode_(raster_mode),
-        is_tile_in_pending_tree_now_bin_(is_tile_in_pending_tree_now_bin),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
         tile_id_(tile_id),
         source_frame_number_(source_frame_number),
         rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   void RunAnalysisOnThread(unsigned thread_index) {
     TRACE_EVENT1("cc",
                  "RasterWorkerPoolTaskImpl::RunAnalysisOnThread",
                  "data",
                  TracedValue::FromValue(DataAsValue().release()));
 
     DCHECK(picture_pile_.get());
     DCHECK(rendering_stats_);
 
     PicturePileImpl* picture_clone =
         picture_pile_->GetCloneForDrawingOnThread(thread_index);
 
     DCHECK(picture_clone);
 
-    base::TimeTicks start_time = rendering_stats_->StartRecording();
     picture_clone->AnalyzeInRect(content_rect_, contents_scale_, &analysis_);
-    base::TimeDelta duration = rendering_stats_->EndRecording(start_time);
 
     // Record the solid color prediction.
     UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
                           analysis_.is_solid_color);
-    rendering_stats_->AddAnalysisResult(duration, analysis_.is_solid_color);
 
     // Clear the flag if we're not using the estimator.
     analysis_.is_solid_color &= kUseColorEstimator;
   }
 
   bool RunRasterOnThread(unsigned thread_index,
                          void* buffer,
                          gfx::Size size,
                          int stride) {
     TRACE_EVENT2(
@@ skipping 52 matching lines @@
         break;
       case HIGH_QUALITY_RASTER_MODE:
         break;
       case NUM_RASTER_MODES:
       default:
         NOTREACHED();
     }
 
     canvas.setDrawFilter(draw_filter.get());
 
+    base::TimeDelta prev_rasterize_time =
+        rendering_stats_->GetImplThreadRenderingStats().rasterize_time;
+
+    picture_clone->RasterToBitmap(
+        &canvas, content_rect_, contents_scale_, rendering_stats_);
+
     if (rendering_stats_->record_rendering_stats()) {
-      PicturePileImpl::RasterStats raster_stats;
-      picture_clone->RasterToBitmap(
-          &canvas, content_rect_, contents_scale_, &raster_stats);
-      rendering_stats_->AddRaster(
-          raster_stats.total_rasterize_time,
-          raster_stats.best_rasterize_time,
-          raster_stats.total_pixels_rasterized,
-          is_tile_in_pending_tree_now_bin_);
-
+      base::TimeDelta current_rasterize_time =
+          rendering_stats_->GetImplThreadRenderingStats().rasterize_time;
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
-          raster_stats.total_rasterize_time.InMicroseconds(),
+          (current_rasterize_time - prev_rasterize_time).InMicroseconds(),
           0,
           100000,
           100);
-    } else {
-      picture_clone->RasterToBitmap(
-          &canvas, content_rect_, contents_scale_, NULL);
     }
 
     ChangeBitmapConfigIfNeeded(bitmap, buffer);
 
     return true;
   }
 
   // Overridden from internal::RasterWorkerPoolTask:
   virtual bool RunOnWorkerThread(unsigned thread_index,
                                  void* buffer,
                                  gfx::Size size,
                                  int stride)
       OVERRIDE {
     RunAnalysisOnThread(thread_index);
     return RunRasterOnThread(thread_index, buffer, size, stride);
   }
   virtual void CompleteOnOriginThread() OVERRIDE {
     reply_.Run(analysis_, !HasFinishedRunning() || WasCanceled());
   }
 
  protected:
   virtual ~RasterWorkerPoolTaskImpl() {}
 
  private:
   scoped_ptr<base::Value> DataAsValue() const {
     scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
     res->Set("tile_id", TracedValue::CreateIDRef(tile_id_).release());
-    res->SetBoolean("is_tile_in_pending_tree_now_bin",
-                    is_tile_in_pending_tree_now_bin_);
     res->Set("resolution", TileResolutionAsValue(tile_resolution_).release());
     res->SetInteger("source_frame_number", source_frame_number_);
     res->SetInteger("layer_id", layer_id_);
     return res.PassAs<base::Value>();
   }
 
   void ChangeBitmapConfigIfNeeded(const SkBitmap& bitmap,
                                   void* buffer) {
     TRACE_EVENT0("cc", "RasterWorkerPoolTaskImpl::ChangeBitmapConfigIfNeeded");
     SkBitmap::Config config = SkBitmapConfigFromFormat(
         resource()->format());
     if (bitmap.getConfig() != config) {
       SkBitmap bitmap_dest;
       IdentityAllocator allocator(buffer);
       bitmap.copyTo(&bitmap_dest, config, &allocator);
       // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
       // bitmap data. This check will be removed once crbug.com/293728 is fixed.
       CHECK_EQ(0u, bitmap_dest.rowBytes() % 4);
     }
   }
 
   PicturePileImpl::Analysis analysis_;
   scoped_refptr<PicturePileImpl> picture_pile_;
   gfx::Rect content_rect_;
   float contents_scale_;
   RasterMode raster_mode_;
-  bool is_tile_in_pending_tree_now_bin_;
   TileResolution tile_resolution_;
   int layer_id_;
   const void* tile_id_;
   int source_frame_number_;
   RenderingStatsInstrumentation* rendering_stats_;
   const RasterWorkerPool::RasterTask::Reply reply_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterWorkerPoolTaskImpl);
 };
 
 class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   ImageDecodeWorkerPoolTaskImpl(skia::LazyPixelRef* pixel_ref,
                                 int layer_id,
                                 RenderingStatsInstrumentation* rendering_stats,
                                 const RasterWorkerPool::Task::Reply& reply)
       : pixel_ref_(pixel_ref),
         layer_id_(layer_id),
         rendering_stats_(rendering_stats),
         reply_(reply) {}
 
   // Overridden from internal::WorkerPoolTask:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
     TRACE_EVENT0("cc", "ImageDecodeWorkerPoolTaskImpl::RunOnWorkerThread");
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         pixel_ref_);
-    base::TimeTicks start_time = rendering_stats_->StartRecording();
     pixel_ref_->Decode();
-    base::TimeDelta duration = rendering_stats_->EndRecording(start_time);
-    rendering_stats_->AddDeferredImageDecode(duration);
   }
   virtual void CompleteOnOriginThread() OVERRIDE {
     reply_.Run(!HasFinishedRunning());
   }
 
  protected:
   virtual ~ImageDecodeWorkerPoolTaskImpl() {}
 
  private:
   skia::LazyPixelRef* pixel_ref_;
@@ skipping 139 matching lines @@
 RasterWorkerPool::RasterTask::~RasterTask() {
 }
 
 // static
 RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
     const Resource* resource,
     PicturePileImpl* picture_pile,
     gfx::Rect content_rect,
     float contents_scale,
     RasterMode raster_mode,
-    bool is_tile_in_pending_tree_now_bin,
     TileResolution tile_resolution,
     int layer_id,
     const void* tile_id,
     int source_frame_number,
     RenderingStatsInstrumentation* rendering_stats,
     const RasterTask::Reply& reply,
     Task::Set* dependencies) {
   return RasterTask(
       new RasterWorkerPoolTaskImpl(resource,
                                    picture_pile,
                                    content_rect,
                                    contents_scale,
                                    raster_mode,
-                                   is_tile_in_pending_tree_now_bin,
                                    tile_resolution,
                                    layer_id,
                                    tile_id,
                                    source_frame_number,
                                    rendering_stats,
                                    reply,
                                    &dependencies->tasks_));
 }
 
 // static
@@ skipping 134 matching lines @@
 
     internal::GraphNode* decode_node = CreateGraphNodeForTask(
         decode_task, priority, graph);
     decode_node->add_dependent(raster_node);
   }
 
   return raster_node;
 }
 
 }  // namespace cc