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/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"
@@ skipping 230 matching lines @@
     EXPECT_CALL(*mock_disk_mount_manager, mount_points())
         .WillRepeatedly(ReturnRef(mount_point_map_));
 
     // 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);
+        cros_settings_->GetProvider(chromeos::kReportDeviceActivityTimes);
     EXPECT_TRUE(device_settings_provider_ != NULL);
     EXPECT_TRUE(
         cros_settings_->RemoveSettingsProvider(device_settings_provider_));
     cros_settings_->AddSettingsProvider(&stub_settings_provider_);
+    owner_settings_service_.reset(
+        new chromeos::FakeOwnerSettingsService(nullptr));
 
-  RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo));
+    RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo));
   }
 
   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)));
   }
 
@@ skipping 66 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_;
+  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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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));
   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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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));
   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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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 24 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);
+  owner_settings_service_->SetBoolean(chromeos::kReportDeviceHardwareStatus,
+                                      false);
   GetStatus();
   EXPECT_EQ(0, status_.volume_info_size());
 }
 
 TEST_F(DeviceStatusCollectorTest, TestAvailableMemory) {
   status_collector_->RefreshSampleResourceUsage();
   GetStatus();
   EXPECT_EQ(static_cast<int>(DeviceStatusCollector::kMaxResourceUsageSamples),
             status_.system_ram_free().size());
   EXPECT_TRUE(status_.has_system_ram_total());
@@ skipping 15 matching lines @@
   // Now set CPU usage to 0.
   const int idle_cpu_usage = 0;
   status_collector_->set_mock_cpu_usage(idle_cpu_usage, 2);
   GetStatus();
   EXPECT_EQ(static_cast<int>(DeviceStatusCollector::kMaxResourceUsageSamples),
             status_.cpu_utilization_pct().size());
   for (const auto utilization : status_.cpu_utilization_pct())
     EXPECT_EQ(idle_cpu_usage, utilization);
 
   // Turning off hardware reporting should not report CPU utilization.
-  cros_settings_->SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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);
+  owner_settings_service_->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