cc: Record more UMAs in CompositorTimingHistory

Also splits out UMAs for Renderer vs. Browser.

BUG=500744
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1241503002

Cr-Commit-Position: refs/heads/master@{#339495}

8 files changed, 340 insertions, 61 deletions

diff --git a/cc/scheduler/compositor_timing_history.cc b/cc/scheduler/compositor_timing_history.cc
index b46c8a1..437278c 100644
--- a/cc/scheduler/compositor_timing_history.cc
+++ b/cc/scheduler/compositor_timing_history.cc
@@ -8,6 +8,31 @@
 #include "base/trace_event/trace_event.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 
+namespace cc {
+
+class CompositorTimingHistory::UMAReporter {
+ public:
+  virtual ~UMAReporter() {}
+
+  virtual void AddBeginMainFrameToCommitDuration(base::TimeDelta duration,
+                                                 base::TimeDelta estimate,
+                                                 bool affects_estimate) = 0;
+  virtual void AddCommitToReadyToActivateDuration(base::TimeDelta duration,
+                                                  base::TimeDelta estimate,
+                                                  bool affects_estimate) = 0;
+  virtual void AddPrepareTilesDuration(base::TimeDelta duration,
+                                       base::TimeDelta estimate,
+                                       bool affects_estimate) = 0;
+  virtual void AddActivateDuration(base::TimeDelta duration,
+                                   base::TimeDelta estimate,
+                                   bool affects_estimate) = 0;
+  virtual void AddDrawDuration(base::TimeDelta duration,
+                               base::TimeDelta estimate,
+                               bool affects_estimate) = 0;
+};
+
+namespace {
+
 // The estimates that affect the compositors deadline use the 100th percentile
 // to avoid missing the Browser's deadline.
 // The estimates related to main-thread responsiveness affect whether
@@ -20,9 +45,158 @@ const double kPrepareTilesEstimationPercentile = 100.0;
 const double kActivateEstimationPercentile = 100.0;
 const double kDrawEstimationPercentile = 100.0;
 
-namespace cc {
+const base::TimeDelta kUmaDurationMin = base::TimeDelta::FromMicroseconds(1);
+const base::TimeDelta kUmaDurationMax = base::TimeDelta::FromSeconds(1);
+const size_t kUmaDurationBucketCount = 100;
+
+// Deprecated because they combine Browser and Renderer stats and have low
+// precision.
+// TODO(brianderson): Remove.
+void DeprecatedDrawDurationUMA(base::TimeDelta duration,
+                               base::TimeDelta estimate) {
+  base::TimeDelta duration_overestimate;
+  base::TimeDelta duration_underestimate;
+  if (duration > estimate)
+    duration_underestimate = duration - estimate;
+  else
+    duration_overestimate = estimate - duration;
+  UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDuration", duration,
+                             base::TimeDelta::FromMilliseconds(1),
+                             base::TimeDelta::FromMilliseconds(100), 50);
+  UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationUnderestimate",
+                             duration_underestimate,
+                             base::TimeDelta::FromMilliseconds(1),
+                             base::TimeDelta::FromMilliseconds(100), 50);
+  UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationOverestimate",
+                             duration_overestimate,
+                             base::TimeDelta::FromMilliseconds(1),
+                             base::TimeDelta::FromMilliseconds(100), 50);
+}
+
+#define UMA_HISTOGRAM_CUSTOM_TIMES_MICROS(name, sample)                \
+  UMA_HISTOGRAM_CUSTOM_COUNTS(                                         \
+      name, sample.InMicroseconds(), kUmaDurationMin.InMicroseconds(), \
+      kUmaDurationMax.InMicroseconds(), kUmaDurationBucketCount);
+
+#define REPORT_COMPOSITOR_TIMING_HISTORY_UMA(category, subcategory)            \
+  do {                                                                         \
+    base::TimeDelta duration_overestimate;                                     \
+    base::TimeDelta duration_underestimate;                                    \
+    if (duration > estimate)                                                   \
+      duration_underestimate = duration - estimate;                            \
+    else                                                                       \
+      duration_overestimate = estimate - duration;                             \
+    UMA_HISTOGRAM_CUSTOM_TIMES_MICROS(                                         \
+        "Scheduling." category "." subcategory "Duration", duration);          \
+    UMA_HISTOGRAM_CUSTOM_TIMES_MICROS("Scheduling." category "." subcategory   \
+                                      "Duration.Underestimate",                \
+                                      duration_underestimate);                 \
+    UMA_HISTOGRAM_CUSTOM_TIMES_MICROS("Scheduling." category "." subcategory   \
+                                      "Duration.Overestimate",                 \
+                                      duration_overestimate);                  \
+    if (!affects_estimate) {                                                   \
+      UMA_HISTOGRAM_CUSTOM_TIMES_MICROS("Scheduling." category "." subcategory \
+                                        "Duration.NotUsedForEstimate",         \
+                                        duration);                             \
+    }                                                                          \
+  } while (false)
+
+class RendererUMAReporter : public CompositorTimingHistory::UMAReporter {
+ public:
+  ~RendererUMAReporter() override {}
+
+  void AddBeginMainFrameToCommitDuration(base::TimeDelta duration,
+                                         base::TimeDelta estimate,
+                                         bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Renderer", "BeginMainFrameToCommit");
+  }
+
+  void AddCommitToReadyToActivateDuration(base::TimeDelta duration,
+                                          base::TimeDelta estimate,
+                                          bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Renderer", "CommitToReadyToActivate");
+  }
+
+  void AddPrepareTilesDuration(base::TimeDelta duration,
+                               base::TimeDelta estimate,
+                               bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Renderer", "PrepareTiles");
+  }
+
+  void AddActivateDuration(base::TimeDelta duration,
+                           base::TimeDelta estimate,
+                           bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Renderer", "Activate");
+  }
+
+  void AddDrawDuration(base::TimeDelta duration,
+                       base::TimeDelta estimate,
+                       bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Renderer", "Draw");
+    DeprecatedDrawDurationUMA(duration, estimate);
+  }
+};
+
+class BrowserUMAReporter : public CompositorTimingHistory::UMAReporter {
+ public:
+  ~BrowserUMAReporter() override {}
+
+  void AddBeginMainFrameToCommitDuration(base::TimeDelta duration,
+                                         base::TimeDelta estimate,
+                                         bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Browser", "BeginMainFrameToCommit");
+  }
+
+  void AddCommitToReadyToActivateDuration(base::TimeDelta duration,
+                                          base::TimeDelta estimate,
+                                          bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Browser", "CommitToReadyToActivate");
+  }
+
+  void AddPrepareTilesDuration(base::TimeDelta duration,
+                               base::TimeDelta estimate,
+                               bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Browser", "PrepareTiles");
+  }
+
+  void AddActivateDuration(base::TimeDelta duration,
+                           base::TimeDelta estimate,
+                           bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Browser", "Activate");
+  }
+
+  void AddDrawDuration(base::TimeDelta duration,
+                       base::TimeDelta estimate,
+                       bool affects_estimate) override {
+    REPORT_COMPOSITOR_TIMING_HISTORY_UMA("Browser", "Draw");
+    DeprecatedDrawDurationUMA(duration, estimate);
+  }
+};
+
+class NullUMAReporter : public CompositorTimingHistory::UMAReporter {
+ public:
+  ~NullUMAReporter() override {}
+  void AddPrepareTilesDuration(base::TimeDelta duration,
+                               base::TimeDelta estimate,
+                               bool affects_estimate) override {}
+  void AddBeginMainFrameToCommitDuration(base::TimeDelta duration,
+                                         base::TimeDelta estimate,
+                                         bool affects_estimate) override {}
+  void AddCommitToReadyToActivateDuration(base::TimeDelta duration,
+                                          base::TimeDelta estimate,
+                                          bool affects_estimate) override {}
+  void AddActivateDuration(base::TimeDelta duration,
+                           base::TimeDelta estimate,
+                           bool affects_estimate) override {}
+  void AddDrawDuration(base::TimeDelta duration,
+                       base::TimeDelta estimate,
+                       bool affects_estimate) override {}
+};
+
+}  // namespace
 
 CompositorTimingHistory::CompositorTimingHistory(
+    UMACategory uma_category,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : enabled_(false),
       begin_main_frame_to_commit_duration_history_(kDurationHistorySize),
@@ -30,23 +204,40 @@ CompositorTimingHistory::CompositorTimingHistory(
       prepare_tiles_duration_history_(kDurationHistorySize),
       activate_duration_history_(kDurationHistorySize),
       draw_duration_history_(kDurationHistorySize),
-      rendering_stats_instrumentation_(rendering_stats_instrumentation) {
-}
+      uma_reporter_(CreateUMAReporter(uma_category)),
+      rendering_stats_instrumentation_(rendering_stats_instrumentation) {}
 
 CompositorTimingHistory::~CompositorTimingHistory() {
 }
 
+scoped_ptr<CompositorTimingHistory::UMAReporter>
+CompositorTimingHistory::CreateUMAReporter(UMACategory category) {
+  switch (category) {
+    case RENDERER_UMA:
+      return make_scoped_ptr(new RendererUMAReporter);
+      break;
+    case BROWSER_UMA:
+      return make_scoped_ptr(new BrowserUMAReporter);
+      break;
+    case NULL_UMA:
+      return make_scoped_ptr(new NullUMAReporter);
+      break;
+  }
+  NOTREACHED();
+  return make_scoped_ptr<CompositorTimingHistory::UMAReporter>(nullptr);
+}
+
 void CompositorTimingHistory::AsValueInto(
     base::trace_event::TracedValue* state) const {
-  state->SetDouble("begin_main_frame_to_commit_duration_estimate_ms",
+  state->SetDouble("begin_main_frame_to_commit_estimate_ms",
                    BeginMainFrameToCommitDurationEstimate().InMillisecondsF());
-  state->SetDouble("commit_to_ready_to_activate_duration_estimate_ms",
+  state->SetDouble("commit_to_ready_to_activate_estimate_ms",
                    CommitToReadyToActivateDurationEstimate().InMillisecondsF());
-  state->SetDouble("prepare_tiles_duration_estimate_ms",
+  state->SetDouble("prepare_tiles_estimate_ms",
                    PrepareTilesDurationEstimate().InMillisecondsF());
-  state->SetDouble("activate_duration_estimate_ms",
+  state->SetDouble("activate_estimate_ms",
                    ActivateDurationEstimate().InMillisecondsF());
-  state->SetDouble("draw_duration_estimate_ms",
+  state->SetDouble("draw_estimate_ms",
                    DrawDurationEstimate().InMillisecondsF());
 }
 
@@ -103,9 +294,13 @@ void CompositorTimingHistory::DidCommit() {
   // Before adding the new data point to the timing history, see what we would
   // have predicted for this frame. This allows us to keep track of the accuracy
   // of our predictions.
+  base::TimeDelta begin_main_frame_to_commit_estimate =
+      BeginMainFrameToCommitDurationEstimate();
+  uma_reporter_->AddBeginMainFrameToCommitDuration(
+      begin_main_frame_to_commit_duration, begin_main_frame_to_commit_estimate,
+      enabled_);
   rendering_stats_instrumentation_->AddBeginMainFrameToCommitDuration(
-      begin_main_frame_to_commit_duration,
-      BeginMainFrameToCommitDurationEstimate());
+      begin_main_frame_to_commit_duration, begin_main_frame_to_commit_estimate);
 
   if (enabled_) {
     begin_main_frame_to_commit_duration_history_.InsertSample(
@@ -123,10 +318,11 @@ void CompositorTimingHistory::WillPrepareTiles() {
 void CompositorTimingHistory::DidPrepareTiles() {
   DCHECK_NE(base::TimeTicks(), start_prepare_tiles_time_);
 
-  if (enabled_) {
-    base::TimeDelta prepare_tiles_duration = Now() - start_prepare_tiles_time_;
+  base::TimeDelta prepare_tiles_duration = Now() - start_prepare_tiles_time_;
+  uma_reporter_->AddPrepareTilesDuration(
+      prepare_tiles_duration, PrepareTilesDurationEstimate(), enabled_);
+  if (enabled_)
     prepare_tiles_duration_history_.InsertSample(prepare_tiles_duration);
-  }
 
   start_prepare_tiles_time_ = base::TimeTicks();
 }
@@ -142,8 +338,13 @@ void CompositorTimingHistory::ReadyToActivate() {
   // Before adding the new data point to the timing history, see what we would
   // have predicted for this frame. This allows us to keep track of the accuracy
   // of our predictions.
+
+  base::TimeDelta commit_to_ready_to_activate_estimate =
+      CommitToReadyToActivateDurationEstimate();
+  uma_reporter_->AddCommitToReadyToActivateDuration(
+      time_since_commit, commit_to_ready_to_activate_estimate, enabled_);
   rendering_stats_instrumentation_->AddCommitToActivateDuration(
-      time_since_commit, CommitToReadyToActivateDurationEstimate());
+      time_since_commit, commit_to_ready_to_activate_estimate);
 
   if (enabled_) {
     commit_to_ready_to_activate_duration_history_.InsertSample(
@@ -160,10 +361,13 @@ void CompositorTimingHistory::WillActivate() {
 
 void CompositorTimingHistory::DidActivate() {
   DCHECK_NE(base::TimeTicks(), start_activate_time_);
-  if (enabled_) {
-    base::TimeDelta activate_duration = Now() - start_activate_time_;
+  base::TimeDelta activate_duration = Now() - start_activate_time_;
+
+  uma_reporter_->AddActivateDuration(activate_duration,
+                                     ActivateDurationEstimate(), enabled_);
+  if (enabled_)
     activate_duration_history_.InsertSample(activate_duration);
-  }
+
   start_activate_time_ = base::TimeTicks();
 }
 
@@ -179,11 +383,11 @@ void CompositorTimingHistory::DidDraw() {
   // Before adding the new data point to the timing history, see what we would
   // have predicted for this frame. This allows us to keep track of the accuracy
   // of our predictions.
-  base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
+  base::TimeDelta draw_estimate = DrawDurationEstimate();
   rendering_stats_instrumentation_->AddDrawDuration(draw_duration,
-                                                    draw_duration_estimate);
+                                                    draw_estimate);
 
-  AddDrawDurationUMA(draw_duration, draw_duration_estimate);
+  uma_reporter_->AddDrawDuration(draw_duration, draw_estimate, enabled_);
 
   if (enabled_) {
     draw_duration_history_.InsertSample(draw_duration);
@@ -192,26 +396,4 @@ void CompositorTimingHistory::DidDraw() {
   start_draw_time_ = base::TimeTicks();
 }
 
-void CompositorTimingHistory::AddDrawDurationUMA(
-    base::TimeDelta draw_duration,
-    base::TimeDelta draw_duration_estimate) {
-  base::TimeDelta draw_duration_overestimate;
-  base::TimeDelta draw_duration_underestimate;
-  if (draw_duration > draw_duration_estimate)
-    draw_duration_underestimate = draw_duration - draw_duration_estimate;
-  else
-    draw_duration_overestimate = draw_duration_estimate - draw_duration;
-  UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDuration", draw_duration,
-                             base::TimeDelta::FromMilliseconds(1),
-                             base::TimeDelta::FromMilliseconds(100), 50);
-  UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationUnderestimate",
-                             draw_duration_underestimate,
-                             base::TimeDelta::FromMilliseconds(1),
-                             base::TimeDelta::FromMilliseconds(100), 50);
-  UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationOverestimate",
-                             draw_duration_overestimate,
-                             base::TimeDelta::FromMilliseconds(1),
-                             base::TimeDelta::FromMilliseconds(100), 50);
-}
-
 }  // namespace cc
diff --git a/cc/scheduler/compositor_timing_history.h b/cc/scheduler/compositor_timing_history.h
index d64c38f..e580c5e 100644
--- a/cc/scheduler/compositor_timing_history.h
+++ b/cc/scheduler/compositor_timing_history.h
@@ -5,6 +5,7 @@
 #ifndef CC_SCHEDULER_COMPOSITOR_TIMING_HISTORY_H_
 #define CC_SCHEDULER_COMPOSITOR_TIMING_HISTORY_H_
 
+#include "base/memory/scoped_ptr.h"
 #include "cc/base/rolling_time_delta_history.h"
 
 namespace base {
@@ -19,7 +20,15 @@ class RenderingStatsInstrumentation;
 
 class CC_EXPORT CompositorTimingHistory {
  public:
-  explicit CompositorTimingHistory(
+  enum UMACategory {
+    RENDERER_UMA,
+    BROWSER_UMA,
+    NULL_UMA,
+  };
+  class UMAReporter;
+
+  CompositorTimingHistory(
+      UMACategory uma_category,
       RenderingStatsInstrumentation* rendering_stats_instrumentation);
   virtual ~CompositorTimingHistory();
 
@@ -45,11 +54,9 @@ class CC_EXPORT CompositorTimingHistory {
   void DidDraw();
 
  protected:
+  static scoped_ptr<UMAReporter> CreateUMAReporter(UMACategory category);
   virtual base::TimeTicks Now() const;
 
-  void AddDrawDurationUMA(base::TimeDelta draw_duration,
-                          base::TimeDelta draw_duration_estimate);
-
   bool enabled_;
 
   RollingTimeDeltaHistory begin_main_frame_to_commit_duration_history_;
@@ -64,6 +71,7 @@ class CC_EXPORT CompositorTimingHistory {
   base::TimeTicks start_activate_time_;
   base::TimeTicks start_draw_time_;
 
+  scoped_ptr<UMAReporter> uma_reporter_;
   RenderingStatsInstrumentation* rendering_stats_instrumentation_;
 
  private:
diff --git a/cc/scheduler/compositor_timing_history_unittest.cc b/cc/scheduler/compositor_timing_history_unittest.cc
index 6045e3a..5ffd68e 100644
--- a/cc/scheduler/compositor_timing_history_unittest.cc
+++ b/cc/scheduler/compositor_timing_history_unittest.cc
@@ -16,7 +16,7 @@ class TestCompositorTimingHistory : public CompositorTimingHistory {
  public:
   TestCompositorTimingHistory(CompositorTimingHistoryTest* test,
                               RenderingStatsInstrumentation* rendering_stats)
-      : CompositorTimingHistory(rendering_stats), test_(test) {}
+      : CompositorTimingHistory(NULL_UMA, rendering_stats), test_(test) {}
 
  protected:
   base::TimeTicks Now() const override;
diff --git a/cc/test/scheduler_test_common.cc b/cc/test/scheduler_test_common.cc
index 7419b21..ffbc244 100644
--- a/cc/test/scheduler_test_common.cc
+++ b/cc/test/scheduler_test_common.cc
@@ -75,10 +75,10 @@ scoped_ptr<FakeCompositorTimingHistory> FakeCompositorTimingHistory::Create() {
 
 FakeCompositorTimingHistory::FakeCompositorTimingHistory(
     scoped_ptr<RenderingStatsInstrumentation> rendering_stats_instrumentation)
-    : CompositorTimingHistory(rendering_stats_instrumentation.get()),
+    : CompositorTimingHistory(CompositorTimingHistory::NULL_UMA,
+                              rendering_stats_instrumentation.get()),
       rendering_stats_instrumentation_owned_(
-          rendering_stats_instrumentation.Pass()) {
-}
+          rendering_stats_instrumentation.Pass()) {}
 
 FakeCompositorTimingHistory::~FakeCompositorTimingHistory() {
 }
diff --git a/cc/trees/single_thread_proxy.cc b/cc/trees/single_thread_proxy.cc
index 5637830..6b369c5 100644
--- a/cc/trees/single_thread_proxy.cc
+++ b/cc/trees/single_thread_proxy.cc
@@ -66,6 +66,7 @@ SingleThreadProxy::SingleThreadProxy(
 
     scoped_ptr<CompositorTimingHistory> compositor_timing_history(
         new CompositorTimingHistory(
+            CompositorTimingHistory::BROWSER_UMA,
             layer_tree_host->rendering_stats_instrumentation()));
 
     scheduler_on_impl_thread_ = Scheduler::Create(
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index 533c490..7ba4f7a 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -1067,7 +1067,8 @@ void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion) {
       layer_tree_host()->settings().ToSchedulerSettings());
 
   scoped_ptr<CompositorTimingHistory> compositor_timing_history(
-      new CompositorTimingHistory(impl().rendering_stats_instrumentation));
+      new CompositorTimingHistory(CompositorTimingHistory::RENDERER_UMA,
+                                  impl().rendering_stats_instrumentation));
 
   impl().scheduler = Scheduler::Create(
       this, scheduler_settings, impl().layer_tree_host_id,
diff --git a/components/view_manager/surfaces/surfaces_scheduler.cc b/components/view_manager/surfaces/surfaces_scheduler.cc
index bee565a..9eec00e 100644
--- a/components/view_manager/surfaces/surfaces_scheduler.cc
+++ b/components/view_manager/surfaces/surfaces_scheduler.cc
@@ -15,7 +15,8 @@ SurfacesScheduler::SurfacesScheduler()
           cc::RenderingStatsInstrumentation::Create()) {
   cc::SchedulerSettings settings;
   scoped_ptr<cc::CompositorTimingHistory> compositor_timing_history(
-      new cc::CompositorTimingHistory(rendering_stats_instrumentation_.get()));
+      new cc::CompositorTimingHistory(cc::CompositorTimingHistory::NULL_UMA,
+                                      rendering_stats_instrumentation_.get()));
   scheduler_ = cc::Scheduler::Create(
       this, settings, 0, base::MessageLoop::current()->task_runner().get(),
       nullptr, compositor_timing_history.Pass());
diff --git a/tools/metrics/histograms/histograms.xml b/tools/metrics/histograms/histograms.xml
index f68e0c4..a64a5d9 100644
--- a/tools/metrics/histograms/histograms.xml
+++ b/tools/metrics/histograms/histograms.xml
@@ -34163,30 +34163,38 @@ http://cs/file:chrome/histograms.xml - but prefer this file for new entries.
 </histogram>
 
 <histogram name="Renderer.DrawDuration" units="milliseconds">
-  <owner>Please list the metric's owners. Add more owner tags as needed.</owner>
-  <summary>The time it takes for the compositor to draw a frame.</summary>
+  <owner>brianderson@chromium.org</owner>
+  <summary>
+    Deprecated: Replaced by Scheduling.Renderer.DrawDuration. The time it takes
+    for the compositor to draw a frame.
+  </summary>
 </histogram>
 
 <histogram name="Renderer.DrawDurationOverestimate" units="milliseconds">
-  <owner>Please list the metric's owners. Add more owner tags as needed.</owner>
+  <owner>brianderson@chromium.org</owner>
   <summary>
-    The amount by which the compositor's draw duration was overestimated in a
+    Deprecated: Replaced by Scheduling.Renderer.DrawDuration.Overestimate. The
+    amount by which the compositor's draw duration was overestimated in a
     particular frame (0 if the duration was perfectly predicted or
     underestimated).
   </summary>
 </histogram>
 
 <histogram name="Renderer.DrawDurationUnderestimate" units="milliseconds">
-  <owner>Please list the metric's owners. Add more owner tags as needed.</owner>
+  <owner>brianderson@chromium.org</owner>
   <summary>
-    The amount by which the compositor's draw duration was underestimated in a
+    Deprecated: Replaced by Scheduling.Renderer.DrawDuration.Underestimate. The
+    amount by which the compositor's draw duration was underestimated in a
     particular frame (0 if the duration was perfectly predicted or
     overestimated).
   </summary>
 </histogram>
 
 <histogram name="Renderer.GpuLatency" units="milliseconds">
-  <owner>Please list the metric's owners. Add more owner tags as needed.</owner>
+  <obsolete>
+    Measurement no longer taken.
+  </obsolete>
+  <owner>brianderson@chromium.org</owner>
   <summary>
     The delay between the compositor submitting a command to the GPU and that
     command executing on the GPU. This delay is measured once per frame.
@@ -34194,7 +34202,10 @@ http://cs/file:chrome/histograms.xml - but prefer this file for new entries.
 </histogram>
 
 <histogram name="Renderer.GpuLatencyOverestimate" units="milliseconds">
-  <owner>Please list the metric's owners. Add more owner tags as needed.</owner>
+  <obsolete>
+    Measurement no longer taken.
+  </obsolete>
+  <owner>brianderson@chromium.org</owner>
   <summary>
     The amount by which GPU latency was overestimated in a particular frame (0
     if the latency was perfectly predicted or underestimated).
@@ -34202,7 +34213,10 @@ http://cs/file:chrome/histograms.xml - but prefer this file for new entries.
 </histogram>
 
 <histogram name="Renderer.GpuLatencyUnderestimate" units="milliseconds">
-  <owner>Please list the metric's owners. Add more owner tags as needed.</owner>
+  <obsolete>
+    Measurement no longer taken.
+  </obsolete>
+  <owner>brianderson@chromium.org</owner>
   <summary>
     The amount by which GPU latency was underestimated in a particular frame (0
     if the latency was perfectly predicted or overestimated).
@@ -37324,6 +37338,42 @@ http://cs/file:chrome/histograms.xml - but prefer this file for new entries.
   </summary>
 </histogram>
 
+<histogram name="Scheduling.ActivateDuration">
+  <owner>brianderson@chromium.org</owner>
+  <summary>
+    How long it takes for the compositor to activate the pending tree.
+  </summary>
+</histogram>
+
+<histogram name="Scheduling.BeginMainFrameToCommitDuration">
+  <owner>brianderson@chromium.org</owner>
+  <summary>
+    How long it takes for the blink main thread to respond to the compositors
+    SendBeginMainFrame.
+  </summary>
+</histogram>
+
+<histogram name="Scheduling.CommitToReadyToActivateDuration">
+  <owner>brianderson@chromium.org</owner>
+  <summary>
+    How long it takes for the compositor to rasterize pending tree content after
+    a commit before it is ready for activation.
+  </summary>
+</histogram>
+
+<histogram name="Scheduling.DrawDuration">
+  <owner>brianderson@chromium.org</owner>
+  <summary>How long it takes the compositor to draw a frame.</summary>
+</histogram>
+
+<histogram name="Scheduling.PrepareTilesDuration">
+  <owner>brianderson@chromium.org</owner>
+  <summary>
+    How long it takes the compositor to PreapreTiles, which determines what
+    rasterization work to do.
+  </summary>
+</histogram>
+
 <histogram name="Sdch3.AdvertisedWithSecureScheme" enum="BooleanHttps">
   <owner>ellyjones@chromium.org</owner>
   <summary>
@@ -71162,6 +71212,42 @@ To add a new entry, add it with any value and run test to compute valid value.
   <affected-histogram name="CloudPrint.UrlFetcherUploadSize"/>
 </histogram_suffixes>
 
+<histogram_suffixes name="CompositorTimingHistoryProcess" separator="."
+    ordering="prefix">
+  <suffix name="Browser"/>
+  <suffix name="Renderer"/>
+  <affected-histogram name="Scheduling.ActivateDuration"/>
+  <affected-histogram name="Scheduling.BeginMainFrameToCommitDuration"/>
+  <affected-histogram name="Scheduling.CommitToReadyToActivateDuration"/>
+  <affected-histogram name="Scheduling.DrawDuration"/>
+  <affected-histogram name="Scheduling.PrepareTilesDuration"/>
+</histogram_suffixes>
+
+<histogram_suffixes name="CompositorTimingHistorySubcategory" separator=".">
+  <suffix name="NotUsedForEstimate"
+      label="Samples that don't affect estimates. For example, because we are
+             coming out of idle."/>
+  <suffix name="Overestimate"
+      label="Tracks when the compositor's estimates were too high and by how
+             much."/>
+  <suffix name="Underestimate"
+      label="Tracks when the compositor's estimates were too low and by how
+             much."/>
+  <affected-histogram name="Scheduling.Browser.ActivateDuration"/>
+  <affected-histogram name="Scheduling.Browser.BeginMainFrameToCommitDuration"/>
+  <affected-histogram
+      name="Scheduling.Browser.CommitToReadyToActivateDuration"/>
+  <affected-histogram name="Scheduling.Browser.DrawDuration"/>
+  <affected-histogram name="Scheduling.Browser.PrepareTilesDuration"/>
+  <affected-histogram name="Scheduling.Renderer.ActivateDuration"/>
+  <affected-histogram
+      name="Scheduling.Renderer.BeginMainFrameToCommitDuration"/>
+  <affected-histogram
+      name="Scheduling.Renderer.CommitToReadyToActivateDuration"/>
+  <affected-histogram name="Scheduling.Renderer.DrawDuration"/>
+  <affected-histogram name="Scheduling.Renderer.PrepareTilesDuration"/>
+</histogram_suffixes>
+
 <histogram_suffixes name="ConnCountImpact">
   <suffix name="conn_count_16" label="with 16 persistent connections per host"/>
   <suffix name="conn_count_4" label="with 4 persistent connections per host"/>