Report ARC status asynchronously via DeviceStatusCollector

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>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/environment.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/test/scoped_path_override.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_data.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.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/scoped_cros_settings_test_helper.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 11 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 "mojo/public/cpp/bindings/string.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;
@@ skipping 12 matching lines @@
 const char kPublicAccountId[] = "public_user@localhost";
 
 class TestingDeviceStatusCollector : public policy::DeviceStatusCollector {
  public:
   TestingDeviceStatusCollector(
       PrefService* local_state,
       chromeos::system::StatisticsProvider* provider,
       const policy::DeviceStatusCollector::VolumeInfoFetcher&
           volume_info_fetcher,
       const policy::DeviceStatusCollector::CPUStatisticsFetcher& cpu_fetcher,
-      const policy::DeviceStatusCollector::CPUTempFetcher& cpu_temp_fetcher)
+      const policy::DeviceStatusCollector::CPUTempFetcher& cpu_temp_fetcher,
+      const policy::DeviceStatusCollector::AndroidStatusFetcher&
+          android_status_fetcher)
       : policy::DeviceStatusCollector(local_state,
                                       provider,
                                       volume_info_fetcher,
                                       cpu_fetcher,
-                                      cpu_temp_fetcher) {
+                                      cpu_temp_fetcher,
+                                      android_status_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++)
       IdleStateCallback(states[i]);
   }
 
@@ skipping 100 matching lines @@
     EXPECT_TRUE(found) << "Could not find matching mount point for "
                        << info.volume_id();
   }
   return volume_info;
 }
 
 std::vector<em::CPUTempInfo> GetEmptyCPUTempInfo() {
   return std::vector<em::CPUTempInfo>();
 }
 
+void CallAndroidStatusReceiver(
+    const policy::DeviceStatusCollector::AndroidStatusReceiver& receiver,
+    mojo::String status,
+    mojo::String droid_guard_info) {
+  receiver.Run(status, droid_guard_info);
+}
+
+bool GetEmptyAndroidStatus(
+    const policy::DeviceStatusCollector::AndroidStatusReceiver& receiver) {
+  // Post it to the thread because this call is expected to be asynchronous.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&CallAndroidStatusReceiver, receiver, "", ""));
+  return true;
+}
+
 std::vector<em::CPUTempInfo> GetFakeCPUTempInfo(
     const std::vector<em::CPUTempInfo>& cpu_temp_info) {
   return cpu_temp_info;
 }
 
 }  // namespace
 
 namespace policy {
 
 // Though it is a unit test, this test is linked with browser_tests so that it
@@ skipping 49 matching lines @@
     // DiskMountManager takes ownership of the MockDiskMountManager.
     DiskMountManager::InitializeForTesting(mock_disk_mount_manager.release());
     TestingDeviceStatusCollector::RegisterPrefs(prefs_.registry());
 
     settings_helper_.ReplaceProvider(chromeos::kReportDeviceActivityTimes);
     owner_settings_service_ =
         settings_helper_.CreateOwnerSettingsService(nullptr);
 
     RestartStatusCollector(base::Bind(&GetEmptyVolumeInfo),
                            base::Bind(&GetEmptyCPUStatistics),
-                           base::Bind(&GetEmptyCPUTempInfo));
+                           base::Bind(&GetEmptyCPUTempInfo),
+                           base::Bind(&GetEmptyAndroidStatus));
 
     // Set up a fake local state for KioskAppManager.
     TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
     chromeos::KioskAppManager::RegisterPrefs(local_state_.registry());
 
     // Use FakeUpdateEngineClient.
     std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter =
         chromeos::DBusThreadManager::GetSetterForTesting();
     dbus_setter->SetUpdateEngineClient(
         base::WrapUnique<chromeos::UpdateEngineClient>(update_engine_client_));
@@ skipping 24 matching lines @@
                                 false);
   }
 
   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) {
+      const policy::DeviceStatusCollector::CPUTempFetcher& cpu_temp_fetcher,
+      const policy::DeviceStatusCollector::AndroidStatusFetcher&
+          android_status_fetcher) {
     std::vector<em::VolumeInfo> expected_volume_info;
     status_collector_.reset(new TestingDeviceStatusCollector(
         &prefs_, &fake_statistics_provider_, volume_info, cpu_stats,
-        cpu_temp_fetcher));
+        cpu_temp_fetcher, android_status_fetcher));
   }
 
   void GetStatus() {
     device_status_.Clear();
     session_status_.Clear();
     got_session_status_ = false;
     run_loop_.reset(new base::RunLoop());
     status_collector_->GetDeviceAndSessionStatusAsync(base::Bind(
         &DeviceStatusCollectorTest::OnStatusReceived, base::Unretained(this)));
     run_loop_->Run();
@@ skipping 170 matching lines @@
   };
   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));
+                         base::Bind(&GetEmptyCPUTempInfo),
+                         base::Bind(&GetEmptyAndroidStatus));
   status_collector_->Simulate(test_states,
                               sizeof(test_states) / sizeof(ui::IdleState));
 
   GetStatus();
   EXPECT_EQ(6 * ActivePeriodMilliseconds(),
             GetActiveMilliseconds(device_status_));
 }
 
 TEST_F(DeviceStatusCollectorTest, Times) {
   ui::IdleState test_states[] = {
@@ skipping 279 matching lines @@
     info.set_volume_id(mount_point);
     // Just put unique numbers in for storage_total/free.
     info.set_storage_total(size++);
     info.set_storage_free(size++);
     expected_volume_info.push_back(info);
   }
   EXPECT_FALSE(expected_volume_info.empty());
 
   RestartStatusCollector(base::Bind(&GetFakeVolumeInfo, expected_volume_info),
                          base::Bind(&GetEmptyCPUStatistics),
-                         base::Bind(&GetEmptyCPUTempInfo));
+                         base::Bind(&GetEmptyCPUTempInfo),
+                         base::Bind(&GetEmptyAndroidStatus));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
   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) {
@@ skipping 32 matching lines @@
   // 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));
+                         base::Bind(&GetEmptyCPUTempInfo),
+                         base::Bind(&GetEmptyAndroidStatus));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
   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();
@@ skipping 30 matching lines @@
   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));
+                         base::Bind(&GetFakeCPUTempInfo, expected_temp_info),
+                         base::Bind(&GetEmptyAndroidStatus));
   // Force finishing tasks posted by ctor of DeviceStatusCollector.
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
   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) {
@@ skipping 468 matching lines @@
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy