Rework UMAHistogramHelper and StatisticsDeltaReader into [Chrome]HistogramTester.

chrome/renderer/net/net_error_helper_core_unittest.cc

 // Copyright 2013 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 "chrome/renderer/net/net_error_helper_core.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/histogram_tester.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "chrome/common/net/net_error_info.h"
-#include "chrome/test/base/uma_histogram_helper.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "url/gurl.h"
 
 namespace {
 
 using blink::WebURLError;
 using chrome_common_net::DnsProbeStatus;
@@ skipping 2192 matching lines @@
 }
 
 TEST_F(NetErrorHelperCoreAutoReloadTest, ShownWhileNotReloading) {
   SetUpCore(true, true, false);
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   EXPECT_FALSE(timer()->IsRunning());
   core()->OnWasShown();
   EXPECT_TRUE(timer()->IsRunning());
 }
 
-// Return the count for the named histogram, or 0 if there is no histogram by
-// that name. This function is error-tolerant because histograms that have no
-// data points may not be registered, and the unit tests below still need to be
-// able to check that they haven't changed.
-int GetHistogramCount(const char *name) {
-  base::HistogramBase* histogram =
-      base::StatisticsRecorder::FindHistogram(name);
-  if (!histogram)
-    return 0;
-  scoped_ptr<base::HistogramSamples> samples = histogram->SnapshotSamples();
-  if (!samples)
-    return 0;
-  return samples->TotalCount();
-}
-
-void ExpectHistogramDelta(const char *name, int old_count, int delta) {
-  int new_count = GetHistogramCount(name);
-  EXPECT_EQ(old_count + delta, new_count) << "For histogram " << name;
-}
-
 class NetErrorHelperCoreHistogramTest
     : public NetErrorHelperCoreAutoReloadTest {
  public:
   virtual void SetUp() OVERRIDE {
     NetErrorHelperCoreAutoReloadTest::SetUp();
-    StoreOldCounts();
-  }
-
-  void ExpectDelta(const char *name, int delta) {
-    DCHECK(old_counts_.count(name) == 1);
-    ExpectHistogramDelta(name, old_counts_[name], delta);
   }
 
   static const char kCountAtStop[];
   static const char kErrorAtStop[];
   static const char kCountAtSuccess[];
   static const char kErrorAtSuccess[];
   static const char kErrorAtFirstSuccess[];
 
- private:
-  void StoreOldCounts() {
-    for (size_t i = 0; kHistogramNames[i]; i++)
-      old_counts_[kHistogramNames[i]] = GetHistogramCount(kHistogramNames[i]);
-  }
-
-  static const char *kHistogramNames[];
-
-  std::map<std::string, int> old_counts_;
+ protected:
+  base::HistogramTester histogram_tester_;
 };
 
 const char NetErrorHelperCoreHistogramTest::kCountAtStop[] =
     "Net.AutoReload.CountAtStop";
 const char NetErrorHelperCoreHistogramTest::kErrorAtStop[] =
     "Net.AutoReload.ErrorAtStop";
 const char NetErrorHelperCoreHistogramTest::kCountAtSuccess[] =
     "Net.AutoReload.CountAtSuccess";
 const char NetErrorHelperCoreHistogramTest::kErrorAtSuccess[] =
     "Net.AutoReload.ErrorAtSuccess";
 const char NetErrorHelperCoreHistogramTest::kErrorAtFirstSuccess[] =
     "Net.AutoReload.ErrorAtFirstSuccess";
-const char *NetErrorHelperCoreHistogramTest::kHistogramNames[] = {
-  kCountAtStop,
-  kErrorAtStop,
-  kCountAtSuccess,
-  kErrorAtSuccess,
-  kErrorAtFirstSuccess,
-  NULL
-};
 
 // Test that the success histograms are updated when auto-reload succeeds at the
 // first attempt, and that the failure histograms are not updated.
 TEST_F(NetErrorHelperCoreHistogramTest, SuccessAtFirstAttempt) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   timer()->Fire();
   DoSuccessLoad();
 
   // All of CountAtSuccess, ErrorAtSuccess, and ErrorAtFirstSuccess should
   // reflect this successful load. The failure histograms should be unchanged.
-  ExpectDelta(kCountAtSuccess, 1);
-  ExpectDelta(kErrorAtSuccess, 1);
-  ExpectDelta(kErrorAtFirstSuccess, 1);
-  ExpectDelta(kCountAtStop, 0);
-  ExpectDelta(kErrorAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kCountAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtStop, 0);
 }
 
 // Test that the success histograms are updated when auto-reload succeeds but
 // not on the first attempt, and that the first-success histogram is not
 // updated.
 TEST_F(NetErrorHelperCoreHistogramTest, SuccessAtSecondAttempt) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   timer()->Fire();
   EXPECT_TRUE(core()->ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME,
                                              default_url()));
 //  DoErrorLoad(net::ERR_CONNECTION_RESET);
   timer()->Fire();
   DoSuccessLoad();
 
   // CountAtSuccess and ErrorAtSuccess should reflect this successful load, but
   // not ErrorAtFirstSuccess since it wasn't a first success.
-  ExpectDelta(kCountAtSuccess, 1);
-  ExpectDelta(kErrorAtSuccess, 1);
-  ExpectDelta(kErrorAtFirstSuccess, 0);
-  ExpectDelta(kCountAtStop, 0);
-  ExpectDelta(kErrorAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtStop, 0);
 }
 
 // Test that a user stop (caused by the user pressing the 'Stop' button)
 // registers as an auto-reload failure if an auto-reload attempt is in flight.
 // Note that "user stop" is also caused by a cross-process navigation, for which
 // the browser process will send an OnStop to the old process.
 TEST_F(NetErrorHelperCoreHistogramTest, UserStop) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   timer()->Fire();
   core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   core()->OnStop();
 
   // CountAtStop and ErrorAtStop should reflect the failure.
-  ExpectDelta(kCountAtSuccess, 0);
-  ExpectDelta(kErrorAtSuccess, 0);
-  ExpectDelta(kErrorAtFirstSuccess, 0);
-  ExpectDelta(kCountAtStop, 1);
-  ExpectDelta(kErrorAtStop, 1);
+  histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtStop, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtStop, 1);
 }
 
 // Test that a user stop (caused by the user pressing the 'Stop' button)
 // registers as an auto-reload failure even if an auto-reload attempt has not
 // been launched yet (i.e., if the timer is running, but no reload is in
 // flight), because this means auto-reload didn't successfully replace the error
 // page.
 TEST_F(NetErrorHelperCoreHistogramTest, OtherPageLoaded) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   core()->OnStop();
 
-  ExpectDelta(kCountAtSuccess, 0);
-  ExpectDelta(kErrorAtSuccess, 0);
-  ExpectDelta(kErrorAtFirstSuccess, 0);
-  ExpectDelta(kCountAtStop, 1);
-  ExpectDelta(kErrorAtStop, 1);
+  histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtStop, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtStop, 1);
 }
 
 // Test that a commit of a different URL (caused by the user navigating to a
 // different page) with an auto-reload attempt in flight registers as an
 // auto-reload failure.
 TEST_F(NetErrorHelperCoreHistogramTest, OtherPageLoadedAfterTimerFires) {
   const GURL kTestUrl("https://anotherurl");
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   timer()->Fire();
   core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME,
                       kTestUrl);
   core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
-  ExpectDelta(kCountAtSuccess, 0);
-  ExpectDelta(kErrorAtSuccess, 0);
-  ExpectDelta(kErrorAtFirstSuccess, 0);
-  ExpectDelta(kCountAtStop, 1);
-  ExpectDelta(kErrorAtStop, 1);
+  histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtStop, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtStop, 1);
 }
 
 // Test that a commit of the same URL with an auto-reload attempt in flight
 // registers as an auto-reload success.
 TEST_F(NetErrorHelperCoreHistogramTest, SamePageLoadedAfterTimerFires) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   timer()->Fire();
   DoSuccessLoad();
 
-  ExpectDelta(kCountAtSuccess, 1);
-  ExpectDelta(kErrorAtSuccess, 1);
-  ExpectDelta(kErrorAtFirstSuccess, 1);
-  ExpectDelta(kCountAtStop, 0);
-  ExpectDelta(kErrorAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kCountAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtStop, 0);
 }
 
 TEST_F(NetErrorHelperCoreHistogramTest, SamePageLoadedAfterLoadStarts) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   timer()->Fire();
   // Autoreload attempt starts
   core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   // User does a manual reload
   DoSuccessLoad();
 
-  ExpectDelta(kCountAtSuccess, 1);
-  ExpectDelta(kErrorAtSuccess, 1);
-  ExpectDelta(kErrorAtFirstSuccess, 1);
-  ExpectDelta(kCountAtStop, 0);
-  ExpectDelta(kErrorAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 1);
+  histogram_tester_.ExpectTotalCount(kCountAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtStop, 0);
 }
 
 // In this test case, the user presses the reload button manually after an
 // auto-reload fails and the error page is suppressed.
 TEST_F(NetErrorHelperCoreHistogramTest, ErrorPageLoadedAfterTimerFires) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   timer()->Fire();
   core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   EXPECT_TRUE(core()->ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME,
                                              default_url()));
   DoErrorLoad(net::ERR_CONNECTION_RESET);
 
-  ExpectDelta(kCountAtSuccess, 0);
-  ExpectDelta(kErrorAtSuccess, 0);
-  ExpectDelta(kErrorAtFirstSuccess, 0);
-  ExpectDelta(kCountAtStop, 0);
-  ExpectDelta(kErrorAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtStop, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtStop, 0);
 }
 
 TEST_F(NetErrorHelperCoreHistogramTest, SuccessPageLoadedBeforeTimerFires) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME,
                       GURL(kFailedHttpsUrl));
 
-  ExpectDelta(kCountAtSuccess, 0);
-  ExpectDelta(kErrorAtSuccess, 0);
-  ExpectDelta(kErrorAtFirstSuccess, 0);
-  ExpectDelta(kCountAtStop, 1);
-  ExpectDelta(kErrorAtStop, 1);
+  histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0);
+  histogram_tester_.ExpectTotalCount(kCountAtStop, 1);
+  histogram_tester_.ExpectTotalCount(kErrorAtStop, 1);
 }
 
 
 TEST_F(NetErrorHelperCoreTest, ExplicitReloadSucceeds) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   EXPECT_EQ(0, reload_count());
   core()->ExecuteButtonPress(NetErrorHelperCore::RELOAD_BUTTON);
   EXPECT_EQ(1, reload_count());
 }
 
 TEST_F(NetErrorHelperCoreTest, ExplicitLoadStaleSucceeds) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);
   EXPECT_EQ(0, load_stale_count());
   core()->ExecuteButtonPress(NetErrorHelperCore::LOAD_STALE_BUTTON);
   EXPECT_EQ(1, load_stale_count());
   EXPECT_EQ(GURL(kFailedUrl), load_stale_url());
 }
 
 } // namespace