Report ARC status asynchronously via DeviceStatusCollector

chrome/browser/chromeos/policy/device_status_collector.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_POLICY_DEVICE_STATUS_COLLECTOR_H_
 #define CHROME_BROWSER_CHROMEOS_POLICY_DEVICE_STATUS_COLLECTOR_H_
 
 #include <stdint.h>
 
 #include <deque>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/callback_list.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chromeos/system/version_loader.h"
 #include "components/policy/proto/device_management_backend.pb.h"
+#include "mojo/public/cpp/bindings/string.h"
 #include "ui/base/idle/idle.h"
 
 namespace chromeos {
 class CrosSettings;
 namespace system {
 class StatisticsProvider;
 }
 }
 
 namespace content {
@@ skipping 22 matching lines @@
   //
   // The format of this line from /proc/stat is:
   //   cpu  user_time nice_time system_time idle_time
   using CPUStatisticsFetcher = base::Callback<std::string(void)>;
 
   // Reads CPU temperatures from /sys/class/hwmon/hwmon*/temp*_input and
   // appropriate labels from /sys/class/hwmon/hwmon*/temp*_label.
   using CPUTempFetcher =
       base::Callback<std::vector<enterprise_management::CPUTempInfo>()>;
 
+  using AndroidStatusFetcher =
+      base::Callback<std::pair<mojo::String, mojo::String>(void)>;
+
   // Called in the UI thread after the device and session status have been
   // collected asynchronously in GetDeviceAndSessionStatusAsync. Null pointers
   // indicate errors or that device or session status reporting is disabled.
   using StatusCallback = base::Callback<void(
       std::unique_ptr<enterprise_management::DeviceStatusReportRequest>,
       std::unique_ptr<enterprise_management::SessionStatusReportRequest>)>;
 
   // Constructor. Callers can inject their own VolumeInfoFetcher,
   // CPUStatisticsFetcher and CPUTempFetcher. These callbacks are executed on
   // Blocking Pool. A null callback can be passed for either parameter, to use
   // the default implementation.
   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_);
   virtual ~DeviceStatusCollector();
 
   // Gathers device and session status information and calls the passed response
   // callback. Null pointers passed into the response indicate errors or that
   // device or session status reporting is disabled.
   virtual void GetDeviceAndSessionStatusAsync(const StatusCallback& response);
 
   // Called after the status information has successfully been submitted to
   // the server.
   void OnSubmittedSuccessfully();
@@ skipping 78 matching lines @@
   bool GetOsUpdateStatus(
       enterprise_management::DeviceStatusReportRequest* status);
   bool GetRunningKioskApp(
       enterprise_management::DeviceStatusReportRequest* status);
 
   // Helpers for the various portions of SESSION STATUS. Return true if they
   // actually report any status. Functions that queue async queries take
   // a |GetStatusState| instance.
   bool GetAccountStatus(
       enterprise_management::SessionStatusReportRequest* status);
+  bool GetAndroidStatus(
+      enterprise_management::SessionStatusReportRequest* status,
+      scoped_refptr<GetStatusState> state);  // Queues async queries!
 
   // Update the cached values of the reporting settings.
   void UpdateReportingSettings();
 
   // Callback invoked to update our cpu usage information.
   void ReceiveCPUStatistics(const std::string& statistics);
 
   PrefService* const local_state_;
 
   // The last time an idle state check was performed.
@@ skipping 27 matching lines @@
 
   // Callback invoked to fetch information about the mounted disk volumes.
   VolumeInfoFetcher volume_info_fetcher_;
 
   // Callback invoked to fetch information about cpu usage.
   CPUStatisticsFetcher cpu_statistics_fetcher_;
 
   // Callback invoked to fetch information about cpu temperature.
   CPUTempFetcher cpu_temp_fetcher_;
 
+  AndroidStatusFetcher android_status_fetcher_;
+
   chromeos::system::StatisticsProvider* const statistics_provider_;
 
   chromeos::CrosSettings* const cros_settings_;
 
   // The most recent CPU readings.
   uint64_t last_cpu_active_ = 0;
   uint64_t last_cpu_idle_ = 0;
 
   // Cached values of the reporting settings from the device policy.
   bool report_version_info_ = false;
   bool report_activity_times_ = false;
   bool report_boot_mode_ = false;
   bool report_network_interfaces_ = false;
   bool report_users_ = false;
   bool report_hardware_status_ = false;
   bool report_session_status_ = false;
+  bool report_android_status_ = false;
   bool report_os_update_status_ = false;
   bool report_running_kiosk_app_ = false;
 
   std::unique_ptr<chromeos::CrosSettings::ObserverSubscription>
       version_info_subscription_;
   std::unique_ptr<chromeos::CrosSettings::ObserverSubscription>
       activity_times_subscription_;
   std::unique_ptr<chromeos::CrosSettings::ObserverSubscription>
       boot_mode_subscription_;
   std::unique_ptr<chromeos::CrosSettings::ObserverSubscription>
@@ skipping 14 matching lines @@
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<DeviceStatusCollector> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceStatusCollector);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_CHROMEOS_POLICY_DEVICE_STATUS_COLLECTOR_H_