Replace MockStatisticsProvider with FakeStatisticsProvider.

chrome/browser/chromeos/customization_document_unittest.cc

 // Copyright (c) 2011 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 "chrome/browser/chromeos/customization_document.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/net/network_portal_detector_test_impl.h"
 #include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service_mock_factory.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #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"
 #include "extensions/common/manifest.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 59 matching lines @@
     "    }\n"
     "  }\n"
     "}";
 
 const char kDummyCustomizationID[] = "test-dummy";
 
 }  // anonymous namespace
 
 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());
   EXPECT_EQ("xkb:ru::rus", customization.keyboard_layout());
 
   EXPECT_EQ("file:///opt/oem/eula/en-US/eula.html",
             customization.GetEULAPage("en-US"));
   EXPECT_EQ("file:///opt/oem/eula/ru-RU/eula.html",
             customization.GetEULAPage("ru-RU"));
   EXPECT_EQ("file:///opt/oem/eula/en/eula.html",
             customization.GetEULAPage("ja"));
 }
 
 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());
   EXPECT_EQ("Asia/Tokyo", customization.initial_timezone());
   EXPECT_EQ("mozc-jp", customization.keyboard_layout());
 }
 
 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());
 }
 
 class TestURLFetcherCallback {
  public:
   scoped_ptr<net::FakeURLFetcher> CreateURLFetcher(
       const GURL& url,
       net::URLFetcherDelegate* d,
       const std::string& response_data,
@@ skipping 43 matching lines @@
   ServicesCustomizationDocumentTest()
     : factory_(NULL,
                base::Bind(&TestURLFetcherCallback::CreateURLFetcher,
                base::Unretained(&url_callback_))) {
   }
 
   // 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();
     const NetworkState* default_network =
         NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
     std::string default_network_path =
         default_network ? default_network->path() : "";
 
     NetworkPortalDetector::InitializeForTesting(&network_portal_detector_);
     NetworkPortalDetector::CaptivePortalState online_state;
     online_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
     online_state.response_code = 204;
     std::string guid =
         default_network ? default_network->guid() : std::string();
     network_portal_detector_.SetDefaultNetworkForTesting(guid);
     if (!guid.empty()) {
       network_portal_detector_.SetDetectionResultsForTesting(
           guid, online_state);
     }
 
     TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
     ServicesCustomizationDocument::RegisterPrefs(local_state_.registry());
   }
 
   virtual void TearDown() override {
     TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
     NetworkHandler::Shutdown();
     DBusThreadManager::Shutdown();
     NetworkPortalDetector::InitializeForTesting(NULL);
-    chromeos::system::StatisticsProvider::SetTestProvider(NULL);
 
     ServicesCustomizationDocument::ShutdownForTesting();
   }
 
   void RunUntilIdle() {
     base::RunLoop().RunUntilIdle();
   }
 
   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,
                            const std::string& manifest) {
     GURL url(base::StringPrintf(ServicesCustomizationDocument::kManifestUrl,
                                 id.c_str()));
     factory_.SetFakeResponse(url,
                              manifest,
                              net::HTTP_OK,
                              net::URLRequestStatus::SUCCESS);
@@ skipping 20 matching lines @@
     scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
         new user_prefs::PrefRegistrySyncable);
     scoped_ptr<PrefServiceSyncable> prefs(
         factory.CreateSyncable(registry.get()));
     chrome::RegisterUserProfilePrefs(registry.get());
     profile_builder.SetPrefService(prefs.Pass());
     return profile_builder.Build();
   }
 
  private:
-  system::MockStatisticsProvider mock_statistics_provider_;
+  system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   content::TestBrowserThreadBundle thread_bundle_;
   TestingPrefServiceSimple local_state_;
   TestURLFetcherCallback url_callback_;
   net::FakeURLFetcherFactory factory_;
   NetworkPortalDetectorTestImpl network_portal_detector_;
 };
 
 TEST_F(ServicesCustomizationDocumentTest, Basic) {
   AddCustomizationIdToVp(kDummyCustomizationID);
   AddExpectedManifest(kDummyCustomizationID, kGoodServicesManifest);
@@ skipping 153 matching lines @@
   EXPECT_CALL(visitor, OnExternalExtensionUpdateUrlFound(_, _, _, _, _, _))
       .Times(0);
   EXPECT_CALL(visitor, OnExternalProviderReady(_))
       .Times(1);
 
   RunUntilIdle();
   EXPECT_TRUE(doc->IsReady());
 }
 
 }  // namespace chromeos