Report ARC status asynchronously via DeviceStatusCollector

chrome/browser/chromeos/policy/device_status_collector.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 <algorithm>
 #include <cstdio>
 #include <limits>
 #include <memory>
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/ref_counted.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/update_engine_client.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "chromeos/network/device_state.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/system/statistics_provider.h"
+#include "components/arc/arc_bridge_service.h"
+#include "components/arc/common/enterprise_reporting.mojom.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/proto/device_management_backend.pb.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_type.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 148 matching lines @@
         contents.push_back(info);
       } else {
         LOG(WARNING) << "Unable to read CPU temp from "
                      << temperature_path.MaybeAsASCII();
       }
     }
   }
   return contents;
 }
 
+bool ReadAndroidStatus(
+    const policy::DeviceStatusCollector::AndroidStatusReceiver& receiver) {
+  auto* const arc_service = arc::ArcBridgeService::Get();
+  if (!arc_service)
+    return false;
+  auto* const instance_holder = arc_service->enterprise_reporting();
+  if (!instance_holder)
+    return false;
+  auto* const instance = instance_holder->GetInstanceForMethod("GetStatus", 1);
+  if (!instance)
+    return false;
+  instance->GetStatus(receiver);
+  return true;
+}
+
 // Returns the DeviceLocalAccount associated with the current kiosk session.
 // Returns null if there is no active kiosk session, or if that kiosk
 // session has been removed from policy since the session started, in which
 // case we won't report its status).
 std::unique_ptr<policy::DeviceLocalAccount> GetCurrentKioskDeviceLocalAccount(
     chromeos::CrosSettings* settings) {
   if (!user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return std::unique_ptr<policy::DeviceLocalAccount>();
   const user_manager::User* const user =
       user_manager::UserManager::Get()->GetActiveUser();
@@ skipping 102 matching lines @@
 
   // Queues an async callback to query CPU temperature information.
   void SampleCPUTempInfo(
       const policy::DeviceStatusCollector::CPUTempFetcher& cpu_temp_fetcher) {
     // Call out to the blocking pool to sample CPU temp.
     base::PostTaskAndReplyWithResult(
         content::BrowserThread::GetBlockingPool(), FROM_HERE, cpu_temp_fetcher,
         base::Bind(&GetStatusState::OnCPUTempInfoReceived, this));
   }
 
+  bool FetchAndroidStatus(
+      const policy::DeviceStatusCollector::AndroidStatusFetcher&
+          android_status_fetcher) {
+    return android_status_fetcher.Run(
+        base::Bind(&GetStatusState::OnAndroidInfoReceived, this));
+  }
+
  private:
   friend class RefCountedThreadSafe<GetStatusState>;
 
   // Posts the response on the UI thread. As long as there is an outstanding
   // async query, the query holds a reference to us, so the destructor is
   // not called.
   ~GetStatusState() {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(response_, base::Passed(&device_status_),
                                       base::Passed(&session_status_)));
   }
 
   void OnVolumeInfoReceived(const std::vector<em::VolumeInfo>& volume_info) {
     device_status_->clear_volume_info();
     for (const em::VolumeInfo& info : volume_info)
       *device_status_->add_volume_info() = info;
   }
 
   void OnCPUTempInfoReceived(
       const std::vector<em::CPUTempInfo>& cpu_temp_info) {
     if (cpu_temp_info.empty())
       DLOG(WARNING) << "Unable to read CPU temp information.";
 
     device_status_->clear_cpu_temp_info();
     for (const em::CPUTempInfo& info : cpu_temp_info)
       *device_status_->add_cpu_temp_info() = info;
   }
 
+  void OnAndroidInfoReceived(mojo::String status,
+                             mojo::String droid_guard_info) {
+    em::AndroidStatus* const android_status =
+        session_status_->mutable_android_status();
+    android_status->set_status_payload(status);
+    android_status->set_droid_guard_info(droid_guard_info);
+  }
+
   const scoped_refptr<base::SequencedTaskRunner> task_runner_;
   policy::DeviceStatusCollector::StatusCallback response_;
   std::unique_ptr<em::DeviceStatusReportRequest> device_status_ =
       base::MakeUnique<em::DeviceStatusReportRequest>();
   std::unique_ptr<em::SessionStatusReportRequest> session_status_ =
       base::MakeUnique<em::SessionStatusReportRequest>();
 };
 
 DeviceStatusCollector::DeviceStatusCollector(
     PrefService* local_state,
     chromeos::system::StatisticsProvider* provider,
     const VolumeInfoFetcher& volume_info_fetcher,
     const CPUStatisticsFetcher& cpu_statistics_fetcher,
-    const CPUTempFetcher& cpu_temp_fetcher)
+    const CPUTempFetcher& cpu_temp_fetcher,
+    const AndroidStatusFetcher& android_status_fetcher)
     : max_stored_past_activity_days_(kMaxStoredPastActivityDays),
       max_stored_future_activity_days_(kMaxStoredFutureActivityDays),
       local_state_(local_state),
       last_idle_check_(Time()),
       volume_info_fetcher_(volume_info_fetcher),
       cpu_statistics_fetcher_(cpu_statistics_fetcher),
       cpu_temp_fetcher_(cpu_temp_fetcher),
+      android_status_fetcher_(android_status_fetcher),
       statistics_provider_(provider),
       cros_settings_(chromeos::CrosSettings::Get()),
       task_runner_(nullptr),
       weak_factory_(this) {
   // Get the task runner of the current thread, so we can queue status responses
   // on this thread.
   CHECK(base::SequencedTaskRunnerHandle::IsSet());
   task_runner_ = base::SequencedTaskRunnerHandle::Get();
 
   if (volume_info_fetcher_.is_null())
     volume_info_fetcher_ = base::Bind(&GetVolumeInfo);
 
   if (cpu_statistics_fetcher_.is_null())
     cpu_statistics_fetcher_ = base::Bind(&ReadCPUStatistics);
 
   if (cpu_temp_fetcher_.is_null())
     cpu_temp_fetcher_ = base::Bind(&ReadCPUTempInfo);
 
+  if (android_status_fetcher_.is_null())
+    android_status_fetcher_ = base::Bind(&ReadAndroidStatus);
+
   idle_poll_timer_.Start(FROM_HERE,
                          TimeDelta::FromSeconds(kIdlePollIntervalSeconds),
                          this, &DeviceStatusCollector::CheckIdleState);
   resource_usage_sampling_timer_.Start(
       FROM_HERE, TimeDelta::FromSeconds(kResourceUsageSampleIntervalSeconds),
       this, &DeviceStatusCollector::SampleResourceUsage);
 
   // Watch for changes to the individual policies that control what the status
   // reports contain.
   base::Closure callback =
@@ skipping 85 matching lines @@
           chromeos::kReportDeviceUsers, &report_users_)) {
     report_users_ = true;
   }
 
   const bool already_reporting_hardware_status = report_hardware_status_;
   if (!cros_settings_->GetBoolean(
           chromeos::kReportDeviceHardwareStatus, &report_hardware_status_)) {
     report_hardware_status_ = true;
   }
 
-  if (!cros_settings_->GetBoolean(
-          chromeos::kReportDeviceSessionStatus, &report_session_status_)) {
-    report_session_status_ = true;
+  if (!cros_settings_->GetBoolean(chromeos::kReportDeviceSessionStatus,
+                                  &report_kiosk_session_status_)) {
+    report_kiosk_session_status_ = true;
   }
 
+  // TODO(phweiss): Create policy to control this, and turn it on by default.
+  report_android_status_ = false;
+
   if (!report_hardware_status_) {
     ClearCachedResourceUsage();
   } else if (!already_reporting_hardware_status) {
     // Turning on hardware status reporting - fetch an initial sample
     // immediately instead of waiting for the sampling timer to fire.
     SampleResourceUsage();
   }
 
   // Os update status and running kiosk app reporting are disabled by default.
   if (!cros_settings_->GetBoolean(chromeos::kReportOsUpdateStatus,
@@ skipping 502 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Some of the data we're collecting is gathered in background threads.
   // This object keeps track of the state of each async request.
   scoped_refptr<GetStatusState> state(
       new GetStatusState(task_runner_, response));
 
   // Gather device status (might queue some async queries)
   GetDeviceStatus(state);
 
-  // Gather device status (might queue some async queries)
+  // Gather session status (might queue some async queries)
   GetSessionStatus(state);
 
   // If there are no outstanding async queries, e.g. from GetHardwareStatus(),
   // the destructor of |state| calls |response|. If there are async queries, the
   // queries hold references to |state|, so that |state| is only destroyed when
   // the last async query has finished.
 }
 
 void DeviceStatusCollector::GetDeviceStatus(
     scoped_refptr<GetStatusState> state) {
@@ skipping 27 matching lines @@
   // Wipe pointer if we didn't actually add any data.
   if (!anything_reported)
     state->ResetDeviceStatus();
 }
 
 void DeviceStatusCollector::GetSessionStatus(
     scoped_refptr<GetStatusState> state) {
   em::SessionStatusReportRequest* status = state->session_status();
   bool anything_reported = false;
 
-  if (report_session_status_)
-    anything_reported |= GetAccountStatus(status);
+  if (report_kiosk_session_status_)
+    anything_reported |= GetKioskSessionStatus(status);
+  if (report_android_status_)
+    anything_reported |= GetAndroidStatus(status, state);
 
   // Wipe pointer if we didn't actually add any data.
   if (!anything_reported)
     state->ResetSessionStatus();
 }
 
-bool DeviceStatusCollector::GetAccountStatus(
+bool DeviceStatusCollector::GetKioskSessionStatus(
     em::SessionStatusReportRequest* status) {
   std::unique_ptr<const DeviceLocalAccount> account =
       GetAutoLaunchedKioskSessionInfo();
   if (!account)
     return false;
 
   // Get the account ID associated with this user.
   status->set_device_local_account_id(account->account_id);
   em::AppStatus* app_status = status->add_installed_apps();
   app_status->set_app_id(account->kiosk_app_id);
 
   // Look up the app and get the version.
   const std::string app_version = GetAppVersion(account->kiosk_app_id);
   if (app_version.empty()) {
     DLOG(ERROR) << "Unable to get version for extension: "
                 << account->kiosk_app_id;
   } else {
     app_status->set_extension_version(app_version);
   }
 
   return true;
 }
 
+bool DeviceStatusCollector::GetAndroidStatus(
+    em::SessionStatusReportRequest* status,
+    const scoped_refptr<GetStatusState>& state) {
+  return state->FetchAndroidStatus(android_status_fetcher_);
+}
+
 std::string DeviceStatusCollector::GetAppVersion(
     const std::string& kiosk_app_id) {
   Profile* const profile =
       chromeos::ProfileHelper::Get()->GetProfileByUser(
           user_manager::UserManager::Get()->GetActiveUser());
   const extensions::ExtensionRegistry* const registry =
       extensions::ExtensionRegistry::Get(profile);
   const extensions::Extension* const extension = registry->GetExtensionById(
       kiosk_app_id, extensions::ExtensionRegistry::EVERYTHING);
   if (!extension)
     return std::string();
   return extension->VersionString();
 }
 
 void DeviceStatusCollector::OnSubmittedSuccessfully() {
   TrimStoredActivityPeriods(last_reported_day_, duration_for_last_reported_day_,
                             std::numeric_limits<int64_t>::max());
 }
 
 void DeviceStatusCollector::OnOSVersion(const std::string& version) {
   os_version_ = version;
 }
 
 void DeviceStatusCollector::OnOSFirmware(const std::string& version) {
   firmware_version_ = version;
 }
 
 }  // namespace policy