Create ForTesting method rather than declaring a dozen "friend" classes.

base/metrics/persistent_histogram_allocator_unittest.cc

 // Copyright 2016 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 "base/metrics/persistent_histogram_allocator.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/bucket_ranges.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/metrics/statistics_recorder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 class PersistentHistogramAllocatorTest : public testing::Test {
  protected:
   const int32_t kAllocatorMemorySize = 64 << 10;  // 64 KiB
 
-  PersistentHistogramAllocatorTest() { CreatePersistentHistogramAllocator(); }
+  PersistentHistogramAllocatorTest()
+      : statistics_recorder_(StatisticsRecorder::CreateTemporaryForTesting()) {
+    CreatePersistentHistogramAllocator();
+  }
   ~PersistentHistogramAllocatorTest() override {
     DestroyPersistentHistogramAllocator();
   }
 
   void CreatePersistentHistogramAllocator() {
     allocator_memory_.reset(new char[kAllocatorMemorySize]);
 
     GlobalHistogramAllocator::ReleaseForTesting();
     memset(allocator_memory_.get(), 0, kAllocatorMemorySize);
     GlobalHistogramAllocator::GetCreateHistogramResultHistogram();
     GlobalHistogramAllocator::CreateWithPersistentMemory(
         allocator_memory_.get(), kAllocatorMemorySize, 0, 0,
         "PersistentHistogramAllocatorTest");
     allocator_ = GlobalHistogramAllocator::Get()->memory_allocator();
   }
 
   void DestroyPersistentHistogramAllocator() {
     allocator_ = nullptr;
     GlobalHistogramAllocator::ReleaseForTesting();
   }
 
-  std::unique_ptr<StatisticsRecorder> CreateLocalStatisticsRecorder() {
-    return WrapUnique(new StatisticsRecorder());
-  }
-
-  StatisticsRecorder statistics_recorder_;
+  std::unique_ptr<StatisticsRecorder> statistics_recorder_;
   std::unique_ptr<char[]> allocator_memory_;
   PersistentMemoryAllocator* allocator_ = nullptr;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentHistogramAllocatorTest);
 };
 
 TEST_F(PersistentHistogramAllocatorTest, CreateAndIterateTest) {
   PersistentMemoryAllocator::MemoryInfo meminfo0;
   allocator_->GetMemoryInfo(&meminfo0);
@@ skipping 68 matching lines @@
   recovered = histogram_iter.GetNext();
   EXPECT_FALSE(recovered);
 }
 
 TEST_F(PersistentHistogramAllocatorTest, StatisticsRecorderTest) {
   size_t starting_sr_count = StatisticsRecorder::GetHistogramCount();
 
   // Create a local StatisticsRecorder in which the newly created histogram
   // will be recorded.
   std::unique_ptr<StatisticsRecorder> local_sr =
-      CreateLocalStatisticsRecorder();
+      StatisticsRecorder::CreateTemporaryForTesting();
   EXPECT_EQ(0U, StatisticsRecorder::GetHistogramCount());
 
   HistogramBase* histogram = LinearHistogram::FactoryGet(
       "TestHistogram", 1, 10, 10, HistogramBase::kIsPersistent);
   EXPECT_TRUE(histogram);
   EXPECT_EQ(1U, StatisticsRecorder::GetHistogramCount());
   histogram->Add(3);
   histogram->Add(1);
   histogram->Add(4);
   histogram->Add(1);
@@ skipping 24 matching lines @@
   // Ensure that the data got merged, too.
   std::unique_ptr<HistogramSamples> snapshot = found->SnapshotSamples();
   EXPECT_EQ(recovered->SnapshotSamples()->TotalCount(), snapshot->TotalCount());
   EXPECT_EQ(1, snapshot->GetCount(3));
   EXPECT_EQ(2, snapshot->GetCount(1));
   EXPECT_EQ(1, snapshot->GetCount(4));
   EXPECT_EQ(1, snapshot->GetCount(6));
 }
 
 }  // namespace base