Replace MockStatisticsProvider with FakeStatisticsProvider.

MockStatisticsProvider is a typical example of gmock only causing
excess boilerplate and poor readability. This change implements a
proper fake and converts all consumers.

BUG=None
TEST=unit_tests/browser_tests still compile and pass.

Review URL: https://codereview.chromium.org/644413003

Cr-Commit-Position: refs/heads/master@{#299350}

chrome/browser/chromeos/customization_document_unittest.cc

@@ -21,7 +21,7 @@
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
-#include "chromeos/system/mock_statistics_provider.h"
+#include "chromeos/system/fake_statistics_provider.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/common/extension.h"
@@ -101,21 +101,18 @@ const char kDummyCustomizationID[] = "test-dummy";
 
 namespace chromeos {
 
-using ::testing::_;
 using ::testing::DoAll;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SetArgumentPointee;
+using ::testing::_;
 
 TEST(StartupCustomizationDocumentTest, Basic) {
-  system::MockStatisticsProvider mock_statistics_provider;
-  EXPECT_CALL(mock_statistics_provider, GetMachineStatistic(_, NotNull()))
-      .WillRepeatedly(Return(false));
-  EXPECT_CALL(mock_statistics_provider,
-      GetMachineStatistic(std::string("hardware_class"), NotNull()))
-          .WillOnce(DoAll(SetArgumentPointee<1>(std::string("Mario 12345")),
-                          Return(true)));
-  StartupCustomizationDocument customization(&mock_statistics_provider,
+  system::ScopedFakeStatisticsProvider fake_statistics_provider;
+
+  // hardware_class selects the appropriate entry in hwid_map in the manifest.
+  fake_statistics_provider.SetMachineStatistic("hardware_class", "Mario 12345");
+  StartupCustomizationDocument customization(&fake_statistics_provider,
                                              kGoodStartupManifest);
   EXPECT_EQ("ru-RU", customization.initial_locale());
   EXPECT_EQ("Europe/Moscow", customization.initial_timezone());
@@ -130,24 +127,15 @@ TEST(StartupCustomizationDocumentTest, Basic) {
 }
 
 TEST(StartupCustomizationDocumentTest, VPD) {
-  system::MockStatisticsProvider mock_statistics_provider;
-  EXPECT_CALL(mock_statistics_provider,
-      GetMachineStatistic(std::string("hardware_class"), NotNull()))
-          .WillOnce(DoAll(SetArgumentPointee<1>(std::string("Mario 12345")),
-                          Return(true)));
-  EXPECT_CALL(mock_statistics_provider,
-      GetMachineStatistic(std::string("initial_locale"), NotNull()))
-          .WillOnce(DoAll(SetArgumentPointee<1>(std::string("ja")),
-                          Return(true)));
-  EXPECT_CALL(mock_statistics_provider,
-      GetMachineStatistic(std::string("initial_timezone"), NotNull()))
-          .WillOnce(DoAll(SetArgumentPointee<1>(std::string("Asia/Tokyo")),
-                          Return(true)));
-  EXPECT_CALL(mock_statistics_provider,
-      GetMachineStatistic(std::string("keyboard_layout"), NotNull()))
-          .WillOnce(DoAll(SetArgumentPointee<1>(std::string("mozc-jp")),
-                          Return(true)));
-  StartupCustomizationDocument customization(&mock_statistics_provider,
+  system::ScopedFakeStatisticsProvider fake_statistics_provider;
+
+  // hardware_class selects the appropriate entry in hwid_map in the manifest.
+  fake_statistics_provider.SetMachineStatistic("hardware_class", "Mario 12345");
+  fake_statistics_provider.SetMachineStatistic("initial_locale", "ja");
+  fake_statistics_provider.SetMachineStatistic("initial_timezone",
+                                               "Asia/Tokyo");
+  fake_statistics_provider.SetMachineStatistic("keyboard_layout", "mozc-jp");
+  StartupCustomizationDocument customization(&fake_statistics_provider,
                                              kGoodStartupManifest);
   EXPECT_TRUE(customization.IsReady());
   EXPECT_EQ("ja", customization.initial_locale());
@@ -156,8 +144,8 @@ TEST(StartupCustomizationDocumentTest, VPD) {
 }
 
 TEST(StartupCustomizationDocumentTest, BadManifest) {
-  system::MockStatisticsProvider mock_statistics_provider;
-  StartupCustomizationDocument customization(&mock_statistics_provider,
+  system::ScopedFakeStatisticsProvider fake_statistics_provider;
+  StartupCustomizationDocument customization(&fake_statistics_provider,
                                              kBadManifest);
   EXPECT_FALSE(customization.IsReady());
 }
@@ -221,11 +209,6 @@ class ServicesCustomizationDocumentTest : public testing::Test {
   virtual void SetUp() override {
     ServicesCustomizationDocument::InitializeForTesting();
 
-    EXPECT_CALL(mock_statistics_provider_, GetMachineStatistic(_, NotNull()))
-        .WillRepeatedly(Return(false));
-    chromeos::system::StatisticsProvider::SetTestProvider(
-        &mock_statistics_provider_);
-
     DBusThreadManager::Initialize();
     NetworkHandler::Initialize();
     RunUntilIdle();
@@ -255,7 +238,6 @@ class ServicesCustomizationDocumentTest : public testing::Test {
     NetworkHandler::Shutdown();
     DBusThreadManager::Shutdown();
     NetworkPortalDetector::InitializeForTesting(NULL);
-    chromeos::system::StatisticsProvider::SetTestProvider(NULL);
 
     ServicesCustomizationDocument::ShutdownForTesting();
   }
@@ -265,10 +247,8 @@ class ServicesCustomizationDocumentTest : public testing::Test {
   }
 
   void AddCustomizationIdToVp(const std::string& id) {
-    EXPECT_CALL(mock_statistics_provider_,
-        GetMachineStatistic(system::kCustomizationIdKey, NotNull()))
-            .WillOnce(DoAll(SetArgumentPointee<1>(id),
-                            Return(true)));
+    fake_statistics_provider_.SetMachineStatistic(system::kCustomizationIdKey,
+                                                  id);
   }
 
   void AddExpectedManifest(const std::string& id,
@@ -309,7 +289,7 @@ class ServicesCustomizationDocumentTest : public testing::Test {
   }
 
  private:
-  system::MockStatisticsProvider mock_statistics_provider_;
+  system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   content::TestBrowserThreadBundle thread_bundle_;
   TestingPrefServiceSimple local_state_;
   TestURLFetcherCallback url_callback_;

chrome/browser/chromeos/login/oobe_localization_browsertest.cc

@@ -19,6 +19,7 @@
 #include "chromeos/ime/extension_ime_util.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "chromeos/ime/input_method_whitelist.h"
+#include "chromeos/system/fake_statistics_provider.h"
 #include "chromeos/system/statistics_provider.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
@@ -41,55 +42,6 @@ const char* kUSLayout = "xkb:us::eng";
 
 }
 
-namespace system {
-
-// Custom StatisticsProvider that will return each set of region settings.
-class FakeStatisticsProvider : public StatisticsProvider {
- public:
-  virtual ~FakeStatisticsProvider() {}
-
-  void set_locale(const std::string& locale) {
-    initial_locale_ = locale;
-  }
-
-  void set_keyboard_layout(const std::string& keyboard_layout) {
-    keyboard_layout_ = keyboard_layout;
-  }
-
- private:
-  // StatisticsProvider overrides.
-  virtual void StartLoadingMachineStatistics(
-      const scoped_refptr<base::TaskRunner>& file_task_runner,
-      bool load_oem_manifest) override {
-  }
-
-  // Populates the named machine statistic for initial_locale and
-  // keyboard_layout only.
-  virtual bool GetMachineStatistic(const std::string& name,
-                                   std::string* result) override {
-    if (name == "initial_locale")
-      *result = initial_locale_;
-    else if (name == "keyboard_layout")
-      *result = keyboard_layout_;
-    else
-      return false;
-
-    return true;
-  }
-
-  virtual bool GetMachineFlag(const std::string& name, bool* result) override {
-    return false;
-  }
-
-  virtual void Shutdown() override {
-  }
-
-  std::string initial_locale_;
-  std::string keyboard_layout_;
-};
-
-}  // namespace system
-
 struct LocalizationTestParams {
   const char* initial_locale;
   const char* keyboard_layout;
@@ -162,7 +114,6 @@ class OobeLocalizationTest
       public testing::WithParamInterface<const LocalizationTestParams*> {
  public:
   OobeLocalizationTest();
-  virtual ~OobeLocalizationTest();
 
   // Verifies that the comma-separated |values| corresponds with the first
   // values in |select_id|, optionally checking for an options group label after
@@ -196,23 +147,17 @@ class OobeLocalizationTest
   }
 
  private:
-  scoped_ptr<system::FakeStatisticsProvider> statistics_provider_;
+  system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   test::JSChecker checker;
 
   DISALLOW_COPY_AND_ASSIGN(OobeLocalizationTest);
 };
 
 OobeLocalizationTest::OobeLocalizationTest() : LoginManagerTest(false) {
-  statistics_provider_.reset(new system::FakeStatisticsProvider());
-  // Set the instance returned by GetInstance() for testing.
-  system::StatisticsProvider::SetTestProvider(statistics_provider_.get());
-
-  statistics_provider_->set_locale(GetParam()->initial_locale);
-  statistics_provider_->set_keyboard_layout(GetParam()->keyboard_layout);
-}
-
-OobeLocalizationTest::~OobeLocalizationTest() {
-  system::StatisticsProvider::SetTestProvider(NULL);
+  fake_statistics_provider_.SetMachineStatistic("initial_locale",
+                                                GetParam()->initial_locale);
+  fake_statistics_provider_.SetMachineStatistic("keyboard_layout",
+                                                GetParam()->keyboard_layout);
 }
 
 bool OobeLocalizationTest::VerifyInitialOptions(const char* select_id,

chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos_unittest.cc

@@ -31,7 +31,7 @@
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
-#include "chromeos/system/mock_statistics_provider.h"
+#include "chromeos/system/fake_statistics_provider.h"
 #include "chromeos/system/statistics_provider.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/cloud/mock_device_management_service.h"
@@ -74,15 +74,7 @@ class DeviceCloudPolicyManagerChromeOSTest
         state_keys_broker_(&fake_session_manager_client_,
                            base::MessageLoopProxy::current()),
         store_(NULL) {
-    EXPECT_CALL(mock_statistics_provider_,
-                GetMachineStatistic(_, _))
-        .WillRepeatedly(Return(false));
-    EXPECT_CALL(mock_statistics_provider_,
-                GetMachineStatistic("serial_number", _))
-        .WillRepeatedly(DoAll(SetArgumentPointee<1>(std::string("test_sn")),
-                              Return(true)));
-    chromeos::system::StatisticsProvider::SetTestProvider(
-        &mock_statistics_provider_);
+    fake_statistics_provider_.SetMachineStatistic("serial_numer", "test_sn");
     std::vector<std::string> state_keys;
     state_keys.push_back("1");
     state_keys.push_back("2");
@@ -191,7 +183,7 @@ class DeviceCloudPolicyManagerChromeOSTest
   MockDeviceManagementService consumer_device_management_service_;
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
-  chromeos::system::MockStatisticsProvider mock_statistics_provider_;
+  chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   chromeos::FakeSessionManagerClient fake_session_manager_client_;
   chromeos::FakeCryptohomeClient* fake_cryptohome_client_;
   ServerBackedStateKeysBroker state_keys_broker_;

chrome/browser/chromeos/policy/device_status_collector_browsertest.cc

@@ -26,21 +26,15 @@
 #include "chromeos/network/network_handler.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/cros_settings_provider.h"
-#include "chromeos/system/mock_statistics_provider.h"
+#include "chromeos/system/fake_statistics_provider.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/geolocation_provider.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "policy/proto/device_management_backend.pb.h"
-#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
-using ::testing::DoAll;
-using ::testing::NotNull;
-using ::testing::Return;
-using ::testing::SetArgPointee;
-using ::testing::_;
 using base::Time;
 using base::TimeDelta;
 
@@ -165,9 +159,6 @@ class DeviceStatusCollectorTest : public testing::Test {
 
     TestingDeviceStatusCollector::RegisterPrefs(prefs_.registry());
 
-    EXPECT_CALL(statistics_provider_, GetMachineStatistic(_, NotNull()))
-        .WillRepeatedly(Return(false));
-
     // Remove the real DeviceSettingsProvider and replace it with a stub.
     cros_settings_ = chromeos::CrosSettings::Get();
     device_settings_provider_ =
@@ -201,7 +192,7 @@ class DeviceStatusCollectorTest : public testing::Test {
         base::Bind(&MockPositionUpdateRequester);
     status_collector_.reset(
         new TestingDeviceStatusCollector(&prefs_,
-                                         &statistics_provider_,
+                                         &fake_statistics_provider_,
                                          &callback));
   }
 
@@ -265,7 +256,7 @@ class DeviceStatusCollectorTest : public testing::Test {
 
   ScopedStubEnterpriseInstallAttributes install_attributes_;
   TestingPrefServiceSimple prefs_;
-  chromeos::system::MockStatisticsProvider statistics_provider_;
+  chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::CrosSettings* cros_settings_;
@@ -517,18 +508,13 @@ TEST_F(DeviceStatusCollectorTest, ActivityTimesKeptUntilSubmittedSuccessfully) {
 
 TEST_F(DeviceStatusCollectorTest, DevSwitchBootMode) {
   // Test that boot mode data is reported by default.
-  EXPECT_CALL(statistics_provider_,
-              GetMachineStatistic("devsw_boot", NotNull()))
-      .WillOnce(DoAll(SetArgPointee<1>("0"), Return(true)));
+  fake_statistics_provider_.SetMachineStatistic("devsw_boot", "0");
   GetStatus();
   EXPECT_EQ("Verified", status_.boot_mode());
 
   // Test that boot mode data is not reported if the pref turned off.
   cros_settings_->SetBoolean(chromeos::kReportDeviceBootMode, false);
 
-  EXPECT_CALL(statistics_provider_,
-              GetMachineStatistic("devsw_boot", NotNull()))
-      .WillRepeatedly(DoAll(SetArgPointee<1>("0"), Return(true)));
   GetStatus();
   EXPECT_FALSE(status_.has_boot_mode());
 
@@ -536,27 +522,19 @@ TEST_F(DeviceStatusCollectorTest, DevSwitchBootMode) {
   // statistics provider returns valid data.
   cros_settings_->SetBoolean(chromeos::kReportDeviceBootMode, true);
 
-  EXPECT_CALL(statistics_provider_,
-              GetMachineStatistic("devsw_boot", NotNull()))
-      .WillOnce(DoAll(SetArgPointee<1>("(error)"), Return(true)));
+  fake_statistics_provider_.SetMachineStatistic("devsw_boot", "(error)");
   GetStatus();
   EXPECT_FALSE(status_.has_boot_mode());
 
-  EXPECT_CALL(statistics_provider_,
-              GetMachineStatistic("devsw_boot", NotNull()))
-      .WillOnce(DoAll(SetArgPointee<1>(" "), Return(true)));
+  fake_statistics_provider_.SetMachineStatistic("devsw_boot", " ");
   GetStatus();
   EXPECT_FALSE(status_.has_boot_mode());
 
-  EXPECT_CALL(statistics_provider_,
-              GetMachineStatistic("devsw_boot", NotNull()))
-      .WillOnce(DoAll(SetArgPointee<1>("0"), Return(true)));
+  fake_statistics_provider_.SetMachineStatistic("devsw_boot", "0");
   GetStatus();
   EXPECT_EQ("Verified", status_.boot_mode());
 
-  EXPECT_CALL(statistics_provider_,
-              GetMachineStatistic("devsw_boot", NotNull()))
-      .WillOnce(DoAll(SetArgPointee<1>("1"), Return(true)));
+  fake_statistics_provider_.SetMachineStatistic("devsw_boot", "1");
   GetStatus();
   EXPECT_EQ("Dev", status_.boot_mode());
 }

chrome/browser/extensions/external_provider_impl_chromeos_unittest.cc

@@ -19,15 +19,10 @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
-#include "chromeos/system/mock_statistics_provider.h"
+#include "chromeos/system/fake_statistics_provider.h"
 #include "chromeos/system/statistics_provider.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_utils.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-using ::testing::_;
-using ::testing::NotNull;
-using ::testing::Return;
 
 namespace extensions {
 
@@ -69,23 +64,17 @@ class ExternalProviderImplChromeOSTest : public ExtensionServiceTestBase {
 
     external_externsions_overrides_.reset(new base::ScopedPathOverride(
         chrome::DIR_EXTERNAL_EXTENSIONS, data_dir().Append("external")));
-
-    chromeos::system::StatisticsProvider::SetTestProvider(
-        &mock_statistics_provider_);
-    EXPECT_CALL(mock_statistics_provider_, GetMachineStatistic(_, NotNull()))
-        .WillRepeatedly(Return(false));
   }
 
   virtual void TearDown() override {
     chromeos::KioskAppManager::Shutdown();
-    chromeos::system::StatisticsProvider::SetTestProvider(NULL);
     TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
   }
 
  private:
   TestingPrefServiceSimple local_state_;
   scoped_ptr<base::ScopedPathOverride> external_externsions_overrides_;
-  chromeos::system::MockStatisticsProvider mock_statistics_provider_;
+  chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   chromeos::FakeUserManager* fake_user_manager_;
   chromeos::ScopedUserManagerEnabler scoped_user_manager_;
 

chrome/browser/extensions/external_provider_impl_unittest.cc

@@ -33,13 +33,13 @@
 #include "chrome/browser/chromeos/customization_document.h"
 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
-#include "chromeos/system/mock_statistics_provider.h"
+#include "chromeos/system/fake_statistics_provider.h"
 #include "chromeos/system/statistics_provider.h"
 #endif
 
-using ::testing::_;
 using ::testing::NotNull;
 using ::testing::Return;
+using ::testing::_;
 
 namespace extensions {
 
@@ -99,19 +99,10 @@ class ExternalProviderImplTest : public ExtensionServiceTestBase {
     CommandLine* cmdline = CommandLine::ForCurrentProcess();
     cmdline->AppendSwitchASCII(switches::kAppsGalleryUpdateURL,
                                test_server_->GetURL(kManifestPath).spec());
-#if defined(OS_CHROMEOS)
-    chromeos::system::StatisticsProvider::SetTestProvider(
-        &mock_statistics_provider_);
-    EXPECT_CALL(mock_statistics_provider_, GetMachineStatistic(_, NotNull()))
-        .WillRepeatedly(Return(false));
-#endif
   }
 
   virtual void TearDown() override {
-#if defined(OS_CHROMEOS)
-    chromeos::system::StatisticsProvider::SetTestProvider(NULL);
     TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
-#endif
   }
 
  private:
@@ -151,8 +142,11 @@ class ExternalProviderImplTest : public ExtensionServiceTestBase {
 
   scoped_ptr<EmbeddedTestServer> test_server_;
   scoped_ptr<ExtensionCacheFake> test_extension_cache_;
+
 #if defined(OS_CHROMEOS)
-  chromeos::system::MockStatisticsProvider mock_statistics_provider_;
+  // chromeos::ServicesCustomizationExternalLoader is hooked up as an
+  // extensions::ExternalLoader and depends on a functioning StatisticsProvider.
+  chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   TestingPrefServiceSimple local_state_;
 #endif
 

chromeos/chromeos.gyp

@@ -542,8 +542,8 @@
         'network/mock_managed_network_configuration_handler.h',
         'network/onc/onc_test_utils.cc',
         'network/onc/onc_test_utils.h',
-        'system/mock_statistics_provider.cc',
-        'system/mock_statistics_provider.h',
+        'system/fake_statistics_provider.cc',
+        'system/fake_statistics_provider.h',
       ],
       'include_dirs': [
         '..',

chromeos/system/fake_statistics_provider.cc

+// Copyright 2014 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 "chromeos/system/fake_statistics_provider.h"
+
+namespace chromeos {
+namespace system {
+
+FakeStatisticsProvider::FakeStatisticsProvider() {
+}
+
+FakeStatisticsProvider::~FakeStatisticsProvider() {
+}
+
+void FakeStatisticsProvider::StartLoadingMachineStatistics(
+    const scoped_refptr<base::TaskRunner>& file_task_runner,
+    bool load_oem_manifest) {
+}
+
+bool FakeStatisticsProvider::GetMachineStatistic(const std::string& name,
+                                                 std::string* result) {
+  std::map<std::string, std::string>::const_iterator match =
+      machine_statistics_.find(name);
+  if (match != machine_statistics_.end() && result)
+    *result = match->second;
+  return match != machine_statistics_.end();
+}
+
+bool FakeStatisticsProvider::GetMachineFlag(const std::string& name,
+                                            bool* result) {
+  std::map<std::string, bool>::const_iterator match = machine_flags_.find(name);
+  if (match != machine_flags_.end() && result)
+    *result = match->second;
+  return match != machine_flags_.end();
+}
+
+void FakeStatisticsProvider::Shutdown() {
+}
+
+void FakeStatisticsProvider::SetMachineStatistic(const std::string& key,
+                                                 const std::string& value) {
+  machine_statistics_[key] = value;
+}
+
+void FakeStatisticsProvider::ClearMachineStatistic(const std::string& key) {
+  machine_statistics_.erase(key);
+}
+
+void FakeStatisticsProvider::SetMachineFlag(const std::string& key,
+                                            bool value) {
+  machine_flags_[key] = value;
+}
+
+void FakeStatisticsProvider::ClearMachineFlag(const std::string& key) {
+  machine_flags_.erase(key);
+}
+
+ScopedFakeStatisticsProvider::ScopedFakeStatisticsProvider() {
+  StatisticsProvider::SetTestProvider(this);
+}
+
+ScopedFakeStatisticsProvider::~ScopedFakeStatisticsProvider() {
+  StatisticsProvider::SetTestProvider(NULL);
+}
+
+}  // namespace system
+}  // namespace chromeos

chromeos/system/fake_statistics_provider.h

+// Copyright 2014 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.
+
+#ifndef CHROMEOS_SYSTEM_FAKE_STATISTICS_PROVIDER_H_
+#define CHROMEOS_SYSTEM_FAKE_STATISTICS_PROVIDER_H_
+
+#include <map>
+#include <string>
+
+#include "chromeos/system/statistics_provider.h"
+
+namespace chromeos {
+namespace system {
+
+// A fake StatisticsProvider implementation that is useful in tests.
+class FakeStatisticsProvider : public StatisticsProvider {
+ public:
+  FakeStatisticsProvider();
+  virtual ~FakeStatisticsProvider();
+
+  // StatisticsProvider implementation:
+  virtual void StartLoadingMachineStatistics(
+      const scoped_refptr<base::TaskRunner>& file_task_runner,
+      bool load_oem_manifest) override;
+  virtual bool GetMachineStatistic(const std::string& name,
+                                   std::string* result) override;
+  virtual bool GetMachineFlag(const std::string& name, bool* result) override;
+  virtual void Shutdown() override;
+
+  void SetMachineStatistic(const std::string& key, const std::string& value);
+  void ClearMachineStatistic(const std::string& key);
+  void SetMachineFlag(const std::string& key, bool value);
+  void ClearMachineFlag(const std::string& key);
+
+ private:
+  std::map<std::string, std::string> machine_statistics_;
+  std::map<std::string, bool> machine_flags_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeStatisticsProvider);
+};
+
+// A convenience subclass that automatically registers itself as the test
+// StatisticsProvider during construction and cleans up at destruction.
+class ScopedFakeStatisticsProvider : public FakeStatisticsProvider {
+ public:
+  ScopedFakeStatisticsProvider();
+  virtual ~ScopedFakeStatisticsProvider();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScopedFakeStatisticsProvider);
+};
+
+}  // namespace system
+}  // namespace chromeos
+
+#endif  // CHROMEOS_SYSTEM_FAKE_STATISTICS_PROVIDER_H_

chromeos/system/mock_statistics_provider.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 "chromeos/system/mock_statistics_provider.h"
-
-namespace chromeos {
-namespace system {
-
-MockStatisticsProvider::MockStatisticsProvider() {}
-
-MockStatisticsProvider::~MockStatisticsProvider() {}
-
-}  // namespace system
-}  // namespace chromeos

chromeos/system/mock_statistics_provider.h

-// 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.
-
-#ifndef CHROMEOS_SYSTEM_MOCK_STATISTICS_PROVIDER_H_
-#define CHROMEOS_SYSTEM_MOCK_STATISTICS_PROVIDER_H_
-
-#include "base/basictypes.h"
-#include "chromeos/system/statistics_provider.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace chromeos {
-namespace system {
-
-class CHROMEOS_EXPORT MockStatisticsProvider : public StatisticsProvider {
- public:
-  MockStatisticsProvider();
-  virtual ~MockStatisticsProvider();
-
-  MOCK_METHOD2(StartLoadingMachineStatistics, void(
-      const scoped_refptr<base::TaskRunner>&,
-      bool));
-  MOCK_METHOD2(GetMachineStatistic, bool(const std::string& name,
-                                         std::string* result));
-  MOCK_METHOD2(GetMachineFlag, bool(const std::string& name,
-                                    bool* result));
-  MOCK_METHOD0(Shutdown, void());
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockStatisticsProvider);
-};
-
-}  // namespace system
-}  // namespace chromeos
-
-#endif  // CHROMEOS_SYSTEM_MOCK_STATISTICS_PROVIDER_H_