Switch to direct use of OwnerSettingsServiceChromeOS::Set() in tests.

chrome/browser/chromeos/policy/network_configuration_updater_unittest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/device_network_configuration_updater.h"
 #include "chrome/browser/chromeos/policy/user_network_configuration_updater.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
+#include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chromeos/network/fake_network_device_handler.h"
 #include "chromeos/network/mock_managed_network_configuration_handler.h"
 #include "chromeos/network/onc/onc_certificate_importer.h"
 #include "chromeos/network/onc/onc_test_utils.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "components/onc/onc_constants.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
@@ skipping 165 matching lines @@
 }
 
 ACTION_P(SetCertificateList, list) {
   if (arg2)
     *arg2 = list;
   return true;
 }
 
 }  // namespace
 
-class NetworkConfigurationUpdaterTest : public testing::Test {
+class NetworkConfigurationUpdaterTest : public chromeos::OwnerSettingsTestBase {
  protected:
   NetworkConfigurationUpdaterTest() : certificate_importer_(NULL) {}
 
   virtual void SetUp() override {
+    chromeos::OwnerSettingsTestBase::SetUp();
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(false));
     provider_.Init();
     PolicyServiceImpl::Providers providers;
     providers.push_back(&provider_);
     policy_service_.reset(new PolicyServiceImpl(providers));
 
     scoped_ptr<base::DictionaryValue> fake_toplevel_onc =
         chromeos::onc::ReadDictionaryFromJson(kFakeONC);
 
@@ skipping 10 matching lines @@
     base::ListValue* certs = NULL;
     fake_toplevel_onc->GetListWithoutPathExpansion(
         onc::toplevel_config::kCertificates, &certs);
     AppendAll(*certs, &fake_certificates_);
 
     certificate_importer_ = new FakeCertificateImporter;
     certificate_importer_owned_.reset(certificate_importer_);
   }
 
   virtual void TearDown() override {
+    chromeos::OwnerSettingsTestBase::TearDown();
     network_configuration_updater_.reset();
     provider_.Shutdown();
     base::RunLoop().RunUntilIdle();
   }
 
   void MarkPolicyProviderInitialized() {
     Mock::VerifyAndClearExpectations(&provider_);
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     provider_.SetAutoRefresh();
     provider_.RefreshPolicies();
     base::RunLoop().RunUntilIdle();
   }
 
   void UpdateProviderPolicy(const PolicyMap& policy) {
     provider_.UpdateChromePolicy(policy);
     base::RunLoop().RunUntilIdle();
   }
 
   UserNetworkConfigurationUpdater*
   CreateNetworkConfigurationUpdaterForUserPolicy(
       bool allow_trusted_certs_from_policy,
       bool set_cert_importer) {
     UserNetworkConfigurationUpdater* updater =
         UserNetworkConfigurationUpdater::CreateForUserPolicy(
-            &profile_,
-            allow_trusted_certs_from_policy,
-            fake_user_,
-            policy_service_.get(),
-            &network_config_handler_).release();
+            profile_.get(), allow_trusted_certs_from_policy, fake_user_,
+            policy_service_.get(), &network_config_handler_).release();
     if (set_cert_importer) {
       EXPECT_TRUE(certificate_importer_owned_);
       updater->SetCertificateImporterForTest(
           certificate_importer_owned_.Pass());
     }
     network_configuration_updater_.reset(updater);
     return updater;
   }
 
   void CreateNetworkConfigurationUpdaterForDevicePolicy() {
     network_configuration_updater_ =
         DeviceNetworkConfigurationUpdater::CreateForDevicePolicy(
             policy_service_.get(),
             &network_config_handler_,
             &network_device_handler_,
             chromeos::CrosSettings::Get());
   }
 
   base::ListValue fake_network_configs_;
   base::DictionaryValue fake_global_network_config_;
   base::ListValue fake_certificates_;
   StrictMock<chromeos::MockManagedNetworkConfigurationHandler>
       network_config_handler_;
   FakeNetworkDeviceHandler network_device_handler_;
 
-  // Not used directly. Required for CrosSettings.
-  chromeos::ScopedTestDeviceSettingsService scoped_device_settings_service_;
-  chromeos::ScopedTestCrosSettings scoped_cros_settings_;
-
   // Ownership of certificate_importer_owned_ is passed to the
   // NetworkConfigurationUpdater. When that happens, |certificate_importer_|
   // continues to point to that instance but |certificate_importer_owned_| is
   // released.
   FakeCertificateImporter* certificate_importer_;
   scoped_ptr<chromeos::onc::CertificateImporter> certificate_importer_owned_;
 
   StrictMock<MockConfigurationPolicyProvider> provider_;
   scoped_ptr<PolicyServiceImpl> policy_service_;
   FakeUser fake_user_;
 
-  TestingProfile profile_;
-
   scoped_ptr<NetworkConfigurationUpdater> network_configuration_updater_;
-  content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(NetworkConfigurationUpdaterTest, CellularAllowRoaming) {
   // Ignore network config updates.
   EXPECT_CALL(network_config_handler_, SetPolicy(_, _, _, _)).Times(AtLeast(1));
 
-  // Setup the DataRoaming device setting.
-  chromeos::CrosSettings* cros_settings = chromeos::CrosSettings::Get();
-  chromeos::CrosSettingsProvider* device_settings_provider =
-      cros_settings->GetProvider(chromeos::kSignedDataRoamingEnabled);
-  cros_settings->RemoveSettingsProvider(device_settings_provider);
-  delete device_settings_provider;
-  chromeos::StubCrosSettingsProvider* stub_settings_provider =
-      new chromeos::StubCrosSettingsProvider;
-  cros_settings->AddSettingsProvider(stub_settings_provider);
-
-  chromeos::CrosSettings::Get()->Set(chromeos::kSignedDataRoamingEnabled,
-                                     base::FundamentalValue(false));
+  ReplaceProvider(chromeos::kSignedDataRoamingEnabled);
+  owner_settings_service_->SetBoolean(chromeos::kSignedDataRoamingEnabled,
+                                      false);
   EXPECT_FALSE(network_device_handler_.allow_roaming_);
 
   CreateNetworkConfigurationUpdaterForDevicePolicy();
   MarkPolicyProviderInitialized();
-  chromeos::CrosSettings::Get()->Set(chromeos::kSignedDataRoamingEnabled,
-                                     base::FundamentalValue(true));
+  owner_settings_service_->SetBoolean(chromeos::kSignedDataRoamingEnabled,
+                                      true);
   EXPECT_TRUE(network_device_handler_.allow_roaming_);
 
-  chromeos::CrosSettings::Get()->Set(chromeos::kSignedDataRoamingEnabled,
-                                     base::FundamentalValue(false));
+  owner_settings_service_->SetBoolean(chromeos::kSignedDataRoamingEnabled,
+                                      false);
   EXPECT_FALSE(network_device_handler_.allow_roaming_);
 }
 
 TEST_F(NetworkConfigurationUpdaterTest, PolicyIsValidatedAndRepaired) {
   scoped_ptr<base::DictionaryValue> onc_repaired =
       chromeos::onc::test_utils::ReadTestDictionary(
           "repaired_toplevel_partially_invalid.onc");
 
   base::ListValue* network_configs_repaired = NULL;
   onc_repaired->GetListWithoutPathExpansion(
@@ skipping 325 matching lines @@
   EXPECT_EQ(ExpectedImportCertificatesCallCount(),
             certificate_importer_->GetAndResetImportCount());
 }
 
 INSTANTIATE_TEST_CASE_P(NetworkConfigurationUpdaterTestWithParamInstance,
                         NetworkConfigurationUpdaterTestWithParam,
                         testing::Values(key::kDeviceOpenNetworkConfiguration,
                                         key::kOpenNetworkConfiguration));
 
 }  // namespace policy