Refactored device status uploading out of policy fetch infrastructure.

components/policy/core/common/cloud/cloud_policy_client.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 "components/policy/core/common/cloud/cloud_policy_client.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 27 matching lines @@
          type == GetChromeUserPolicyType();
 }
 
 }  // namespace
 
 CloudPolicyClient::Observer::~Observer() {}
 
 void CloudPolicyClient::Observer::OnRobotAuthCodesFetched(
     CloudPolicyClient* client) {}
 
-CloudPolicyClient::StatusProvider::~StatusProvider() {}
-
 CloudPolicyClient::CloudPolicyClient(
     const std::string& machine_id,
     const std::string& machine_model,
     const std::string& verification_key_hash,
     UserAffiliation user_affiliation,
     DeviceManagementService* service,
     scoped_refptr<net::URLRequestContextGetter> request_context)
     : machine_id_(machine_id),
       machine_model_(machine_model),
       verification_key_hash_(verification_key_hash),
@@ skipping 119 matching lines @@
             last_policy_timestamp_ - base::Time::UnixEpoch());
         fetch_request->set_timestamp(timestamp.InMilliseconds());
       }
       if (!invalidation_payload_.empty()) {
         fetch_request->set_invalidation_version(invalidation_version_);
         fetch_request->set_invalidation_payload(invalidation_payload_);
       }
     }
   }
 
-  // Add status data.
-  if (status_provider_) {
-    if (!status_provider_->GetDeviceStatus(
-            request->mutable_device_status_report_request())) {
-      request->clear_device_status_report_request();
-    }
-    if (!status_provider_->GetSessionStatus(
-            request->mutable_session_status_report_request())) {
-      request->clear_session_status_report_request();
-    }
-  }
-
   // Add device state keys.
   if (!state_keys_to_upload_.empty()) {
     em::DeviceStateKeyUpdateRequest* key_update_request =
         request->mutable_device_state_key_update_request();
     for (std::vector<std::string>::const_iterator key(
              state_keys_to_upload_.begin());
          key != state_keys_to_upload_.end();
          ++key) {
       key_update_request->add_server_backed_state_key(*key);
     }
@@ skipping 58 matching lines @@
   request->mutable_cert_upload_request()->set_device_certificate(
       certificate_data);
 
   DeviceManagementRequestJob::Callback job_callback = base::Bind(
       &CloudPolicyClient::OnCertificateUploadCompleted,
       base::Unretained(this),
       callback);
   request_job_->Start(job_callback);
 }
 
+void CloudPolicyClient::UploadDeviceStatus(
+    const em::DeviceStatusReportRequest* device_status,
+    const em::SessionStatusReportRequest* session_status,
+    const CloudPolicyClient::StatusCallback& callback) {
+  CHECK(is_registered());
+  // Should pass in at least one type of status.
+  DCHECK(device_status || session_status);
+  request_job_.reset(
+      service_->CreateJob(DeviceManagementRequestJob::TYPE_UPLOAD_STATUS,
+                          GetRequestContext()));
+  request_job_->SetDMToken(dm_token_);
+  request_job_->SetClientID(client_id_);
+
+  em::DeviceManagementRequest* request = request_job_->GetRequest();
+  if (device_status)
+    *request->mutable_device_status_report_request() = *device_status;
+  if (session_status)
+    *request->mutable_session_status_report_request() = *session_status;
+
+  DeviceManagementRequestJob::Callback job_callback = base::Bind(
+      &CloudPolicyClient::OnStatusUploadCompleted,
+      base::Unretained(this),
+      callback);
+
+  // TODO(atwilson): Change CloudPolicyClient to support multiple requests in
+  // parallel, so status upload requests don't get cancelled by things like
+  // policy fetches (http://crbug.com/452563).
+  request_job_->Start(job_callback);
+}
+
 void CloudPolicyClient::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void CloudPolicyClient::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void CloudPolicyClient::SetStatusProvider(scoped_ptr<StatusProvider> provider) {
-  status_provider_ = provider.Pass();
-}
-
-bool CloudPolicyClient::HasStatusProviderForTest() {
-  return status_provider_;
-}
-
 void CloudPolicyClient::AddPolicyTypeToFetch(
     const std::string& policy_type,
     const std::string& settings_entity_id) {
   types_to_fetch_.insert(std::make_pair(policy_type, settings_entity_id));
 }
 
 void CloudPolicyClient::RemovePolicyTypeToFetch(
     const std::string& policy_type,
     const std::string& settings_entity_id) {
   types_to_fetch_.erase(std::make_pair(policy_type, settings_entity_id));
@@ skipping 111 matching lines @@
       if (policy_data.has_settings_entity_id())
         entity_id = policy_data.settings_entity_id();
       std::pair<std::string, std::string> key(type, entity_id);
       if (ContainsKey(responses_, key)) {
         LOG(WARNING) << "Duplicate PolicyFetchResponse for type: "
             << type << ", entity: " << entity_id << ", ignoring";
         continue;
       }
       responses_[key] = new em::PolicyFetchResponse(response);
     }
-    if (status_provider_)
-      status_provider_->OnSubmittedSuccessfully();
     state_keys_to_upload_.clear();
     NotifyPolicyFetched();
   } else {
     NotifyClientError();
   }
 }
 
 void CloudPolicyClient::OnUnregisterCompleted(
     DeviceManagementStatus status,
     int net_error,
@@ skipping 25 matching lines @@
 
   status_ = status;
   if (status != DM_STATUS_SUCCESS) {
     NotifyClientError();
     callback.Run(false);
     return;
   }
   callback.Run(true);
 }
 
+void CloudPolicyClient::OnStatusUploadCompleted(
+    const CloudPolicyClient::StatusCallback& callback,
+    DeviceManagementStatus status,
+    int net_error,
+    const enterprise_management::DeviceManagementResponse& response) {
+  status_ = status;
+  if (status != DM_STATUS_SUCCESS)
+    NotifyClientError();
+
+  callback.Run(status == DM_STATUS_SUCCESS);
+}
+
 void CloudPolicyClient::NotifyPolicyFetched() {
   FOR_EACH_OBSERVER(Observer, observers_, OnPolicyFetched(this));
 }
 
 void CloudPolicyClient::NotifyRegistrationStateChanged() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRegistrationStateChanged(this));
 }
 
 void CloudPolicyClient::NotifyRobotAuthCodesFetched() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRobotAuthCodesFetched(this));
 }
 
 void CloudPolicyClient::NotifyClientError() {
   FOR_EACH_OBSERVER(Observer, observers_, OnClientError(this));
 }
 
 }  // namespace policy