cros: Convert SessionStateDelegateChromeOS tests

chrome/browser/ui/ash/session_controller_client_unittest.cc

 // Copyright 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 "chrome/browser/ui/ash/session_state_delegate_chromeos.h"
+#include "chrome/browser/ui/ash/session_controller_client.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/policy/policy_cert_service.h"
 #include "chrome/browser/chromeos/policy/policy_cert_service_factory.h"
 #include "chrome/browser/chromeos/policy/policy_cert_verifier.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/cert/x509_certificate.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace chromeos {
+using chromeos::FakeChromeUserManager;
 
 namespace {
 
 const char* kUser = "user@test.com";
 
 // Weak ptr to PolicyCertVerifier - object is freed in test destructor once
 // we've ensured the profile has been shut down.
-policy::PolicyCertVerifier* g_policy_cert_verifier_for_factory = NULL;
+policy::PolicyCertVerifier* g_policy_cert_verifier_for_factory = nullptr;
 
 std::unique_ptr<KeyedService> CreateTestPolicyCertService(
     content::BrowserContext* context) {
   return policy::PolicyCertService::CreateForTesting(
       kUser, g_policy_cert_verifier_for_factory,
       user_manager::UserManager::Get());
 }
 
 }  // namespace
 
-class SessionStateDelegateChromeOSTest : public testing::Test {
+class SessionControllerClientTest : public testing::Test {
  protected:
-  SessionStateDelegateChromeOSTest() : user_manager_(NULL) {
-  }
-
-  ~SessionStateDelegateChromeOSTest() override {}
+  SessionControllerClientTest() {}
+  ~SessionControllerClientTest() override {}
 
   void SetUp() override {
     // Initialize the UserManager singleton to a fresh FakeChromeUserManager
     // instance.
     user_manager_ = new FakeChromeUserManager;
     user_manager_enabler_.reset(
         new chromeos::ScopedUserManagerEnabler(user_manager_));
 
-    // Create our SessionStateDelegate to experiment with.
-    session_state_delegate_.reset(new SessionStateDelegateChromeos());
     testing::Test::SetUp();
   }
 
   void TearDown() override {
     testing::Test::TearDown();
-    session_state_delegate_.reset();
     user_manager_enabler_.reset();
-    user_manager_ = NULL;
+    user_manager_ = nullptr;
     // Clear our cached pointer to the PolicyCertVerifier.
-    g_policy_cert_verifier_for_factory = NULL;
+    g_policy_cert_verifier_for_factory = nullptr;
     profile_manager_.reset();
 
     // We must ensure that the PolicyCertVerifier outlives the
     // PolicyCertService so shutdown the profile here. Additionally, we need
     // to run the message loop between freeing the PolicyCertService and
     // freeing the PolicyCertVerifier (see
     // PolicyCertService::OnTrustAnchorsChanged() which is called from
     // PolicyCertService::Shutdown()).
     base::RunLoop().RunUntilIdle();
   }
 
   // Add and log in a user to the session.
   void UserAddedToSession(std::string user) {
     user_manager()->AddUser(AccountId::FromUserEmail(user));
     user_manager()->LoginUser(AccountId::FromUserEmail(user));
   }
 
   // Get the active user.
   const std::string& GetActiveUserEmail() {
     return user_manager::UserManager::Get()
         ->GetActiveUser()
         ->GetAccountId()
         .GetUserEmail();
   }
 
   FakeChromeUserManager* user_manager() { return user_manager_; }
-  SessionStateDelegateChromeos* session_state_delegate() {
-    return session_state_delegate_.get();
-  }
 
   void InitForMultiProfile() {
     profile_manager_.reset(
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
     ASSERT_TRUE(profile_manager_->SetUp());
 
     const AccountId account_id(AccountId::FromUserEmail(kUser));
     const user_manager::User* user = user_manager()->AddUser(account_id);
 
     // Note that user profiles are created after user login in reality.
     user_profile_ =
         profile_manager_->CreateTestingProfile(account_id.GetUserEmail());
     user_profile_->set_profile_name(account_id.GetUserEmail());
     chromeos::ProfileHelper::Get()->SetUserToProfileMappingForTesting(
         user, user_profile_);
   }
 
   content::TestBrowserThreadBundle threads_;
   std::unique_ptr<policy::PolicyCertVerifier> cert_verifier_;
   std::unique_ptr<TestingProfileManager> profile_manager_;
   TestingProfile* user_profile_;
 
  private:
   std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
-  std::unique_ptr<SessionStateDelegateChromeos> session_state_delegate_;
 
-  // Not owned.
-  FakeChromeUserManager* user_manager_;
+  // Owned by |user_manager_enabler_|.
+  FakeChromeUserManager* user_manager_ = nullptr;
 
-  DISALLOW_COPY_AND_ASSIGN(SessionStateDelegateChromeOSTest);
+  DISALLOW_COPY_AND_ASSIGN(SessionControllerClientTest);
 };
 
 // Make sure that cycling one user does not cause any harm.
-TEST_F(SessionStateDelegateChromeOSTest, CyclingOneUser) {
+TEST_F(SessionControllerClientTest, CyclingOneUser) {
   UserAddedToSession("firstuser@test.com");
 
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
-  session_state_delegate()->CycleActiveUser(
-      ash::SessionStateDelegate::CYCLE_TO_NEXT_USER);
+  SessionControllerClient::DoCycleActiveUser(true);

[James Cook, 2017/03/01 22:02:08]

optional: It would be nice if this function took an enum NEXT/PREVIOUS or an
index +1/-1 instead of true/false.

[xiyuan, 2017/03/01 22:41:03]

Sounds good. It would make more sense to also update the mojo interface to use
an enum as well. Let me do it in another CL and rebase this one after the enum
one lands.

[xiyuan, 2017/03/02 23:17:22]

Done.

   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
-  session_state_delegate()->CycleActiveUser(
-      ash::SessionStateDelegate::CYCLE_TO_PREVIOUS_USER);
+  SessionControllerClient::DoCycleActiveUser(false);
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
 }
 
 // Cycle three users forwards and backwards to see that it works.
-TEST_F(SessionStateDelegateChromeOSTest, CyclingThreeUsers) {
+TEST_F(SessionControllerClientTest, CyclingThreeUsers) {
   UserAddedToSession("firstuser@test.com");
   UserAddedToSession("seconduser@test.com");
   UserAddedToSession("thirduser@test.com");
-  const ash::SessionStateDelegate::CycleUser forward =
-      ash::SessionStateDelegate::CYCLE_TO_NEXT_USER;
 
   // Cycle forward.
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
-  session_state_delegate()->CycleActiveUser(forward);
+  SessionControllerClient::DoCycleActiveUser(true);
   EXPECT_EQ("seconduser@test.com", GetActiveUserEmail());
-  session_state_delegate()->CycleActiveUser(forward);
+  SessionControllerClient::DoCycleActiveUser(true);
   EXPECT_EQ("thirduser@test.com", GetActiveUserEmail());
-  session_state_delegate()->CycleActiveUser(forward);
+  SessionControllerClient::DoCycleActiveUser(true);
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
 
   // Cycle backwards.
-  const ash::SessionStateDelegate::CycleUser backward =
-      ash::SessionStateDelegate::CYCLE_TO_PREVIOUS_USER;
-  session_state_delegate()->CycleActiveUser(backward);
+  SessionControllerClient::DoCycleActiveUser(false);
   EXPECT_EQ("thirduser@test.com", GetActiveUserEmail());
-  session_state_delegate()->CycleActiveUser(backward);
+  SessionControllerClient::DoCycleActiveUser(false);
   EXPECT_EQ("seconduser@test.com", GetActiveUserEmail());
-  session_state_delegate()->CycleActiveUser(backward);
+  SessionControllerClient::DoCycleActiveUser(false);
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
 }
 
 // Make sure MultiProfile disabled by primary user policy.
-TEST_F(SessionStateDelegateChromeOSTest, MultiProfileDisallowedByUserPolicy) {
+TEST_F(SessionControllerClientTest, MultiProfileDisallowedByUserPolicy) {
   InitForMultiProfile();
-  EXPECT_TRUE(
-      session_state_delegate()->IsMultiProfileAllowedByPrimaryUserPolicy());
+  EXPECT_EQ(ash::AddUserSessionPolicy::ALLOWED,
+            SessionControllerClient::GetAddUserSessionPolicy());
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
-  EXPECT_TRUE(
-      session_state_delegate()->IsMultiProfileAllowedByPrimaryUserPolicy());
+  EXPECT_EQ(ash::AddUserSessionPolicy::ERROR_NO_ELIGIBLE_USERS,
+            SessionControllerClient::GetAddUserSessionPolicy());
+
+  user_manager()->AddUser(AccountId::FromUserEmail("bb@b.b"));
+  EXPECT_EQ(ash::AddUserSessionPolicy::ALLOWED,
+            SessionControllerClient::GetAddUserSessionPolicy());
 
   user_profile_->GetPrefs()->SetString(
       prefs::kMultiProfileUserBehavior,
       chromeos::MultiProfileUserController::kBehaviorNotAllowed);
-  EXPECT_FALSE(
-      session_state_delegate()->IsMultiProfileAllowedByPrimaryUserPolicy());
+  EXPECT_EQ(ash::AddUserSessionPolicy::ERROR_NOT_ALLOWED_PRIMARY_USER,
+            SessionControllerClient::GetAddUserSessionPolicy());
 }
 
 // Make sure MultiProfile disabled by primary user policy certificates.
-TEST_F(SessionStateDelegateChromeOSTest,
+TEST_F(SessionControllerClientTest,
        MultiProfileDisallowedByPolicyCertificates) {
   InitForMultiProfile();
+  user_manager()->AddUser(AccountId::FromUserEmail("bb@b.b"));
+
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
-  EXPECT_TRUE(
-      session_state_delegate()->IsMultiProfileAllowedByPrimaryUserPolicy());
+  EXPECT_EQ(ash::AddUserSessionPolicy::ALLOWED,
+            SessionControllerClient::GetAddUserSessionPolicy());
   policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(
       account_id.GetUserEmail());
-  EXPECT_FALSE(
-      session_state_delegate()->IsMultiProfileAllowedByPrimaryUserPolicy());
+  EXPECT_EQ(ash::AddUserSessionPolicy::ERROR_NOT_ALLOWED_PRIMARY_USER,
+            SessionControllerClient::GetAddUserSessionPolicy());
 
   // Flush tasks posted to IO.
   base::RunLoop().RunUntilIdle();
 }
 
 // Make sure MultiProfile disabled by primary user certificates in memory.
-TEST_F(SessionStateDelegateChromeOSTest,
+TEST_F(SessionControllerClientTest,
        MultiProfileDisallowedByPrimaryUserCertificatesInMemory) {
   InitForMultiProfile();
+  user_manager()->AddUser(AccountId::FromUserEmail("bb@b.b"));
+
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
-  EXPECT_TRUE(
-      session_state_delegate()->IsMultiProfileAllowedByPrimaryUserPolicy());
+  EXPECT_EQ(ash::AddUserSessionPolicy::ALLOWED,
+            SessionControllerClient::GetAddUserSessionPolicy());
   cert_verifier_.reset(new policy::PolicyCertVerifier(base::Closure()));
   g_policy_cert_verifier_for_factory = cert_verifier_.get();
   ASSERT_TRUE(
       policy::PolicyCertServiceFactory::GetInstance()->SetTestingFactoryAndUse(
           user_profile_, CreateTestPolicyCertService));
   policy::PolicyCertService* service =
       policy::PolicyCertServiceFactory::GetForProfile(user_profile_);
   ASSERT_TRUE(service);
 
   EXPECT_FALSE(service->has_policy_certificates());
   net::CertificateList certificates;
   certificates.push_back(
       net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem"));
   service->OnTrustAnchorsChanged(certificates);
   EXPECT_TRUE(service->has_policy_certificates());
-  EXPECT_FALSE(
-      session_state_delegate()->IsMultiProfileAllowedByPrimaryUserPolicy());
+  EXPECT_EQ(ash::AddUserSessionPolicy::ERROR_NOT_ALLOWED_PRIMARY_USER,
+            SessionControllerClient::GetAddUserSessionPolicy());
 
   // Flush tasks posted to IO.
   base::RunLoop().RunUntilIdle();
 }
 
 // Make sure adding users to multiprofiles disabled by reaching maximum
 // number of users in sessions.
-TEST_F(SessionStateDelegateChromeOSTest,
+TEST_F(SessionControllerClientTest,
        AddUserToMultiprofileDisallowedByMaximumUsers) {
   InitForMultiProfile();
 
   EXPECT_EQ(ash::AddUserSessionPolicy::ALLOWED,
-            session_state_delegate()->GetAddUserSessionPolicy());
+            SessionControllerClient::GetAddUserSessionPolicy());
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
-  while (session_state_delegate()->NumberOfLoggedInUsers() <
-         session_state_delegate()->GetMaximumNumberOfLoggedInUsers()) {
+  while (user_manager()->GetLoggedInUsers().size() <
+         session_manager::kMaxmiumNumberOfUserSessions) {
     UserAddedToSession("bb@b.b");
   }
   EXPECT_EQ(ash::AddUserSessionPolicy::ERROR_MAXIMUM_USERS_REACHED,
-            session_state_delegate()->GetAddUserSessionPolicy());
+            SessionControllerClient::GetAddUserSessionPolicy());
 }
 
 // Make sure adding users to multiprofiles disabled by logging in all possible
 // users.
-TEST_F(SessionStateDelegateChromeOSTest,
+TEST_F(SessionControllerClientTest,
        AddUserToMultiprofileDisallowedByAllUsersLogged) {
   InitForMultiProfile();
 
   EXPECT_EQ(ash::AddUserSessionPolicy::ALLOWED,
-            session_state_delegate()->GetAddUserSessionPolicy());
+            SessionControllerClient::GetAddUserSessionPolicy());
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
   UserAddedToSession("bb@b.b");
   EXPECT_EQ(ash::AddUserSessionPolicy::ERROR_NO_ELIGIBLE_USERS,
-            session_state_delegate()->GetAddUserSessionPolicy());
+            SessionControllerClient::GetAddUserSessionPolicy());
 }
 
 // Make sure adding users to multiprofiles disabled by primary user policy.
-TEST_F(SessionStateDelegateChromeOSTest,
+TEST_F(SessionControllerClientTest,
        AddUserToMultiprofileDisallowedByPrimaryUserPolicy) {
   InitForMultiProfile();
 
   EXPECT_EQ(ash::AddUserSessionPolicy::ALLOWED,
-            session_state_delegate()->GetAddUserSessionPolicy());
+            SessionControllerClient::GetAddUserSessionPolicy());
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
   user_profile_->GetPrefs()->SetString(
       prefs::kMultiProfileUserBehavior,
       chromeos::MultiProfileUserController::kBehaviorNotAllowed);
   user_manager()->AddUser(AccountId::FromUserEmail("bb@b.b"));
   EXPECT_EQ(ash::AddUserSessionPolicy::ERROR_NOT_ALLOWED_PRIMARY_USER,
-            session_state_delegate()->GetAddUserSessionPolicy());
+            SessionControllerClient::GetAddUserSessionPolicy());
 }
-
-}  // namespace chromeos