Introduce profile for lock screen apps

chrome/browser/chromeos/lock_screen_apps/state_controller_unittest.cc

 // Copyright 2017 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/chromeos/lock_screen_apps/state_controller.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/public/interfaces/tray_action.mojom.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/scoped_command_line.h"
 #include "chrome/browser/chromeos/lock_screen_apps/app_manager.h"
 #include "chrome/browser/chromeos/lock_screen_apps/state_observer.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/ui/apps/chrome_app_delegate.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/session_manager/core/session_manager.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 293 matching lines @@
     ASSERT_TRUE(profile_manager_.SetUp());
 
     BrowserWithTestWindowTest::SetUp();
 
     session_manager_ = base::MakeUnique<session_manager::SessionManager>();
     session_manager_->SetSessionState(
         session_manager::SessionState::LOGIN_PRIMARY);
 
     ASSERT_TRUE(lock_screen_apps::StateController::IsEnabled());
 
+    // Create fake lock screen app profile.
+    lock_screen_profile_ = profile_manager_.CreateTestingProfile(
+        chromeos::ProfileHelper::GetLockScreenAppProfileName());
+
+    InitExtensionSystem(profile());
+    InitExtensionSystem(lock_screen_profile());
+
+    std::unique_ptr<TestAppManager> app_manager =
+        base::MakeUnique<TestAppManager>(
+            &profile_, lock_screen_profile_->GetOriginalProfile());
+    app_manager_ = app_manager.get();
+
     state_controller_ = base::MakeUnique<lock_screen_apps::StateController>();
     state_controller_->SetTrayActionPtrForTesting(
         tray_action_.CreateInterfacePtrAndBind());
+    state_controller_->SetAppManagerForTesting(std::move(app_manager));
+    state_controller_->SetReadyCallbackForTesting(ready_waiter_.QuitClosure());
     state_controller_->Initialize();
     state_controller_->FlushTrayActionForTesting();
 
     state_controller_->AddObserver(&observer_);
-
-    // Create fake sign-in profile.
-    TestingProfile::Builder builder;
-    builder.SetPath(
-        profile_manager_.profiles_dir().AppendASCII(chrome::kInitialProfile));
-    signin_profile_ = builder.BuildIncognito(
-        profile_manager_.CreateTestingProfile(chrome::kInitialProfile));
-
-    InitExtensionSystem(profile());
-    InitExtensionSystem(signin_profile());
-
-    std::unique_ptr<TestAppManager> app_manager =
-        base::MakeUnique<TestAppManager>(&profile_,
-                                         signin_profile_->GetOriginalProfile());
-    app_manager_ = app_manager.get();
-    state_controller_->SetAppManagerForTesting(std::move(app_manager));
   }
 
   void TearDown() override {
     extensions::ExtensionSystem::Get(profile())->Shutdown();
-    extensions::ExtensionSystem::Get(signin_profile())->Shutdown();
+    extensions::ExtensionSystem::Get(lock_screen_profile())->Shutdown();
 
     state_controller_->RemoveObserver(&observer_);
     state_controller_.reset();
     session_manager_.reset();
     app_manager_ = nullptr;
     BrowserWithTestWindowTest::TearDown();
   }
 
   void InitExtensionSystem(Profile* profile) {
     extensions::TestExtensionSystem* extension_system =
@@ skipping 26 matching lines @@
                      extensions::api::app_runtime::ACTION_TYPE_NEW_NOTE,
                      base::MakeUnique<ChromeAppDelegate>(true)));
   }
 
   void ClearObservedStates() {
     state_controller_->FlushTrayActionForTesting();
     observer_.ClearObservedStates();
     tray_action_.ClearObservedStates();
   }
 
+  void SetPrimaryProfileAndWaitUnitlReady() {
+    state_controller_->SetPrimaryProfile(&profile_);
+    ready_waiter_.Run();
+  }
+
   // Helper method to move state controller to the specified state.
   // Should be called at the begining of tests, at most once.
   bool InitializeNoteTakingApp(TrayActionState target_state,
                                bool enable_app_launch) {
     app_ = CreateTestNoteTakingApp(kTestAppId);
-    extensions::ExtensionSystem::Get(signin_profile())
+    extensions::ExtensionSystem::Get(lock_screen_profile())
         ->extension_service()
         ->AddExtension(app_.get());
 
     app_manager_->SetInitialAppState(kTestAppId, enable_app_launch);
-    state_controller_->SetPrimaryProfile(&profile_);
+    SetPrimaryProfileAndWaitUnitlReady();
 
     if (target_state == TrayActionState::kNotAvailable)
       return true;
 
     session_manager_->SetSessionState(session_manager::SessionState::LOCKED);
     if (app_manager_->state() != TestAppManager::State::kStarted) {
       ADD_FAILURE() << "Lock app manager Start not invoked.";
       return false;
     }
 
@@ skipping 13 matching lines @@
     ClearObservedStates();
 
     if (state_controller_->GetLockScreenNoteState() !=
         TrayActionState::kLaunching) {
       ADD_FAILURE() << "Unable to move to launching state.";
       return false;
     }
     if (target_state == TrayActionState::kLaunching)
       return true;
 
-    app_window_ = CreateNoteTakingWindow(signin_profile(), app());
+    app_window_ = CreateNoteTakingWindow(lock_screen_profile(), app());
     if (!app_window_->window()) {
       ADD_FAILURE() << "Not allowed to create app window.";
       return false;
     }
 
     app_window()->Initialize(true /* shown */);
 
     ClearObservedStates();
 
     return state_controller()->GetLockScreenNoteState() ==
            TrayActionState::kActive;
   }
 
   TestingProfile* profile() { return &profile_; }
-  TestingProfile* signin_profile() { return signin_profile_; }
+  TestingProfile* lock_screen_profile() { return lock_screen_profile_; }
 
   session_manager::SessionManager* session_manager() {
     return session_manager_.get();
   }
 
   TestStateObserver* observer() { return &observer_; }
 
   TestTrayAction* tray_action() { return &tray_action_; }
 
   lock_screen_apps::StateController* state_controller() {
     return state_controller_.get();
   }
 
   TestAppManager* app_manager() { return app_manager_; }
 
   TestAppWindow* app_window() { return app_window_.get(); }
   const extensions::Extension* app() { return app_.get(); }
 
  private:
   std::unique_ptr<base::test::ScopedCommandLine> command_line_;
   TestingProfileManager profile_manager_;
   TestingProfile profile_;
-  TestingProfile* signin_profile_ = nullptr;
+  TestingProfile* lock_screen_profile_ = nullptr;
+
+  // Run loop used to throttle test until async state controller initialization
+  // is fully complete. The quit closure for this run loop will be passed to
+  // |state_controller_| as the callback to be run when the state controller is
+  // ready for action.
+  // NOTE: Tests should call |state_controller_->SetPrimaryProfile(Profile*)|
+  // before running the loop, as that is the method that starts the state
+  // controller.
+  base::RunLoop ready_waiter_;
 
   std::unique_ptr<session_manager::SessionManager> session_manager_;
 
   std::unique_ptr<lock_screen_apps::StateController> state_controller_;
 
   TestStateObserver observer_;
   TestTrayAction tray_action_;
   TestAppManager* app_manager_ = nullptr;
 
   std::unique_ptr<TestAppWindow> app_window_;
@@ skipping 17 matching lines @@
 
   EXPECT_EQ(TrayActionState::kNotAvailable,
             state_controller()->GetLockScreenNoteState());
 
   EXPECT_EQ(0u, observer()->observed_states().size());
   EXPECT_EQ(0u, tray_action()->observed_states().size());
 }
 
 TEST_F(LockScreenAppStateTest, SetPrimaryProfile) {
   EXPECT_EQ(TestAppManager::State::kNotInitialized, app_manager()->state());
-  state_controller()->SetPrimaryProfile(profile());
+  SetPrimaryProfileAndWaitUnitlReady();
 
   EXPECT_EQ(TestAppManager::State::kStopped, app_manager()->state());
   EXPECT_EQ(TrayActionState::kNotAvailable,
             state_controller()->GetLockScreenNoteState());
   EXPECT_EQ(0u, observer()->observed_states().size());
 }
 
 TEST_F(LockScreenAppStateTest, SetPrimaryProfileWhenSessionLocked) {
   session_manager()->SetSessionState(session_manager::SessionState::LOCKED);
   EXPECT_EQ(TrayActionState::kNotAvailable,
             state_controller()->GetLockScreenNoteState());
 
   EXPECT_EQ(TestAppManager::State::kNotInitialized, app_manager()->state());
 
   app_manager()->SetInitialAppState(kTestAppId, true);
-  state_controller()->SetPrimaryProfile(profile());
+  SetPrimaryProfileAndWaitUnitlReady();
 
   ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state());
 
   EXPECT_EQ(TrayActionState::kAvailable,
             state_controller()->GetLockScreenNoteState());
 
   ExpectObservedStatesMatch({TrayActionState::kAvailable}, "Available on lock");
 }
 
 TEST_F(LockScreenAppStateTest, SessionLock) {
   app_manager()->SetInitialAppState(kTestAppId, true);
-  state_controller()->SetPrimaryProfile(profile());
+  SetPrimaryProfileAndWaitUnitlReady();
   ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state());
 
   session_manager()->SetSessionState(session_manager::SessionState::LOCKED);
 
   ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state());
 
   EXPECT_EQ(TrayActionState::kAvailable,
             state_controller()->GetLockScreenNoteState());
 
   ExpectObservedStatesMatch({TrayActionState::kAvailable}, "Available on lock");
@@ skipping 13 matching lines @@
   ClearObservedStates();
 
   // Test that subsequent session lock works as expected.
   session_manager()->SetSessionState(session_manager::SessionState::LOCKED);
   ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state());
   ExpectObservedStatesMatch({TrayActionState::kAvailable},
                             "Available on second lock");
 }
 
 TEST_F(LockScreenAppStateTest, SessionUnlockedWhileStartingAppManager) {
-  state_controller()->SetPrimaryProfile(profile());
+  SetPrimaryProfileAndWaitUnitlReady();
   ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state());
 
   session_manager()->SetSessionState(session_manager::SessionState::LOCKED);
 
   ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state());
 
   session_manager()->SetSessionState(session_manager::SessionState::ACTIVE);
   ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state());
 
   EXPECT_EQ(TrayActionState::kNotAvailable,
             state_controller()->GetLockScreenNoteState());
   state_controller()->FlushTrayActionForTesting();
   EXPECT_EQ(0u, observer()->observed_states().size());
   EXPECT_EQ(0u, tray_action()->observed_states().size());
 
   // Test that subsequent session lock works as expected.
   session_manager()->SetSessionState(session_manager::SessionState::LOCKED);
 
   ASSERT_EQ(TestAppManager::State::kStarted, app_manager()->state());
   app_manager()->UpdateApp(kTestAppId, true);
 
   EXPECT_EQ(TrayActionState::kAvailable,
             state_controller()->GetLockScreenNoteState());
   ExpectObservedStatesMatch({TrayActionState::kAvailable}, "Available on lock");
 }
 
 TEST_F(LockScreenAppStateTest, AppManagerNoApp) {
-  state_controller()->SetPrimaryProfile(profile());
+  SetPrimaryProfileAndWaitUnitlReady();
   ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state());
 
   session_manager()->SetSessionState(session_manager::SessionState::LOCKED);
 
   EXPECT_EQ(TestAppManager::State::kStarted, app_manager()->state());
 
   EXPECT_EQ(TrayActionState::kNotAvailable,
             state_controller()->GetLockScreenNoteState());
   state_controller()->FlushTrayActionForTesting();
   EXPECT_EQ(0u, observer()->observed_states().size());
@@ skipping 13 matching lines @@
   app_manager()->SetInitialAppState(kTestAppId, false);
 
   session_manager()->SetSessionState(session_manager::SessionState::LOCKED);
 
   EXPECT_EQ(TrayActionState::kAvailable,
             state_controller()->GetLockScreenNoteState());
   ExpectObservedStatesMatch({TrayActionState::kAvailable}, "Available on lock");
 }
 
 TEST_F(LockScreenAppStateTest, AppAvailabilityChanges) {
-  state_controller()->SetPrimaryProfile(profile());
+  SetPrimaryProfileAndWaitUnitlReady();
   ASSERT_EQ(TestAppManager::State::kStopped, app_manager()->state());
 
   app_manager()->SetInitialAppState(kTestAppId, false);
   session_manager()->SetSessionState(session_manager::SessionState::LOCKED);
 
   EXPECT_EQ(TestAppManager::State::kStarted, app_manager()->state());
 
   EXPECT_EQ(TrayActionState::kAvailable,
             state_controller()->GetLockScreenNoteState());
   ExpectObservedStatesMatch({TrayActionState::kAvailable}, "Available on lock");
@@ skipping 117 matching lines @@
       {TrayActionState::kLaunching, TrayActionState::kAvailable},
       "Second failed launch on new note request");
   EXPECT_EQ(2, app_manager()->launch_count());
 }
 
 TEST_F(LockScreenAppStateTest, AppWindowRegistration) {
   ASSERT_TRUE(InitializeNoteTakingApp(TrayActionState::kAvailable,
                                       true /* enable_app_launch */));
 
   std::unique_ptr<TestAppWindow> app_window =
-      CreateNoteTakingWindow(signin_profile(), app());
+      CreateNoteTakingWindow(lock_screen_profile(), app());
   EXPECT_FALSE(app_window->window());
 
   tray_action()->SendNewNoteRequest();
   state_controller()->FlushTrayActionForTesting();
 
   EXPECT_EQ(TrayActionState::kLaunching,
             state_controller()->GetLockScreenNoteState());
   observer()->ClearObservedStates();
   tray_action()->ClearObservedStates();
 
   std::unique_ptr<TestAppWindow> non_eligible_app_window =
       CreateNoteTakingWindow(profile(), app());
   EXPECT_FALSE(non_eligible_app_window->window());
 
   EXPECT_FALSE(state_controller()->CreateAppWindowForLockScreenAction(
-      signin_profile(), app(), extensions::api::app_runtime::ACTION_TYPE_NONE,
+      lock_screen_profile(), app(),
+      extensions::api::app_runtime::ACTION_TYPE_NONE,
       base::MakeUnique<ChromeAppDelegate>(true)));
 
-  app_window = CreateNoteTakingWindow(signin_profile(), app());
+  app_window = CreateNoteTakingWindow(lock_screen_profile(), app());
   ASSERT_TRUE(app_window->window());
 
   app_window->Initialize(true /* shown */);
   EXPECT_EQ(TrayActionState::kActive,
             state_controller()->GetLockScreenNoteState());
 
   // Test that second app window cannot be registered.
   std::unique_ptr<TestAppWindow> second_app_window =
-      CreateNoteTakingWindow(signin_profile(), app());
+      CreateNoteTakingWindow(lock_screen_profile(), app());
   EXPECT_FALSE(second_app_window->window());
 
   // Test the app window does not get closed by itself.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(app_window->closed());
 
   EXPECT_EQ(TrayActionState::kActive,
             state_controller()->GetLockScreenNoteState());
 
   // Closing the second app window, will not change the state.
   second_app_window->Close();
   EXPECT_EQ(TrayActionState::kActive,
             state_controller()->GetLockScreenNoteState());
 
   app_window->Close();
   EXPECT_EQ(TrayActionState::kAvailable,
             state_controller()->GetLockScreenNoteState());
 }
 
 TEST_F(LockScreenAppStateTest, AppWindowClosedBeforeBeingShown) {
   ASSERT_TRUE(InitializeNoteTakingApp(TrayActionState::kLaunching,
                                       true /* enable_app_launch */));
 
   std::unique_ptr<TestAppWindow> app_window =
-      CreateNoteTakingWindow(signin_profile(), app());
+      CreateNoteTakingWindow(lock_screen_profile(), app());
   ASSERT_TRUE(app_window->window());
   app_window->Initialize(false /* shown */);
 
   app_window->Close();
   EXPECT_EQ(TrayActionState::kAvailable,
             state_controller()->GetLockScreenNoteState());
 }
 
 TEST_F(LockScreenAppStateTest, AppWindowClosedOnSessionUnlock) {
   ASSERT_TRUE(InitializeNoteTakingApp(TrayActionState::kActive,
                                       true /* enable_app_launch */));
 
   session_manager()->SetSessionState(session_manager::SessionState::ACTIVE);
   EXPECT_EQ(TrayActionState::kNotAvailable,
             state_controller()->GetLockScreenNoteState());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(app_window()->closed());
 }
 
 TEST_F(LockScreenAppStateTest, AppWindowClosedOnAppUnload) {
   ASSERT_TRUE(InitializeNoteTakingApp(TrayActionState::kActive,
                                       true /* enable_app_launch */));
 
-  extensions::ExtensionSystem::Get(signin_profile())
+  extensions::ExtensionSystem::Get(lock_screen_profile())
       ->extension_service()
       ->UnloadExtension(app()->id(),
                         extensions::UnloadedExtensionReason::UNINSTALL);
   app_manager()->UpdateApp("", false);
 
   EXPECT_EQ(TrayActionState::kNotAvailable,
             state_controller()->GetLockScreenNoteState());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(app_window()->closed());
 }
 
 TEST_F(LockScreenAppStateTest, AppWindowClosedOnNoteTakingAppChange) {
   ASSERT_TRUE(InitializeNoteTakingApp(TrayActionState::kActive,
                                       true /* enable_app_launch */));
 
   scoped_refptr<extensions::Extension> secondary_app =
       CreateTestNoteTakingApp(kSecondaryTestAppId);
-  extensions::ExtensionSystem::Get(signin_profile())
+  extensions::ExtensionSystem::Get(lock_screen_profile())
       ->extension_service()
       ->AddExtension(secondary_app.get());
 
   app_manager()->UpdateApp(secondary_app->id(), true);
 
   EXPECT_EQ(TrayActionState::kAvailable,
             state_controller()->GetLockScreenNoteState());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(app_window()->closed());
 
   tray_action()->SendNewNoteRequest();
   state_controller()->FlushTrayActionForTesting();
 
   std::unique_ptr<TestAppWindow> app_window =
-      CreateNoteTakingWindow(signin_profile(), app());
+      CreateNoteTakingWindow(lock_screen_profile(), app());
   EXPECT_FALSE(app_window->window());
   ASSERT_EQ(TrayActionState::kLaunching,
             state_controller()->GetLockScreenNoteState());
 
   std::unique_ptr<TestAppWindow> secondary_app_window =
-      CreateNoteTakingWindow(signin_profile(), secondary_app.get());
+      CreateNoteTakingWindow(lock_screen_profile(), secondary_app.get());
   ASSERT_TRUE(secondary_app_window->window());
 
   secondary_app_window->Initialize(true /* shown*/);
   EXPECT_EQ(TrayActionState::kActive,
             state_controller()->GetLockScreenNoteState());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(secondary_app_window->closed());
 
   // Uninstall the app and test the secondary app window is closed.
-  extensions::ExtensionSystem::Get(signin_profile())
+  extensions::ExtensionSystem::Get(lock_screen_profile())
       ->extension_service()
       ->UnloadExtension(secondary_app->id(),
                         extensions::UnloadedExtensionReason::UNINSTALL);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(secondary_app_window->closed());
 }