Refactored device status uploading out of policy fetch infrastructure.

chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.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_cloud_policy_manager_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/port.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/attestation/attestation_policy_observer.h"
 #include "chrome/browser/chromeos/login/enrollment/auto_enrollment_controller.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 #include "chrome/browser/chromeos/policy/enterprise_install_attributes.h"
 #include "chrome/browser/chromeos/policy/server_backed_state_keys_broker.h"
+#include "chrome/browser/chromeos/policy/status_uploader.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_constants.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/system/statistics_provider.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/cloud_policy_service.h"
 #include "components/policy/core/common/cloud/cloud_policy_store.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/sha2.h"
 #include "policy/proto/device_management_backend.pb.h"
@@ skipping 72 matching lines @@
     ServerBackedStateKeysBroker* state_keys_broker)
     : CloudPolicyManager(
           dm_protocol::kChromeDevicePolicyType,
           std::string(),
           store.get(),
           task_runner,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)),
       device_store_(store.Pass()),
       state_keys_broker_(state_keys_broker),
+      task_runner_(task_runner),
       local_state_(nullptr) {
 }
 
 DeviceCloudPolicyManagerChromeOS::~DeviceCloudPolicyManagerChromeOS() {}
 
 void DeviceCloudPolicyManagerChromeOS::Initialize(PrefService* local_state) {
   CHECK(local_state);
 
   local_state_ = local_state;
 
@@ skipping 50 matching lines @@
 
 bool DeviceCloudPolicyManagerChromeOS::IsRemoraRequisition() const {
   return GetDeviceRequisition() == kRemoraRequisition;
 }
 
 bool DeviceCloudPolicyManagerChromeOS::IsSharkRequisition() const {
   return GetDeviceRequisition() == kSharkRequisition;
 }
 
 void DeviceCloudPolicyManagerChromeOS::Shutdown() {
+  status_uploader_.reset();
   state_keys_update_subscription_.reset();
   CloudPolicyManager::Shutdown();
 }
 
 // static
 void DeviceCloudPolicyManagerChromeOS::RegisterPrefs(
     PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kDeviceEnrollmentRequisition,
                                std::string());
   registry->RegisterBooleanPref(prefs::kDeviceEnrollmentAutoStart, false);
@@ skipping 22 matching lines @@
 
 // static
 std::string DeviceCloudPolicyManagerChromeOS::GetMachineModel() {
   return GetMachineStatistic(chromeos::system::kHardwareClassKey);
 }
 
 void DeviceCloudPolicyManagerChromeOS::StartConnection(
     scoped_ptr<CloudPolicyClient> client_to_connect,
     EnterpriseInstallAttributes* install_attributes) {
   CHECK(!service());
-  // Enable device reporting for enterprise enrolled devices. We want to do this
-  // even if management is currently inactive, in case management is turned
-  // back on in a future policy fetch.
-  if (install_attributes->IsEnterpriseDevice()) {
-    client_to_connect->SetStatusProvider(
-        scoped_ptr<CloudPolicyClient::StatusProvider>(
-            new DeviceStatusCollector(
-                local_state_,
-                chromeos::system::StatisticsProvider::GetInstance(),
-                DeviceStatusCollector::LocationUpdateRequester(),
-                DeviceStatusCollector::VolumeInfoFetcher())));
-  }
 
   // Set state keys here so the first policy fetch submits them to the server.
   if (ForcedReEnrollmentEnabled())
     client_to_connect->SetStateKeysToUpload(state_keys_broker_->state_keys());
 
   core()->Connect(client_to_connect.Pass());
   core()->StartRefreshScheduler();
   core()->TrackRefreshDelayPref(local_state_,
                                 prefs::kDevicePolicyRefreshRate);
   attestation_policy_observer_.reset(
       new chromeos::attestation::AttestationPolicyObserver(client()));
 
+  // Enable device reporting for enterprise enrolled devices. We want to do this
+  // even if management is currently inactive, in case management is turned
+  // back on in a future policy fetch.
+  if (install_attributes->IsEnterpriseDevice())
+    CreateStatusUploader();
+
   NotifyConnected();
 }
 
 void DeviceCloudPolicyManagerChromeOS::Unregister(
     const UnregisterCallback& callback) {
   if (!service()) {
     LOG(ERROR) << "Tried to unregister but DeviceCloudPolicyManagerChromeOS is "
                << "not connected.";
     callback.Run(false);
     return;
   }
 
   service()->Unregister(callback);
 }
 
 void DeviceCloudPolicyManagerChromeOS::Disconnect() {
+  status_uploader_.reset();
   core()->Disconnect();
 
   NotifyDisconnected();
 }
 
 void DeviceCloudPolicyManagerChromeOS::OnStateKeysUpdated() {
   if (client() && ForcedReEnrollmentEnabled())
     client()->SetStateKeysToUpload(state_keys_broker_->state_keys());
 }
 
@@ skipping 32 matching lines @@
 void DeviceCloudPolicyManagerChromeOS::NotifyConnected() {
   FOR_EACH_OBSERVER(
       Observer, observers_, OnDeviceCloudPolicyManagerConnected());
 }
 
 void DeviceCloudPolicyManagerChromeOS::NotifyDisconnected() {
   FOR_EACH_OBSERVER(
       Observer, observers_, OnDeviceCloudPolicyManagerDisconnected());
 }
 
+void DeviceCloudPolicyManagerChromeOS::CreateStatusUploader() {
+  status_uploader_.reset(
+      new StatusUploader(
+          local_state_,
+          client(),
+          make_scoped_ptr(new DeviceStatusCollector(
+              local_state_,
+              chromeos::system::StatisticsProvider::GetInstance(),
+              DeviceStatusCollector::LocationUpdateRequester(),
+              DeviceStatusCollector::VolumeInfoFetcher())),
+          task_runner_));
+}
+
 }  // namespace policy