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

chrome/browser/chromeos/policy/device_status_collector_browsertest.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 "chrome/browser/chromeos/policy/device_status_collector.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
+#include "chrome/browser/chromeos/ownership/fake_owner_settings_service.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/stub_enterprise_install_attributes.h"
-#include "chrome/browser/chromeos/settings/cros_settings.h"
-#include "chrome/browser/chromeos/settings/device_settings_service.h"
-#include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
+#include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chromeos/dbus/cros_disks_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_ipconfig_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "chromeos/disks/mock_disk_mount_manager.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/settings/cros_settings_names.h"
-#include "chromeos/settings/cros_settings_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 "storage/browser/fileapi/external_mount_points.h"
 #include "storage/browser/fileapi/mount_points.h"
 #include "storage/common/fileapi/file_system_mount_option.h"
 #include "storage/common/fileapi/file_system_types.h"
@@ skipping 172 matching lines @@
 }  // namespace
 
 namespace policy {
 
 // Though it is a unit test, this test is linked with browser_tests so that it
 // runs in a separate process. The intention is to avoid overriding the timezone
 // environment variable for other tests.
 class DeviceStatusCollectorTest : public testing::Test {
  public:
   DeviceStatusCollectorTest()
-    : ui_thread_(content::BrowserThread::UI, &message_loop_),
-      file_thread_(content::BrowserThread::FILE, &message_loop_),
-      io_thread_(content::BrowserThread::IO, &message_loop_),
-      install_attributes_("managed.com",
-                          "user@managed.com",
-                          "device_id",
-                          DEVICE_MODE_ENTERPRISE),
-      user_manager_(new chromeos::MockUserManager()),
-      user_manager_enabler_(user_manager_),
-      fake_device_local_account_(
-          policy::DeviceLocalAccount::TYPE_KIOSK_APP,
-          kKioskAccountId,
-          kKioskAppId,
-          std::string() /* kiosk_app_update_url */) {
+      : ui_thread_(content::BrowserThread::UI, &message_loop_),
+        file_thread_(content::BrowserThread::FILE, &message_loop_),
+        io_thread_(content::BrowserThread::IO, &message_loop_),
+        install_attributes_("managed.com",
+                            "user@managed.com",
+                            "device_id",
+                            DEVICE_MODE_ENTERPRISE),
+        settings_helper_(false),
+        user_manager_(new chromeos::MockUserManager()),
+        user_manager_enabler_(user_manager_),
+        fake_device_local_account_(policy::DeviceLocalAccount::TYPE_KIOSK_APP,
+                                   kKioskAccountId,
+                                   kKioskAppId,
+                                   std::string() /* kiosk_app_update_url */) {
     // Run this test with a well-known timezone so that Time::LocalMidnight()
     // returns the same values on all machines.
     scoped_ptr<base::Environment> env(base::Environment::Create());
     env->SetVar("TZ", "UTC");
 
     // Initialize our mock mounted disk volumes.
     scoped_ptr<chromeos::disks::MockDiskMountManager> mock_disk_mount_manager =
         make_scoped_ptr(new chromeos::disks::MockDiskMountManager());
     AddMountPoint("/mount/volume1");
     AddMountPoint("/mount/volume2");
@@ skipping 10 matching lines @@
     // Just verify that we are properly setting the mount points.
     std::vector<storage::MountPoints::MountPointInfo> external_mount_points;
     storage::ExternalMountPoints::GetSystemInstance()->AddMountPointInfosTo(
         &external_mount_points);
     EXPECT_FALSE(external_mount_points.empty());
 
     // DiskMountManager takes ownership of the MockDiskMountManager.
     DiskMountManager::InitializeForTesting(mock_disk_mount_manager.release());
     TestingDeviceStatusCollector::RegisterPrefs(prefs_.registry());
 
-    // Remove the real DeviceSettingsProvider and replace it with a stub.
-    cros_settings_ = chromeos::CrosSettings::Get();
-    device_settings_provider_ =
-        cros_settings_->GetProvider(chromeos::kReportDeviceVersionInfo);
-    EXPECT_TRUE(device_settings_provider_ != NULL);
-    EXPECT_TRUE(
-        cros_settings_->RemoveSettingsProvider(device_settings_provider_));
-    cros_settings_->AddSettingsProvider(&stub_settings_provider_);
+    settings_helper_.ReplaceProvider(chromeos::kReportDeviceActivityTimes);
+    owner_settings_service_.reset(
+        settings_helper_.CreateOwnerSettingsService(nullptr));
 
     RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
                            base::Bind(&GetEmptyCPUStatistics));
   }
 
   void AddMountPoint(const std::string& mount_point) {
     mount_point_map_.insert(DiskMountManager::MountPointMap::value_type(
         mount_point,
         DiskMountManager::MountPointInfo(
             mount_point, mount_point, chromeos::MOUNT_TYPE_DEVICE,
             chromeos::disks::MOUNT_CONDITION_NONE)));
   }
 
   ~DeviceStatusCollectorTest() override {
     // Finish pending tasks.
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     message_loop_.RunUntilIdle();
     storage::ExternalMountPoints::GetSystemInstance()->RevokeAllFileSystems();
     DiskMountManager::Shutdown();
-
-    // Restore the real DeviceSettingsProvider.
-    EXPECT_TRUE(
-        cros_settings_->RemoveSettingsProvider(&stub_settings_provider_));
-    cros_settings_->AddSettingsProvider(device_settings_provider_);
   }
 
   void SetUp() override {
     // Disable network interface reporting since it requires additional setup.
-    cros_settings_->SetBoolean(chromeos::kReportDeviceNetworkInterfaces, false);
+    settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces,
+                                false);
   }
 
+  void TearDown() override { settings_helper_.RestoreProvider(); }
+
   void RestartStatusCollector(
       const policy::DeviceStatusCollector::VolumeInfoFetcher& volume_info,
       const policy::DeviceStatusCollector::CPUStatisticsFetcher& cpu_stats) {
     policy::DeviceStatusCollector::LocationUpdateRequester callback =
         base::Bind(&MockPositionUpdateRequester);
     std::vector<em::VolumeInfo> expected_volume_info;
     status_collector_.reset(new TestingDeviceStatusCollector(
         &prefs_, &fake_statistics_provider_, callback, volume_info, cpu_stats));
   }
 
@@ skipping 37 matching lines @@
     EXPECT_TRUE(status_.has_device_location());
     em::DeviceLocation location = status_.device_location();
     EXPECT_TRUE(location.has_error_code());
     EXPECT_EQ(em::DeviceLocation::ERROR_CODE_POSITION_UNAVAILABLE,
               location.error_code());
   }
 
   void MockRunningKioskApp(const DeviceLocalAccount& account) {
     std::vector<DeviceLocalAccount> accounts;
     accounts.push_back(account);
-    SetDeviceLocalAccounts(cros_settings_, accounts);
+    SetDeviceLocalAccounts(owner_settings_service_.get(), accounts);
     user_manager_->CreateKioskAppUser(account.user_id);
     EXPECT_CALL(*user_manager_, IsLoggedInAsKioskApp()).WillRepeatedly(
         Return(true));
   }
 
  protected:
   // Convenience method.
   int64 ActivePeriodMilliseconds() {
     return policy::DeviceStatusCollector::kIdlePollIntervalSeconds * 1000;
   }
 
   // Since this is a unit test running in browser_tests we must do additional
   // unit test setup and make a TestingBrowserProcess. Must be first member.
   TestingBrowserProcessInitializer initializer_;
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
 
   ScopedStubEnterpriseInstallAttributes install_attributes_;
   TestingPrefServiceSimple prefs_;
   chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   DiskMountManager::MountPointMap mount_point_map_;
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
-  chromeos::CrosSettings* cros_settings_;
-  chromeos::CrosSettingsProvider* device_settings_provider_;
-  chromeos::StubCrosSettingsProvider stub_settings_provider_;
+  chromeos::ScopedCrosSettingsTestHelper settings_helper_;
+  scoped_ptr<chromeos::FakeOwnerSettingsService> owner_settings_service_;
   chromeos::MockUserManager* user_manager_;
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   em::DeviceStatusReportRequest status_;
   scoped_ptr<TestingDeviceStatusCollector> status_collector_;
   const policy::DeviceLocalAccount fake_device_local_account_;
 };
 
 TEST_F(DeviceStatusCollectorTest, AllIdle) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE
   };
-  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
   // Test reporting with no data.
   GetStatus();
   EXPECT_EQ(0, status_.active_period_size());
   EXPECT_EQ(0, GetActiveMilliseconds(status_));
 
   // Test reporting with a single idle sample.
   status_collector_->Simulate(test_states, 1);
   GetStatus();
   EXPECT_EQ(0, status_.active_period_size());
   EXPECT_EQ(0, GetActiveMilliseconds(status_));
 
   // Test reporting with multiple consecutive idle samples.
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
   GetStatus();
   EXPECT_EQ(0, status_.active_period_size());
   EXPECT_EQ(0, GetActiveMilliseconds(status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, AllActive) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE
   };
-  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
   // Test a single active sample.
   status_collector_->Simulate(test_states, 1);
   GetStatus();
   EXPECT_EQ(1, status_.active_period_size());
   EXPECT_EQ(1 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
   status_.clear_active_period();  // Clear the result protobuf.
 
   // Test multiple consecutive active samples.
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
   GetStatus();
   EXPECT_EQ(1, status_.active_period_size());
   EXPECT_EQ(4 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, MixedStates) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_ACTIVE
   };
-  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
   GetStatus();
   EXPECT_EQ(4 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, StateKeptInPref) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE
   };
-  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
 
   // Process the list a second time after restarting the collector. It should be
   // able to count the active periods found by the original collector, because
   // the results are stored in a pref.
   RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
                          base::Bind(&GetEmptyCPUStatistics));
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
 
   GetStatus();
   EXPECT_EQ(6 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, Times) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE
   };
-  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
   GetStatus();
   EXPECT_EQ(3 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, MaxStoredPeriods) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_IDLE
   };
   const int kMaxDays = 10;
 
-  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
   status_collector_->set_max_stored_past_activity_days(kMaxDays - 1);
   status_collector_->set_max_stored_future_activity_days(1);
   Time baseline = Time::Now().LocalMidnight();
 
   // Simulate 12 active periods.
   for (int i = 0; i < kMaxDays + 2; i++) {
     status_collector_->Simulate(test_states,
                                 sizeof(test_states) / sizeof(ui::IdleState));
     // Advance the simulated clock by a day.
     baseline += TimeDelta::FromDays(1);
@@ skipping 34 matching lines @@
   };
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
   GetStatus();
   EXPECT_EQ(1, status_.active_period_size());
   EXPECT_EQ(3 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, ActivityTimesOff) {
   // Device activity times should not be reported if explicitly disabled.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, false);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, false);
 
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE
   };
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
   GetStatus();
   EXPECT_EQ(0, status_.active_period_size());
   EXPECT_EQ(0, GetActiveMilliseconds(status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, ActivityCrossingMidnight) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE
   };
-  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
   // Set the baseline time to 10 seconds after midnight.
   status_collector_->SetBaselineTime(
       Time::Now().LocalMidnight() + TimeDelta::FromSeconds(10));
 
   status_collector_->Simulate(test_states, 1);
   GetStatus();
   ASSERT_EQ(2, status_.active_period_size());
 
   em::ActiveTimePeriod period0 = status_.active_period(0);
@@ skipping 11 matching lines @@
             kMillisecondsPerDay);
   EXPECT_EQ(time_period1.end_timestamp() - time_period1.start_timestamp(),
             kMillisecondsPerDay);
 }
 
 TEST_F(DeviceStatusCollectorTest, ActivityTimesKeptUntilSubmittedSuccessfully) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE,
   };
-  cros_settings_->SetBoolean(chromeos::kReportDeviceActivityTimes, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
   status_collector_->Simulate(test_states, 2);
   GetStatus();
   EXPECT_EQ(2 * ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
   em::DeviceStatusReportRequest first_status(status_);
 
   // The collector returns the same status again.
   GetStatus();
   EXPECT_EQ(first_status.SerializeAsString(), status_.SerializeAsString());
 
   // After indicating a successful submit, the submitted status gets cleared,
   // but what got collected meanwhile sticks around.
   status_collector_->Simulate(test_states, 1);
   status_collector_->OnSubmittedSuccessfully();
   GetStatus();
   EXPECT_EQ(ActivePeriodMilliseconds(), GetActiveMilliseconds(status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, DevSwitchBootMode) {
   // Test that boot mode data is reported by default.
   fake_statistics_provider_.SetMachineStatistic(
       chromeos::system::kDevSwitchBootKey,
       chromeos::system::kDevSwitchBootValueVerified);
   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);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceBootMode, false);
 
   GetStatus();
   EXPECT_FALSE(status_.has_boot_mode());
 
   // Turn the pref on, and check that the status is reported iff the
   // statistics provider returns valid data.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceBootMode, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceBootMode, true);
 
   fake_statistics_provider_.SetMachineStatistic(
       chromeos::system::kDevSwitchBootKey, "(error)");
   GetStatus();
   EXPECT_FALSE(status_.has_boot_mode());
 
   fake_statistics_provider_.SetMachineStatistic(
       chromeos::system::kDevSwitchBootKey, " ");
   GetStatus();
   EXPECT_FALSE(status_.has_boot_mode());
@@ skipping 13 matching lines @@
 
 TEST_F(DeviceStatusCollectorTest, VersionInfo) {
   // Expect the version info to be reported by default.
   GetStatus();
   EXPECT_TRUE(status_.has_browser_version());
   EXPECT_TRUE(status_.has_os_version());
   EXPECT_TRUE(status_.has_firmware_version());
 
   // When the pref to collect this data is not enabled, expect that none of
   // the fields are present in the protobuf.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceVersionInfo, false);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceVersionInfo, false);
   GetStatus();
   EXPECT_FALSE(status_.has_browser_version());
   EXPECT_FALSE(status_.has_os_version());
   EXPECT_FALSE(status_.has_firmware_version());
 
-  cros_settings_->SetBoolean(chromeos::kReportDeviceVersionInfo, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceVersionInfo, true);
   GetStatus();
   EXPECT_TRUE(status_.has_browser_version());
   EXPECT_TRUE(status_.has_os_version());
   EXPECT_TRUE(status_.has_firmware_version());
 
   // Check that the browser version is not empty. OS version & firmware
   // don't have any reasonable values inside the unit test, so those
   // aren't checked.
   EXPECT_NE("", status_.browser_version());
 }
@@ skipping 11 matching lines @@
   invalid_fix.timestamp = Time::Now();
 
   // Check that when device location reporting is disabled, no location is
   // reported.
   SetMockPositionToReturnNext(valid_fix);
   CheckThatNoLocationIsReported();
 
   // Check that when device location reporting is enabled and a valid fix is
   // available, the location is reported and is stored in local state.
   SetMockPositionToReturnNext(valid_fix);
-  cros_settings_->SetBoolean(chromeos::kReportDeviceLocation, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceLocation, true);
   EXPECT_FALSE(prefs_.GetDictionary(prefs::kDeviceLocation)->empty());
   CheckThatAValidLocationIsReported();
 
   // Restart the status collector. Check that the last known location has been
   // retrieved from local state without requesting a geolocation update.
   SetMockPositionToReturnNext(valid_fix);
   RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
                          base::Bind(&GetEmptyCPUStatistics));
   CheckThatAValidLocationIsReported();
   EXPECT_TRUE(mock_position_to_return_next.get());
 
   // Check that after disabling location reporting again, the last known
   // location has been cleared from local state and is no longer reported.
   SetMockPositionToReturnNext(valid_fix);
-  cros_settings_->SetBoolean(chromeos::kReportDeviceLocation, false);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceLocation, false);
   // Allow the new pref to propagate to the status collector.
   message_loop_.RunUntilIdle();
   EXPECT_TRUE(prefs_.GetDictionary(prefs::kDeviceLocation)->empty());
   CheckThatNoLocationIsReported();
 
   // Check that after enabling location reporting again, an error is reported
   // if no valid fix is available.
   SetMockPositionToReturnNext(invalid_fix);
-  cros_settings_->SetBoolean(chromeos::kReportDeviceLocation, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceLocation, true);
   // Allow the new pref to propagate to the status collector.
   message_loop_.RunUntilIdle();
   CheckThatALocationErrorIsReported();
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportUsers) {
   user_manager_->CreatePublicAccountUser("public@localhost");
   user_manager_->AddUser("user0@managed.com");
   user_manager_->AddUser("user1@managed.com");
   user_manager_->AddUser("user2@managed.com");
   user_manager_->AddUser("user3@unmanaged.com");
   user_manager_->AddUser("user4@managed.com");
   user_manager_->AddUser("user5@managed.com");
 
   // Verify that users are reported by default.
   GetStatus();
   EXPECT_EQ(6, status_.user_size());
 
   // Verify that users are reported after enabling the setting.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceUsers, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceUsers, true);
   GetStatus();
   EXPECT_EQ(6, status_.user_size());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(0).type());
   EXPECT_EQ("user0@managed.com", status_.user(0).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(1).type());
   EXPECT_EQ("user1@managed.com", status_.user(1).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(2).type());
   EXPECT_EQ("user2@managed.com", status_.user(2).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_UNMANAGED, status_.user(3).type());
   EXPECT_FALSE(status_.user(3).has_email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(4).type());
   EXPECT_EQ("user4@managed.com", status_.user(4).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, status_.user(5).type());
   EXPECT_EQ("user5@managed.com", status_.user(5).email());
 
   // Verify that users are no longer reported if setting is disabled.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceUsers, false);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceUsers, false);
   GetStatus();
   EXPECT_EQ(0, status_.user_size());
 }
 
 TEST_F(DeviceStatusCollectorTest, TestVolumeInfo) {
   std::vector<std::string> expected_mount_points;
   std::vector<em::VolumeInfo> expected_volume_info;
   int size = 12345678;
   for (const auto& mount_info :
            DiskMountManager::GetInstance()->mount_points()) {
@@ skipping 28 matching lines @@
         EXPECT_EQ(expected_info.storage_free(), info.storage_free());
         found = true;
         break;
       }
     }
     EXPECT_TRUE(found) << "No matching VolumeInfo for "
                        << expected_info.volume_id();
   }
 
   // Now turn off hardware status reporting - should have no data.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
   GetStatus();
   EXPECT_EQ(0, status_.volume_info_size());
 }
 
 TEST_F(DeviceStatusCollectorTest, TestAvailableMemory) {
   // Refresh our samples. Sample more than kMaxHardwareSamples times to
   // make sure that the code correctly caps the number of cached samples.
   for (int i = 0; i < static_cast<int>(
                           DeviceStatusCollector::kMaxResourceUsageSamples + 1);
        ++i) {
@@ skipping 38 matching lines @@
   GetStatus();
 
   // Should not be more than kMaxResourceUsageSamples, and they should all show
   // the CPU is idle.
   EXPECT_EQ(static_cast<int>(DeviceStatusCollector::kMaxResourceUsageSamples),
             status_.cpu_utilization_pct().size());
   for (const auto utilization : status_.cpu_utilization_pct())
     EXPECT_EQ(0, utilization);
 
   // Turning off hardware reporting should not report CPU utilization.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
   GetStatus();
   EXPECT_EQ(0, status_.cpu_utilization_pct().size());
 }
 
 TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfNotKioskMode) {
   // Should not report session status if we don't have an active kiosk app.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceSessionStatus, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, true);
   em::SessionStatusReportRequest session_status;
   EXPECT_FALSE(status_collector_->GetDeviceSessionStatus(&session_status));
 }
 
 TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfSessionReportingDisabled) {
   // Should not report session status if session status reporting is disabled.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceSessionStatus, false);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, false);
   status_collector_->set_kiosk_account(make_scoped_ptr(
       new policy::DeviceLocalAccount(fake_device_local_account_)).Pass());
   // Set up a device-local account for single-app kiosk mode.
   MockRunningKioskApp(fake_device_local_account_);
 
   em::SessionStatusReportRequest session_status;
   EXPECT_FALSE(status_collector_->GetDeviceSessionStatus(&session_status));
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportSessionStatus) {
-  cros_settings_->SetBoolean(chromeos::kReportDeviceSessionStatus, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, true);
   status_collector_->set_kiosk_account(make_scoped_ptr(
       new policy::DeviceLocalAccount(fake_device_local_account_)).Pass());
 
   // Set up a device-local account for single-app kiosk mode.
   MockRunningKioskApp(fake_device_local_account_);
 
   em::SessionStatusReportRequest session_status;
   EXPECT_TRUE(status_collector_->GetDeviceSessionStatus(&session_status));
   ASSERT_EQ(1, session_status.installed_apps_size());
   EXPECT_EQ(kKioskAccountId, session_status.device_local_account_id());
@@ skipping 212 matching lines @@
   // Mock that we are in kiosk mode so we report network state.
   status_collector_->set_kiosk_account(make_scoped_ptr(
       new policy::DeviceLocalAccount(fake_device_local_account_)).Pass());
 
   // Interfaces should be reported by default.
   GetStatus();
   EXPECT_LT(0, status_.network_interface_size());
   EXPECT_LT(0, status_.network_state_size());
 
   // No interfaces should be reported if the policy is off.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceNetworkInterfaces, false);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, false);
   GetStatus();
   EXPECT_EQ(0, status_.network_interface_size());
   EXPECT_EQ(0, status_.network_state_size());
 
   // Switch the policy on and verify the interface list is present.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
+  settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
 
   int count = 0;
   for (size_t i = 0; i < arraysize(kFakeDevices); ++i) {
     const FakeDeviceData& dev = kFakeDevices[i];
     if (dev.expected_type == -1)
       continue;
 
     // Find the corresponding entry in reporting data.
     bool found_match = false;
@@ skipping 43 matching lines @@
         found_match = true;
         break;
       }
     }
     EXPECT_TRUE(found_match) << "No matching state for fake network "
                              << " (" << state.name << ")";
   }
 }
 
 }  // namespace policy