Update policy backend and testserver for the newest policy protocol

chrome/browser/policy/device_policy_identity_strategy.cc

Index: chrome/browser/policy/device_policy_identity_strategy.cc
diff --git a/chrome/browser/policy/device_policy_identity_strategy.cc b/chrome/browser/policy/device_policy_identity_strategy.cc
index 0f199450979ed41f9364aa4a4d5e92c9e96628b3..b27ff4a2238c482996b3f04e5611195dea3f5a06 100644
--- a/chrome/browser/policy/device_policy_identity_strategy.cc
+++ b/chrome/browser/policy/device_policy_identity_strategy.cc
@@ -8,16 +8,86 @@
 #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)

[Mattias Nissler (ping if slow), 2011/03/01 10:25:49]

hm, it's not really a callback, so why not just name it strategy?

[gfeher, 2011/03/01 15:53:00]

Done.

+      : 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();

[Mattias Nissler (ping if slow), 2011/03/01 10:25:49]

You can make use of base::WeakPtr instead, that handles the whole
pointer-reset-on-destruction business for you.

[gfeher, 2011/03/01 15:53:00]

Done.

+
+ 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());
@@ -35,14 +105,49 @@ DevicePolicyIdentityStrategy::DevicePolicyIdentityStrategy()
   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.
@@ -55,7 +160,7 @@ bool DevicePolicyIdentityStrategy::GetCredentials(std::string* username,
 
   // 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.
@@ -86,8 +191,10 @@ void DevicePolicyIdentityStrategy::OnDeviceTokenAvailable(
 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,
@@ -100,10 +207,10 @@ void DevicePolicyIdentityStrategy::Observe(NotificationType type,
       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 {