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/histograms.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.PicturePileRecordUs",
+    "Renderer4.PicturePileRecordedAreaPerMs");
+
 }  // 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);
+
+  // Count the area that is being invalidated.
+  for (Region::Iterator it(*invalidation); it.has_rect(); it.next())

[enne (OOO), 2015/04/13 21:52:27]

You need to intersect these invalidations with the interest rect.  Both
recording sources would handle a billion pixel long page that fully invalidated
every frame at the same speed as an interest rect-sized page that fully
invalidated every frame.

[jbroman, 2015/04/14 16:02:17]

Which rect is the right one to intersect with? I see interest_rect in
PicturePile, but not in DisplayListRecordingSource, and it's not clear to me
what the distinction between the interest rect and the recorded viewport
(apparently the intsersection of the interest rect with the layer bounds?) is.

Can you clarify this for me, please? Thanks for your patience. :)

[enne (OOO), 2015/04/14 16:55:19]

Oops, sorry forgot to address this comment.  You should intersect with the
recorded_viewport_, which is the interest rect intersected the layer bounds.

+    timer.AddArea(it.rect().size().GetArea());
+
   std::vector<gfx::Rect> invalid_tiles;
   GetInvalidTileRects(interest_rect, &invalid_tiles);
   std::vector<gfx::Rect> record_rects;
   ClusterTiles(invalid_tiles, &record_rects);
 
   if (record_rects.empty())
     return updated;
 
   CreatePictures(painter, recording_mode, record_rects);
 
@@ skipping 474 matching lines @@
 
 void PicturePile::SetBufferPixels(int new_buffer_pixels) {
   if (new_buffer_pixels == buffer_pixels())
     return;
 
   Clear();
   tiling_.SetBorderTexels(new_buffer_pixels);
 }
 
 }  // namespace cc