Move base/prefs to components/prefs

components/prefs/json_pref_store_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 "base/prefs/json_pref_store.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_samples.h"
-#include "base/metrics/statistics_recorder.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_filter.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
 const char kHomePage[] = "homepage";
 
+const char kReadJson[] =
+    "{\n"
+    "  \"homepage\": \"http://www.cnn.com\",\n"
+    "  \"some_directory\": \"/usr/local/\",\n"
+    "  \"tabs\": {\n"
+    "    \"new_windows_in_tabs\": true,\n"
+    "    \"max_tabs\": 20\n"
+    "  }\n"
+    "}";
+
+const char kInvalidJson[] = "!@#$%^&";
+
+// Expected output for tests using RunBasicJsonPrefStoreTest().
+const char kWriteGolden[] =
+    "{\"homepage\":\"http://www.cnn.com\","
+     "\"long_int\":{\"pref\":\"214748364842\"},"
+     "\"some_directory\":\"/usr/sbin/\","
+     "\"tabs\":{\"max_tabs\":10,\"new_windows_in_tabs\":false}}";
+
 // Set the time on the given SimpleTestClock to the given time in minutes.
 void SetCurrentTimeInMinutes(double minutes, base::SimpleTestClock* clock) {
   const int32_t kBaseTimeMins = 100;
   clock->SetNow(base::Time::FromDoubleT((kBaseTimeMins + minutes) * 60));
 }
 
 // A PrefFilter that will intercept all calls to FilterOnLoad() and hold on
 // to the |prefs| until explicitly asked to release them.
 class InterceptingPrefFilter : public PrefFilter {
  public:
@@ skipping 47 matching lines @@
  public:
   MOCK_METHOD1(OnError, void(PersistentPrefStore::PrefReadError));
 };
 
 }  // namespace
 
 class JsonPrefStoreTest : public testing::Test {
  protected:
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-
-    ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir_));
-    data_dir_ = data_dir_.AppendASCII("prefs");
-    ASSERT_TRUE(PathExists(data_dir_));
   }
 
   void TearDown() override {
     // Make sure all pending tasks have been processed (e.g., deleting the
     // JsonPrefStore may post write tasks).
     RunLoop().RunUntilIdle();
   }
 
   // The path to temporary directory used to contain the test operations.
   base::ScopedTempDir temp_dir_;
-  // The path to the directory where the test data is stored.
-  base::FilePath data_dir_;
   // A message loop that we can use as the file thread message loop.
   MessageLoop message_loop_;
-
- private:
-  // Ensure histograms are reset for each test.
-  StatisticsRecorder statistics_recorder_;
 };
 
 // Test fallback behavior for a nonexistent file.
 TEST_F(JsonPrefStoreTest, NonExistentFile) {
   base::FilePath bogus_input_file = temp_dir_.path().AppendASCII("read.txt");
   ASSERT_FALSE(PathExists(bogus_input_file));
   scoped_refptr<JsonPrefStore> pref_store = new JsonPrefStore(
       bogus_input_file, message_loop_.task_runner(), scoped_ptr<PrefFilter>());
   EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE,
             pref_store->ReadPrefs());
@@ skipping 10 matching lines @@
   scoped_refptr<JsonPrefStore> pref_store =
       new JsonPrefStore(bogus_input_file, bogus_alternate_input_file,
                         message_loop_.task_runner(), scoped_ptr<PrefFilter>());
   EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE,
             pref_store->ReadPrefs());
   EXPECT_FALSE(pref_store->ReadOnly());
 }
 
 // Test fallback behavior for an invalid file.
 TEST_F(JsonPrefStoreTest, InvalidFile) {
-  base::FilePath invalid_file_original = data_dir_.AppendASCII("invalid.json");
   base::FilePath invalid_file = temp_dir_.path().AppendASCII("invalid.json");
-  ASSERT_TRUE(base::CopyFile(invalid_file_original, invalid_file));
+  ASSERT_LT(0, base::WriteFile(invalid_file,
+                               kInvalidJson, arraysize(kInvalidJson) - 1));
+
   scoped_refptr<JsonPrefStore> pref_store = new JsonPrefStore(
       invalid_file, message_loop_.task_runner(), scoped_ptr<PrefFilter>());
   EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_JSON_PARSE,
             pref_store->ReadPrefs());
   EXPECT_FALSE(pref_store->ReadOnly());
 
   // The file should have been moved aside.
   EXPECT_FALSE(PathExists(invalid_file));
   base::FilePath moved_aside = temp_dir_.path().AppendASCII("invalid.bad");
   EXPECT_TRUE(PathExists(moved_aside));
-  EXPECT_TRUE(TextContentsEqual(invalid_file_original, moved_aside));
+
+  std::string moved_aside_contents;
+  ASSERT_TRUE(base::ReadFileToString(moved_aside, &moved_aside_contents));
+  EXPECT_EQ(kInvalidJson, moved_aside_contents);
 }
 
-// This function is used to avoid code duplication while testing synchronous and
-// asynchronous version of the JsonPrefStore loading.
+// This function is used to avoid code duplication while testing synchronous
+// and asynchronous version of the JsonPrefStore loading. It validates that the
+// given output file's contents matches kWriteGolden.
 void RunBasicJsonPrefStoreTest(JsonPrefStore* pref_store,
-                               const base::FilePath& output_file,
-                               const base::FilePath& golden_output_file) {
+                               const base::FilePath& output_file) {
   const char kNewWindowsInTabs[] = "tabs.new_windows_in_tabs";
   const char kMaxTabs[] = "tabs.max_tabs";
   const char kLongIntPref[] = "long_int.pref";
 
   std::string cnn("http://www.cnn.com");
 
   const Value* actual;
   EXPECT_TRUE(pref_store->GetValue(kHomePage, &actual));
   std::string string_value;
   EXPECT_TRUE(actual->GetAsString(&string_value));
@@ skipping 41 matching lines @@
       kLongIntPref,
       make_scoped_ptr(new StringValue(base::Int64ToString(214748364842LL))),
       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(pref_store->GetValue(kLongIntPref, &actual));
   EXPECT_TRUE(actual->GetAsString(&string_value));
   int64_t value;
   base::StringToInt64(string_value, &value);
   EXPECT_EQ(214748364842LL, value);
 
   // Serialize and compare to expected output.
-  ASSERT_TRUE(PathExists(golden_output_file));
   pref_store->CommitPendingWrite();
   RunLoop().RunUntilIdle();
-  EXPECT_TRUE(TextContentsEqual(golden_output_file, output_file));
+
+  std::string output_contents;
+  ASSERT_TRUE(base::ReadFileToString(output_file, &output_contents));
+  EXPECT_EQ(kWriteGolden, output_contents);
   ASSERT_TRUE(base::DeleteFile(output_file, false));
 }
 
 TEST_F(JsonPrefStoreTest, Basic) {
-  ASSERT_TRUE(base::CopyFile(data_dir_.AppendASCII("read.json"),
-                             temp_dir_.path().AppendASCII("write.json")));
+  base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
+  ASSERT_LT(0, base::WriteFile(input_file,
+                               kReadJson, arraysize(kReadJson) - 1));
 
   // Test that the persistent value can be loaded.
-  base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
   ASSERT_TRUE(PathExists(input_file));
   scoped_refptr<JsonPrefStore> pref_store = new JsonPrefStore(
       input_file, message_loop_.task_runner(), scoped_ptr<PrefFilter>());
   ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs());
   EXPECT_FALSE(pref_store->ReadOnly());
   EXPECT_TRUE(pref_store->IsInitializationComplete());
 
   // The JSON file looks like this:
   // {
   //   "homepage": "http://www.cnn.com",
   //   "some_directory": "/usr/local/",
   //   "tabs": {
   //     "new_windows_in_tabs": true,
   //     "max_tabs": 20
   //   }
   // }
 
-  RunBasicJsonPrefStoreTest(
-      pref_store.get(), input_file, data_dir_.AppendASCII("write.golden.json"));
+  RunBasicJsonPrefStoreTest(pref_store.get(), input_file);
 }
 
 TEST_F(JsonPrefStoreTest, BasicAsync) {
-  ASSERT_TRUE(base::CopyFile(data_dir_.AppendASCII("read.json"),
-                             temp_dir_.path().AppendASCII("write.json")));
+  base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
+  ASSERT_LT(0, base::WriteFile(input_file,
+                               kReadJson, arraysize(kReadJson) - 1));
 
   // Test that the persistent value can be loaded.
-  base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
-  ASSERT_TRUE(PathExists(input_file));
   scoped_refptr<JsonPrefStore> pref_store = new JsonPrefStore(
       input_file, message_loop_.task_runner(), scoped_ptr<PrefFilter>());
 
   {
     MockPrefStoreObserver mock_observer;
     pref_store->AddObserver(&mock_observer);
 
     MockReadErrorDelegate* mock_error_delegate = new MockReadErrorDelegate;
     pref_store->ReadPrefsAsync(mock_error_delegate);
 
@@ skipping 10 matching lines @@
   // The JSON file looks like this:
   // {
   //   "homepage": "http://www.cnn.com",
   //   "some_directory": "/usr/local/",
   //   "tabs": {
   //     "new_windows_in_tabs": true,
   //     "max_tabs": 20
   //   }
   // }
 
-  RunBasicJsonPrefStoreTest(
-      pref_store.get(), input_file, data_dir_.AppendASCII("write.golden.json"));
+  RunBasicJsonPrefStoreTest(pref_store.get(), input_file);
 }
 
 TEST_F(JsonPrefStoreTest, PreserveEmptyValues) {
   FilePath pref_file = temp_dir_.path().AppendASCII("empty_values.json");
 
   scoped_refptr<JsonPrefStore> pref_store = new JsonPrefStore(
       pref_file, message_loop_.task_runner(), scoped_ptr<PrefFilter>());
 
   // Set some keys with empty values.
   pref_store->SetValue("list", make_scoped_ptr(new base::ListValue),
@@ skipping 55 matching lines @@
   EXPECT_CALL(mock_observer, OnInitializationCompleted(true)).Times(1);
   EXPECT_CALL(*mock_error_delegate,
               OnError(PersistentPrefStore::PREF_READ_ERROR_NO_FILE)).Times(1);
   RunLoop().RunUntilIdle();
   pref_store->RemoveObserver(&mock_observer);
 
   EXPECT_FALSE(pref_store->ReadOnly());
 }
 
 TEST_F(JsonPrefStoreTest, ReadWithInterceptor) {
-  ASSERT_TRUE(base::CopyFile(data_dir_.AppendASCII("read.json"),
-                             temp_dir_.path().AppendASCII("write.json")));
-
-  // Test that the persistent value can be loaded.
   base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
-  ASSERT_TRUE(PathExists(input_file));
+  ASSERT_LT(0, base::WriteFile(input_file,
+                               kReadJson, arraysize(kReadJson) - 1));
 
   scoped_ptr<InterceptingPrefFilter> intercepting_pref_filter(
       new InterceptingPrefFilter());
   InterceptingPrefFilter* raw_intercepting_pref_filter_ =
       intercepting_pref_filter.get();
   scoped_refptr<JsonPrefStore> pref_store =
       new JsonPrefStore(input_file, message_loop_.task_runner(),
                         std::move(intercepting_pref_filter));
 
   ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE,
@@ skipping 15 matching lines @@
   // The JSON file looks like this:
   // {
   //   "homepage": "http://www.cnn.com",
   //   "some_directory": "/usr/local/",
   //   "tabs": {
   //     "new_windows_in_tabs": true,
   //     "max_tabs": 20
   //   }
   // }
 
-  RunBasicJsonPrefStoreTest(
-      pref_store.get(), input_file, data_dir_.AppendASCII("write.golden.json"));
+  RunBasicJsonPrefStoreTest(pref_store.get(), input_file);
 }
 
 TEST_F(JsonPrefStoreTest, ReadAsyncWithInterceptor) {
-  ASSERT_TRUE(base::CopyFile(data_dir_.AppendASCII("read.json"),
-                             temp_dir_.path().AppendASCII("write.json")));
-
-  // Test that the persistent value can be loaded.
   base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
-  ASSERT_TRUE(PathExists(input_file));
+  ASSERT_LT(0, base::WriteFile(input_file,
+                               kReadJson, arraysize(kReadJson) - 1));
 
   scoped_ptr<InterceptingPrefFilter> intercepting_pref_filter(
       new InterceptingPrefFilter());
   InterceptingPrefFilter* raw_intercepting_pref_filter_ =
       intercepting_pref_filter.get();
   scoped_refptr<JsonPrefStore> pref_store =
       new JsonPrefStore(input_file, message_loop_.task_runner(),
                         std::move(intercepting_pref_filter));
 
   MockPrefStoreObserver mock_observer;
@@ skipping 34 matching lines @@
   // The JSON file looks like this:
   // {
   //   "homepage": "http://www.cnn.com",
   //   "some_directory": "/usr/local/",
   //   "tabs": {
   //     "new_windows_in_tabs": true,
   //     "max_tabs": 20
   //   }
   // }
 
-  RunBasicJsonPrefStoreTest(
-      pref_store.get(), input_file, data_dir_.AppendASCII("write.golden.json"));
+  RunBasicJsonPrefStoreTest(pref_store.get(), input_file);
 }
 
 TEST_F(JsonPrefStoreTest, AlternateFile) {
-  ASSERT_TRUE(
-      base::CopyFile(data_dir_.AppendASCII("read.json"),
-                     temp_dir_.path().AppendASCII("alternate.json")));
+  base::FilePath alternate_input_file =
+      temp_dir_.path().AppendASCII("alternate.json");
+  ASSERT_LT(0, base::WriteFile(alternate_input_file,
+                               kReadJson, arraysize(kReadJson) - 1));
 
   // Test that the alternate file is moved to the main file and read as-is from
   // there.
   base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
-  base::FilePath alternate_input_file =
-      temp_dir_.path().AppendASCII("alternate.json");
   ASSERT_FALSE(PathExists(input_file));
   ASSERT_TRUE(PathExists(alternate_input_file));
   scoped_refptr<JsonPrefStore> pref_store =
       new JsonPrefStore(input_file, alternate_input_file,
                         message_loop_.task_runner(), scoped_ptr<PrefFilter>());
 
   ASSERT_FALSE(PathExists(input_file));
   ASSERT_TRUE(PathExists(alternate_input_file));
   ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs());
 
   ASSERT_TRUE(PathExists(input_file));
   ASSERT_FALSE(PathExists(alternate_input_file));
 
   EXPECT_FALSE(pref_store->ReadOnly());
   EXPECT_TRUE(pref_store->IsInitializationComplete());
 
   // The JSON file looks like this:
   // {
   //   "homepage": "http://www.cnn.com",
   //   "some_directory": "/usr/local/",
   //   "tabs": {
   //     "new_windows_in_tabs": true,
   //     "max_tabs": 20
   //   }
   // }
 
-  RunBasicJsonPrefStoreTest(
-      pref_store.get(), input_file, data_dir_.AppendASCII("write.golden.json"));
+  RunBasicJsonPrefStoreTest(pref_store.get(), input_file);
 }
 
 TEST_F(JsonPrefStoreTest, AlternateFileIgnoredWhenMainFileExists) {
-  ASSERT_TRUE(
-      base::CopyFile(data_dir_.AppendASCII("read.json"),
-                     temp_dir_.path().AppendASCII("write.json")));
-  ASSERT_TRUE(
-      base::CopyFile(data_dir_.AppendASCII("invalid.json"),
-                     temp_dir_.path().AppendASCII("alternate.json")));
+  base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
+  ASSERT_LT(0, base::WriteFile(input_file,
+                               kReadJson, arraysize(kReadJson) - 1));
+
+  base::FilePath alternate_input_file =
+      temp_dir_.path().AppendASCII("alternate.json");
+  ASSERT_LT(0, base::WriteFile(alternate_input_file,
+                               kInvalidJson, arraysize(kInvalidJson) - 1));
 
   // Test that the alternate file is ignored and that the read occurs from the
   // existing main file. There is no attempt at even deleting the alternate
   // file as this scenario should never happen in normal user-data-dirs.
-  base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
-  base::FilePath alternate_input_file =
-      temp_dir_.path().AppendASCII("alternate.json");
-  ASSERT_TRUE(PathExists(input_file));
-  ASSERT_TRUE(PathExists(alternate_input_file));
   scoped_refptr<JsonPrefStore> pref_store =
       new JsonPrefStore(input_file, alternate_input_file,
                         message_loop_.task_runner(), scoped_ptr<PrefFilter>());
 
   ASSERT_TRUE(PathExists(input_file));
   ASSERT_TRUE(PathExists(alternate_input_file));
   ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs());
 
   ASSERT_TRUE(PathExists(input_file));
   ASSERT_TRUE(PathExists(alternate_input_file));
 
   EXPECT_FALSE(pref_store->ReadOnly());
   EXPECT_TRUE(pref_store->IsInitializationComplete());
 
   // The JSON file looks like this:
   // {
   //   "homepage": "http://www.cnn.com",
   //   "some_directory": "/usr/local/",
   //   "tabs": {
   //     "new_windows_in_tabs": true,
   //     "max_tabs": 20
   //   }
   // }
 
-  RunBasicJsonPrefStoreTest(
-      pref_store.get(), input_file, data_dir_.AppendASCII("write.golden.json"));
+  RunBasicJsonPrefStoreTest(pref_store.get(), input_file);
 }
 
 TEST_F(JsonPrefStoreTest, AlternateFileDNE) {
-  ASSERT_TRUE(
-      base::CopyFile(data_dir_.AppendASCII("read.json"),
-                     temp_dir_.path().AppendASCII("write.json")));
+  base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
+  ASSERT_LT(0, base::WriteFile(input_file,
+                               kReadJson, arraysize(kReadJson) - 1));
 
   // Test that the basic read works fine when an alternate file is specified but
   // does not exist.
-  base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
   base::FilePath alternate_input_file =
       temp_dir_.path().AppendASCII("alternate.json");
   ASSERT_TRUE(PathExists(input_file));
   ASSERT_FALSE(PathExists(alternate_input_file));
   scoped_refptr<JsonPrefStore> pref_store =
       new JsonPrefStore(input_file, alternate_input_file,
                         message_loop_.task_runner(), scoped_ptr<PrefFilter>());
 
   ASSERT_TRUE(PathExists(input_file));
   ASSERT_FALSE(PathExists(alternate_input_file));
   ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs());
 
   ASSERT_TRUE(PathExists(input_file));
   ASSERT_FALSE(PathExists(alternate_input_file));
 
   EXPECT_FALSE(pref_store->ReadOnly());
   EXPECT_TRUE(pref_store->IsInitializationComplete());
 
   // The JSON file looks like this:
   // {
   //   "homepage": "http://www.cnn.com",
   //   "some_directory": "/usr/local/",
   //   "tabs": {
   //     "new_windows_in_tabs": true,
   //     "max_tabs": 20
   //   }
   // }
 
-  RunBasicJsonPrefStoreTest(
-      pref_store.get(), input_file, data_dir_.AppendASCII("write.golden.json"));
+  RunBasicJsonPrefStoreTest(pref_store.get(), input_file);
 }
 
 TEST_F(JsonPrefStoreTest, BasicAsyncWithAlternateFile) {
-  ASSERT_TRUE(
-      base::CopyFile(data_dir_.AppendASCII("read.json"),
-                     temp_dir_.path().AppendASCII("alternate.json")));
+  base::FilePath alternate_input_file =
+      temp_dir_.path().AppendASCII("alternate.json");
+  ASSERT_LT(0, base::WriteFile(alternate_input_file,
+                               kReadJson, arraysize(kReadJson) - 1));
 
   // Test that the alternate file is moved to the main file and read as-is from
   // there even when the read is made asynchronously.
   base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
-  base::FilePath alternate_input_file =
-      temp_dir_.path().AppendASCII("alternate.json");
-  ASSERT_FALSE(PathExists(input_file));
-  ASSERT_TRUE(PathExists(alternate_input_file));
   scoped_refptr<JsonPrefStore> pref_store =
       new JsonPrefStore(input_file, alternate_input_file,
                         message_loop_.task_runner(), scoped_ptr<PrefFilter>());
 
   ASSERT_FALSE(PathExists(input_file));
   ASSERT_TRUE(PathExists(alternate_input_file));
 
   {
     MockPrefStoreObserver mock_observer;
     pref_store->AddObserver(&mock_observer);
@@ skipping 17 matching lines @@
   // The JSON file looks like this:
   // {
   //   "homepage": "http://www.cnn.com",
   //   "some_directory": "/usr/local/",
   //   "tabs": {
   //     "new_windows_in_tabs": true,
   //     "max_tabs": 20
   //   }
   // }
 
-  RunBasicJsonPrefStoreTest(
-      pref_store.get(), input_file, data_dir_.AppendASCII("write.golden.json"));
+  RunBasicJsonPrefStoreTest(pref_store.get(), input_file);
 }
 
 TEST_F(JsonPrefStoreTest, WriteCountHistogramTestBasic) {
+  base::HistogramTester histogram_tester;
+
   SimpleTestClock* test_clock = new SimpleTestClock;
   SetCurrentTimeInMinutes(0, test_clock);
   JsonPrefStore::WriteCountHistogram histogram(
       base::TimeDelta::FromSeconds(10),
       base::FilePath(FILE_PATH_LITERAL("/tmp/Local State")),
       scoped_ptr<base::Clock>(test_clock));
   int32_t report_interval =
       JsonPrefStore::WriteCountHistogram::kHistogramWriteReportIntervalMins;
 
   histogram.RecordWriteOccured();
 
   SetCurrentTimeInMinutes(1.5 * report_interval, test_clock);
   histogram.ReportOutstandingWrites();
   scoped_ptr<HistogramSamples> samples =
       histogram.GetHistogram()->SnapshotSamples();
-  ASSERT_EQ(1, samples->GetCount(1));
-  ASSERT_EQ(1, samples->TotalCount());
+
+  std::string histogram_name = histogram.GetHistogram()->histogram_name();
+  histogram_tester.ExpectBucketCount(histogram_name, 1, 1);
+  histogram_tester.ExpectTotalCount(histogram_name, 1);
 
   ASSERT_EQ("Settings.JsonDataWriteCount.Local_State",
             histogram.GetHistogram()->histogram_name());
   ASSERT_TRUE(histogram.GetHistogram()->HasConstructionArguments(1, 30, 31));
 }
 
 TEST_F(JsonPrefStoreTest, WriteCountHistogramTestSinglePeriod) {
+  base::HistogramTester histogram_tester;
+
   SimpleTestClock* test_clock = new SimpleTestClock;
   SetCurrentTimeInMinutes(0, test_clock);
   JsonPrefStore::WriteCountHistogram histogram(
       base::TimeDelta::FromSeconds(10),
       base::FilePath(FILE_PATH_LITERAL("/tmp/Local State")),
       scoped_ptr<base::Clock>(test_clock));
   int32_t report_interval =
       JsonPrefStore::WriteCountHistogram::kHistogramWriteReportIntervalMins;
 
   histogram.RecordWriteOccured();
   SetCurrentTimeInMinutes(0.5 * report_interval, test_clock);
   histogram.RecordWriteOccured();
   SetCurrentTimeInMinutes(0.7 * report_interval, test_clock);
   histogram.RecordWriteOccured();
 
   // Nothing should be recorded until the report period has elapsed.
-  scoped_ptr<HistogramSamples> samples =
-      histogram.GetHistogram()->SnapshotSamples();
-  ASSERT_EQ(0, samples->TotalCount());
+  std::string histogram_name = histogram.GetHistogram()->histogram_name();
+  histogram_tester.ExpectTotalCount(histogram_name, 0);
 
   SetCurrentTimeInMinutes(1.3 * report_interval, test_clock);
   histogram.RecordWriteOccured();
 
   // Now the report period has elapsed.
-  samples = histogram.GetHistogram()->SnapshotSamples();
-  ASSERT_EQ(1, samples->GetCount(3));
-  ASSERT_EQ(1, samples->TotalCount());
+  histogram_tester.ExpectBucketCount(histogram_name, 3, 1);
+  histogram_tester.ExpectTotalCount(histogram_name, 1);
 
   // The last write won't be recorded because the second count period hasn't
   // fully elapsed.
   SetCurrentTimeInMinutes(1.5 * report_interval, test_clock);
   histogram.ReportOutstandingWrites();
 
-  samples = histogram.GetHistogram()->SnapshotSamples();
-  ASSERT_EQ(1, samples->GetCount(3));
-  ASSERT_EQ(1, samples->TotalCount());
+  histogram_tester.ExpectBucketCount(histogram_name, 3, 1);
+  histogram_tester.ExpectTotalCount(histogram_name, 1);
 }
 
 TEST_F(JsonPrefStoreTest, WriteCountHistogramTestMultiplePeriods) {
+  base::HistogramTester histogram_tester;
+
   SimpleTestClock* test_clock = new SimpleTestClock;
   SetCurrentTimeInMinutes(0, test_clock);
   JsonPrefStore::WriteCountHistogram histogram(
       base::TimeDelta::FromSeconds(10),
       base::FilePath(FILE_PATH_LITERAL("/tmp/Local State")),
       scoped_ptr<base::Clock>(test_clock));
   int32_t report_interval =
       JsonPrefStore::WriteCountHistogram::kHistogramWriteReportIntervalMins;
 
   histogram.RecordWriteOccured();
@@ skipping 11 matching lines @@
   histogram.RecordWriteOccured();
   SetCurrentTimeInMinutes(2.7 * report_interval, test_clock);
   histogram.RecordWriteOccured();
   SetCurrentTimeInMinutes(3.3 * report_interval, test_clock);
   histogram.RecordWriteOccured();
 
   // The last write won't be recorded because the second count period hasn't
   // fully elapsed
   SetCurrentTimeInMinutes(3.5 * report_interval, test_clock);
   histogram.ReportOutstandingWrites();
-  scoped_ptr<HistogramSamples> samples =
-      histogram.GetHistogram()->SnapshotSamples();
-  ASSERT_EQ(2, samples->GetCount(3));
-  ASSERT_EQ(1, samples->GetCount(2));
-  ASSERT_EQ(3, samples->TotalCount());
+  std::string histogram_name = histogram.GetHistogram()->histogram_name();
+  histogram_tester.ExpectBucketCount(histogram_name, 3, 2);
+  histogram_tester.ExpectBucketCount(histogram_name, 2, 1);
+  histogram_tester.ExpectTotalCount(histogram_name, 3);
 }
 
 TEST_F(JsonPrefStoreTest, WriteCountHistogramTestPeriodWithGaps) {
+  base::HistogramTester histogram_tester;
+
   SimpleTestClock* test_clock = new SimpleTestClock;
   SetCurrentTimeInMinutes(0, test_clock);
   JsonPrefStore::WriteCountHistogram histogram(
       base::TimeDelta::FromSeconds(10),
       base::FilePath(FILE_PATH_LITERAL("/tmp/Local State")),
       scoped_ptr<base::Clock>(test_clock));
   int32_t report_interval =
       JsonPrefStore::WriteCountHistogram::kHistogramWriteReportIntervalMins;
 
   // 1 write in the first period.
@@ skipping 12 matching lines @@
   // 3 writes in the sixth period.
   SetCurrentTimeInMinutes(5.1 * report_interval, test_clock);
   histogram.RecordWriteOccured();
   SetCurrentTimeInMinutes(5.3 * report_interval, test_clock);
   histogram.RecordWriteOccured();
   SetCurrentTimeInMinutes(5.5 * report_interval, test_clock);
   histogram.RecordWriteOccured();
 
   SetCurrentTimeInMinutes(6.1 * report_interval, test_clock);
   histogram.ReportOutstandingWrites();
-  scoped_ptr<HistogramSamples> samples =
-      histogram.GetHistogram()->SnapshotSamples();
-  ASSERT_EQ(3, samples->GetCount(0));
-  ASSERT_EQ(1, samples->GetCount(1));
-  ASSERT_EQ(1, samples->GetCount(2));
-  ASSERT_EQ(1, samples->GetCount(3));
-  ASSERT_EQ(6, samples->TotalCount());
+  std::string histogram_name = histogram.GetHistogram()->histogram_name();
+  histogram_tester.ExpectBucketCount(histogram_name, 0, 3);
+  histogram_tester.ExpectBucketCount(histogram_name, 1, 1);
+  histogram_tester.ExpectBucketCount(histogram_name, 2, 1);
+  histogram_tester.ExpectBucketCount(histogram_name, 3, 1);
+  histogram_tester.ExpectTotalCount(histogram_name, 6);
 }
 
 class JsonPrefStoreLossyWriteTest : public JsonPrefStoreTest {
  protected:
   void SetUp() override {
     JsonPrefStoreTest::SetUp();
     test_file_ = temp_dir_.path().AppendASCII("test.json");
   }
 
   // Creates a JsonPrefStore with the given |file_writer|.
@@ skipping 128 matching lines @@
   ASSERT_TRUE(file_writer->HasPendingWrite());
 
   // Call CommitPendingWrite and check that the lossy pref is there with the
   // last value set above.
   pref_store->CommitPendingWrite();
   ASSERT_FALSE(file_writer->HasPendingWrite());
   ASSERT_EQ("{\"lossy\":\"lossy\"}", GetTestFileContents());
 }
 
 }  // namespace base