Add calls to store/retrieve user policy to SessionManagerClient.

chrome/browser/chromeos/dbus/session_manager_client.cc

 // 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.
 
 #include "chrome/browser/chromeos/dbus/session_manager_client.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/string_util.h"
 #include "dbus/bus.h"
@@ skipping 116 matching lines @@
     dbus::MessageWriter writer(&method_call);
     writer.AppendString("");  // Unique ID is deprecated
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnStopSession,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // 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 char* 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 char* method_name,

[satorux1, 2012/04/04 19:41:15]

Please use const std::string&. we rarely use const char*. Please fix other
places too.

[Mattias Nissler (ping if slow), 2012/04/05 09:29:14]

Done.

+                               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(
         reinterpret_cast<const uint8*>(policy_blob.data()), policy_blob.size());
     session_manager_proxy_->CallMethod(
         &method_call,
         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)
         << "Failed to call "
         << login_manager::kSessionManagerEmitLoginPromptReady;
   }
 
   // Called when kSessionManagerEmitLoginPromptVisible method is complete.
   void OnEmitLoginPromptVisible(dbus::Response* response) {
     LOG_IF(ERROR, !response)
@@ skipping 22 matching lines @@
         << login_manager::kSessionManagerStartSession;
   }
 
   // Called when kSessionManagerStopSession method is complete.
   void OnStopSession(dbus::Response* response) {
     LOG_IF(ERROR, !response)
         << "Failed to call "
         << login_manager::kSessionManagerStopSession;
   }
 
-  // Called when kSessionManagerRetrievePolicy method is complete.
-  void OnRetrievePolicy(RetrievePolicyCallback callback,
+  // Called when kSessionManagerRetrievePolicy or
+  // kSessionManagerRetrieveUserPolicy  method is complete.
+  void OnRetrievePolicy(const char* 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;
     }
     dbus::MessageReader reader(response);
     uint8* values = NULL;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&values, &length)) {
       LOG(ERROR) << "Invalid response: " << response->ToString();
       callback.Run("");
       return;
     }
     // static_cast does not work due to signedness.
     std::string serialized_proto(reinterpret_cast<char*>(values), length);
     callback.Run(serialized_proto);
   }
 
-  // Called when kSessionManagerStorePolicy method is complete.
-  void OnStorePolicy(StorePolicyCallback callback, dbus::Response* response) {
+  // Called when kSessionManagerStorePolicy or kSessionManagerStoreUserPolicy
+  // method is complete.
+  void OnStorePolicy(const char* method_name,
+                     StorePolicyCallback callback,
+                     dbus::Response* response) {
+    bool success = false;
     if (!response) {
-      LOG(ERROR) << "Failed to call "
-                 << login_manager::kSessionManagerStorePolicy;
-      return;
-    }
-    dbus::MessageReader reader(response);
-    bool success = false;
-    if (!reader.PopBool(&success)) {
-      LOG(ERROR) << "Invalid response: " << response->ToString();
-      return;
+      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);
   }
 
   // Called when the owner key set signal is received.
   void OwnerKeySetReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     std::string result_string;
     if (!reader.PopString(&result_string)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
@@ skipping 34 matching lines @@
 class SessionManagerClientStubImpl : public SessionManagerClient {
   // SessionManagerClient overrides.
   virtual void AddObserver(Observer* observer) OVERRIDE {}
   virtual void RemoveObserver(Observer* observer) OVERRIDE {}
   virtual void EmitLoginPromptReady() OVERRIDE {}
   virtual void EmitLoginPromptVisible() OVERRIDE {}
   virtual void RestartJob(int pid, const std::string& command_line) OVERRIDE {}
   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 StorePolicy(const std::string& policy_blob,
-                           StorePolicyCallback callback) OVERRIDE {
+  virtual void RetrieveUserPolicy(RetrievePolicyCallback callback) OVERRIDE {
+    callback.Run("");
+  }
+  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() {
 }
 
 SessionManagerClient::~SessionManagerClient() {
 }
 
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos