telemetry: Refactored rasterize_and_record measurement.

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/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 170 matching lines @@
                     opaque_rect_,
                     pixel_refs_));
     clones_.push_back(clone);
 
     clone->EmitTraceSnapshotAlias(this);
   }
 }
 
 void Picture::Record(ContentLayerClient* painter,
                      const SkTileGridPicture::TileGridInfo& tile_grid_info) {
-  TRACE_EVENT1(benchmark_instrumentation::kCategory,
-               benchmark_instrumentation::kPictureRecord,
-               benchmark_instrumentation::kData, AsTraceableRecordData());
+  TRACE_EVENT1("cc", "Picture::Record",
+               "data", AsTraceableRecordData());
 
   DCHECK(!tile_grid_info.fTileInterval.isEmpty());
   picture_ = skia::AdoptRef(new SkTileGridPicture(
       layer_rect_.width(), layer_rect_.height(), tile_grid_info));
 
   SkCanvas* canvas = picture_->beginRecording(
       layer_rect_.width(),
       layer_rect_.height(),
       SkPicture::kUsePathBoundsForClip_RecordingFlag |
       SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
@@ skipping 66 matching lines @@
     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());
   }
 
   min_pixel_cell_ = gfx::Point(min_x, min_y);
   max_pixel_cell_ = gfx::Point(max_x, max_y);
 }
 
-void Picture::Raster(
+int Picture::Raster(
     SkCanvas* canvas,
     SkDrawPictureCallback* callback,
     gfx::Rect content_rect,
     float contents_scale) {
-  TRACE_EVENT_BEGIN1(benchmark_instrumentation::kCategory,
-                     benchmark_instrumentation::kPictureRaster,
-                     "data",
-                     AsTraceableRasterData(content_rect, contents_scale));
+  TRACE_EVENT_BEGIN1(
+      "cc", "Picture::Raster",
+      "data", AsTraceableRasterData(content_rect, contents_scale));
 
   DCHECK(picture_);
 
   canvas->save();
   canvas->clipRect(gfx::RectToSkRect(content_rect));
   canvas->scale(contents_scale, contents_scale);
   canvas->translate(layer_rect_.x(), layer_rect_.y());
   picture_->draw(canvas, callback);
   SkIRect bounds;
   canvas->getClipDeviceBounds(&bounds);
   canvas->restore();
-  TRACE_EVENT_END1(benchmark_instrumentation::kCategory,
-                   benchmark_instrumentation::kPictureRaster,
-                   benchmark_instrumentation::kNumPixelsRasterized,
-                   bounds.width() * bounds.height());
+  TRACE_EVENT_END1(
+      "cc", "Picture::Raster",
+      "num_pixels_rasterized", bounds.width() * bounds.height());
+  return bounds.width() * bounds.height();
 }
 
 void Picture::Replay(SkCanvas* canvas) {
   TRACE_EVENT_BEGIN0("cc", "Picture::Replay");
   DCHECK(picture_);
 
   picture_->draw(canvas);
   SkIRect bounds;
   canvas->getClipDeviceBounds(&bounds);
   TRACE_EVENT_END1("cc", "Picture::Replay",
@@ skipping 141 matching lines @@
   raster_data->SetDouble("rect_y", rect.y());
   raster_data->SetDouble("rect_width", rect.width());
   raster_data->SetDouble("rect_height", rect.height());
   return TracedValue::FromValue(raster_data.release());
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
     Picture::AsTraceableRecordData() const {
   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());
+  record_data->SetInteger("width", layer_rect_.width());
+  record_data->SetInteger("height", layer_rect_.height());
   return TracedValue::FromValue(record_data.release());
 }
 
 }  // namespace cc