Implement a policy to autologin a public account.

chrome/browser/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 25 matching lines @@
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/fake_session_manager_client.h"
 #include "chromeos/dbus/mock_dbus_thread_manager.h"
-#include "chromeos/dbus/session_manager_client.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_watcher.h"
 #include "content/public/browser/web_contents.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace em = enterprise_management;
 
 using testing::Return;
 
 namespace policy {
 
 namespace {
 
 const char kAccountId1[] = "dla1@example.com";
 const char kAccountId2[] = "dla2@example.com";
 const char kDisplayName1[] = "display name for account 1";
 const char kDisplayName2[] = "display name for account 2";
 const char* kStartupURLs[] = {
   "chrome://policy",
   "chrome://about",
 };
 
-// Observes a specific notification type and quits the message loop once a
-// condition holds.
-class NotificationWatcher : public content::NotificationObserver {
- public:
-  // Callback invoked on notifications. Should return true when the condition
-  // that the caller is waiting for is satisfied.
-  typedef base::Callback<bool(void)> ConditionTestCallback;
-
-  explicit NotificationWatcher(int notification_type,
-                               const ConditionTestCallback& callback)
-      : type_(notification_type),
-        callback_(callback) {}
-
-  void Run() {
-    if (callback_.Run())
-      return;
-
-    content::NotificationRegistrar registrar;
-    registrar.Add(this, type_, content::NotificationService::AllSources());
-    run_loop_.Run();
-  }
-
-  // content::NotificationObserver:
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE {
-    if (callback_.Run())
-      run_loop_.Quit();
-  }
-
- private:
-  int type_;
-  ConditionTestCallback callback_;
-  base::RunLoop run_loop_;
-
-  DISALLOW_COPY_AND_ASSIGN(NotificationWatcher);
-};
-
-// A fake implementation of session_manager. Accepts policy blobs to be set and
-// returns them unmodified.
-class FakeSessionManagerClient : public chromeos::SessionManagerClient {
- public:
-  FakeSessionManagerClient() {}
-  virtual ~FakeSessionManagerClient() {}
-
-  // SessionManagerClient:
-  virtual void AddObserver(Observer* observer) OVERRIDE {}
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
-  virtual bool HasObserver(Observer* observer) OVERRIDE { return false; }
-  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 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(
-      const RetrievePolicyCallback& callback) OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(callback, user_policy_));
-  }
-  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;
-    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_;
-  }
-  void set_user_policy(const std::string& policy_blob) {
-    user_policy_ = 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> 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;
 
   FakeCryptohomeClient() {}
   virtual ~FakeCryptohomeClient() {}
 
   virtual void SetAsyncCallStatusHandlers(
@@ skipping 266 matching lines @@
   void CheckPublicSessionPresent(const std::string& id) {
     const chromeos::User* user = chromeos::UserManager::Get()->FindUser(id);
     ASSERT_TRUE(user);
     EXPECT_EQ(id, user->email());
     EXPECT_EQ(chromeos::User::USER_TYPE_PUBLIC_ACCOUNT, user->GetType());
   }
 
   LocalPolicyTestServer test_server_;
   base::ScopedTempDir temp_dir_;
 
-  FakeSessionManagerClient session_manager_client_;
+  chromeos::FakeSessionManagerClient session_manager_client_;
   FakeCryptohomeClient cryptohome_client_;
 };
 
 static bool IsKnownUser(const std::string& account_id) {
   return chromeos::UserManager::Get()->IsKnownUser(account_id);
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, LoginScreen) {
-  NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
-                      base::Bind(&IsKnownUser, kAccountId1)).Run();
-  NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
-                      base::Bind(&IsKnownUser, kAccountId2)).Run();
+  content::NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
+                               base::Bind(&IsKnownUser, kAccountId1)).Run();
+  content::NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
+                               base::Bind(&IsKnownUser, kAccountId2)).Run();
 
   CheckPublicSessionPresent(kAccountId1);
   CheckPublicSessionPresent(kAccountId2);
 }
 
 static bool DisplayNameMatches(const std::string& account_id,
                         const std::string& display_name) {
   const chromeos::User* user =
       chromeos::UserManager::Get()->FindUser(account_id);
   if (!user || user->display_name().empty())
     return false;
   EXPECT_EQ(UTF8ToUTF16(display_name), user->display_name());
   return true;
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, DisplayName) {
-  NotificationWatcher(
+  content::NotificationWatcher(
       chrome::NOTIFICATION_USER_LIST_CHANGED,
       base::Bind(&DisplayNameMatches, kAccountId1, kDisplayName1)).Run();
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, PolicyDownload) {
   // Policy for kAccountId2 is not installed in session_manager_client, make
   // sure it gets fetched from the server. Note that the test setup doesn't set
   // up policy for kAccountId2, so the presence of the display name can be used
   // as signal to indicate successful policy download.
-  NotificationWatcher(
+  ASSERT_TRUE(session_manager_client_.device_local_account_policy(
+      kAccountId2).empty());
+  content::NotificationWatcher(
       chrome::NOTIFICATION_USER_LIST_CHANGED,
       base::Bind(&DisplayNameMatches, kAccountId2, kDisplayName2)).Run();
 
   // Sanity check: The policy should be present now.
   ASSERT_FALSE(session_manager_client_.device_local_account_policy(
       kAccountId2).empty());
 }
 
 static bool IsNotKnownUser(const std::string& account_id) {
   return !IsKnownUser(account_id);
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, DevicePolicyChange) {
   // Wait until the login screen is up.
-  NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
-                      base::Bind(&IsKnownUser, kAccountId1)).Run();
-  NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
-                      base::Bind(&IsKnownUser, kAccountId2)).Run();
+  content::NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
+                               base::Bind(&IsKnownUser, kAccountId1)).Run();
+  content::NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
+                               base::Bind(&IsKnownUser, kAccountId2)).Run();
 
   // Update policy to remove kAccountId2.
   em::ChromeDeviceSettingsProto policy;
   policy.mutable_show_user_names()->set_show_user_names(true);
   policy.mutable_device_local_accounts()->add_account()->set_id(kAccountId1);
 
   test_server_.UpdatePolicy(dm_protocol::kChromeDevicePolicyType, std::string(),
                             policy.SerializeAsString());
   g_browser_process->policy_service()->RefreshPolicies(base::Closure());
 
   // Make sure the second device-local account disappears.
-  NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
-                      base::Bind(&IsNotKnownUser, kAccountId2)).Run();
+  content::NotificationWatcher(chrome::NOTIFICATION_USER_LIST_CHANGED,
+                               base::Bind(&IsNotKnownUser, kAccountId2)).Run();
 }
 
 static bool IsSessionStarted() {
   return chromeos::UserManager::Get()->IsSessionStarted();
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, StartSession) {
   // This observes the display name becoming available as this indicates
   // device-local account policy is fully loaded, which is a prerequisite for
   // successful login.
-  NotificationWatcher(
+  content::NotificationWatcher(
       chrome::NOTIFICATION_USER_LIST_CHANGED,
       base::Bind(&DisplayNameMatches, kAccountId1, kDisplayName1)).Run();
 
   chromeos::ExistingUserController* controller =
       chromeos::ExistingUserController::current_controller();
   ASSERT_TRUE(controller);
   controller->LoginAsPublicAccount(kAccountId1);
 
   // Wait for the session to start.
-  NotificationWatcher(chrome::NOTIFICATION_SESSION_STARTED,
-                      base::Bind(IsSessionStarted)).Run();
+  content::NotificationWatcher(chrome::NOTIFICATION_SESSION_STARTED,
+                               base::Bind(IsSessionStarted)).Run();
 
   // Check that the startup pages specified in policy were opened.
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   Browser* browser =
       chrome::FindLastActiveWithHostDesktopType(chrome::HOST_DESKTOP_TYPE_ASH);
   ASSERT_TRUE(browser);
 
   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