Update from https://crrev.com/333737

base/metrics/histogram_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.
 
-// Test of Histogram class
+#include "base/metrics/histogram.h"
 
 #include <climits>
 #include <algorithm>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/bucket_ranges.h"
-#include "base/metrics/histogram.h"
 #include "base/metrics/sample_vector.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/pickle.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using std::vector;
-
 namespace base {
 
 class HistogramTest : public testing::Test {
  protected:
   void SetUp() override {
     // Each test will have a clean state (no Histogram / BucketRanges
     // registered).
     InitializeStatisticsRecorder();
   }
 
@@ skipping 15 matching lines @@
 TEST_F(HistogramTest, BasicTest) {
   // Try basic construction
   HistogramBase* histogram = Histogram::FactoryGet(
       "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
   EXPECT_TRUE(histogram);
 
   HistogramBase* linear_histogram = LinearHistogram::FactoryGet(
       "TestLinearHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
   EXPECT_TRUE(linear_histogram);
 
-  vector<int> custom_ranges;
+  std::vector<int> custom_ranges;
   custom_ranges.push_back(1);
   custom_ranges.push_back(5);
   HistogramBase* custom_histogram = CustomHistogram::FactoryGet(
       "TestCustomHistogram", custom_ranges, HistogramBase::kNoFlags);
   EXPECT_TRUE(custom_histogram);
 
   // Use standard macros (but with fixed samples)
   LOCAL_HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays(1));
   LOCAL_HISTOGRAM_COUNTS("Test3Histogram", 30);
 
@@ skipping 81 matching lines @@
   EXPECT_EQ(6, ranges2.range(4));
   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges2.range(5));
   // The correspoding LinearHistogram should use the correct ranges.
   Histogram* histogram2 = static_cast<Histogram*>(
       LinearHistogram::FactoryGet("Linear2", 1, 6, 5, HistogramBase::kNoFlags));
   EXPECT_TRUE(ranges2.Equals(histogram2->bucket_ranges()));
 }
 
 TEST_F(HistogramTest, ArrayToCustomRangesTest) {
   const HistogramBase::Sample ranges[3] = {5, 10, 20};
-  vector<HistogramBase::Sample> ranges_vec =
+  std::vector<HistogramBase::Sample> ranges_vec =
       CustomHistogram::ArrayToCustomRanges(ranges, 3);
   ASSERT_EQ(6u, ranges_vec.size());
   EXPECT_EQ(5, ranges_vec[0]);
   EXPECT_EQ(6, ranges_vec[1]);
   EXPECT_EQ(10, ranges_vec[2]);
   EXPECT_EQ(11, ranges_vec[3]);
   EXPECT_EQ(20, ranges_vec[4]);
   EXPECT_EQ(21, ranges_vec[5]);
 }
 
 TEST_F(HistogramTest, CustomHistogramTest) {
   // A well prepared custom ranges.
-  vector<HistogramBase::Sample> custom_ranges;
+  std::vector<HistogramBase::Sample> custom_ranges;
   custom_ranges.push_back(1);
   custom_ranges.push_back(2);
 
   Histogram* histogram = static_cast<Histogram*>(
       CustomHistogram::FactoryGet("TestCustomHistogram1", custom_ranges,
                                   HistogramBase::kNoFlags));
   const BucketRanges* ranges = histogram->bucket_ranges();
   ASSERT_EQ(4u, ranges->size());
   EXPECT_EQ(0, ranges->range(0));  // Auto added.
   EXPECT_EQ(1, ranges->range(1));
@@ skipping 29 matching lines @@
   EXPECT_EQ(4, ranges->range(2));
   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(3));
 }
 
 TEST_F(HistogramTest, CustomHistogramWithOnly2Buckets) {
   // This test exploits the fact that the CustomHistogram can have 2 buckets,
   // while the base class Histogram is *supposed* to have at least 3 buckets.
   // We should probably change the restriction on the base class (or not inherit
   // the base class!).
 
-  vector<HistogramBase::Sample> custom_ranges;
+  std::vector<HistogramBase::Sample> custom_ranges;
   custom_ranges.push_back(4);
 
   Histogram* histogram = static_cast<Histogram*>(
       CustomHistogram::FactoryGet("2BucketsCustomHistogram", custom_ranges,
                                   HistogramBase::kNoFlags));
   const BucketRanges* ranges = histogram->bucket_ranges();
   ASSERT_EQ(3u, ranges->size());
   EXPECT_EQ(0, ranges->range(0));
   EXPECT_EQ(4, ranges->range(1));
   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(2));
@@ skipping 15 matching lines @@
 
   // Verify they landed in the underflow, and overflow buckets.
   scoped_ptr<SampleVector> samples = histogram->SnapshotSampleVector();
   EXPECT_EQ(2, samples->GetCountAtIndex(0));
   EXPECT_EQ(0, samples->GetCountAtIndex(1));
   size_t array_size = histogram->bucket_count();
   EXPECT_EQ(kBucketCount, array_size);
   EXPECT_EQ(0, samples->GetCountAtIndex(array_size - 2));
   EXPECT_EQ(2, samples->GetCountAtIndex(array_size - 1));
 
-  vector<int> custom_ranges;
+  std::vector<int> custom_ranges;
   custom_ranges.push_back(10);
   custom_ranges.push_back(50);
   custom_ranges.push_back(100);
   Histogram* test_custom_histogram = static_cast<Histogram*>(
       CustomHistogram::FactoryGet("TestCustomRangeBoundedHistogram",
                                   custom_ranges, HistogramBase::kNoFlags));
 
   // Put two samples "out of bounds" above and below.
   test_custom_histogram->Add(5);
   test_custom_histogram->Add(-50);
@@ skipping 128 matching lines @@
 
   uint32 checksum;
   EXPECT_TRUE(iter.ReadUInt32(&checksum));
   EXPECT_EQ(histogram->bucket_ranges()->checksum(), checksum);
 
   // No more data in the pickle.
   EXPECT_FALSE(iter.SkipBytes(1));
 }
 
 TEST_F(HistogramTest, CustomHistogramSerializeInfo) {
-  vector<int> custom_ranges;
+  std::vector<int> custom_ranges;
   custom_ranges.push_back(10);
   custom_ranges.push_back(100);
 
   HistogramBase* custom_histogram = CustomHistogram::FactoryGet(
       "TestCustomRangeBoundedHistogram",
       custom_ranges,
       HistogramBase::kNoFlags);
   Pickle pickle;
   custom_histogram->SerializeInfo(&pickle);
 
@@ skipping 58 matching lines @@
       histogram->HasConstructionArguments(
           1, HistogramBase::kSampleType_MAX - 1, 8));
 
   HistogramBase* linear_histogram = LinearHistogram::FactoryGet(
       "BadRangesLinear", 0, HistogramBase::kSampleType_MAX, 8,
       HistogramBase::kNoFlags);
   EXPECT_TRUE(
       linear_histogram->HasConstructionArguments(
           1, HistogramBase::kSampleType_MAX - 1, 8));
 
-  vector<int> custom_ranges;
+  std::vector<int> custom_ranges;
   custom_ranges.push_back(0);
   custom_ranges.push_back(5);
   Histogram* custom_histogram = static_cast<Histogram*>(
       CustomHistogram::FactoryGet(
           "BadRangesCustom", custom_ranges, HistogramBase::kNoFlags));
   const BucketRanges* ranges = custom_histogram->bucket_ranges();
   ASSERT_EQ(3u, ranges->size());
   EXPECT_EQ(0, ranges->range(0));
   EXPECT_EQ(5, ranges->range(1));
   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(2));
 
   // CustomHistogram does not accepts kSampleType_MAX as range.
   custom_ranges.push_back(HistogramBase::kSampleType_MAX);
   EXPECT_DEATH(CustomHistogram::FactoryGet("BadRangesCustom2", custom_ranges,
                                            HistogramBase::kNoFlags),
                "");
 
   // CustomHistogram needs at least 1 valid range.
   custom_ranges.clear();
   custom_ranges.push_back(0);
   EXPECT_DEATH(CustomHistogram::FactoryGet("BadRangesCustom3", custom_ranges,
                                            HistogramBase::kNoFlags),
                "");
 }
 #endif
 
 }  // namespace base