chrome/browser/chromeos/login/crash_restore_browsertest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6 #include <vector>
   7
   8 #include "base/command_line.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/run_loop.h"
  11 #include "chrome/browser/chromeos/login/user.h"
  12 #include "chrome/browser/chromeos/login/user_manager.h"
  13 #include "chrome/common/chrome_switches.h"
  14 #include "chrome/test/base/in_process_browser_test.h"
  15 #include "chromeos/chromeos_switches.h"
  16 #include "chromeos/dbus/cryptohome_client.h"
  17 #include "chromeos/dbus/fake_dbus_thread_manager.h"
  18 #include "chromeos/dbus/fake_session_manager_client.h"
  19 #include "chromeos/dbus/session_manager_client.h"
  20 #include "content/public/test/test_utils.h"
  21 #include "testing/gmock/include/gmock/gmock.h"
  22 #include "third_party/cros_system_api/dbus/service_constants.h"
  23
  24 namespace chromeos {
  25
  26 namespace {
  27
  28 const char kUserId1[] = "user1@example.com";
  29 const char kUserId2[] = "user2@example.com";
  30 const char kUserId3[] = "user3@example.com";
  31
  32 }  // namespace
  33
  34 class CrashRestoreSimpleTest : public InProcessBrowserTest {
  35  protected:
  36   CrashRestoreSimpleTest() : session_started_count_(0) {}
  37
  38   virtual ~CrashRestoreSimpleTest() {}
  39
  40   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  41     command_line->AppendSwitch(::switches::kMultiProfiles);
  42     command_line->AppendSwitchASCII(switches::kLoginUser, kUserId1);
  43     command_line->AppendSwitchASCII(
  44         switches::kLoginProfile,
  45         CryptohomeClient::GetStubSanitizedUsername(kUserId1));
  46   }
  47
  48   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
  49     // Redirect session_manager DBus calls to FakeSessionManagerClient.
  50     FakeDBusThreadManager* dbus_thread_manager = new FakeDBusThreadManager;
  51     dbus_thread_manager->SetFakeClients();
  52     session_manager_client_ = new FakeSessionManagerClient;
  53     dbus_thread_manager->SetSessionManagerClient(
  54         scoped_ptr<SessionManagerClient>(session_manager_client_));
  55     DBusThreadManager::SetInstanceForTesting(dbus_thread_manager);
  56     // We need to create MessageLoop here to process callback from
  57     // session_manager
  58     base::MessageLoop msg_loop;
  59     session_manager_client_->StartSession(
  60         kUserId1,
  61         base::Bind(&CrashRestoreSimpleTest::OnSessionStarted,
  62                    base::Unretained(this),
  63                    kUserId1));
  64     base::RunLoop().RunUntilIdle();
  65     ASSERT_EQ(1, session_started_count_);
  66   }
  67
  68  public:
  69   void OnSessionStarted(const std::string& user_email, bool success) {
  70     ASSERT_TRUE(success);
  71     ++session_started_count_;
  72   }
  73
  74  protected:
  75   FakeSessionManagerClient* session_manager_client_;
  76   int session_started_count_;
  77 };
  78
  79 IN_PROC_BROWSER_TEST_F(CrashRestoreSimpleTest, RestoreSessionForOneUser) {
  80   UserManager* user_manager = UserManager::Get();
  81   User* user = user_manager->GetActiveUser();
  82   ASSERT_TRUE(user);
  83   EXPECT_EQ(kUserId1, user->email());
  84   EXPECT_EQ(CryptohomeClient::GetStubSanitizedUsername(kUserId1),
  85             user->username_hash());
  86   EXPECT_EQ(1UL, user_manager->GetLoggedInUsers().size());
  87 }
  88
  89 // Observer that keeps track of user sessions restore event.
  90 class UserSessionRestoreObserver :
  91     public UserManager::UserSessionStateObserver {
  92  public:
  93   UserSessionRestoreObserver()
  94       : running_loop_(false),
  95         user_sessions_restored_(UserManager::Get()->UserSessionsRestored()) {
  96     if (!user_sessions_restored_)
  97       UserManager::Get()->AddSessionStateObserver(this);
  98   }
  99   virtual ~UserSessionRestoreObserver() {}
 100
 101   virtual void PendingUserSessionsRestoreFinished() OVERRIDE {
 102     user_sessions_restored_ = true;
 103     UserManager::Get()->RemoveSessionStateObserver(this);
 104     if (!running_loop_)
 105       return;
 106
 107     message_loop_runner_->Quit();
 108     running_loop_ = false;
 109   }
 110
 111   // Wait until the user sessions are restored. If that happened between the
 112   // construction of this object and this call or even before it was created
 113   // then it returns immediately.
 114   void Wait() {
 115     if (user_sessions_restored_)
 116       return;
 117
 118     running_loop_ = true;
 119     message_loop_runner_ = new content::MessageLoopRunner();
 120     message_loop_runner_->Run();
 121   }
 122
 123  private:
 124   bool running_loop_;
 125   bool user_sessions_restored_;
 126   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 127
 128   DISALLOW_COPY_AND_ASSIGN(UserSessionRestoreObserver);
 129 };
 130
 131 class CrashRestoreComplexTest : public CrashRestoreSimpleTest {
 132  protected:
 133   CrashRestoreComplexTest() {}
 134   virtual ~CrashRestoreComplexTest() {}
 135
 136   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 137     CrashRestoreSimpleTest::SetUpInProcessBrowserTestFixture();
 138     // We need to create MessageLoop here to process callback from
 139     // session_manager
 140     base::MessageLoop msg_loop;
 141     session_manager_client_->StartSession(
 142         kUserId2,
 143         base::Bind(&CrashRestoreSimpleTest::OnSessionStarted,
 144                    base::Unretained(this),
 145                    kUserId2));
 146     session_manager_client_->StartSession(
 147         kUserId3,
 148         base::Bind(&CrashRestoreSimpleTest::OnSessionStarted,
 149                    base::Unretained(this),
 150                    kUserId3));
 151     base::RunLoop().RunUntilIdle();
 152     ASSERT_EQ(3, CrashRestoreSimpleTest::session_started_count_);
 153   }
 154 };
 155
 156 IN_PROC_BROWSER_TEST_F(CrashRestoreComplexTest, RestoreSessionForThreeUsers) {
 157   {
 158     UserSessionRestoreObserver restore_observer;
 159     restore_observer.Wait();
 160   }
 161
 162   UserManager* user_manager = UserManager::Get();
 163   DCHECK(user_manager->UserSessionsRestored());
 164
 165   // User that is last in the user sessions map becomes active. This behavior
 166   // will become better defined once each user gets a separate user desktop.
 167   User* user = user_manager->GetActiveUser();
 168   ASSERT_TRUE(user);
 169   EXPECT_EQ(kUserId3, user->email());
 170   EXPECT_EQ(CryptohomeClient::GetStubSanitizedUsername(kUserId3),
 171             user->username_hash());
 172   const UserList& users = user_manager->GetLoggedInUsers();
 173   ASSERT_EQ(3UL, users.size());
 174
 175   // User that becomes active moves to the beginning of the list.
 176   EXPECT_EQ(kUserId3, users[0]->email());
 177   EXPECT_EQ(CryptohomeClient::GetStubSanitizedUsername(kUserId3),
 178             users[0]->username_hash());
 179   EXPECT_EQ(kUserId2, users[1]->email());
 180   EXPECT_EQ(CryptohomeClient::GetStubSanitizedUsername(kUserId2),
 181             users[1]->username_hash());
 182   EXPECT_EQ(kUserId1, users[2]->email());
 183   EXPECT_EQ(CryptohomeClient::GetStubSanitizedUsername(kUserId1),
 184             users[2]->username_hash());
 185 }
 186
 187 }  // namespace chromeos