Updated SessionManagerClient to use the multi-profile user policy calls.

chrome/browser/chromeos/policy/device_local_account_browsertest.cc

 // Copyright (c) 2013 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 <map>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 119 matching lines @@
   virtual void StartDeviceWipe() OVERRIDE {}
   virtual void RequestLockScreen() OVERRIDE {}
   virtual void NotifyLockScreenShown() OVERRIDE {}
   virtual void RequestUnlockScreen() OVERRIDE {}
   virtual void NotifyLockScreenDismissed() OVERRIDE {}
   virtual void RetrieveDevicePolicy(
       const RetrievePolicyCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(FROM_HERE,
                                      base::Bind(callback, device_policy_));
   }
-  virtual void RetrieveUserPolicy(
+  virtual void RetrievePolicyForUser(
+      const std::string& username,
       const RetrievePolicyCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(callback, user_policy_));
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, user_policies_[username]));
   }
   virtual void RetrieveDeviceLocalAccountPolicy(
       const std::string& account_id,
       const RetrievePolicyCallback& callback) OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, device_local_account_policy_[account_id]));
   }
   virtual void StoreDevicePolicy(const std::string& policy_blob,
                                  const StorePolicyCallback& callback) OVERRIDE {
     device_policy_ = policy_blob;
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true));
   }
-  virtual void StoreUserPolicy(const std::string& policy_blob,
-                               const StorePolicyCallback& callback) OVERRIDE {
-    user_policy_ = policy_blob;
+  virtual void StorePolicyForUser(
+      const std::string& username,
+      const std::string& policy_blob,
+      const std::string& policy_key,
+      const StorePolicyCallback& callback) OVERRIDE {
+    user_policies_[username] = policy_blob;
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true));
   }
   virtual void StoreDeviceLocalAccountPolicy(
       const std::string& account_id,
       const std::string& policy_blob,
       const StorePolicyCallback& callback) OVERRIDE {
     device_local_account_policy_[account_id] = policy_blob;
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true));
   }
 
   const std::string& device_policy() const {
     return device_policy_;
   }
   void set_device_policy(const std::string& policy_blob) {
     device_policy_ = policy_blob;
   }
 
-  const std::string& user_policy() const {
-    return user_policy_;
+  const std::string& user_policy(const std::string& username) const {
+    std::map<std::string, std::string>::const_iterator it =
+        user_policies_.find(username);
+    return it == user_policies_.end() ? EmptyString() : it->second;
   }
-  void set_user_policy(const std::string& policy_blob) {
-    user_policy_ = policy_blob;
+  void set_user_policy(const std::string& username,
+                       const std::string& policy_blob) {
+    user_policies_[username] = policy_blob;
   }
 
   const std::string& device_local_account_policy(
       const std::string& account_id) const {
     std::map<std::string, std::string>::const_iterator entry =
         device_local_account_policy_.find(account_id);
     return entry != device_local_account_policy_.end() ? entry->second
                                                        : EmptyString();
   }
   void set_device_local_account_policy(const std::string& account_id,
                                        const std::string& policy_blob) {
     device_local_account_policy_[account_id] = policy_blob;
   }
 
  private:
   std::string device_policy_;
-  std::string user_policy_;
+  std::map<std::string, std::string> user_policies_;
   std::map<std::string, std::string> device_local_account_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeSessionManagerClient);
 };
 
 class FakeCryptohomeClient : public chromeos::CryptohomeClient {
  public:
   using chromeos::CryptohomeClient::AsyncMethodCallback;
   using chromeos::CryptohomeClient::AsyncCallStatusHandler;
   using chromeos::CryptohomeClient::AsyncCallStatusWithDataHandler;
@@ skipping 443 matching lines @@
 
   TabStripModel* tabs = browser->tab_strip_model();
   ASSERT_TRUE(tabs);
   int expected_tab_count = static_cast<int>(arraysize(kStartupURLs));
   EXPECT_EQ(expected_tab_count, tabs->count());
   for (int i = 0; i < expected_tab_count && i < tabs->count(); ++i)
     EXPECT_EQ(GURL(kStartupURLs[i]), tabs->GetWebContentsAt(i)->GetURL());
 }
 
 }  // namespace policy