cros: Update ash when prefs related to lock are changed

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_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/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.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/prefs/pref_service.h"
 #include "components/session_manager/core/session_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"
 
 using chromeos::FakeChromeUserManager;
@@ skipping 24 matching lines @@
   // user_manager::UserManager:
   void UserLoggedIn(const AccountId& account_id,
                     const std::string& user_id_hash,
                     bool browser_restart) override {
     FakeChromeUserManager::UserLoggedIn(account_id, user_id_hash,
                                         browser_restart);
     active_user_ = const_cast<user_manager::User*>(FindUser(account_id));
     NotifyOnLogin();
   }
 
+  user_manager::UserList GetUnlockUsers() const override {
+    // Test case UserPrefsChange expects that the list of the unlock users
+    // depends on prefs::kAllowScreenLock.
+    user_manager::UserList unlock_users;
+    for (user_manager::User* user : users_) {
+      Profile* user_profile =
+          chromeos::ProfileHelper::Get()->GetProfileByUser(user);
+      // Skip if user has a profile and kAllowScreenLock is set to false.
+      if (user_profile &&
+          !user_profile->GetPrefs()->GetBoolean(prefs::kAllowScreenLock)) {
+        continue;
+      }
+
+      unlock_users.push_back(user);
+    }
+
+    return unlock_users;
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(TestChromeUserManager);
 };
 
 // A session controller interface implementation that tracks sessions and users.
 class TestSessionController : public ash::mojom::SessionController {
  public:
   TestSessionController() : binding_(this) {}
   ~TestSessionController() override {}
 
@@ skipping 86 matching lines @@
   const std::string& GetActiveUserEmail() {
     return user_manager::UserManager::Get()
         ->GetActiveUser()
         ->GetAccountId()
         .GetUserEmail();
   }
 
   TestChromeUserManager* user_manager() { return user_manager_; }
 
   // Adds a regular user with a profile.
-  void InitForMultiProfile() {
+  TestingProfile* InitForMultiProfile() {
     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.
-    CreateTestingProfile(user);
+    return CreateTestingProfile(user);
   }
 
   // Calls private methods to create a testing profile.

[James Cook, 2017/05/08 21:50:00]

nit: Maybe note that the profile is owned by the ProfileManager (is it?).

[xiyuan, 2017/05/08 22:27:39]

Done. 

It is sort of owned by ProfileManager. ProfileManager owns ProfilesInfoMap,
which has a linked_ptr<ProfileInfo>, and ProfileInfo owns Profile. The
linked_ptr part is tricky and Profile is released on the last ref of
linked_ptr<ProfileInfo> is gone. This usually happens when destructing
ProfileManager on shutdown.

-  void CreateTestingProfile(const user_manager::User* user) {
+  TestingProfile* CreateTestingProfile(const user_manager::User* user) {
     const AccountId& account_id = user->GetAccountId();
-    user_profile_ =
+    TestingProfile* profile =
         profile_manager_->CreateTestingProfile(account_id.GetUserEmail());
-    user_profile_->set_profile_name(account_id.GetUserEmail());
-    chromeos::ProfileHelper::Get()->SetUserToProfileMappingForTesting(
-        user, user_profile_);
+    profile->set_profile_name(account_id.GetUserEmail());
+    chromeos::ProfileHelper::Get()->SetUserToProfileMappingForTesting(user,
+                                                                      profile);
+    return profile;
   }
 
   content::TestBrowserThreadBundle threads_;
   std::unique_ptr<policy::PolicyCertVerifier> cert_verifier_;
   std::unique_ptr<TestingProfileManager> profile_manager_;
-  TestingProfile* user_profile_;
   session_manager::SessionManager session_manager_;
 
  private:
   std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
 
   // Owned by |user_manager_enabler_|.
   TestChromeUserManager* user_manager_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(SessionControllerClientTest);
 };
@@ skipping 32 matching lines @@
   SessionControllerClient::DoCycleActiveUser(backward);
   EXPECT_EQ("thirduser@test.com", GetActiveUserEmail());
   SessionControllerClient::DoCycleActiveUser(backward);
   EXPECT_EQ("seconduser@test.com", GetActiveUserEmail());
   SessionControllerClient::DoCycleActiveUser(backward);
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
 }
 
 // Make sure MultiProfile disabled by primary user policy.
 TEST_F(SessionControllerClientTest, MultiProfileDisallowedByUserPolicy) {
-  InitForMultiProfile();
+  TestingProfile* user_profile = InitForMultiProfile();
   EXPECT_EQ(ash::AddUserSessionPolicy::ALLOWED,
             SessionControllerClient::GetAddUserSessionPolicy());
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
   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(
+  user_profile->GetPrefs()->SetString(
       prefs::kMultiProfileUserBehavior,
       chromeos::MultiProfileUserController::kBehaviorNotAllowed);
   EXPECT_EQ(ash::AddUserSessionPolicy::ERROR_NOT_ALLOWED_PRIMARY_USER,
             SessionControllerClient::GetAddUserSessionPolicy());
 }
 
 // Make sure MultiProfile disabled by primary user policy certificates.
 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_EQ(ash::AddUserSessionPolicy::ALLOWED,
             SessionControllerClient::GetAddUserSessionPolicy());
   policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(
       account_id.GetUserEmail());
   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(SessionControllerClientTest,
        MultiProfileDisallowedByPrimaryUserCertificatesInMemory) {
-  InitForMultiProfile();
+  TestingProfile* user_profile = InitForMultiProfile();
   user_manager()->AddUser(AccountId::FromUserEmail("bb@b.b"));
 
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
   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));
+          user_profile, CreateTestPolicyCertService));
   policy::PolicyCertService* service =
-      policy::PolicyCertServiceFactory::GetForProfile(user_profile_);
+      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_EQ(ash::AddUserSessionPolicy::ERROR_NOT_ALLOWED_PRIMARY_USER,
             SessionControllerClient::GetAddUserSessionPolicy());
@@ skipping 31 matching lines @@
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
   UserAddedToSession("bb@b.b");
   EXPECT_EQ(ash::AddUserSessionPolicy::ERROR_NO_ELIGIBLE_USERS,
             SessionControllerClient::GetAddUserSessionPolicy());
 }
 
 // Make sure adding users to multiprofiles disabled by primary user policy.
 TEST_F(SessionControllerClientTest,
        AddUserToMultiprofileDisallowedByPrimaryUserPolicy) {
-  InitForMultiProfile();
+  TestingProfile* user_profile = InitForMultiProfile();
 
   EXPECT_EQ(ash::AddUserSessionPolicy::ALLOWED,
             SessionControllerClient::GetAddUserSessionPolicy());
   const AccountId account_id(AccountId::FromUserEmail(kUser));
   user_manager()->LoginUser(account_id);
-  user_profile_->GetPrefs()->SetString(
+  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,
             SessionControllerClient::GetAddUserSessionPolicy());
 }
 
 TEST_F(SessionControllerClientTest, SendUserSession) {
   // Create an object to test and connect it to our test interface.
   SessionControllerClient client;
@@ skipping 50 matching lines @@
                       "child@test.com"));
   session_manager_.SetSessionState(SessionState::ACTIVE);
   SessionControllerClient::FlushForTesting();
 
   // The session controller received session info and user session.
   EXPECT_LT(0u, session_controller.last_user_session()->session_id);
   EXPECT_EQ(user_manager::USER_TYPE_SUPERVISED,
             session_controller.last_user_session()->type);
 
   // Simulate profile creation after login.
-  CreateTestingProfile(user);
-  user_profile_->SetSupervisedUserId("child-id");
+  TestingProfile* user_profile = CreateTestingProfile(user);
+  user_profile->SetSupervisedUserId("child-id");
 
   // Simulate supervised user custodians.
-  PrefService* prefs = user_profile_->GetPrefs();
+  PrefService* prefs = user_profile->GetPrefs();
   prefs->SetString(prefs::kSupervisedUserCustodianEmail, "parent1@test.com");
   prefs->SetString(prefs::kSupervisedUserSecondCustodianEmail,
                    "parent2@test.com");
 
   // Simulate the notification that the profile is ready.
-  client.OnLoginUserProfilePrepared(user_profile_);
+  client.OnLoginUserProfilePrepared(user_profile);
   base::RunLoop().RunUntilIdle();  // For PostTask and mojo interface.
 
   // The custodians were sent over the mojo interface.
   EXPECT_EQ("parent1@test.com",
             session_controller.last_user_session()->custodian_email);
   EXPECT_EQ("parent2@test.com",
             session_controller.last_user_session()->second_custodian_email);
 
   // Simulate an update to the custodian information.
   prefs->SetString(prefs::kSupervisedUserCustodianEmail, "parent3@test.com");
   client.OnCustodianInfoChanged();
   SessionControllerClient::FlushForTesting();
 
   // The updated custodian was sent over the mojo interface.
   EXPECT_EQ("parent3@test.com",
             session_controller.last_user_session()->custodian_email);
 }
+
+TEST_F(SessionControllerClientTest, UserPrefsChange) {
+  // Create an object to test and connect it to our test interface.
+  SessionControllerClient client;
+  TestSessionController session_controller;
+  client.session_controller_ = session_controller.CreateInterfacePtrAndBind();
+  client.Init();
+  SessionControllerClient::FlushForTesting();
+
+  // Simulate login.
+  const AccountId account_id(AccountId::FromUserEmail("user@test.com"));
+  const user_manager::User* user = user_manager()->AddUser(account_id);
+  session_manager_.CreateSession(
+      account_id, chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(
+                      "user@test.com"));
+  session_manager_.SetSessionState(SessionState::ACTIVE);
+  SessionControllerClient::FlushForTesting();
+
+  // Simulate the notification that the profile is ready.
+  TestingProfile* const user_profile = CreateTestingProfile(user);
+  client.OnLoginUserProfilePrepared(user_profile);
+
+  // Manipulate user prefs and verify SessionController is updated.
+  PrefService* const user_prefs = user_profile->GetPrefs();
+
+  user_prefs->SetBoolean(prefs::kAllowScreenLock, true);
+  SessionControllerClient::FlushForTesting();
+  EXPECT_TRUE(session_controller.last_session_info()->can_lock_screen);
+  user_prefs->SetBoolean(prefs::kAllowScreenLock, false);
+  SessionControllerClient::FlushForTesting();
+  EXPECT_FALSE(session_controller.last_session_info()->can_lock_screen);
+
+  user_prefs->SetBoolean(prefs::kEnableAutoScreenLock, true);
+  SessionControllerClient::FlushForTesting();
+  EXPECT_TRUE(
+      session_controller.last_session_info()->should_lock_screen_automatically);
+  user_prefs->SetBoolean(prefs::kEnableAutoScreenLock, false);
+  SessionControllerClient::FlushForTesting();
+  EXPECT_FALSE(
+      session_controller.last_session_info()->should_lock_screen_automatically);
+}