cc: Remove unused metrics from RenderingStats.

cc/resources/picture.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 "cc/resources/picture.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
 #include "base/base64.h"
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/benchmark_instrumentation.h"
-#include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/debug/traced_picture.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/content_layer_client.h"
 #include "skia/ext/lazy_pixel_ref_utils.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkDrawFilter.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/skia/include/utils/SkPictureUtils.h"
@@ skipping 207 matching lines @@
 
   canvas->restore();
   picture_->endRecording();
 
   opaque_rect_ = gfx::ToEnclosedRect(opaque_layer_rect);
 
   EmitTraceSnapshot();
 }
 
 void Picture::GatherPixelRefs(
-    const SkTileGridPicture::TileGridInfo& tile_grid_info,
-    RenderingStatsInstrumentation* stats_instrumentation) {
+    const SkTileGridPicture::TileGridInfo& tile_grid_info) {
   TRACE_EVENT2("cc", "Picture::GatherPixelRefs",
                "width", layer_rect_.width(),
                "height", layer_rect_.height());
 
   DCHECK(picture_);
   cell_size_ = gfx::Size(
       tile_grid_info.fTileInterval.width() +
           2 * tile_grid_info.fMargin.width(),
       tile_grid_info.fTileInterval.height() +
           2 * tile_grid_info.fMargin.height());
   DCHECK_GT(cell_size_.width(), 0);
   DCHECK_GT(cell_size_.height(), 0);
 
   int min_x = std::numeric_limits<int>::max();
   int min_y = std::numeric_limits<int>::max();
   int max_x = 0;
   int max_y = 0;
 
-  base::TimeTicks start_time = stats_instrumentation->StartRecording();
-
   skia::LazyPixelRefList pixel_refs;
   skia::LazyPixelRefUtils::GatherPixelRefs(picture_.get(), &pixel_refs);
   for (skia::LazyPixelRefList::const_iterator it = pixel_refs.begin();
        it != pixel_refs.end();
        ++it) {
     gfx::Point min(
         RoundDown(static_cast<int>(it->pixel_ref_rect.x()),
                   cell_size_.width()),
         RoundDown(static_cast<int>(it->pixel_ref_rect.y()),
                   cell_size_.height()));
     gfx::Point max(
         RoundDown(static_cast<int>(std::ceil(it->pixel_ref_rect.right())),
                   cell_size_.width()),
         RoundDown(static_cast<int>(std::ceil(it->pixel_ref_rect.bottom())),
                   cell_size_.height()));
 
     for (int y = min.y(); y <= max.y(); y += cell_size_.height()) {
       for (int x = min.x(); x <= max.x(); x += cell_size_.width()) {
         PixelRefMapKey key(x, y);
         pixel_refs_[key].push_back(it->lazy_pixel_ref);
       }
     }
 
     min_x = std::min(min_x, min.x());
     min_y = std::min(min_y, min.y());
     max_x = std::max(max_x, max.x());
     max_y = std::max(max_y, max.y());
   }
 
-  base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
-  stats_instrumentation->AddImageGathering(duration);
-
   min_pixel_cell_ = gfx::Point(min_x, min_y);
   max_pixel_cell_ = gfx::Point(max_x, max_y);
 }
 
 void Picture::Raster(
     SkCanvas* canvas,
     SkDrawPictureCallback* callback,
     gfx::Rect content_rect,
     float contents_scale) {
   TRACE_EVENT_BEGIN1(benchmark_instrumentation::kCategory,
@@ skipping 177 matching lines @@
   scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
   record_data->Set("picture_id", TracedValue::CreateIDRef(this).release());
   record_data->SetInteger(benchmark_instrumentation::kWidth,
                           layer_rect_.width());
   record_data->SetInteger(benchmark_instrumentation::kHeight,
                           layer_rect_.height());
   return TracedValue::FromValue(record_data.release());
 }
 
 }  // namespace cc