cc: Remove unused metrics from RenderingStats.

cc/resources/picture_pile_impl.cc

 // Copyright 2012 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 <algorithm>
 #include <limits>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/region.h"
 #include "cc/debug/benchmark_instrumentation.h"
@@ skipping 55 matching lines @@
 PicturePileImpl* PicturePileImpl::GetCloneForDrawingOnThread(
     unsigned thread_index) const {
   CHECK_GT(clones_for_drawing_.clones_.size(), thread_index);
   return clones_for_drawing_.clones_[thread_index].get();
 }
 
 void PicturePileImpl::RasterDirect(
     SkCanvas* canvas,
     gfx::Rect canvas_rect,
     float contents_scale,
-    RasterStats* raster_stats) {
-  RasterCommon(canvas, NULL, canvas_rect, contents_scale, raster_stats);
+    RenderingStatsInstrumentation* rendering_stats_instrumentation) {
+  RasterCommon(canvas,
+               NULL,
+               canvas_rect,
+               contents_scale,
+               rendering_stats_instrumentation);
 }
 
 void PicturePileImpl::RasterForAnalysis(
     skia::AnalysisCanvas* canvas,
     gfx::Rect canvas_rect,
     float contents_scale) {
   RasterCommon(canvas, canvas, canvas_rect, contents_scale, NULL);
 }
 
 void PicturePileImpl::RasterToBitmap(
     SkCanvas* canvas,
     gfx::Rect canvas_rect,
     float contents_scale,
-    RasterStats* raster_stats) {
+    RenderingStatsInstrumentation* rendering_stats_instrumentation) {
 #ifndef NDEBUG
   // Any non-painted areas will be left in this color.
   canvas->clear(DebugColors::NonPaintedFillColor());
 #endif  // NDEBUG
 
   // If this picture has opaque contents, it is guaranteeing that it will
   // draw an opaque rect the size of the layer.  If it is not, then we must
   // clear this canvas ourselves.
   if (!contents_opaque_) {
     // Clearing is about ~4x faster than drawing a rect even if the content
@@ skipping 23 matching lines @@
       inflated_content_rect.Inset(0, 0, -1, -1);
       canvas->clipRect(gfx::RectToSkRect(inflated_content_rect),
                        SkRegion::kReplace_Op);
       canvas->clipRect(gfx::RectToSkRect(deflated_content_rect),
                        SkRegion::kDifference_Op);
       canvas->drawColor(background_color_, SkXfermode::kSrc_Mode);
       canvas->restore();
     }
   }
 
-  RasterCommon(canvas, NULL, canvas_rect, contents_scale, raster_stats);
+  RasterCommon(canvas,
+               NULL,
+               canvas_rect,
+               contents_scale,
+               rendering_stats_instrumentation);
 }
 
 void PicturePileImpl::RasterCommon(
     SkCanvas* canvas,
     SkDrawPictureCallback* callback,
     gfx::Rect canvas_rect,
     float contents_scale,
-    RasterStats* raster_stats) {
+    RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   DCHECK(contents_scale >= min_contents_scale_);
 
   canvas->translate(-canvas_rect.x(), -canvas_rect.y());
 
   gfx::SizeF total_content_size = gfx::ScaleSize(tiling_.total_size(),
                                                  contents_scale);
   gfx::Rect total_content_rect(gfx::ToCeiledSize(total_content_size));
   gfx::Rect content_rect = total_content_rect;
   content_rect.Intersect(canvas_rect);
 
   // Rasterize the collection of relevant picture piles.
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.f / contents_scale);
 
   canvas->clipRect(gfx::RectToSkRect(content_rect),
                    SkRegion::kIntersect_Op);
   Region unclipped(content_rect);
 
-  if (raster_stats) {
-    raster_stats->total_pixels_rasterized = 0;
-    raster_stats->total_rasterize_time = base::TimeDelta::FromSeconds(0);
-    raster_stats->best_rasterize_time = base::TimeDelta::FromSeconds(0);
-  }
-
   for (TilingData::Iterator tile_iter(&tiling_, layer_rect);
        tile_iter; ++tile_iter) {
     PictureListMap::iterator map_iter =
         picture_list_map_.find(tile_iter.index());
     if (map_iter == picture_list_map_.end())
       continue;
     PictureList& pic_list= map_iter->second;
     if (pic_list.empty())
       continue;
 
@@ skipping 11 matching lines @@
 
       DCHECK(!content_clip.IsEmpty()) <<
           "Layer rect: " << (*i)->LayerRect().ToString() <<
           "Contents scale: " << contents_scale;
 
       content_clip.Intersect(canvas_rect);
 
       if (!unclipped.Intersects(content_clip))
         continue;
 
-      base::TimeDelta total_duration =
-          base::TimeDelta::FromInternalValue(0);
       base::TimeDelta best_duration =
           base::TimeDelta::FromInternalValue(std::numeric_limits<int64>::max());
       int repeat_count = std::max(1, slow_down_raster_scale_factor_for_debug_);
 
       TRACE_EVENT0(benchmark_instrumentation::kCategory,
                    benchmark_instrumentation::kRasterLoop);
       for (int j = 0; j < repeat_count; ++j) {
         base::TimeTicks start_time;
-        if (raster_stats)
-          start_time = base::TimeTicks::HighResNow();
-
+        if (rendering_stats_instrumentation)
+          start_time = rendering_stats_instrumentation->StartRecording();
         (*i)->Raster(canvas, callback, content_clip, contents_scale);
-
-        if (raster_stats) {
-          base::TimeDelta duration = base::TimeTicks::HighResNow() - start_time;
-          total_duration += duration;
+        if (rendering_stats_instrumentation) {
+          base::TimeDelta duration =
+              rendering_stats_instrumentation->EndRecording(start_time);
           best_duration = std::min(best_duration, duration);
         }
       }
-
-      if (raster_stats) {
-        raster_stats->total_pixels_rasterized +=
+      if (rendering_stats_instrumentation) {
+        int64 rasterized_pixel_count =
             repeat_count * content_clip.width() * content_clip.height();
-        raster_stats->total_rasterize_time += total_duration;
-        raster_stats->best_rasterize_time += best_duration;
+        rendering_stats_instrumentation->AddRaster(best_duration,
+                                                   rasterized_pixel_count);
       }
 
       if (show_debug_picture_borders_) {
         gfx::Rect border = gfx::ScaleToEnclosedRect(
              (*i)->LayerRect(), contents_scale);
         border.Inset(0, 0, 1, 1);
 
         SkPaint picture_border_paint;
         picture_border_paint.setColor(DebugColors::PictureBorderColor());
         canvas->drawLine(border.x(), border.y(), border.right(), border.y(),
@@ skipping 147 matching lines @@
     PictureList& picture_list = (*pli).second;
     for (PictureList::iterator picture = picture_list.begin();
          picture != picture_list.end();
          picture++) {
       (*picture)->EmitTraceSnapshot();
     }
   }
 }
 
 }  // namespace cc