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/histograms.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"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/input/layer_selection_bound.h"
@@ skipping 536 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)

[flackr, 2016/12/08 22:35:08]

nit: >= condition in each of these is unnecessary given that we haven't returned
yet.

[majidvp, 2016/12/19 20:39:33]

Done.

+    return 1;
+  else if (numLayers >= 30 && numLayers < 70)
+    return 2;
+  else if (numLayers >= 70 && numLayers < 150)
+    return 3;
+  else

[flackr, 2016/12/08 22:35:08]

per the style guide, no else (or else if) after return.

[majidvp, 2016/12/19 20:39:33]

Done.

+    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();
+
+  if (const char* client_name = GetClientNameForMetrics()) {
+    std::string histogram_name = base::StringPrintf(
+        "Compositing.%s.LayersUpdateTime.%d", client_name,
+        GetLayersUpdateTimeHistogramBucket(layer_tree_->NumLayers()));
+    base::Histogram::FactoryGet(histogram_name, 0, 10000000, 50,
+                                base::HistogramBase::kUmaTargetedHistogramFlag)
+        ->Add(timer.Elapsed().InMicroseconds());
+  }
+
   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