cc: Add UMA stats for record and raster time.

cc/resources/picture_pile.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_pile.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
+#include "cc/base/histogram_macros.h"
 #include "cc/base/region.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "skia/ext/analysis_canvas.h"
 
 namespace {
 // Layout pixel buffer around the visible layer rect to record.  Any base
 // picture that intersects the visible layer rect expanded by this distance
 // will be recorded.
 const int kPixelDistanceToRecord = 8000;
 // We don't perform solid color analysis on images that have more than 10 skia
@@ skipping 121 matching lines @@
 
   *record_rects = vertical_clustering;
 }
 
 #ifdef NDEBUG
 const bool kDefaultClearCanvasSetting = false;
 #else
 const bool kDefaultClearCanvasSetting = true;
 #endif
 
+DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
+    ScopedPicturePileUpdateTimer,
+    "Renderer4.PicturePileUpdateUs",
+    "Renderer4.PicturePileUpdatePixelsPerMs");
+
 }  // namespace
 
 namespace cc {
 
 PicturePile::PicturePile(float min_contents_scale,
                          const gfx::Size& tile_grid_size)
     : min_contents_scale_(0),
       slow_down_raster_scale_factor_for_debug_(0),
       gather_pixel_refs_(false),
       has_any_recordings_(false),
@@ skipping 12 matching lines @@
 PicturePile::~PicturePile() {
 }
 
 bool PicturePile::UpdateAndExpandInvalidation(
     ContentLayerClient* painter,
     Region* invalidation,
     const gfx::Size& layer_size,
     const gfx::Rect& visible_layer_rect,
     int frame_number,
     RecordingSource::RecordingMode recording_mode) {
+  ScopedPicturePileUpdateTimer timer;
+
   gfx::Rect interest_rect = visible_layer_rect;
   interest_rect.Inset(-pixel_record_distance_, -pixel_record_distance_);
   recorded_viewport_ = interest_rect;
   recorded_viewport_.Intersect(gfx::Rect(layer_size));
 
   bool updated = ApplyInvalidationAndResize(interest_rect, invalidation,
                                             layer_size, frame_number);
   std::vector<gfx::Rect> invalid_tiles;
   GetInvalidTileRects(interest_rect, invalidation, visible_layer_rect,
                       frame_number, &invalid_tiles);
   std::vector<gfx::Rect> record_rects;
   ClusterTiles(invalid_tiles, &record_rects);
 
   if (record_rects.empty())
     return updated;
 
+  // Count the area that is being recorded.
+  for (const auto& record_rect : record_rects)
+    timer.AddArea(record_rect.size().GetArea());
+
   CreatePictures(painter, recording_mode, record_rects);
 
   DetermineIfSolidColor();
 
   has_any_recordings_ = true;
   DCHECK(CanRasterSlowTileCheck(recorded_viewport_));
   return true;
 }
 
 bool PicturePile::ApplyInvalidationAndResize(const gfx::Rect& interest_rect,
@@ skipping 469 matching lines @@
 
 void PicturePile::SetBufferPixels(int new_buffer_pixels) {
   if (new_buffer_pixels == buffer_pixels())
     return;
 
   Clear();
   tiling_.SetBorderTexels(new_buffer_pixels);
 }
 
 }  // namespace cc