cc: Add UMA stats for record and raster time.

cc/base/histograms_unittest.cc

+// 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.
+
+#include "cc/base/histograms.h"
+
+#include <limits>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+using base::TimeDelta;
+using Sample = base::HistogramBase::Sample;
+
+namespace cc {
+
+class ScopedUMAHistogramAreaTimerBaseTest : public ::testing::Test {
+ protected:
+  void ExpectInvalid(base::TimeDelta elapsed, int area) {
+    Sample time_microseconds;
+    Sample pixels_per_ms;
+    EXPECT_FALSE(ScopedUMAHistogramAreaTimerBase::GetHistogramValues(
+        elapsed, area, &time_microseconds, &pixels_per_ms));
+  }
+
+  void ExpectValidHistogramValues(base::TimeDelta elapsed,
+                                  int area,
+                                  Sample expected_time_microseconds,
+                                  Sample expected_pixels_per_ms) {
+    Sample time_microseconds;
+    Sample pixels_per_ms;
+    ASSERT_TRUE(ScopedUMAHistogramAreaTimerBase::GetHistogramValues(
+        elapsed, area, &time_microseconds, &pixels_per_ms));
+    EXPECT_EQ(expected_time_microseconds, time_microseconds);
+    EXPECT_EQ(expected_pixels_per_ms, pixels_per_ms);
+  }
+};
+
+namespace {
+
+TEST_F(ScopedUMAHistogramAreaTimerBaseTest, CommonCase) {
+  ExpectValidHistogramValues(TimeDelta::FromMicroseconds(500), 1000, 500, 2000);
+  ExpectValidHistogramValues(TimeDelta::FromMicroseconds(300), 1000, 300, 3333);
+}
+
+TEST_F(ScopedUMAHistogramAreaTimerBaseTest, ZeroArea) {
+  ExpectValidHistogramValues(TimeDelta::FromMicroseconds(500), 0, 500, 0);
+}
+
+TEST_F(ScopedUMAHistogramAreaTimerBaseTest, ZeroTime) {
+  ExpectValidHistogramValues(TimeDelta(), 1000, 0,
+                             std::numeric_limits<Sample>::max());

[chrishtr, 2015/04/13 19:54:09]

Shouldn't this case just bail and not record a histogram entry?

[jbroman, 2015/04/13 19:58:04]

Should it? It seems to me that if we do often manage to record in under one
microsecond (which is what maps to 0), we ought to report that. I don't feel
super strongly (especially since I suspect this is uncommon), but this doesn't
seem irrational to me.

It's easy enough to change, though.

[chrishtr, 2015/04/13 20:06:19]

I think it would be bad to average with infinity (if that is what would happen)
and allow it to affect the stats histograms. Alternatively, you could just round
up all times to be at least one microsecond, which on reflection seems fine
because the measurement timing probably has that much noise anyway. This would
avoid the whole issue of dividing by zero.

[jbroman, 2015/04/13 20:52:52]

Well, not infinity, just a big number. And of course the histogram bucket data
is still there.

Changed, with tests correspondingly adjusted to show the results.

+}
+
+TEST_F(ScopedUMAHistogramAreaTimerBaseTest, ZeroTimeAndArea) {
+  ExpectInvalid(TimeDelta(), 0);
+}
+
+TEST_F(ScopedUMAHistogramAreaTimerBaseTest, VeryLargeTime) {
+  ExpectValidHistogramValues(TimeDelta::FromHours(24), 1000,
+                             std::numeric_limits<Sample>::max(), 0);
+}
+
+TEST_F(ScopedUMAHistogramAreaTimerBaseTest, VeryLargeArea) {
+  ExpectValidHistogramValues(TimeDelta::FromMicroseconds(500), 1000000000, 500,
+                             2000000000);
+  ExpectValidHistogramValues(TimeDelta::FromMicroseconds(1000),
+                             std::numeric_limits<int>::max(), 1000,
+                             std::numeric_limits<Sample>::max());
+}
+
+}  // namespace
+}  // namespace cc