cc: Add UMA stats for record and raster time.

cc/base/histogram_macros.h

Index: cc/base/histogram_macros.h
diff --git a/cc/base/histogram_macros.h b/cc/base/histogram_macros.h
new file mode 100644
index 0000000000000000000000000000000000000000..0f5b71a4e65d599b915c356d2a1d7cf6890c44fb
--- /dev/null
+++ b/cc/base/histogram_macros.h
@@ -0,0 +1,48 @@
+// Copyright 2015 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.
+
+#ifndef CC_BASE_HISTOGRAM_MACROS_H_
+#define CC_BASE_HISTOGRAM_MACROS_H_
+
+#include <limits>
+
+#include "base/metrics/histogram_macros.h"
+#include "base/numerics/safe_math.h"
+#include "base/timer/elapsed_timer.h"
+
+// Emits UMA histogram trackers for time spent as well as area (in pixels)
+// processed per unit time. Time is measured in microseconds, and work in
+// pixels per millisecond.

[chrishtr, 2015/04/10 17:41:39]

Why the difference in time units?

[jbroman, 2015/04/13 19:34:00]

Time would have been in milliseconds, but UMA records integral values only (so
we'd mostly record values in the range 0-2 which is rather coarse).

For pixels/time, no such issue applies (and in fact 0-1M pixels/ms is about the
range I'd expect to see in practice, using my Z620 as a rough upper bound; 1M is
the default max value of UMA_HISTOGRAM_COUNTS). No strong objections to changing
to pixels/microsecond, though, if you want that.

+//
+// Usage:
+//   // Outside of a method, perhaps in a namespace.
+//   DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(ScopedReticulateSplinesTimer,
+//                                          "ReticulateSplinesUs",
+//                                          "ReticulateSplinesPixelsPerMs");
+//
+//   // Inside a method.
+//   ScopedReticulateSplinesTimer timer;
+//   timer.AddArea(some_rect.size().GetArea());
+#define DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(class_name, time_histogram,  \
+                                               area_histogram)              \
+  class class_name {                                                        \
+   public:                                                                  \
+    class_name();                                                           \
+    ~class_name();                                                          \
+    void AddArea(int area) { area_ += area; }                               \
+    void SetArea(int area) { area_ = area; }                                \
+                                                                            \
+   private:                                                                 \
+    base::ElapsedTimer timer_;                                              \
+    base::CheckedNumeric<int> area_;                                        \
+  };                                                                        \
+  class_name::class_name() : area_(0) {}                                    \
+  class_name::~class_name() {                                               \
+    base::TimeDelta elapsed = timer_.Elapsed();                             \
+    int area = area_.ValueOrDefault(std::numeric_limits<int>::max());       \
+    UMA_HISTOGRAM_COUNTS(time_histogram, elapsed.InMicroseconds());         \
+    UMA_HISTOGRAM_COUNTS(area_histogram, area / elapsed.InMillisecondsF()); \

[chrishtr, 2015/04/10 17:41:39]

Protect against divide by zero?

[jbroman, 2015/04/13 19:33:59]

Euh, the division is defined, but I forgot that the cast back to int32_t is
undefined. Since that's evidence that this is complicated enough to demand unit
test, I've refactored a base class with unit tests out.

saturated_cast + IsNaN should be enough to handle this.

+  }
+
+#endif  // CC_BASE_HISTOGRAM_MACROS_H_