Update policy backend and testserver for the newest policy protocol

chrome/browser/policy/device_token_fetcher.h

 // 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.
 
 #ifndef CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_
 #define CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_
 #pragma once
 
 #include <string>
 
 #include "base/observer_list.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "chrome/browser/policy/device_management_backend.h"
+#include "chrome/browser/policy/proto/device_management_backend.pb.h"
 
 namespace policy {
 
 class CloudPolicyCache;
 class DeviceManagementService;
 
 namespace em = enterprise_management;
 
 // Fetches the device token that can be used for policy requests with the device
 // management server, either from disk if it already has been successfully
@@ skipping 16 matching lines @@
   // Version for tests that allows to set timing paramters.
   DeviceTokenFetcher(DeviceManagementService* service,
                      CloudPolicyCache* cache,
                      int64 token_fetch_error_delay_ms,
                      int64 unmanaged_device_refresh_rate_ms);
   virtual ~DeviceTokenFetcher();
 
   // Starts fetching a token.
   // Declared virtual so it can be overridden by mocks.
   virtual void FetchToken(const std::string& auth_token,
-                          const std::string& device_id);
+                          const std::string& device_id,
+                          em::DeviceRegisterRequest_Type policy_type,
+                          const std::string& machine_id);
 
   // Returns the device management token or the empty string if not available.
   // Declared virtual so it can be overridden by mocks.
   virtual const std::string& GetDeviceToken();
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // DeviceManagementBackend::DeviceRegisterResponseDelegate method overrides:
   virtual void HandleRegisterResponse(
@@ skipping 56 matching lines @@
   // State the fetcher is currently in.
   FetcherState state_;
 
   // Current device token.
   std::string device_token_;
 
   // Contains the AuthToken for the device management server.
   std::string auth_token_;
   // Device identifier to send to the server.
   std::string device_id_;
+  // Contains policy type to send to the server.
+  em::DeviceRegisterRequest_Type policy_type_;
+  // Contains physical machine id to send to the server.
+  std::string machine_id_;
 
   // Task that has been scheduled to retry fetching a token.
   CancelableTask* retry_task_;
 
   ScopedRunnableMethodFactory<DeviceTokenFetcher> method_factory_;
 
   ObserverList<Observer, true> observer_list_;
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_DEVICE_TOKEN_FETCHER_H_