Update policy backend and testserver for the newest policy protocol

chrome/browser/policy/device_token_fetcher.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/device_token_fetcher.h"
 
 #include <algorithm>
 
 #include "base/message_loop.h"
 #include "chrome/browser/policy/cloud_policy_cache.h"
 #include "chrome/browser/policy/device_management_service.h"
+#include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 
 namespace {
 
 // Retry after 3 seconds (with exponential backoff) after token fetch errors.
 const int64 kTokenFetchErrorDelayMilliseconds = 3 * 1000;
 // For unmanaged devices, check once per day whether they're still unmanaged.
 const int64 kUnmanagedDeviceRefreshRateMilliseconds = 24 * 60 * 60 * 1000;
 
 }  // namespace
@@ skipping 21 matching lines @@
   Initialize(service,
              cache,
              token_fetch_error_delay_ms,
              unmanaged_device_refresh_rate_ms);
 }
 
 DeviceTokenFetcher::~DeviceTokenFetcher() {
   CancelRetryTask();
 }
 
-void DeviceTokenFetcher::FetchToken(const std::string& auth_token,
-                                    const std::string& device_id) {
+void DeviceTokenFetcher::FetchToken(
+    const std::string& auth_token,
+    const std::string& device_id,
+    em::DeviceRegisterRequest_Type policy_type,
+    const std::string& machine_id) {
   SetState(STATE_INACTIVE);
   auth_token_ = auth_token;
   device_id_ = device_id;
+  policy_type_ = policy_type;
+  machine_id_ = machine_id;
   FetchTokenInternal();
 }
 
 void DeviceTokenFetcher::FetchTokenInternal() {
   DCHECK(state_ != STATE_TOKEN_AVAILABLE);
   DCHECK(!auth_token_.empty() && !device_id_.empty());
   // Construct a new backend, which will discard any previous requests.
   backend_.reset(service_->CreateBackend());
   em::DeviceRegisterRequest request;
+  request.set_type(policy_type_);
+  if (!machine_id_.empty())
+    request.set_machine_id(machine_id_);
+  request.set_machine_model(kRegisterRequestMachineModel);
   backend_->ProcessRegisterRequest(auth_token_, device_id_, request, this);
 }
 
 const std::string& DeviceTokenFetcher::GetDeviceToken() {
   return device_token_;
 }
 
 void DeviceTokenFetcher::AddObserver(DeviceTokenFetcher::Observer* observer) {
   observer_list_.AddObserver(observer);
 }
@@ skipping 92 matching lines @@
 }
 
 void DeviceTokenFetcher::CancelRetryTask() {
   if (retry_task_) {
     retry_task_->Cancel();
     retry_task_ = NULL;
   }
 }
 
 }  // namespace policy