Introduce profile for lock screen apps

chrome/browser/chromeos/lock_screen_apps/state_controller.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 <utility>
 
 #include "ash/public/interfaces/constants.mojom.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/string16.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/lock_screen_apps/app_manager_impl.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
-#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
+#include "components/prefs/pref_service.h"
 #include "components/session_manager/core/session_manager.h"
 #include "content/public/common/service_manager_connection.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/common/extension.h"
 #include "services/service_manager/public/cpp/connector.h"
 
 using ash::mojom::TrayActionState;
 
 namespace lock_screen_apps {
@@ skipping 10 matching lines @@
       chromeos::switches::kEnableLockScreenApps);
 }
 
 // static
 StateController* StateController::Get() {
   DCHECK(g_instance || !IsEnabled());
   return g_instance;
 }
 
 StateController::StateController()
-    : binding_(this), app_window_observer_(this), session_observer_(this) {
+    : binding_(this),
+      app_window_observer_(this),
+      session_observer_(this),
+      weak_ptr_factory_(this) {
   DCHECK(!g_instance);
   DCHECK(IsEnabled());
 
   g_instance = this;
 }
 
 StateController::~StateController() {
   DCHECK_EQ(g_instance, this);
   g_instance = nullptr;
 }
 
 void StateController::SetTrayActionPtrForTesting(
     ash::mojom::TrayActionPtr tray_action_ptr) {
   tray_action_ptr_ = std::move(tray_action_ptr);
 }
 
 void StateController::FlushTrayActionForTesting() {
   tray_action_ptr_.FlushForTesting();
 }
 
+void StateController::SetReadyCallbackForTesting(
+    const base::Closure& ready_callback) {
+  DCHECK(ready_callback_.is_null());
+
+  ready_callback_ = ready_callback;
+}
+
 void StateController::SetAppManagerForTesting(
     std::unique_ptr<AppManager> app_manager) {
   DCHECK(!app_manager_);
   app_manager_ = std::move(app_manager);
 }
 
 void StateController::Initialize() {
   // The tray action ptr might be set previously if the client was being created
   // for testing.
   if (!tray_action_ptr_) {
     service_manager::Connector* connector =
         content::ServiceManagerConnection::GetForProcess()->GetConnector();
     connector->BindInterface(ash::mojom::kServiceName, &tray_action_ptr_);
   }
   ash::mojom::TrayActionClientPtr client;
   binding_.Bind(mojo::MakeRequest(&client));
   tray_action_ptr_->SetClient(std::move(client), lock_screen_note_state_);
 }
 
 void StateController::SetPrimaryProfile(Profile* profile) {
+  g_browser_process->profile_manager()->CreateProfileAsync(
+      chromeos::ProfileHelper::GetLockScreenAppProfilePath(),
+      base::Bind(&StateController::OnProfilesReady,
+                 weak_ptr_factory_.GetWeakPtr(), profile),
+      base::string16() /* name */, "" /* icon_url*/,
+      "" /* supervised_user_id */);
+}
+
+void StateController::OnProfilesReady(Profile* primary_profile,
+                                      Profile* lock_screen_profile,
+                                      Profile::CreateStatus status) {
+  // Ignore CREATED status - wait for profile to be initialized before
+  // continuing.
+  if (status == Profile::CREATE_STATUS_CREATED)
+    return;
+
+  // On error, bail out - this will cause the lock screen apps to remain
+  // unavailable on the device.
+  if (status != Profile::CREATE_STATUS_INITIALIZED) {
+    LOG(ERROR) << "Failed to create profile for lock screen apps.";
+    return;
+  }
+
+  DCHECK(!lock_screen_profile_);
+
+  lock_screen_profile_ = lock_screen_profile;
+  lock_screen_profile_->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles,
+                                               true);
+
   // App manager might have been set previously by a test.
   if (!app_manager_)
     app_manager_ = base::MakeUnique<AppManagerImpl>();
-  app_manager_->Initialize(
-      profile,
-      chromeos::ProfileHelper::GetSigninProfile()->GetOriginalProfile());
+  app_manager_->Initialize(primary_profile, lock_screen_profile);
 
   session_observer_.Add(session_manager::SessionManager::Get());
   OnSessionStateChanged();
+
+  // SessionController is fully initialized at this point.
+  if (!ready_callback_.is_null()) {
+    ready_callback_.Run();
+    ready_callback_.Reset();
+  }
 }
 
 void StateController::AddObserver(StateObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void StateController::RemoveObserver(StateObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 40 matching lines @@
     content::BrowserContext* context,
     const extensions::Extension* extension,
     extensions::api::app_runtime::ActionType action,
     std::unique_ptr<extensions::AppDelegate> app_delegate) {
   if (action != extensions::api::app_runtime::ACTION_TYPE_NEW_NOTE)
     return nullptr;
 
   if (lock_screen_note_state_ != TrayActionState::kLaunching)
     return nullptr;
 
-  if (!chromeos::ProfileHelper::GetSigninProfile()->IsSameProfile(
+  if (!lock_screen_profile_->IsSameProfile(
           Profile::FromBrowserContext(context))) {
     return nullptr;
   }
 
   if (!extension || app_manager_->GetNoteTakingAppId() != extension->id())
     return nullptr;
 
   // The ownership of the window is passed to the caller of this method.
   note_app_window_ =
       new extensions::AppWindow(context, app_delegate.release(), extension);
-  app_window_observer_.Add(extensions::AppWindowRegistry::Get(
-      chromeos::ProfileHelper::GetSigninProfile()));
+  app_window_observer_.Add(
+      extensions::AppWindowRegistry::Get(lock_screen_profile_));
   UpdateLockScreenNoteState(TrayActionState::kActive);
   return note_app_window_;
 }
 
 void StateController::MoveToBackground() {
   if (GetLockScreenNoteState() != TrayActionState::kActive)
     return;
   UpdateLockScreenNoteState(TrayActionState::kBackground);
 }
 
@@ skipping 41 matching lines @@
 }
 
 void StateController::NotifyLockScreenNoteStateChanged() {
   for (auto& observer : observers_)
     observer.OnLockScreenNoteStateChanged(lock_screen_note_state_);
 
   tray_action_ptr_->UpdateLockScreenNoteState(lock_screen_note_state_);
 }
 
 }  // namespace lock_screen_apps