Refactored DeviceStatusCollector to enable truely asynchronous status queries

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 36 matching lines @@
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/system/fake_statistics_provider.h"
 #include "components/policy/proto/device_management_backend.pb.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/testing_pref_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
-#include "device/geolocation/geolocation_provider.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"
 #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::Return;
 using ::testing::ReturnRef;
 using base::Time;
 using base::TimeDelta;
 using chromeos::disks::DiskMountManager;
 
 namespace em = enterprise_management;
 
 namespace {
 
 const int64_t kMillisecondsPerDay = Time::kMicrosecondsPerDay / 1000;
 const char kKioskAccountId[] = "kiosk_user@localhost";
 const char kKioskAppId[] = "kiosk_app_id";
 const char kExternalMountPoint[] = "/a/b/c";
 const char kPublicAccountId[] = "public_user@localhost";
 
-std::unique_ptr<device::Geoposition> mock_position_to_return_next;
-
-void SetMockPositionToReturnNext(const device::Geoposition& position) {
-  mock_position_to_return_next.reset(new device::Geoposition(position));
-}
-
-void MockPositionUpdateRequester(
-    const device::GeolocationProvider::LocationUpdateCallback& callback) {
-  if (!mock_position_to_return_next.get())
-    return;
-
-  // If the fix is invalid, the DeviceStatusCollector will immediately request
-  // another update when it receives the callback. This is desirable and safe in
-  // real life where geolocation updates arrive asynchronously. In this testing
-  // harness, the callback is invoked synchronously upon request, leading to a
-  // request-callback loop. The loop is broken by returning the mock position
-  // only once.
-  std::unique_ptr<device::Geoposition> position(
-      mock_position_to_return_next.release());
-  callback.Run(*position);
-}
-
 class TestingDeviceStatusCollector : public policy::DeviceStatusCollector {
  public:
   TestingDeviceStatusCollector(
       PrefService* local_state,
       chromeos::system::StatisticsProvider* provider,
-      const policy::DeviceStatusCollector::LocationUpdateRequester&
-          location_update_requester,
       const policy::DeviceStatusCollector::VolumeInfoFetcher&
           volume_info_fetcher,
       const policy::DeviceStatusCollector::CPUStatisticsFetcher& cpu_fetcher,
       const policy::DeviceStatusCollector::CPUTempFetcher& cpu_temp_fetcher)
       : policy::DeviceStatusCollector(local_state,
                                       provider,
-                                      location_update_requester,
                                       volume_info_fetcher,
                                       cpu_fetcher,
                                       cpu_temp_fetcher) {
     // Set the baseline time to a fixed value (1 AM) to prevent test flakiness
     // due to a single activity period spanning two days.
     SetBaselineTime(Time::Now().LocalMidnight() + TimeDelta::FromHours(1));
   }
 
   void Simulate(ui::IdleState* states, int len) {
     for (int i = 0; i < len; i++)
@@ skipping 25 matching lines @@
     return std::unique_ptr<policy::DeviceLocalAccount>();
   }
 
   std::string GetAppVersion(const std::string& app_id) override {
     // Just return the app_id as the version - this makes it easy for tests
     // to confirm that the correct app's version was requested.
     return app_id;
   }
 
   void RefreshSampleResourceUsage() {
-    SampleHardwareStatus();
+    SampleResourceUsage();
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
   }
 
  protected:
   void CheckIdleState() override {
     // This should never be called in testing, as it results in a dbus call.
     ADD_FAILURE();
   }
 
   // Each time this is called, returns a time that is a fixed increment
@@ skipping 172 matching lines @@
   }
 
   void TearDown() override {
     settings_helper_.RestoreProvider();
   }
 
   void RestartStatusCollector(
       const policy::DeviceStatusCollector::VolumeInfoFetcher& volume_info,
       const policy::DeviceStatusCollector::CPUStatisticsFetcher& cpu_stats,
       const policy::DeviceStatusCollector::CPUTempFetcher& cpu_temp_fetcher) {
-    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,
+        &prefs_, &fake_statistics_provider_, volume_info, cpu_stats,
         cpu_temp_fetcher));
   }
 
-  void GetDeviceStatus() {
+  void GetStatus() {
     device_status_.Clear();
+    session_status_.Clear();
+    got_session_status_ = false;
     run_loop_.reset(new base::RunLoop());
-    status_collector_->GetDeviceStatusAsync(
-        base::Bind(&DeviceStatusCollectorTest::OnDeviceStatusReceived,
-                   base::Unretained(this)));
+    status_collector_->GetDeviceAndSessionStatusAsync(base::Bind(
+        &DeviceStatusCollectorTest::OnStatusReceived, base::Unretained(this)));
     run_loop_->Run();
     run_loop_.reset();
   }
 
-  void OnDeviceStatusReceived(
-      std::unique_ptr<em::DeviceStatusReportRequest> status) {
-    if (status)
-      device_status_ = *status;
+  void OnStatusReceived(
+      std::unique_ptr<em::DeviceStatusReportRequest> device_status,
+      std::unique_ptr<em::SessionStatusReportRequest> session_status) {
+    if (device_status)
+      device_status_ = *device_status;
+    got_session_status_ = session_status != nullptr;
+    if (got_session_status_)
+      session_status_ = *session_status;
     EXPECT_TRUE(run_loop_);
     run_loop_->Quit();
   }
 
-  void GetSessionStatus() {
-    session_status_.Clear();
-    got_session_status_ = false;
-    run_loop_.reset(new base::RunLoop());
-    status_collector_->GetDeviceSessionStatusAsync(
-        base::Bind(&DeviceStatusCollectorTest::OnSessionStatusReceived,
-                   base::Unretained(this)));
-    run_loop_->Run();
-    run_loop_.reset();
-  }
-
-  void OnSessionStatusReceived(
-      std::unique_ptr<em::SessionStatusReportRequest> status) {
-    got_session_status_ = status != nullptr;
-    if (got_session_status_)
-      session_status_ = *status;
-    EXPECT_TRUE(run_loop_);
-    run_loop_->Quit();
-  }
-
-  void CheckThatNoLocationIsReported() {
-    GetDeviceStatus();
-    EXPECT_FALSE(device_status_.has_device_location());
-  }
-
-  void CheckThatAValidLocationIsReported() {
-    // Checks that a location is being reported which matches the valid fix
-    // set using SetMockPositionToReturnNext().
-    GetDeviceStatus();
-    EXPECT_TRUE(device_status_.has_device_location());
-    em::DeviceLocation location = device_status_.device_location();
-    if (location.has_error_code())
-      EXPECT_EQ(em::DeviceLocation::ERROR_CODE_NONE, location.error_code());
-    EXPECT_TRUE(location.has_latitude());
-    EXPECT_TRUE(location.has_longitude());
-    EXPECT_TRUE(location.has_accuracy());
-    EXPECT_TRUE(location.has_timestamp());
-    EXPECT_FALSE(location.has_altitude());
-    EXPECT_FALSE(location.has_altitude_accuracy());
-    EXPECT_FALSE(location.has_heading());
-    EXPECT_FALSE(location.has_speed());
-    EXPECT_FALSE(location.has_error_message());
-    EXPECT_DOUBLE_EQ(4.3, location.latitude());
-    EXPECT_DOUBLE_EQ(-7.8, location.longitude());
-    EXPECT_DOUBLE_EQ(3., location.accuracy());
-    // Check that the timestamp is not older than ten minutes.
-    EXPECT_TRUE(Time::Now() - Time::FromDoubleT(location.timestamp() / 1000.) <
-                TimeDelta::FromMinutes(10));
-  }
-
-  void CheckThatALocationErrorIsReported() {
-    GetDeviceStatus();
-    EXPECT_TRUE(device_status_.has_device_location());
-    em::DeviceLocation location = device_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(owner_settings_service_.get(), accounts);
     user_manager_->CreateKioskAppUser(
         AccountId::FromUserEmail(account.user_id));
     EXPECT_CALL(*user_manager_, IsLoggedInAsKioskApp()).WillRepeatedly(
         Return(true));
   }
 
@@ skipping 66 matching lines @@
 
 TEST_F(DeviceStatusCollectorTest, AllIdle) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE,
     ui::IDLE_STATE_IDLE
   };
   settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
   // Test reporting with no data.
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(0, device_status_.active_period_size());
   EXPECT_EQ(0, GetActiveMilliseconds(device_status_));
 
   // Test reporting with a single idle sample.
   status_collector_->Simulate(test_states, 1);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(0, device_status_.active_period_size());
   EXPECT_EQ(0, GetActiveMilliseconds(device_status_));
 
   // Test reporting with multiple consecutive idle samples.
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(0, device_status_.active_period_size());
   EXPECT_EQ(0, GetActiveMilliseconds(device_status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, AllActive) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_ACTIVE
   };
   settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
   // Test a single active sample.
   status_collector_->Simulate(test_states, 1);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(1, device_status_.active_period_size());
   EXPECT_EQ(1 * ActivePeriodMilliseconds(),
             GetActiveMilliseconds(device_status_));
   device_status_.clear_active_period();  // Clear the result protobuf.
 
   // Test multiple consecutive active samples.
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(1, device_status_.active_period_size());
   EXPECT_EQ(4 * ActivePeriodMilliseconds(),
             GetActiveMilliseconds(device_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
   };
   settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(4 * ActivePeriodMilliseconds(),
             GetActiveMilliseconds(device_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
   };
   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),
                          base::Bind(&GetEmptyCPUTempInfo));
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
 
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(6 * ActivePeriodMilliseconds(),
             GetActiveMilliseconds(device_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
   };
   settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(3 * ActivePeriodMilliseconds(),
             GetActiveMilliseconds(device_status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, MaxStoredPeriods) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE,
     ui::IDLE_STATE_IDLE
   };
   const int kMaxDays = 10;
 
   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);
     status_collector_->SetBaselineTime(baseline);
   }
 
   // Check that we don't exceed the max number of periods.
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(kMaxDays - 1, device_status_.active_period_size());
 
   // Simulate some future times.
   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);
     status_collector_->SetBaselineTime(baseline);
   }
   // Set the clock back so the previous simulated times are in the future.
   baseline -= TimeDelta::FromDays(20);
   status_collector_->SetBaselineTime(baseline);
 
   // Collect one more data point to trigger pruning.
   status_collector_->Simulate(test_states, 1);
 
   // Check that we don't exceed the max number of periods.
   device_status_.clear_active_period();
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_LT(device_status_.active_period_size(), kMaxDays);
 }
 
 TEST_F(DeviceStatusCollectorTest, ActivityTimesEnabledByDefault) {
   // Device activity times should be reported by default.
   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));
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(1, device_status_.active_period_size());
   EXPECT_EQ(3 * ActivePeriodMilliseconds(),
             GetActiveMilliseconds(device_status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, ActivityTimesOff) {
   // Device activity times should not be reported if explicitly disabled.
   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));
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(0, device_status_.active_period_size());
   EXPECT_EQ(0, GetActiveMilliseconds(device_status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, ActivityCrossingMidnight) {
   ui::IdleState test_states[] = {
     ui::IDLE_STATE_ACTIVE
   };
   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);
-  GetDeviceStatus();
+  GetStatus();
   ASSERT_EQ(2, device_status_.active_period_size());
 
   em::ActiveTimePeriod period0 = device_status_.active_period(0);
   em::ActiveTimePeriod period1 = device_status_.active_period(1);
   EXPECT_EQ(ActivePeriodMilliseconds() - 10000, period0.active_duration());
   EXPECT_EQ(10000, period1.active_duration());
 
   em::TimePeriod time_period0 = period0.time_period();
   em::TimePeriod time_period1 = period1.time_period();
 
   EXPECT_EQ(time_period0.end_timestamp(), time_period1.start_timestamp());
 
   // Ensure that the start and end times for the period are a day apart.
   EXPECT_EQ(time_period0.end_timestamp() - time_period0.start_timestamp(),
             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,
   };
+  // Make sure CPU stats get reported in time. If we don't run this, the second
+  // call to |GetStatus()| will contain these stats, but the first call won't
+  // and the EXPECT_EQ test below fails.
   base::RunLoop().RunUntilIdle();
+
   settings_helper_.SetBoolean(chromeos::kReportDeviceActivityTimes, true);
 
   status_collector_->Simulate(test_states, 2);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(2 * ActivePeriodMilliseconds(),
             GetActiveMilliseconds(device_status_));
   em::DeviceStatusReportRequest first_status(device_status_);
 
   // The collector returns the same status again.
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(first_status.SerializeAsString(),
             device_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();
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(ActivePeriodMilliseconds(), GetActiveMilliseconds(device_status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, DevSwitchBootMode) {
   // Test that boot mode data is reported by default.
   fake_statistics_provider_.SetMachineStatistic(
       chromeos::system::kDevSwitchBootKey,
       chromeos::system::kDevSwitchBootValueVerified);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ("Verified", device_status_.boot_mode());
 
   // Test that boot mode data is not reported if the pref turned off.
   settings_helper_.SetBoolean(chromeos::kReportDeviceBootMode, false);
 
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_FALSE(device_status_.has_boot_mode());
 
   // Turn the pref on, and check that the status is reported iff the
   // statistics provider returns valid data.
   settings_helper_.SetBoolean(chromeos::kReportDeviceBootMode, true);
 
   fake_statistics_provider_.SetMachineStatistic(
       chromeos::system::kDevSwitchBootKey, "(error)");
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_FALSE(device_status_.has_boot_mode());
 
   fake_statistics_provider_.SetMachineStatistic(
       chromeos::system::kDevSwitchBootKey, " ");
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_FALSE(device_status_.has_boot_mode());
 
   fake_statistics_provider_.SetMachineStatistic(
       chromeos::system::kDevSwitchBootKey,
       chromeos::system::kDevSwitchBootValueVerified);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ("Verified", device_status_.boot_mode());
 
   fake_statistics_provider_.SetMachineStatistic(
       chromeos::system::kDevSwitchBootKey,
       chromeos::system::kDevSwitchBootValueDev);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ("Dev", device_status_.boot_mode());
 }
 
 TEST_F(DeviceStatusCollectorTest, VersionInfo) {
   // Expect the version info to be reported by default.
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_TRUE(device_status_.has_browser_version());
   EXPECT_TRUE(device_status_.has_os_version());
   EXPECT_TRUE(device_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.
   settings_helper_.SetBoolean(chromeos::kReportDeviceVersionInfo, false);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_FALSE(device_status_.has_browser_version());
   EXPECT_FALSE(device_status_.has_os_version());
   EXPECT_FALSE(device_status_.has_firmware_version());
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceVersionInfo, true);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_TRUE(device_status_.has_browser_version());
   EXPECT_TRUE(device_status_.has_os_version());
   EXPECT_TRUE(device_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("", device_status_.browser_version());
 }
 
-TEST_F(DeviceStatusCollectorTest, Location) {
-  device::Geoposition valid_fix;
-  valid_fix.latitude = 4.3;
-  valid_fix.longitude = -7.8;
-  valid_fix.accuracy = 3.;
-  valid_fix.timestamp = Time::Now();
-
-  device::Geoposition invalid_fix;
-  invalid_fix.error_code = device::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
-  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);
-  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),
-                         base::Bind(&GetEmptyCPUTempInfo));
-  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);
-  settings_helper_.SetBoolean(chromeos::kReportDeviceLocation, false);
-  // Allow the new pref to propagate to the status collector.
-  base::RunLoop().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);
-  settings_helper_.SetBoolean(chromeos::kReportDeviceLocation, true);
-  // Allow the new pref to propagate to the status collector.
-  base::RunLoop().RunUntilIdle();
-  CheckThatALocationErrorIsReported();
-}
-
 TEST_F(DeviceStatusCollectorTest, ReportUsers) {
   const AccountId public_account_id(
       AccountId::FromUserEmail("public@localhost"));
   const AccountId account_id0(AccountId::FromUserEmail("user0@managed.com"));
   const AccountId account_id1(AccountId::FromUserEmail("user1@managed.com"));
   const AccountId account_id2(AccountId::FromUserEmail("user2@managed.com"));
   const AccountId account_id3(AccountId::FromUserEmail("user3@unmanaged.com"));
   const AccountId account_id4(AccountId::FromUserEmail("user4@managed.com"));
   const AccountId account_id5(AccountId::FromUserEmail("user5@managed.com"));
 
   user_manager_->CreatePublicAccountUser(public_account_id);
   user_manager_->AddUserWithAffiliation(account_id0, true);
   user_manager_->AddUserWithAffiliation(account_id1, true);
   user_manager_->AddUserWithAffiliation(account_id2, true);
   user_manager_->AddUserWithAffiliation(account_id3, false);
   user_manager_->AddUserWithAffiliation(account_id4, true);
   user_manager_->AddUserWithAffiliation(account_id5, true);
 
   // Verify that users are reported by default.
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(6, device_status_.user_size());
 
   // Verify that users are reported after enabling the setting.
   settings_helper_.SetBoolean(chromeos::kReportDeviceUsers, true);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(6, device_status_.user_size());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, device_status_.user(0).type());
   EXPECT_EQ(account_id0.GetUserEmail(), device_status_.user(0).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, device_status_.user(1).type());
   EXPECT_EQ(account_id1.GetUserEmail(), device_status_.user(1).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, device_status_.user(2).type());
   EXPECT_EQ(account_id2.GetUserEmail(), device_status_.user(2).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_UNMANAGED, device_status_.user(3).type());
   EXPECT_FALSE(device_status_.user(3).has_email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, device_status_.user(4).type());
   EXPECT_EQ(account_id4.GetUserEmail(), device_status_.user(4).email());
   EXPECT_EQ(em::DeviceUser::USER_TYPE_MANAGED, device_status_.user(5).type());
   EXPECT_EQ(account_id5.GetUserEmail(), device_status_.user(5).email());
 
   // Verify that users are no longer reported if setting is disabled.
   settings_helper_.SetBoolean(chromeos::kReportDeviceUsers, false);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(0, device_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()) {
     expected_mount_points.push_back(mount_info.first);
@@ skipping 10 matching lines @@
   }
   EXPECT_FALSE(expected_volume_info.empty());
 
   RestartStatusCollector(base::Bind(&GetFakeVolumeInfo, expected_volume_info),
                          base::Bind(&GetEmptyCPUStatistics),
                          base::Bind(&GetEmptyCPUTempInfo));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(expected_mount_points.size(),
             static_cast<size_t>(device_status_.volume_info_size()));
 
   // Walk the returned VolumeInfo to make sure it matches.
   for (const em::VolumeInfo& expected_info : expected_volume_info) {
     bool found = false;
     for (const em::VolumeInfo& info : device_status_.volume_info()) {
       if (info.volume_id() == expected_info.volume_id()) {
         EXPECT_EQ(expected_info.storage_total(), info.storage_total());
         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.
   settings_helper_.SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(0, device_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) {
     status_collector_->RefreshSampleResourceUsage();
     base::RunLoop().RunUntilIdle();
   }
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(static_cast<int>(DeviceStatusCollector::kMaxResourceUsageSamples),
             device_status_.system_ram_free().size());
   EXPECT_TRUE(device_status_.has_system_ram_total());
   // No good way to inject specific test values for available system RAM, so
   // just make sure it's > 0.
   EXPECT_GT(device_status_.system_ram_total(), 0);
 }
 
 TEST_F(DeviceStatusCollectorTest, TestCPUSamples) {
   // Mock 100% CPU usage.
   std::string full_cpu_usage("cpu  500 0 500 0 0 0 0");
   RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
                          base::Bind(&GetFakeCPUStatistics, full_cpu_usage),
                          base::Bind(&GetEmptyCPUTempInfo));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
-  GetDeviceStatus();
+  GetStatus();
   ASSERT_EQ(1, device_status_.cpu_utilization_pct().size());
   EXPECT_EQ(100, device_status_.cpu_utilization_pct(0));
 
   // Now sample CPU usage again (active usage counters will not increase
   // so should show 0% cpu usage).
   status_collector_->RefreshSampleResourceUsage();
   base::RunLoop().RunUntilIdle();
-  GetDeviceStatus();
+  GetStatus();
   ASSERT_EQ(2, device_status_.cpu_utilization_pct().size());
   EXPECT_EQ(0, device_status_.cpu_utilization_pct(1));
 
   // Now store a bunch of 0% cpu usage and make sure we cap the max number of
   // samples.
   for (int i = 0;
        i < static_cast<int>(DeviceStatusCollector::kMaxResourceUsageSamples);
        ++i) {
     status_collector_->RefreshSampleResourceUsage();
     base::RunLoop().RunUntilIdle();
   }
-  GetDeviceStatus();
+  GetStatus();
 
   // Should not be more than kMaxResourceUsageSamples, and they should all show
   // the CPU is idle.
   EXPECT_EQ(static_cast<int>(DeviceStatusCollector::kMaxResourceUsageSamples),
             device_status_.cpu_utilization_pct().size());
   for (const auto utilization : device_status_.cpu_utilization_pct())
     EXPECT_EQ(0, utilization);
 
   // Turning off hardware reporting should not report CPU utilization.
   settings_helper_.SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(0, device_status_.cpu_utilization_pct().size());
 }
 
 TEST_F(DeviceStatusCollectorTest, TestCPUTemp) {
   std::vector<em::CPUTempInfo> expected_temp_info;
   int cpu_cnt = 12;
   for (int i = 0; i < cpu_cnt; ++i) {
     em::CPUTempInfo info;
     info.set_cpu_temp(i * 10 + 100);
     info.set_cpu_label(base::StringPrintf("Core %d", i));
     expected_temp_info.push_back(info);
   }
 
   RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
                          base::Bind(&GetEmptyCPUStatistics),
                          base::Bind(&GetFakeCPUTempInfo, expected_temp_info));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(expected_temp_info.size(),
             static_cast<size_t>(device_status_.cpu_temp_info_size()));
 
   // Walk the returned CPUTempInfo to make sure it matches.
   for (const em::CPUTempInfo& expected_info : expected_temp_info) {
     bool found = false;
     for (const em::CPUTempInfo& info : device_status_.cpu_temp_info()) {
       if (info.cpu_label() == expected_info.cpu_label()) {
         EXPECT_EQ(expected_info.cpu_temp(), info.cpu_temp());
         found = true;
         break;
       }
     }
     EXPECT_TRUE(found) << "No matching CPUTempInfo for "
                        << expected_info.cpu_label();
   }
 
   // Now turn off hardware status reporting - should have no data.
   settings_helper_.SetBoolean(chromeos::kReportDeviceHardwareStatus, false);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(0, device_status_.cpu_temp_info_size());
 }
 
 TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfNotKioskMode) {
   // Should not report session status if we don't have an active kiosk app.
   settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, true);
-  GetSessionStatus();
+  GetStatus();
   EXPECT_FALSE(got_session_status_);
 }
 
 TEST_F(DeviceStatusCollectorTest, NoSessionStatusIfSessionReportingDisabled) {
   // Should not report session status if session status reporting is disabled.
   settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, false);
   status_collector_->set_kiosk_account(
       base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
   // Set up a device-local account for single-app kiosk mode.
   MockRunningKioskApp(fake_device_local_account_);
 
-  GetSessionStatus();
+  GetStatus();
   EXPECT_FALSE(got_session_status_);
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportSessionStatus) {
   settings_helper_.SetBoolean(chromeos::kReportDeviceSessionStatus, true);
   status_collector_->set_kiosk_account(
       base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
 
   // Set up a device-local account for single-app kiosk mode.
   MockRunningKioskApp(fake_device_local_account_);
 
-  GetSessionStatus();
+  GetStatus();
   EXPECT_TRUE(got_session_status_);
   ASSERT_EQ(1, session_status_.installed_apps_size());
   EXPECT_EQ(kKioskAccountId, session_status_.device_local_account_id());
   const em::AppStatus app = session_status_.installed_apps(0);
   EXPECT_EQ(kKioskAppId, app.app_id());
   // Test code just sets the version to the app ID.
   EXPECT_EQ(kKioskAppId, app.extension_version());
   EXPECT_FALSE(app.has_status());
   EXPECT_FALSE(app.has_error());
 }
 
 TEST_F(DeviceStatusCollectorTest, NoOsUpdateStatusByDefault) {
   MockPlatformVersion("1234.0.0");
   MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
                                                     "1234.0.0");
 
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_FALSE(device_status_.has_os_update_status());
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportOsUpdateStatusUpToDate) {
   MockPlatformVersion("1234.0.0");
   settings_helper_.SetBoolean(chromeos::kReportOsUpdateStatus, true);
 
   const char* kRequiredPlatformVersions[] = {"1234", "1234.0", "1234.0.0"};
 
   for (size_t i = 0; i < arraysize(kRequiredPlatformVersions); ++i) {
     MockAutoLaunchKioskAppWithRequiredPlatformVersion(
         fake_device_local_account_, kRequiredPlatformVersions[i]);
 
-    GetDeviceStatus();
+    GetStatus();
     ASSERT_TRUE(device_status_.has_os_update_status())
         << "Required platform version=" << kRequiredPlatformVersions[i];
     EXPECT_EQ(em::OsUpdateStatus::OS_UP_TO_DATE,
               device_status_.os_update_status().update_status())
         << "Required platform version=" << kRequiredPlatformVersions[i];
     EXPECT_EQ(kRequiredPlatformVersions[i],
               device_status_.os_update_status().new_required_platform_version())
         << "Required platform version=" << kRequiredPlatformVersions[i];
   }
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportOsUpdateStatus) {
   MockPlatformVersion("1234.0.0");
   settings_helper_.SetBoolean(chromeos::kReportOsUpdateStatus, true);
   MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
                                                     "1235");
 
   chromeos::UpdateEngineClient::Status update_status;
   update_status.status = chromeos::UpdateEngineClient::UPDATE_STATUS_IDLE;
 
-  GetDeviceStatus();
+  GetStatus();
   ASSERT_TRUE(device_status_.has_os_update_status());
   EXPECT_EQ(em::OsUpdateStatus::OS_IMAGE_DOWNLOAD_NOT_STARTED,
             device_status_.os_update_status().update_status());
 
   const chromeos::UpdateEngineClient::UpdateStatusOperation kUpdateEngineOps[] =
       {
           chromeos::UpdateEngineClient::UPDATE_STATUS_DOWNLOADING,
           chromeos::UpdateEngineClient::UPDATE_STATUS_VERIFYING,
           chromeos::UpdateEngineClient::UPDATE_STATUS_FINALIZING,
       };
 
   for (size_t i = 0; i < arraysize(kUpdateEngineOps); ++i) {
     update_status.status = kUpdateEngineOps[i];
     update_status.new_version = "1235.1.2";
     update_engine_client_->PushLastStatus(update_status);
 
-    GetDeviceStatus();
+    GetStatus();
     ASSERT_TRUE(device_status_.has_os_update_status());
     EXPECT_EQ(em::OsUpdateStatus::OS_IMAGE_DOWNLOAD_IN_PROGRESS,
               device_status_.os_update_status().update_status());
     EXPECT_EQ("1235.1.2",
               device_status_.os_update_status().new_platform_version());
     EXPECT_EQ(
         "1235",
         device_status_.os_update_status().new_required_platform_version());
   }
 
   update_status.status =
       chromeos::UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT;
   update_engine_client_->PushLastStatus(update_status);
-  GetDeviceStatus();
+  GetStatus();
   ASSERT_TRUE(device_status_.has_os_update_status());
   EXPECT_EQ(em::OsUpdateStatus::OS_UPDATE_NEED_REBOOT,
             device_status_.os_update_status().update_status());
 }
 
 TEST_F(DeviceStatusCollectorTest, NoRunningKioskAppByDefault) {
   MockPlatformVersion("1234.0.0");
   MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
                                                     "1234.0.0");
   status_collector_->set_kiosk_account(
       base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
   MockRunningKioskApp(fake_device_local_account_);
 
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_FALSE(device_status_.has_running_kiosk_app());
 }
 
 TEST_F(DeviceStatusCollectorTest, NoRunningKioskAppWhenNotInKioskSession) {
   settings_helper_.SetBoolean(chromeos::kReportRunningKioskApp, true);
   MockPlatformVersion("1234.0.0");
   MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
                                                     "1234.0.0");
 
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_FALSE(device_status_.has_running_kiosk_app());
 }
 
 TEST_F(DeviceStatusCollectorTest, ReportRunningKioskApp) {
   settings_helper_.SetBoolean(chromeos::kReportRunningKioskApp, true);
   MockPlatformVersion("1234.0.0");
   MockAutoLaunchKioskAppWithRequiredPlatformVersion(fake_device_local_account_,
                                                     "1235");
   MockRunningKioskApp(fake_device_local_account_);
   status_collector_->set_kiosk_account(
       base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
 
-  GetDeviceStatus();
+  GetStatus();
   ASSERT_TRUE(device_status_.has_running_kiosk_app());
   const em::AppStatus app = device_status_.running_kiosk_app();
   EXPECT_EQ(kKioskAppId, app.app_id());
   EXPECT_EQ("1235", app.required_platform_version());
   EXPECT_FALSE(app.has_status());
   EXPECT_FALSE(app.has_error());
 }
 
 // Fake device state.
 struct FakeDeviceData {
@@ skipping 251 matching lines @@
       }
       EXPECT_TRUE(found_match) << "No matching state for fake network "
                                << " (" << state.name << ")";
     }
   }
 };
 
 TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NoNetworkStateIfNotKiosk) {
   // If not in an active kiosk session, there should be network interfaces
   // reported, but no network state.
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_LT(0, device_status_.network_interface_size());
   EXPECT_EQ(0, device_status_.network_state_size());
 }
 
 TEST_F(DeviceStatusCollectorNetworkInterfacesTest, NetworkInterfaces) {
   // Mock that we are in kiosk mode so we report network state.
   status_collector_->set_kiosk_account(
       base::MakeUnique<policy::DeviceLocalAccount>(fake_device_local_account_));
 
   // Interfaces should be reported by default.
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_LT(0, device_status_.network_interface_size());
   EXPECT_LT(0, device_status_.network_state_size());
 
   // No interfaces should be reported if the policy is off.
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, false);
-  GetDeviceStatus();
+  GetStatus();
   EXPECT_EQ(0, device_status_.network_interface_size());
   EXPECT_EQ(0, device_status_.network_state_size());
 
   // Switch the policy on and verify the interface list is present.
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
-  GetDeviceStatus();
+  GetStatus();
 
   VerifyNetworkReporting();
 }
 
 TEST_F(DeviceStatusCollectorNetworkInterfacesTest, ReportIfPublicSession) {
   // Report netowork state for public accounts.
   user_manager_->CreatePublicAccountUser(
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
-  GetDeviceStatus();
+  GetStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy