UMA metric for LayerUpdateTimes

cc/trees/layer_tree_host_in_process.cc

 // Copyright 2011 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/trees/layer_tree_host_in_process.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <stack>
 #include <string>
 #include <unordered_map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/timer/elapsed_timer.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
 #include "cc/blimp/client_picture_cache.h"
 #include "cc/blimp/engine_picture_cache.h"
 #include "cc/blimp/image_serialization_processor.h"
 #include "cc/blimp/picture_data.h"
 #include "cc/blimp/picture_data_conversions.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
@@ skipping 538 matching lines @@
 
 void LayerTreeHostInProcess::Composite(base::TimeTicks frame_begin_time) {
   DCHECK(IsSingleThreaded());
   // This function is only valid when not using the scheduler.
   DCHECK(!settings_.single_thread_proxy_scheduler);
   SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
 
   proxy->CompositeImmediately(frame_begin_time);
 }
 
+static int GetLayersUpdateTimeHistogramBucket(size_t numLayers) {
+  // We uses the following exponential (ratio 2) bucketization:
+  // [0, 10), [10, 30), [30, 70), [70, 150), [150, infinity)
+  if (numLayers < 10)
+    return 0;
+  else if (numLayers >= 10 && numLayers < 30)
+    return 1;
+  else if (numLayers >= 30 && numLayers < 70)
+    return 2;
+  else if (numLayers >= 70 && numLayers < 150)
+    return 3;
+  else
+    return 4;
+}
+
 bool LayerTreeHostInProcess::UpdateLayers() {
   if (!layer_tree_->root_layer())
     return false;
   DCHECK(!layer_tree_->root_layer()->parent());
+  base::ElapsedTimer timer;
+
   bool result = DoUpdateLayers(layer_tree_->root_layer());
   micro_benchmark_controller_.DidUpdateLayers();
+
+  std::string histogram_name = base::StringPrintf(
+      "Compositing.Renderer.LayersUpdateTime.%d",

[ajuma, 2016/12/03 01:28:23]

This is going to get called for both the browser and renderers. To separate
them, you can use GetClientNameForMetrics (see LayerTreeHostImpl::PrepareToDraw
for an example).

[majidvp, 2016/12/08 20:19:18]

Thanks for the comment. Fixed!

+      GetLayersUpdateTimeHistogramBucket(layer_tree_->NumLayers()));
+  base::Histogram::FactoryTimeGet(
+      histogram_name, base::TimeDelta::FromMilliseconds(1),
+      base::TimeDelta::FromSeconds(10), 50,
+      base::HistogramBase::kUmaTargetedHistogramFlag)
+      ->AddTime(timer.Elapsed());
+
   return result || next_commit_forces_redraw_;
 }
 
 void LayerTreeHostInProcess::DidCompletePageScaleAnimation() {
   did_complete_scale_animation_ = true;
 }
 
 void LayerTreeHostInProcess::RecordGpuRasterizationHistogram() {
   // Gpu rasterization is only supported for Renderer compositors.
   // Checking for IsSingleThreaded() to exclude Browser compositors.
@@ skipping 220 matching lines @@
   return compositor_mode_ == CompositorMode::SINGLE_THREADED;
 }
 
 bool LayerTreeHostInProcess::IsThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::THREADED ||
          task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::THREADED;
 }
 
 }  // namespace cc