Introduce profile for lock screen apps

chrome/browser/chromeos/lock_screen_apps/state_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_LOCK_SCREEN_APPS_STATE_CONTROLLER_H_
 #define CHROME_BROWSER_CHROMEOS_LOCK_SCREEN_APPS_STATE_CONTROLLER_H_
 
 #include <memory>
 
 #include "ash/public/interfaces/tray_action.mojom.h"
+#include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/scoped_observer.h"
 #include "chrome/browser/chromeos/lock_screen_apps/app_manager.h"
 #include "chrome/browser/chromeos/lock_screen_apps/state_observer.h"
+#include "chrome/browser/profiles/profile.h"
 #include "components/session_manager/core/session_manager_observer.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/common/api/app_runtime.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
-class Profile;
-
 namespace content {
 class BrowserContext;
 }
 
 namespace extensions {
 class AppDelegate;
 class AppWindow;
 class Extension;
-}
+}  // namespace extensions
 
 namespace session_manager {
 class SessionManager;
 }
 
 namespace lock_screen_apps {
 
 class StateObserver;
 
 // Manages state of lock screen action handler apps, and notifies
@@ skipping 15 matching lines @@
   // Note that only one StateController is allowed per process. Creating a
   // StateController will set global instance ptr that can be accessed using
   // |Get|. This pointer will be reset when the StateController is destroyed.
   StateController();
   ~StateController() override;
 
   // Sets the tray action that should be used by |StateController|.
   // Has to be called before |Initialize|.
   void SetTrayActionPtrForTesting(ash::mojom::TrayActionPtr tray_action_ptr);
   void FlushTrayActionForTesting();
+  // Sets the callback that will be run when the state controller is fully
+  // initialized and ready for action.
+  void SetReadyCallbackForTesting(const base::Closure& ready_callback);
   // Sets test AppManager implementation. Should be called before
   // |SetPrimaryProfile|
   void SetAppManagerForTesting(std::unique_ptr<AppManager> app_manager);
 
   // Initializes mojo bindings for the StateController - it creates binding to
   // ash's tray action interface and sets this object as the interface's client.
   void Initialize();
   void SetPrimaryProfile(Profile* profile);
 
   void AddObserver(StateObserver* observer);
@@ skipping 25 matching lines @@
 
   // If there are any active lock screen action handlers, moved their windows
   // to background, to ensure lock screen UI is visible.
   void MoveToBackground();
 
   // If there are any lock screen action handler in background, moves their
   // windows back to foreground (i.e. visible over lock screen UI).
   void MoveToForeground();
 
  private:
+  // Called when profiles needed to run lock screen apps are ready - i.e. when
+  // primary user profiles was set using |SetPrimaryProfile| and the profile in

[xiyuan, 2017/06/22 20:15:25]

nit:   primary user profiles
-> the primary user profile

[tbarzic, 2017/06/22 20:51:15]

Done.

+  // which app lock screen windows will be run creation is done.
+  // |status| - The lock screen profile creation status.
+  void OnProfilesReady(Profile* primary_profile,
+                       Profile* lock_screen_profile,
+                       Profile::CreateStatus status);
+
   // Called when app manager reports that note taking availability has changed.
   void OnNoteTakingAvailabilityChanged();
 
   // If there is an app window registered as a handler for note taking action
   // on lock screen, unregisters the window, and closes is if |close_window| is
   // set. It changes the current state to kAvailable or kNotAvailable, depending
   // on whether lock screen note taking action can still be handled.
   void ResetNoteTakingWindowAndMoveToNextState(bool close_window);
 
   // Requests lock screen note action state change to |state|.
   // Returns whether the action state has changed.
   bool UpdateLockScreenNoteState(ash::mojom::TrayActionState state);
 
   // Notifies observers that the lock screen note action state changed.
   void NotifyLockScreenNoteStateChanged();
 
   // Lock screen note action state.
   ash::mojom::TrayActionState lock_screen_note_state_ =
       ash::mojom::TrayActionState::kNotAvailable;
 
   base::ObserverList<StateObserver> observers_;
 
   mojo::Binding<ash::mojom::TrayActionClient> binding_;
   ash::mojom::TrayActionPtr tray_action_ptr_;
 
+  Profile* lock_screen_profile_ = nullptr;
+
   std::unique_ptr<AppManager> app_manager_;
 
   extensions::AppWindow* note_app_window_ = nullptr;
 
   ScopedObserver<extensions::AppWindowRegistry,
                  extensions::AppWindowRegistry::Observer>
       app_window_observer_;
   ScopedObserver<session_manager::SessionManager,
                  session_manager::SessionManagerObserver>
       session_observer_;
 
+  // If set, this callback will be run when the state controller is fully
+  // initialized. It can be used to throttle tests until state controller
+  // is ready for action - i.e. until the state controller starts reacting
+  // to session / app manager changes.
+  base::Closure ready_callback_;
+
+  base::WeakPtrFactory<StateController> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(StateController);
 };
 
 }  // namespace lock_screen_apps
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOCK_SCREEN_APPS_STATE_CONTROLLER_H_