Update policy backend and testserver for the newest policy protocol

chrome/browser/policy/device_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/device_policy_identity_strategy.h"
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/ownership_service.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/net/gaia/token_service.h"
+#include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/guid.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 
 namespace policy {
 
+// Responsible for querying device ownership on the FILE thread.
+class DevicePolicyIdentityStrategy::OwnershipChecker
+    : public base::RefCountedThreadSafe<
+          DevicePolicyIdentityStrategy::OwnershipChecker> {
+ public:
+  explicit OwnershipChecker(DevicePolicyIdentityStrategy* callback)
+      : callback_(callback) {
+  }
+
+  // Initiates a query on the file thread to check if the currently logged in
+  // user is the owner.
+  void CheckCurrentUserIsOwner();
+
+  // Cancels the query.
+  void Cancel();
+
+ private:
+  void CheckOnFileThread();
+  void CallbackOnUIThread(bool current_user_is_owner);
+
+ private:
+  friend class base::RefCountedThreadSafe<OwnershipChecker>;
+
+  ~OwnershipChecker() {}
+
+  // The object to be called back with the result.
+  DevicePolicyIdentityStrategy* callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(OwnershipChecker);
+};
+
+void DevicePolicyIdentityStrategy::OwnershipChecker::CheckCurrentUserIsOwner() {
+  if (callback_ == NULL)
+    return;
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      NewRunnableMethod(
+          this,
+          &DevicePolicyIdentityStrategy::OwnershipChecker::CheckOnFileThread));
+}
+
+void DevicePolicyIdentityStrategy::OwnershipChecker::CheckOnFileThread() {
+  bool current_user_is_owner =
+      chromeos::OwnershipService::GetSharedInstance()->CurrentUserIsOwner();
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      NewRunnableMethod(
+          this,
+          &DevicePolicyIdentityStrategy::OwnershipChecker::CallbackOnUIThread,
+          current_user_is_owner));
+}
+
+void DevicePolicyIdentityStrategy::OwnershipChecker::CallbackOnUIThread(
+    bool current_user_is_owner) {
+  if (callback_ != NULL) {
+    callback_->OnOwnershipInformationAvailable(current_user_is_owner);
+    callback_ = NULL;
+  }
+}
+
+void DevicePolicyIdentityStrategy::OwnershipChecker::Cancel() {
+  callback_ = NULL;
+}
+
 DevicePolicyIdentityStrategy::DevicePolicyIdentityStrategy()
-    : should_register_(false) {
+    : should_register_(false),
+      current_user_is_owner_(false),
+      ownership_checker_(NULL) {
   registrar_.Add(this,
                  NotificationType::TOKEN_AVAILABLE,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::LOGIN_USER_CHANGED,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::OWNERSHIP_TAKEN,
                  NotificationService::AllSources());
   registrar_.Add(this,
                  NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
                  NotificationService::AllSources());
 
   // TODO(mnissler): Figure out how to read the machine id.
   machine_id_ = "dummy-cros-machine-ID";
 }
 
+DevicePolicyIdentityStrategy::~DevicePolicyIdentityStrategy() {
+  if (ownership_checker_)
+    ownership_checker_->Cancel();
+}
+
+void DevicePolicyIdentityStrategy::OnOwnershipInformationAvailable(
+    bool current_user_is_owner) {
+  current_user_is_owner_ = current_user_is_owner;
+  CheckAndTriggerFetch();
+}
+
+void DevicePolicyIdentityStrategy::CheckOwnershipAndTriggerFetch() {
+  // Cancel any pending queries.
+  if (ownership_checker_)
+    ownership_checker_->Cancel();
+  // Set to false until we know that the current user is the owner.
+  current_user_is_owner_ = false;
+  // Issue a new query.
+  ownership_checker_ = new OwnershipChecker(this);
+  ownership_checker_->CheckCurrentUserIsOwner();
+}
+
 std::string DevicePolicyIdentityStrategy::GetDeviceToken() {
   return device_token_;
 }
 
 std::string DevicePolicyIdentityStrategy::GetDeviceID() {
+  return device_id_;
+}
+
+std::string DevicePolicyIdentityStrategy::GetMachineID() {
   return machine_id_;
 }
 
+em::DeviceRegisterRequest_Type
+DevicePolicyIdentityStrategy::GetPolicyRegisterType() {
+  return em::DeviceRegisterRequest::DEVICE;
+}
+
+std::string DevicePolicyIdentityStrategy::GetPolicyType() {
+  return kChromeDevicePolicyType;
+}
+
 bool DevicePolicyIdentityStrategy::GetCredentials(std::string* username,
                                                   std::string* auth_token) {
   // Only register if requested.
   if (!should_register_)
     return false;
 
   // Need to know the machine id.
   if (machine_id_.empty())
     return false;
 
   // Only fetch credentials (and, subsequently, token/policy) when the owner
   // is logged in.
-  if (!chromeos::OwnershipService::GetSharedInstance()->CurrentUserIsOwner())
+  if (!current_user_is_owner_)
     return false;
 
   // We need to know about the profile of the logged in user.
   Profile* profile = g_browser_process->profile_manager()->GetDefaultProfile();
   if (!profile) {
     NOTREACHED() << "Current user profile inaccessible";
     return false;
   }
 
   *username = chromeos::UserManager::Get()->logged_in_user().email();
@@ skipping 10 matching lines @@
   // Reset registration flag, so we only attempt registration once.
   should_register_ = false;
 
   device_token_ = token;
   NotifyDeviceTokenChanged();
 }
 
 void DevicePolicyIdentityStrategy::CheckAndTriggerFetch() {
   std::string username;
   std::string auth_token;
-  if (GetCredentials(&username, &auth_token))
+  if (GetCredentials(&username, &auth_token)) {
+    device_id_ = guid::GenerateGUID();
     NotifyAuthChanged();
+  }
 }
 
 void DevicePolicyIdentityStrategy::Observe(NotificationType type,
                                            const NotificationSource& source,
                                            const NotificationDetails& details) {
   if (type == NotificationType::TOKEN_AVAILABLE) {
     const TokenService::TokenAvailableDetails* token_details =
         Details<const TokenService::TokenAvailableDetails>(details).ptr();
     if (token_details->service() == GaiaConstants::kDeviceManagementService)
       CheckAndTriggerFetch();
   } else if (type == NotificationType::LOGIN_USER_CHANGED) {
     should_register_ = false;
-    CheckAndTriggerFetch();
+    CheckOwnershipAndTriggerFetch();
   } else if (type == NotificationType::OWNERSHIP_TAKEN) {
     should_register_ = true;
-    CheckAndTriggerFetch();
+    CheckOwnershipAndTriggerFetch();
   } else if (type == NotificationType::OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
     CheckAndTriggerFetch();
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace policy