SampleSet -> HistogramSamples (will be reused by SparseHistogram)

net/url_request/url_request_throttler_unittest.cc

 // Copyright (c) 2012 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 "net/url_request/url_request_throttler_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
+#include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/pickle.h"
+#include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "net/base/load_flags.h"
 #include "net/base/test_completion_callback.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_header_interface.h"
 #include "net/url_request/url_request_throttler_test_support.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace net {
 
 namespace {
 
 using base::Histogram;
+using base::HistogramSamples;
 using base::StatisticsRecorder;
 
 class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry {
  public:
   explicit MockURLRequestThrottlerEntry(
       net::URLRequestThrottlerManager* manager)
       : net::URLRequestThrottlerEntry(manager, ""),
         mock_backoff_entry_(&backoff_policy_) {
     InitPolicy();
   }
@@ skipping 125 matching lines @@
 };
 
 }  // namespace
 
 class URLRequestThrottlerEntryTest : public testing::Test {
  protected:
   URLRequestThrottlerEntryTest() : request_(GURL(), NULL, &context_) {
   }
 
   virtual void SetUp();
+  virtual void TearDown();
 
   // After calling this function, histogram snapshots in |samples_| contain
   // only the delta caused by the test case currently running.
   void CalculateHistogramDeltas();
 
   TimeTicks now_;
   MockURLRequestThrottlerManager manager_;  // Dummy object, not used.
   scoped_refptr<MockURLRequestThrottlerEntry> entry_;
 
-  std::map<std::string, Histogram::SampleSet> original_samples_;
-  std::map<std::string, Histogram::SampleSet> samples_;
+  std::map<std::string, HistogramSamples*> original_samples_;
+  std::map<std::string, HistogramSamples*> samples_;
 
   TestURLRequestContext context_;
   TestURLRequest request_;
 };
 
 // List of all histograms we care about in these unit tests.
 const char* kHistogramNames[] = {
   "Throttling.FailureCountAtSuccess",
   "Throttling.PerceivedDowntime",
   "Throttling.RequestThrottled",
   "Throttling.SiteOptedOut",
 };
 
 void URLRequestThrottlerEntryTest::SetUp() {
   request_.set_load_flags(0);
 
   now_ = TimeTicks::Now();
   entry_ = new MockURLRequestThrottlerEntry(&manager_);
   entry_->ResetToBlank(now_);
 
   for (size_t i = 0; i < arraysize(kHistogramNames); ++i) {
     // Must retrieve original samples for each histogram for comparison
     // as other tests may affect them.
     const char* name = kHistogramNames[i];
-    Histogram::SampleSet& original = original_samples_[name];
     Histogram* histogram = StatisticsRecorder::FindHistogram(name);
     if (histogram) {
-      histogram->SnapshotSample(&original);
+      original_samples_[name] = histogram->SnapshotSamples().release();
+    } else {
+      original_samples_[name] = NULL;
     }
   }
 }
 
+void URLRequestThrottlerEntryTest::TearDown() {
+  STLDeleteValues(&original_samples_);
+  STLDeleteValues(&samples_);
+}
+
 void URLRequestThrottlerEntryTest::CalculateHistogramDeltas() {
   for (size_t i = 0; i < arraysize(kHistogramNames); ++i) {
     const char* name = kHistogramNames[i];
-    Histogram::SampleSet& original = original_samples_[name];
-    Histogram::SampleSet& sample = samples_[name];
+    HistogramSamples* original = original_samples_[name];
 
     Histogram* histogram = StatisticsRecorder::FindHistogram(name);
     if (histogram) {
       ASSERT_EQ(Histogram::kUmaTargetedHistogramFlag, histogram->flags());
 
-      histogram->SnapshotSample(&sample);
-      // Ensure |original| size is same as |sample|, then subtract original
-      // values.
-      original.Resize(histogram->bucket_count());
-      sample.Subtract(original);
+      scoped_ptr<HistogramSamples> samples(histogram->SnapshotSamples());
+      if (original != NULL)

[Ilya Sherman, 2012/09/12 03:20:58]

nit: You can just write this as "if (original)"

[kaiwang, 2012/09/20 22:54:59]

Done.

+        samples->Subtract(*original);
+      samples_[name] = samples.release();

[Ilya Sherman, 2012/09/12 03:20:58]

Is |samples_[name]| guaranteed to be empty prior to this?  If not, this looks
like it will leak memory.

[kaiwang, 2012/09/20 22:54:59]

it's guranteed to be empty

     }
   }
 
   // Ensure we don't accidentally use the originals in our tests.
+  STLDeleteValues(&original_samples_);
   original_samples_.clear();
 }
 
 std::ostream& operator<<(std::ostream& out, const base::TimeTicks& time) {
   return out << time.ToInternalValue();
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceDuringExponentialBackoff) {
   entry_->set_exponential_backoff_release_time(
       entry_->fake_time_now_ + TimeDelta::FromMilliseconds(1));
   EXPECT_TRUE(entry_->ShouldRejectRequest(request_));
 
   // Also end-to-end test the load flags exceptions.
   request_.set_load_flags(LOAD_MAYBE_USER_GESTURE);
   EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
 
   CalculateHistogramDeltas();
-  ASSERT_EQ(1, samples_["Throttling.RequestThrottled"].counts(0));
-  ASSERT_EQ(1, samples_["Throttling.RequestThrottled"].counts(1));
+  ASSERT_EQ(1, samples_["Throttling.RequestThrottled"]->GetCount(0));
+  ASSERT_EQ(1, samples_["Throttling.RequestThrottled"]->GetCount(1));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceNotDuringExponentialBackoff) {
   entry_->set_exponential_backoff_release_time(entry_->fake_time_now_);
   EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
   entry_->set_exponential_backoff_release_time(
       entry_->fake_time_now_ - TimeDelta::FromMilliseconds(1));
   EXPECT_FALSE(entry_->ShouldRejectRequest(request_));
 
   CalculateHistogramDeltas();
-  ASSERT_EQ(2, samples_["Throttling.RequestThrottled"].counts(0));
-  ASSERT_EQ(0, samples_["Throttling.RequestThrottled"].counts(1));
+  ASSERT_EQ(2, samples_["Throttling.RequestThrottled"]->GetCount(0));
+  ASSERT_EQ(0, samples_["Throttling.RequestThrottled"]->GetCount(1));
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateFailure) {
   MockURLRequestThrottlerHeaderAdapter failure_response(503);
   entry_->UpdateWithResponse("", &failure_response);
   EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_)
       << "A failure should increase the release_time";
 }
 
 TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccess) {
@@ skipping 267 matching lines @@
         FAIL();
     }
 
     scoped_refptr<net::URLRequestThrottlerEntryInterface> entry_after =
         manager.RegisterRequestUrl(GURL("http://www.example.com/"));
     EXPECT_FALSE(entry_after->ShouldRejectRequest(request_));
   }
 }
 
 }  // namespace net