Update policy backend and testserver for the newest policy protocol

chrome/browser/policy/cloud_policy_controller.cc

 // Copyright (c) 2011 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 "base/message_loop.h"
 #include "base/rand_util.h"
@@ skipping 75 matching lines @@
   // Reschedule the refresh task if necessary.
   if (state_ == STATE_POLICY_VALID)
     SetState(STATE_POLICY_VALID);
 }
 
 void CloudPolicyController::HandlePolicyResponse(
     const em::DevicePolicyResponse& response) {
   if (state_ == STATE_TOKEN_UNAVAILABLE)
     return;
 
-  cache_->SetDevicePolicy(response);
-  SetState(STATE_POLICY_VALID);
-}
-
-void CloudPolicyController::HandleCloudPolicyResponse(
-    const em::CloudPolicyResponse& response) {
-  if (state_ == STATE_TOKEN_UNAVAILABLE)
-    return;
-
-  cache_->SetPolicy(response);
-  SetState(STATE_POLICY_VALID);
+  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.";
+    }
+    // Use the new version of the protocol
+    cache_->SetPolicy(response.response(0));
+    SetState(STATE_POLICY_VALID);
+  } else {
+    cache_->SetDevicePolicy(response);
+    SetState(STATE_POLICY_VALID);
+  }
 }
 
 void CloudPolicyController::OnError(DeviceManagementBackend::ErrorCode code) {
   if (state_ == STATE_TOKEN_UNAVAILABLE)
     return;
 
   if (code == DeviceManagementBackend::kErrorServiceDeviceNotFound ||
       code == DeviceManagementBackend::kErrorServiceManagementTokenInvalid) {
     LOG(WARNING) << "The device token was either invalid or unknown to the "
                  << "device manager, re-registering device.";
     SetState(STATE_TOKEN_UNAVAILABLE);
   } else if (code ==
              DeviceManagementBackend::kErrorServiceManagementNotSupported) {
     VLOG(1) << "The device is no longer managed, resetting device token.";
     SetState(STATE_TOKEN_UNAVAILABLE);
-  } else if (!fallback_to_old_protocol_ &&
-             code == DeviceManagementBackend::kErrorRequestInvalid) {
-    LOG(WARNING) << "Device manager doesn't understand new protocol, falling "
-                 << "back to old request.";
-    fallback_to_old_protocol_ = true;
-    SetState(STATE_TOKEN_VALID);  // Triggers SendPolicyRequest() immediately.
   } else {
-    LOG(WARNING) << "Could not provide policy from the device manager (error = "
-                 << code << "), will retry in "
-                 << (effective_policy_refresh_error_delay_ms_ / 1000)
-                 << " seconds.";
     SetState(STATE_POLICY_ERROR);
   }
 }
 
 void CloudPolicyController::OnDeviceTokenAvailable() {
   identity_strategy_->OnDeviceTokenAvailable(token_fetcher_->GetDeviceToken());
 }
 
 void CloudPolicyController::OnDeviceTokenChanged() {
   if (identity_strategy_->GetDeviceToken().empty())
@@ skipping 35 matching lines @@
     int policy_refresh_deviation_factor_percent,
     int64 policy_refresh_deviation_max_ms,
     int64 policy_refresh_error_delay_ms) {
   DCHECK(cache);
 
   cache_ = cache;
   backend_.reset(backend);
   token_fetcher_ = token_fetcher;
   identity_strategy_ = identity_strategy;
   state_ = STATE_TOKEN_UNAVAILABLE;
-  fallback_to_old_protocol_ = false;
   delayed_work_task_ = NULL;
   policy_refresh_rate_ms_ = policy_refresh_rate_ms;
   policy_refresh_deviation_factor_percent_ =
       policy_refresh_deviation_factor_percent;
   policy_refresh_deviation_max_ms_ = policy_refresh_deviation_max_ms;
   policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms;
   effective_policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms;
 
   token_fetcher_->AddObserver(this);
   identity_strategy_->AddObserver(this);
   if (!identity_strategy_->GetDeviceToken().empty())
     SetState(STATE_TOKEN_VALID);
   else
     SetState(STATE_TOKEN_UNAVAILABLE);
 }
 
 void CloudPolicyController::FetchToken() {
   std::string username;
   std::string auth_token;
   std::string device_id = identity_strategy_->GetDeviceID();
+  std::string machine_id = identity_strategy_->GetMachineID();
+  em::DeviceRegisterRequest_Type policy_type =
+      identity_strategy_->GetPolicyRegisterType();
   if (identity_strategy_->GetCredentials(&username, &auth_token) &&
       CanBeInManagedDomain(username)) {
-    token_fetcher_->FetchToken(auth_token, device_id);
+    token_fetcher_->FetchToken(auth_token, device_id, policy_type, machine_id);
   }
 }
 
 void CloudPolicyController::SendPolicyRequest() {
   DCHECK(!identity_strategy_->GetDeviceToken().empty());
-  if (!fallback_to_old_protocol_) {
-    em::CloudPolicyRequest policy_request;
-    policy_request.set_policy_scope(kChromePolicyScope);
-    backend_->ProcessCloudPolicyRequest(identity_strategy_->GetDeviceToken(),
-                                        identity_strategy_->GetDeviceID(),
-                                        policy_request, this);
-  } else {
-    em::DevicePolicyRequest policy_request;
-    policy_request.set_policy_scope(kChromePolicyScope);
-    em::DevicePolicySettingRequest* setting =
-        policy_request.add_setting_request();
-    setting->set_key(kChromeDevicePolicySettingKey);
-    setting->set_watermark("");
-    backend_->ProcessPolicyRequest(identity_strategy_->GetDeviceToken(),
-                                   identity_strategy_->GetDeviceID(),
-                                   policy_request, this);
+  em::DevicePolicyRequest policy_request;
+  em::PolicyFetchRequest* fetch_request = policy_request.add_request();
+  fetch_request->set_signature_type(em::PolicyFetchRequest::X509);
+  fetch_request->set_policy_type(identity_strategy_->GetPolicyType());
+  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());
   }
+
+  // TODO(gfeher): Remove the following block when the server is migrated.
+  // Set fields for the old protocol.
+  policy_request.set_policy_scope(kChromePolicyScope);
+  em::DevicePolicySettingRequest* setting =
+      policy_request.add_setting_request();
+  setting->set_key(kChromeDevicePolicySettingKey);
+  setting->set_watermark("");
+
+  backend_->ProcessPolicyRequest(identity_strategy_->GetDeviceToken(),
+                                 identity_strategy_->GetDeviceID(),
+                                 policy_request, this);
 }
 
 void CloudPolicyController::DoDelayedWork() {
   DCHECK(delayed_work_task_);
   delayed_work_task_ = NULL;
 
   switch (state_) {
     case STATE_TOKEN_UNAVAILABLE:
       FetchToken();
       return;
@@ skipping 56 matching lines @@
 }
 
 int64 CloudPolicyController::GetRefreshDelay() {
   int64 deviation = (policy_refresh_deviation_factor_percent_ *
                      policy_refresh_rate_ms_) / 100;
   deviation = std::min(deviation, policy_refresh_deviation_max_ms_);
   return policy_refresh_rate_ms_ - base::RandGenerator(deviation + 1);
 }
 
 }  // namespace policy