Add calls to store/retrieve user policy to SessionManagerClient.

BUG=chromium:87383
TEST=None

Review URL: https://chromiumcodereview.appspot.com/9961014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@130907 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 93 insertions, 42 deletions

diff --git a/chrome/browser/chromeos/dbus/mock_session_manager_client.h b/chrome/browser/chromeos/dbus/mock_session_manager_client.h
index 5d0643e..7c6b41b 100644
--- a/chrome/browser/chromeos/dbus/mock_session_manager_client.h
+++ b/chrome/browser/chromeos/dbus/mock_session_manager_client.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -25,8 +25,12 @@ class MockSessionManagerClient : public SessionManagerClient {
   MOCK_METHOD2(RestartJob, void(int, const std::string&));
   MOCK_METHOD1(StartSession, void(const std::string&));
   MOCK_METHOD0(StopSession, void(void));
-  MOCK_METHOD1(RetrievePolicy, void(RetrievePolicyCallback));
-  MOCK_METHOD2(StorePolicy, void(const std::string&, StorePolicyCallback));
+  MOCK_METHOD1(RetrieveDevicePolicy, void(RetrievePolicyCallback));
+  MOCK_METHOD1(RetrieveUserPolicy, void(RetrievePolicyCallback));
+  MOCK_METHOD2(StoreDevicePolicy, void(const std::string&,
+                                       StorePolicyCallback));
+  MOCK_METHOD2(StoreUserPolicy, void(const std::string&,
+                                     StorePolicyCallback));
 };
 
 }  // namespace chromeos
diff --git a/chrome/browser/chromeos/dbus/session_manager_client.cc b/chrome/browser/chromeos/dbus/session_manager_client.cc
index 2509102..e106a0a 100644
--- a/chrome/browser/chromeos/dbus/session_manager_client.cc
+++ b/chrome/browser/chromeos/dbus/session_manager_client.cc
@@ -134,22 +134,52 @@ class SessionManagerClientImpl : public SessionManagerClient {
   }
 
   // SessionManagerClient override.
-  virtual void RetrievePolicy(RetrievePolicyCallback callback) OVERRIDE {
+  virtual void RetrieveDevicePolicy(RetrievePolicyCallback callback) OVERRIDE {
+    CallRetrievePolicy(login_manager::kSessionManagerRetrievePolicy,
+                       callback);
+  }
+
+  // SessionManagerClient override.
+  virtual void RetrieveUserPolicy(RetrievePolicyCallback callback) OVERRIDE {
+    CallRetrievePolicy(login_manager::kSessionManagerRetrieveUserPolicy,
+                       callback);
+  }
+
+  // SessionManagerClient override.
+  virtual void StoreDevicePolicy(const std::string& policy_blob,
+                                 StorePolicyCallback callback) OVERRIDE {
+    CallStorePolicy(login_manager::kSessionManagerStorePolicy,
+                    policy_blob, callback);
+  }
+
+  // SessionManagerClient override.
+  virtual void StoreUserPolicy(const std::string& policy_blob,
+                               StorePolicyCallback callback) OVERRIDE {
+    CallStorePolicy(login_manager::kSessionManagerStoreUserPolicy,
+                    policy_blob, callback);
+  }
+
+ private:
+  // Helper for Retrieve{User,Device}Policy.
+  virtual void CallRetrievePolicy(const std::string& method_name,
+                                  RetrievePolicyCallback callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
-                                 login_manager::kSessionManagerRetrievePolicy);
+                                 method_name);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnRetrievePolicy,
                    weak_ptr_factory_.GetWeakPtr(),
+                   method_name,
                    callback));
   }
 
-  // SessionManagerClient override.
-  virtual void StorePolicy(const std::string& policy_blob,
-                           StorePolicyCallback callback) OVERRIDE {
+  // Helper for Store{User,Device}Policy.
+  virtual void CallStorePolicy(const std::string& method_name,
+                               const std::string& policy_blob,
+                               StorePolicyCallback callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
-                                 login_manager::kSessionManagerStorePolicy);
+                                 method_name);
     dbus::MessageWriter writer(&method_call);
     // static_cast does not work due to signedness.
     writer.AppendArrayOfBytes(
@@ -159,10 +189,10 @@ class SessionManagerClientImpl : public SessionManagerClient {
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnStorePolicy,
                    weak_ptr_factory_.GetWeakPtr(),
+                   method_name,
                    callback));
   }
 
- private:
   // Called when kSessionManagerEmitLoginPromptReady method is complete.
   void OnEmitLoginPromptReady(dbus::Response* response) {
     LOG_IF(ERROR, !response)
@@ -205,12 +235,13 @@ class SessionManagerClientImpl : public SessionManagerClient {
         << login_manager::kSessionManagerStopSession;
   }
 
-  // Called when kSessionManagerRetrievePolicy method is complete.
-  void OnRetrievePolicy(RetrievePolicyCallback callback,
+  // Called when kSessionManagerRetrievePolicy or
+  // kSessionManagerRetrieveUserPolicy  method is complete.
+  void OnRetrievePolicy(const std::string& method_name,
+                        RetrievePolicyCallback callback,
                         dbus::Response* response) {
     if (!response) {
-      LOG(ERROR) << "Failed to call "
-                 << login_manager::kSessionManagerRetrievePolicy;
+      LOG(ERROR) << "Failed to call " << method_name;
       callback.Run("");
       return;
     }
@@ -227,18 +258,18 @@ class SessionManagerClientImpl : public SessionManagerClient {
     callback.Run(serialized_proto);
   }
 
-  // Called when kSessionManagerStorePolicy method is complete.
-  void OnStorePolicy(StorePolicyCallback callback, dbus::Response* response) {
-    if (!response) {
-      LOG(ERROR) << "Failed to call "
-                 << login_manager::kSessionManagerStorePolicy;
-      return;
-    }
-    dbus::MessageReader reader(response);
+  // Called when kSessionManagerStorePolicy or kSessionManagerStoreUserPolicy
+  // method is complete.
+  void OnStorePolicy(const std::string& method_name,
+                     StorePolicyCallback callback,
+                     dbus::Response* response) {
     bool success = false;
-    if (!reader.PopBool(&success)) {
-      LOG(ERROR) << "Invalid response: " << response->ToString();
-      return;
+    if (!response) {
+      LOG(ERROR) << "Failed to call " << method_name;
+    } else {
+      dbus::MessageReader reader(response);
+      if (!reader.PopBool(&success))
+        LOG(ERROR) << "Invalid response: " << response->ToString();
     }
     callback.Run(success);
   }
@@ -293,14 +324,20 @@ class SessionManagerClientStubImpl : public SessionManagerClient {
   virtual void RestartEntd() OVERRIDE {}
   virtual void StartSession(const std::string& user_email) OVERRIDE {}
   virtual void StopSession() OVERRIDE {}
-  virtual void RetrievePolicy(RetrievePolicyCallback callback) OVERRIDE {
+  virtual void RetrieveDevicePolicy(RetrievePolicyCallback callback) OVERRIDE {
+    callback.Run("");
+  }
+  virtual void RetrieveUserPolicy(RetrievePolicyCallback callback) OVERRIDE {
     callback.Run("");
   }
-  virtual void StorePolicy(const std::string& policy_blob,
-                           StorePolicyCallback callback) OVERRIDE {
+  virtual void StoreDevicePolicy(const std::string& policy_blob,
+                                 StorePolicyCallback callback) OVERRIDE {
+    callback.Run(true);
+  }
+  virtual void StoreUserPolicy(const std::string& policy_blob,
+                               StorePolicyCallback callback) OVERRIDE {
     callback.Run(true);
   }
-
 };
 
 SessionManagerClient::SessionManagerClient() {
diff --git a/chrome/browser/chromeos/dbus/session_manager_client.h b/chrome/browser/chromeos/dbus/session_manager_client.h
index 1041b58..a787fad 100644
--- a/chrome/browser/chromeos/dbus/session_manager_client.h
+++ b/chrome/browser/chromeos/dbus/session_manager_client.h
@@ -52,24 +52,34 @@ class SessionManagerClient {
   // Stops the current session.
   virtual void StopSession() = 0;
 
-  // Used for RetrievePolicy. Takes a serialized protocol buffer as string.
+  // Used for RetrieveDevicePolicy and RetrieveUserPolicy. Takes a serialized
+  // protocol buffer as string.  Upon success, we will pass a protobuf to the
+  // callback.  On failure, we will pass "".
   typedef base::Callback<void(const std::string&)> RetrievePolicyCallback;
 
-  // Fetches the policy blob stored by the session manager.  Upon
-  // completion of the retrieve attempt, we will call the provided
-  // callback.  Policies are serialized protocol buffers.  Upon success,
-  // we will pass a protobuf to the callback.  On failure, we will pass
-  // "".
-  virtual void RetrievePolicy(RetrievePolicyCallback callback) = 0;
+  // Fetches the device policy blob stored by the session manager.  Upon
+  // completion of the retrieve attempt, we will call the provided callback.
+  virtual void RetrieveDevicePolicy(RetrievePolicyCallback callback) = 0;
 
-  // Used for StorePolicyCallback. Takes a boolean indicating whether the
-  // operation was successful or not.
+  // Fetches the user policy blob stored by the session manager for the
+  // currently signed-in user.  Upon completion of the retrieve attempt, we will
+  // call the provided callback.
+  virtual void RetrieveUserPolicy(RetrievePolicyCallback callback) = 0;
+
+  // Used for StoreDevicePolicy and StoreUserPolicy. Takes a boolean indicating
+  // whether the operation was successful or not.
   typedef base::Callback<void(bool)> StorePolicyCallback;
 
-  // Attempts to store |policy_blob| asynchronously.  Upon completion of
-  // the store attempt, we will call callback.
-  virtual void StorePolicy(const std::string& policy_bob,
-                           StorePolicyCallback callback) = 0;
+  // Attempts to asynchronously store |policy_blob| as device policy.  Upon
+  // completion of the store attempt, we will call callback.
+  virtual void StoreDevicePolicy(const std::string& policy_blob,
+                                 StorePolicyCallback callback) = 0;
+
+  // Attempts to asynchronously store |policy_blob| as user policy for the
+  // currently signed-in user.  Upon completion of the store attempt, we will
+  // call callback.
+  virtual void StoreUserPolicy(const std::string& policy_blob,
+                               StorePolicyCallback callback) = 0;
 
   // Creates the instance.
   static SessionManagerClient* Create(DBusClientImplementationType type,