Loading the Launcher with a Locked Profile launched UserManager.

chrome/browser/ui/webui/signin/user_manager_screen_handler.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/webui/signin/user_manager_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/screenlock_private/screenlock_private_api.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_info_cache_observer.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/signin/local_auth.h"
+#include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/user_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
@@ skipping 98 matching lines @@
   DCHECK(service);
   return service->GetBoolean(prefs::kBrowserGuestModeEnabled);
 }
 
 bool IsAddPersonEnabled() {
   PrefService* service = g_browser_process->local_state();
   DCHECK(service);
   return service->GetBoolean(prefs::kBrowserAddPersonEnabled);
 }
 
+// Executes the action specified by the URL's Hash parameter, if any. Deletes
+// itself after the action would be performed.

[tapted, 2015/01/27 22:40:26]

nit: now that it's base::Owned, the Closure will delete it. (i.e. no longer
deletes itself)

[Mike Lerman, 2015/01/28 20:26:46]

Done.

+class UrlHashHelper : public chrome::BrowserListObserver {
+ public:
+  UrlHashHelper(Browser* browser, const std::string& hash);
+  ~UrlHashHelper() override;
+
+  void ExecuteUrlHash();
+
+  // chrome::BrowserListObserver overrides:
+  void OnBrowserRemoved(Browser* browser) override;
+
+ private:
+  Browser* browser_;
+  Profile* profile_;
+  chrome::HostDesktopType desktop_type_;
+  const std::string& hash_;

[tapted, 2015/01/27 22:40:26]

This can't be const-reference, just the constructor argument. Doing this results
in the string data still being owned by UserManagerScreenHandler, but there's
nothing that ties the lifetime of UrlHashHelper to UserManagerScreenHandler.

passing string arguments by const reference is talked about at
http://www.chromium.org/developers/chromium-string-usage (i.e. "For function
input parameters, prefer to pass a string by const reference instead of making a
new copy.")

[Mike Lerman, 2015/01/28 20:26:46]

Ah that makes sense. Thanks!

+
+  DISALLOW_COPY_AND_ASSIGN(UrlHashHelper);
+};
+
+UrlHashHelper::UrlHashHelper(Browser* browser, const std::string& hash)
+    : browser_(browser),
+      profile_(browser->profile()),
+      desktop_type_(browser->host_desktop_type()),
+      hash_(hash) {
+  BrowserList::AddObserver(this);
+}
+
+UrlHashHelper::~UrlHashHelper() {
+  BrowserList::RemoveObserver(this);
+}
+
+void UrlHashHelper::OnBrowserRemoved(Browser* browser) {
+  if (browser == browser_)
+    browser_ = nullptr;
+}
+
+// This UrlHashHelper will be deleted after the execution of this method.
+void UrlHashHelper::ExecuteUrlHash() {
+  if (hash_ == profiles::kUserManagerSelectProfileAppLauncher) {
+    AppListService* app_list_service = AppListService::Get(desktop_type_);
+    app_list_service->ShowForProfile(profile_);
+    return;
+  }
+
+  Browser* target_browser = browser_;
+  if (!target_browser) {
+    target_browser = chrome::FindLastActiveWithProfile(profile_, desktop_type_);
+    if (!target_browser)
+      return;
+  }
+
+  if (hash_ == profiles::kUserManagerSelectProfileTaskManager)
+    chrome::OpenTaskManager(target_browser);
+  else if (hash_ == profiles::kUserManagerSelectProfileAboutChrome)
+    chrome::ShowAboutChrome(target_browser);
+  else if (hash_ == profiles::kUserManagerSelectProfileChromeSettings)
+    chrome::ShowSettings(target_browser);
+  else if (hash_ == profiles::kUserManagerSelectProfileChromeMemory)
+    chrome::ShowMemory(target_browser);
+}
+
 }  // namespace
 
 // ProfileUpdateObserver ------------------------------------------------------
 
 class UserManagerScreenHandler::ProfileUpdateObserver
     : public ProfileInfoCacheObserver {
  public:
   ProfileUpdateObserver(
       ProfileManager* profile_manager, UserManagerScreenHandler* handler)
       : profile_manager_(profile_manager),
@@ skipping 551 matching lines @@
   // Unlock the profile after browser opens so startup can read the lock bit.
   // Any necessary authentication must have been successful to reach this point.
   if (!browser->profile()->IsGuestSession()) {
     ProfileInfoCache& info_cache =
         g_browser_process->profile_manager()->GetProfileInfoCache();
     size_t index = info_cache.GetIndexOfProfileWithPath(
         browser->profile()->GetPath());
     info_cache.SetProfileSigninRequiredAtIndex(index, false);
   }
 
-  if (url_hash_ == profiles::kUserManagerSelectProfileTaskManager) {
+  if (!url_hash_.empty()) {
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&chrome::OpenTaskManager, browser));
-  } else if (url_hash_ == profiles::kUserManagerSelectProfileAboutChrome) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&chrome::ShowAboutChrome, browser));
-  } else if (url_hash_ == profiles::kUserManagerSelectProfileChromeSettings) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&chrome::ShowSettings, browser));
-  } else if (url_hash_ == profiles::kUserManagerSelectProfileChromeMemory) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&chrome::ShowMemory, browser));
+        FROM_HERE,
+        base::Bind(&UrlHashHelper::ExecuteUrlHash,
+                   base::Owned(new UrlHashHelper(browser, url_hash_))));
   }
 
   // This call is last as it deletes this object.
   UserManager::Hide();
 }
 
 void UserManagerScreenHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
@@ skipping 19 matching lines @@
     Profile* profile, Profile::CreateStatus profile_create_status) {
   Browser* browser = chrome::FindAnyBrowser(profile, false, desktop_type_);
   if (browser && browser->window()) {
     OnBrowserWindowReady(browser);
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
   }
 }