cc: Add UMA stats for record and raster time.

cc/layers/picture_layer.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/layers/picture_layer.h"
 
 #include "base/auto_reset.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/timer/elapsed_timer.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/resources/display_list_recording_source.h"
 #include "cc/resources/picture_pile.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
@@ skipping 111 matching lines @@
 
   recording_source_->SetBackgroundColor(SafeOpaqueBackgroundColor());
   recording_source_->SetRequiresClear(!contents_opaque() &&
                                       !client_->FillsBoundsCompletely());
 
   TRACE_EVENT1("cc", "PictureLayer::Update",
                "source_frame_number",
                layer_tree_host()->source_frame_number());
   devtools_instrumentation::ScopedLayerTreeTask update_layer(
       devtools_instrumentation::kUpdateLayer, id(), layer_tree_host()->id());
+  base::ElapsedTimer timer;
 
   // Calling paint in WebKit can sometimes cause invalidations, so save
   // off the invalidation prior to calling update.
   pending_invalidation_.Swap(&recording_invalidation_);
   pending_invalidation_.Clear();
 
   if (layer_tree_host()->settings().record_full_layer) {
     // Workaround for http://crbug.com/235910 - to retain backwards compat
     // the full page content must always be provided in the picture layer.
     visible_layer_rect = gfx::Rect(layer_size);
   }
 
   // UpdateAndExpandInvalidation will give us an invalidation that covers
   // anything not explicitly recorded in this frame. We give this region
   // to the impl side so that it drops tiles that may not have a recording
   // for them.
+  int recorded_area = 0;
   DCHECK(client_);
   updated |= recording_source_->UpdateAndExpandInvalidation(
       client_, &recording_invalidation_, layer_size, visible_layer_rect,
-      update_source_frame_number_, RecordingSource::RECORD_NORMALLY);
+      update_source_frame_number_, RecordingSource::RECORD_NORMALLY,
+      &recorded_area);

[enne (OOO), 2015/04/09 17:37:34]

Yeah, I think this is the right metric.  Can you put all of this internal to
PicturePile so recorded area doesn't have to get returned?

Yeah, yeah, you have to duplicate the UMA stat call, but I think it's ok to have
bolted on stats, rather than plumbing their dependencies through like they're
first class citizens.

[jbroman, 2015/04/09 20:54:06]

Okay, split (with different stat names). This triggered Fowler's rule of three,
so I refactored into a macro (but the chromium-style plugin made me make the
destructor non-inline because it has a templated member . . . oh well). PTAL.

   last_updated_visible_content_rect_ = visible_content_rect();
 
   if (updated) {
     SetNeedsPushProperties();
   } else {
     // If this invalidation did not affect the recording source, then it can be
     // cleared as an optimization.
     recording_invalidation_.Clear();
   }
 
+  base::TimeDelta elapsed = timer.Elapsed();
+  UMA_HISTOGRAM_COUNTS("Renderer4.PictureLayerUpdateUs",
+                       elapsed.InMicroseconds());
+  UMA_HISTOGRAM_COUNTS("Renderer4.PictureLayerUpdatePixelsPerMs",
+                       recorded_area / elapsed.InMillisecondsF());
+
   return updated;
 }
 
 void PictureLayer::SetIsMask(bool is_mask) {
   is_mask_ = is_mask;
 }
 
 skia::RefPtr<SkPicture> PictureLayer::GetPicture() const {
   // We could either flatten the RecordingSource into a single SkPicture,
   // or paint a fresh one depending on what we intend to do with the
   // picture. For now we just paint a fresh one to get consistent results.
   if (!DrawsContent())
     return skia::RefPtr<SkPicture>();
 
   gfx::Size layer_size = bounds();
   const LayerTreeSettings& settings = layer_tree_host()->settings();
 
   if (settings.use_display_lists) {
     scoped_ptr<RecordingSource> recording_source;
     recording_source.reset(
         new DisplayListRecordingSource(settings.default_tile_grid_size));
     Region recording_invalidation;
     recording_source->UpdateAndExpandInvalidation(
         client_, &recording_invalidation, layer_size, gfx::Rect(layer_size),
-        update_source_frame_number_, RecordingSource::RECORD_NORMALLY);
+        update_source_frame_number_, RecordingSource::RECORD_NORMALLY, nullptr);
 
     scoped_refptr<RasterSource> raster_source =
         recording_source->CreateRasterSource(false);
 
     return raster_source->GetFlattenedPicture();
   }
 
   int width = layer_size.width();
   int height = layer_size.height();
 
@@ skipping 25 matching lines @@
 
 bool PictureLayer::HasDrawableContent() const {
   return client_ && Layer::HasDrawableContent();
 }
 
 void PictureLayer::RunMicroBenchmark(MicroBenchmark* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 }  // namespace cc