Update policy backend and testserver for the newest policy protocol

chrome/browser/policy/user_policy_identity_strategy.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/user_policy_identity_strategy.h"
 
 #include "base/file_util.h"
 #include "chrome/browser/browser_signin.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/net/gaia/token_service.h"
+#include "chrome/browser/policy/proto/device_management_backend.pb.h"
+#include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/guid.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_details.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_source.h"
 
 namespace policy {
 
@@ skipping 11 matching lines @@
   void Store(const std::string& token, const std::string& device_id);
 
  private:
   void LoadOnFileThread();
   void NotifyOnUIThread(const std::string& token,
                         const std::string& device_id);
   void StoreOnFileThread(const std::string& token,
                          const std::string& device_id);
 
   const base::WeakPtr<UserPolicyIdentityStrategy> identity_strategy_;
-  const FilePath& cache_file_;
+  const FilePath cache_file_;
 
   DISALLOW_COPY_AND_ASSIGN(TokenCache);
 };
 
 UserPolicyIdentityStrategy::TokenCache::TokenCache(
     const base::WeakPtr<UserPolicyIdentityStrategy>& identity_strategy,
     const FilePath& cache_file)
     : identity_strategy_(identity_strategy),
-      cache_file_(cache_file) {}
+      cache_file_(cache_file) {
+}
 
 void UserPolicyIdentityStrategy::TokenCache::Load() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           this, &UserPolicyIdentityStrategy::TokenCache::LoadOnFileThread));
 }
 
 void UserPolicyIdentityStrategy::TokenCache::Store(
@@ skipping 87 matching lines @@
 UserPolicyIdentityStrategy::~UserPolicyIdentityStrategy() {}
 
 std::string UserPolicyIdentityStrategy::GetDeviceToken() {
   return device_token_;
 }
 
 std::string UserPolicyIdentityStrategy::GetDeviceID() {
   return device_id_;
 }
 
+std::string UserPolicyIdentityStrategy::GetMachineID() {
+  return device_id_;
+}
+
+em::DeviceRegisterRequest_Type
+UserPolicyIdentityStrategy::GetPolicyRegisterType() {
+  return em::DeviceRegisterRequest::USER;
+}
+
+std::string UserPolicyIdentityStrategy::GetPolicyType() {
+  return kChromeUserPolicyType;
+}
+
+
 bool UserPolicyIdentityStrategy::GetCredentials(std::string* username,
                                                 std::string* auth_token) {
   *username = GetCurrentUser();
   *auth_token = profile_->GetTokenService()->GetTokenForService(
       GaiaConstants::kDeviceManagementService);
 
   return !username->empty() && !auth_token->empty() && !device_id_.empty();
 }
 
 void UserPolicyIdentityStrategy::OnDeviceTokenAvailable(
@@ skipping 54 matching lines @@
   } else if (type == NotificationType::GOOGLE_SIGNIN_SUCCESSFUL) {
     if (profile_ == Source<Profile>(source).ptr())
       CheckAndTriggerFetch();
 #endif
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace policy