cros: Remove supervised user methods from SystemTrayDelegate

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/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;
 
 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 = nullptr;
 
 std::unique_ptr<KeyedService> CreateTestPolicyCertService(
     content::BrowserContext* context) {
   return policy::PolicyCertService::CreateForTesting(
       kUser, g_policy_cert_verifier_for_factory,
       user_manager::UserManager::Get());
 }
 
+// A user manager that does not set profiles as loaded and notifies observers
+// when users being added to a session.
+class TestChromeUserManager : public FakeChromeUserManager {
+ public:
+  TestChromeUserManager() = default;
+  ~TestChromeUserManager() override = default;
+
+  // 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();
+  }
+
+ 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 {}
+
+  ash::mojom::SessionControllerPtr CreateInterfacePtrAndBind() {
+    return binding_.CreateInterfacePtrAndBind();
+  }
+
+  ash::mojom::SessionInfo* last_session_info() {
+    return last_session_info_.get();
+  }
+
+  ash::mojom::UserSession* last_user_session() {
+    return last_user_session_.get();
+  }
+
+  // ash::mojom::SessionController:
+  void SetClient(ash::mojom::SessionControllerClientPtr client) override {}
+  void SetSessionInfo(ash::mojom::SessionInfoPtr info) override {
+    last_session_info_ = info->Clone();
+  }
+  void UpdateUserSession(ash::mojom::UserSessionPtr user_session) override {
+    last_user_session_ = user_session->Clone();
+  }
+  void SetUserSessionOrder(
+      const std::vector<uint32_t>& user_session_order) override {}
+  void StartLock(const StartLockCallback& callback) override {}
+  void RunUnlockAnimation(const RunUnlockAnimationCallback& callback) override {
+  }
+  void NotifyChromeTerminating() override {}
+
+ private:
+  mojo::Binding<ash::mojom::SessionController> binding_;
+
+  ash::mojom::SessionInfoPtr last_session_info_;
+  ash::mojom::UserSessionPtr last_user_session_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestSessionController);
+};
+
 }  // namespace
 
 class SessionControllerClientTest : public testing::Test {
  protected:
   SessionControllerClientTest() {}
   ~SessionControllerClientTest() override {}
 
   void SetUp() override {
-    // Initialize the UserManager singleton to a fresh FakeChromeUserManager
-    // instance.
-    user_manager_ = new FakeChromeUserManager;
+    testing::Test::SetUp();
+
+    // Initialize the UserManager singleton.
+    user_manager_ = new TestChromeUserManager;
     user_manager_enabler_.reset(
         new chromeos::ScopedUserManagerEnabler(user_manager_));
 
-    testing::Test::SetUp();
+    profile_manager_.reset(
+        new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
+    ASSERT_TRUE(profile_manager_->SetUp());
   }
 
   void TearDown() override {
-    testing::Test::TearDown();
     user_manager_enabler_.reset();
     user_manager_ = nullptr;
     // Clear our cached pointer to the PolicyCertVerifier.
     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();
+
+    testing::Test::TearDown();
   }
 
   // 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_; }
+  TestChromeUserManager* user_manager() { return user_manager_; }
 
+  // Adds a regular user with a profile.
   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.
+    CreateTestingProfile(user);
+  }
+
+  // Calls private methods to create a testing profile.
+  void CreateTestingProfile(const user_manager::User* user) {
+    const AccountId& account_id = user->GetAccountId();
     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_;
+  session_manager::SessionManager session_manager_;
 
  private:
   std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
 
   // Owned by |user_manager_enabler_|.
-  FakeChromeUserManager* user_manager_ = nullptr;
+  TestChromeUserManager* user_manager_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(SessionControllerClientTest);
 };
 
 // Make sure that cycling one user does not cause any harm.
 TEST_F(SessionControllerClientTest, CyclingOneUser) {
   UserAddedToSession("firstuser@test.com");
 
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
   SessionControllerClient::DoCycleActiveUser(ash::CycleUserDirection::NEXT);
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
   SessionControllerClient::DoCycleActiveUser(ash::CycleUserDirection::PREVIOUS);
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
 }
 
 // Cycle three users forwards and backwards to see that it works.
 TEST_F(SessionControllerClientTest, CyclingThreeUsers) {
   UserAddedToSession("firstuser@test.com");
   UserAddedToSession("seconduser@test.com");
   UserAddedToSession("thirduser@test.com");
-  const ash::CycleUserDirection forward = ash::CycleUserDirection::NEXT;
+  user_manager()->SwitchActiveUser(
+      AccountId::FromUserEmail("firstuser@test.com"));
 
   // Cycle forward.
+  const ash::CycleUserDirection forward = ash::CycleUserDirection::NEXT;
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
   SessionControllerClient::DoCycleActiveUser(forward);
   EXPECT_EQ("seconduser@test.com", GetActiveUserEmail());
   SessionControllerClient::DoCycleActiveUser(forward);
   EXPECT_EQ("thirduser@test.com", GetActiveUserEmail());
   SessionControllerClient::DoCycleActiveUser(forward);
   EXPECT_EQ("firstuser@test.com", GetActiveUserEmail());
 
   // Cycle backwards.
   const ash::CycleUserDirection backward = ash::CycleUserDirection::PREVIOUS;
@@ skipping 119 matching lines @@
             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,
             SessionControllerClient::GetAddUserSessionPolicy());
 }
+
+TEST_F(SessionControllerClientTest, SupervisedUser) {
+  // 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 the login screen. No user session yet.
+  session_manager_.SetSessionState(
+      session_manager::SessionState::LOGIN_PRIMARY);
+  EXPECT_FALSE(session_controller.last_user_session());
+
+  // Simulate a supervised user logging in.
+  const AccountId account_id(AccountId::FromUserEmail("child@test.com"));
+  const user_manager::User* user =
+      user_manager()->AddSupervisedUser(account_id);
+  ASSERT_TRUE(user);
+
+  // Start session. This logs in the user and sends an active user notification.
+  // The hash must match the one used by FakeChromeUserManager.
+  session_manager_.CreateSession(
+      account_id, chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(
+                      "child@test.com"));
+  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");
+
+  // Simulate supervised user custodians.
+  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_);
+  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);
+}