Convert DeviceTokenFetcher and CloudPolicyController response callbacks.

chrome/browser/policy/cloud_policy_controller.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/policy/cloud_policy_controller.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "chrome/browser/policy/cloud_policy_cache_base.h"
+#include "chrome/browser/policy/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud_policy_subsystem.h"
 #include "chrome/browser/policy/delayed_work_scheduler.h"
 #include "chrome/browser/policy/device_management_service.h"
 #include "chrome/browser/policy/device_token_fetcher.h"
 #include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/policy_notifier.h"
-#include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/common/guid.h"
 
 namespace {
 
 // The maximum ratio in percent of the policy refresh rate we use for adjusting
 // the policy refresh time instant. The rationale is to avoid load spikes from
 // many devices that were set up in sync for some reason.
 const int kPolicyRefreshDeviationFactorPercent = 10;
 // Maximum deviation we are willing to accept.
 const int64 kPolicyRefreshDeviationMaxInMilliseconds = 30 * 60 * 1000;
@@ skipping 82 matching lines @@
       // The controller doesn't have enough material to start a token fetch,
       // but observers of the cache are waiting for the refresh.
       SetState(STATE_TOKEN_UNMANAGED);
     }
   } else {
     // The token is valid, so the next step is to fetch policy.
     SetState(STATE_TOKEN_VALID);
   }
 }
 
-void CloudPolicyController::HandlePolicyResponse(
-    const em::DevicePolicyResponse& response) {
-  if (response.response_size() > 0) {
-    if (response.response_size() > 1) {
-      LOG(WARNING) << "More than one policy in the response of the device "
-                   << "management server, discarding.";
+void CloudPolicyController::OnPolicyFetchCompleted(
+    DeviceManagementStatus status,
+    const em::DeviceManagementResponse& response) {
+  if (status == DM_STATUS_SUCCESS && !response.has_policy_response()) {
+    // Handled below.
+    status = DM_STATUS_RESPONSE_DECODING_ERROR;
+  }
+
+  switch (status) {
+    case DM_STATUS_SUCCESS: {
+      const em::DevicePolicyResponse& policy_response(
+          response.policy_response());
+      if (policy_response.response_size() > 0) {
+        if (policy_response.response_size() > 1) {
+          LOG(WARNING) << "More than one policy in the response of the device "
+                       << "management server, discarding.";
+        }
+        const em::PolicyFetchResponse& fetch_response(
+            policy_response.response(0));
+        if (!fetch_response.has_error_code() ||
+            fetch_response.error_code() == dm_protocol::POLICY_FETCH_SUCCESS) {
+          cache_->SetPolicy(fetch_response);
+          SetState(STATE_POLICY_VALID);
+        } else {
+          UMA_HISTOGRAM_ENUMERATION(kMetricPolicy,
+                                    kMetricPolicyFetchBadResponse,
+                                    kMetricPolicySize);
+          SetState(STATE_POLICY_UNAVAILABLE);
+        }
+      } else {
+        UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchBadResponse,
+                                  kMetricPolicySize);
+        SetState(STATE_POLICY_UNAVAILABLE);
+      }
+      return;
     }
-    if (!response.response(0).has_error_code() ||
-        response.response(0).error_code() ==
-            DeviceManagementBackend::kPolicyFetchSuccess) {
-      cache_->SetPolicy(response.response(0));
-      SetState(STATE_POLICY_VALID);
-    } else {
-      UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchBadResponse,
-                                kMetricPolicySize);
-      SetState(STATE_POLICY_UNAVAILABLE);
-    }
-  } else {
-    UMA_HISTOGRAM_ENUMERATION(kMetricPolicy, kMetricPolicyFetchBadResponse,
-                              kMetricPolicySize);
-    SetState(STATE_POLICY_UNAVAILABLE);
-  }
-}
-
-void CloudPolicyController::OnError(DeviceManagementBackend::ErrorCode code) {
-  switch (code) {
-    case DeviceManagementBackend::kErrorServiceDeviceNotFound:
-    case DeviceManagementBackend::kErrorServiceDeviceIdConflict:
-    case DeviceManagementBackend::kErrorServiceManagementTokenInvalid: {
+    case DM_STATUS_SERVICE_DEVICE_NOT_FOUND:
+    case DM_STATUS_SERVICE_DEVICE_ID_CONFLICT:
+    case DM_STATUS_SERVICE_MANAGEMENT_TOKEN_INVALID:
       LOG(WARNING) << "The device token was either invalid or unknown to the "
                    << "device manager, re-registering device.";
       // Will retry fetching a token but gracefully backing off.
       SetState(STATE_TOKEN_ERROR);
       return;
-    }
-    case DeviceManagementBackend::kErrorServiceInvalidSerialNumber: {
+    case DM_STATUS_SERVICE_INVALID_SERIAL_NUMBER:
       VLOG(1) << "The device is no longer enlisted for the domain.";
       token_fetcher_->SetSerialNumberInvalidState();
       SetState(STATE_TOKEN_ERROR);
       return;
-    }
-    case DeviceManagementBackend::kErrorServiceManagementNotSupported: {
+    case DM_STATUS_SERVICE_MANAGEMENT_NOT_SUPPORTED:
       VLOG(1) << "The device is no longer managed.";
       token_fetcher_->SetUnmanagedState();
       SetState(STATE_TOKEN_UNMANAGED);
       return;
-    }
-    case DeviceManagementBackend::kErrorServicePolicyNotFound:
-    case DeviceManagementBackend::kErrorRequestInvalid:
-    case DeviceManagementBackend::kErrorServiceActivationPending:
-    case DeviceManagementBackend::kErrorResponseDecoding:
-    case DeviceManagementBackend::kErrorHttpStatus: {
+    case DM_STATUS_SERVICE_POLICY_NOT_FOUND:
+    case DM_STATUS_REQUEST_INVALID:
+    case DM_STATUS_SERVICE_ACTIVATION_PENDING:
+    case DM_STATUS_RESPONSE_DECODING_ERROR:
+    case DM_STATUS_HTTP_STATUS_ERROR:
       VLOG(1) << "An error in the communication with the policy server occurred"
               << ", will retry in a few hours.";
       SetState(STATE_POLICY_UNAVAILABLE);
       return;
-    }
-    case DeviceManagementBackend::kErrorRequestFailed:
-    case DeviceManagementBackend::kErrorTemporaryUnavailable: {
+    case DM_STATUS_REQUEST_FAILED:
+    case DM_STATUS_TEMPORARY_UNAVAILABLE:
       VLOG(1) << "A temporary error in the communication with the policy server"
               << " occurred.";
       // Will retry last operation but gracefully backing off.
       SetState(STATE_POLICY_ERROR);
       return;
-    }
   }
 
   NOTREACHED();
   SetState(STATE_POLICY_ERROR);
 }
 
 void CloudPolicyController::OnDeviceTokenChanged() {
   if (data_store_->device_token().empty())
     SetState(STATE_TOKEN_UNAVAILABLE);
   else
@@ skipping 71 matching lines @@
       token_fetcher_->FetchToken();
     } else {
       SetState(STATE_TOKEN_UNMANAGED);
     }
   } else {
     VLOG(1) << "Not ready to fetch DMToken yet, will try again later.";
   }
 }
 
 void CloudPolicyController::SendPolicyRequest() {
-  backend_.reset(service_->CreateBackend());
   DCHECK(!data_store_->device_token().empty());
-  em::DevicePolicyRequest policy_request;
-  em::PolicyFetchRequest* fetch_request = policy_request.add_request();
+  request_job_.reset(
+      service_->CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH));
+  request_job_->SetDMToken(data_store_->device_token());
+  request_job_->SetClientID(data_store_->device_id());
+  request_job_->SetUserAffiliation(data_store_->user_affiliation());
+
+  em::DeviceManagementRequest* request = request_job_->GetRequest();
+  em::PolicyFetchRequest* fetch_request =
+      request->mutable_policy_request()->add_request();
   em::DeviceStatusReportRequest device_status;
   fetch_request->set_signature_type(em::PolicyFetchRequest::SHA1_RSA);
   fetch_request->set_policy_type(data_store_->policy_type());
   if (cache_->machine_id_missing() && !data_store_->machine_id().empty())
     fetch_request->set_machine_id(data_store_->machine_id());
   if (!cache_->is_unmanaged() &&
       !cache_->last_policy_refresh_time().is_null()) {
     base::TimeDelta timestamp =
         cache_->last_policy_refresh_time() - base::Time::UnixEpoch();
     fetch_request->set_timestamp(timestamp.InMilliseconds());
   }
   int key_version = 0;
   if (cache_->GetPublicKeyVersion(&key_version))
     fetch_request->set_public_key_version(key_version);
 
 #if defined(OS_CHROMEOS)
-  if (data_store_->device_status_collector())
-    data_store_->device_status_collector()->GetStatus(&device_status);
+  if (data_store_->device_status_collector()) {
+    data_store_->device_status_collector()->GetStatus(
+        request->mutable_device_status_report_request());
+  }
 #endif
 
-  backend_->ProcessPolicyRequest(data_store_->device_token(),
-                                 data_store_->device_id(),
-                                 data_store_->user_affiliation(),
-                                 policy_request, &device_status, this);
+  request_job_->Start(base::Bind(&CloudPolicyController::OnPolicyFetchCompleted,
+                                 base::Unretained(this)));
 }
 
 void CloudPolicyController::DoWork() {
   switch (state_) {
     case STATE_TOKEN_UNAVAILABLE:
     case STATE_TOKEN_ERROR:
       FetchToken();
       return;
     case STATE_TOKEN_VALID:
     case STATE_POLICY_VALID:
     case STATE_POLICY_ERROR:
     case STATE_POLICY_UNAVAILABLE:
       SendPolicyRequest();
       return;
     case STATE_TOKEN_UNMANAGED:
       return;
   }
 
   NOTREACHED() << "Unhandled state" << state_;
 }
 
 void CloudPolicyController::SetState(
     CloudPolicyController::ControllerState new_state) {
   state_ = new_state;
 
-  backend_.reset();  // Stop any pending requests.
+  request_job_.reset();  // Stop any pending requests.
 
   base::Time now(base::Time::NowFromSystemTime());
   base::Time refresh_at;
   base::Time last_refresh(cache_->last_policy_refresh_time());
   if (last_refresh.is_null())
     last_refresh = now;
 
   // Determine when to take the next step.
   bool inform_notifier_done = false;
   switch (state_) {
@@ skipping 67 matching lines @@
 }
 
 int64 CloudPolicyController::GetRefreshDelay() {
   int64 deviation = (kPolicyRefreshDeviationFactorPercent *
                      policy_refresh_rate_ms_) / 100;
   deviation = std::min(deviation, kPolicyRefreshDeviationMaxInMilliseconds);
   return policy_refresh_rate_ms_ - base::RandGenerator(deviation + 1);
 }
 
 }  // namespace policy