Access to Chrome via the System Tray should go through the User Manager.

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/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/singleton_tabs.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"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
@@ skipping 37 matching lines @@
   if (status != Profile::CREATE_STATUS_INITIALIZED)
     return;
   profiles::FindOrCreateNewWindowForProfile(
     profile,
     chrome::startup::IS_PROCESS_STARTUP,
     chrome::startup::IS_FIRST_RUN,
     desktop_type,
     false);
 }
 
-// This callback is run after switching to a new profile has finished. This
-// means either a new browser window has been opened, or an existing one
-// has been found, which means we can safely close the User Manager without
-// accidentally terminating the browser process. The task needs to be posted,
-// as HideUserManager will end up destroying its WebContents, which will
-// destruct the UserManagerScreenHandler as well.
-void OnSwitchToProfileComplete() {
-  base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&chrome::HideUserManager));
-}
-
 std::string GetAvatarImageAtIndex(
     size_t index, const ProfileInfoCache& info_cache) {
   bool is_gaia_picture =
       info_cache.IsUsingGAIAPictureOfProfileAtIndex(index) &&
       info_cache.GetGAIAPictureOfProfileAtIndex(index);
 
   // If the avatar is too small (i.e. the old-style low resolution avatar),
   // it will be pixelated when displayed in the User Manager, so we should
   // return the placeholder avatar instead.
   gfx::Image avatar_image = info_cache.GetAvatarIconOfProfileAtIndex(index);
@@ skipping 95 matching lines @@
   ProfileManager* profile_manager_;
 
   UserManagerScreenHandler* user_manager_handler_;  // Weak; owns us.
 
   DISALLOW_COPY_AND_ASSIGN(ProfileUpdateObserver);
 };
 
 // UserManagerScreenHandler ---------------------------------------------------
 
 UserManagerScreenHandler::UserManagerScreenHandler()
-    : desktop_type_(chrome::GetActiveDesktop()) {
+    : desktop_type_(chrome::GetActiveDesktop()),
+      weak_ptr_factory_(this) {
   profileInfoCacheObserver_.reset(
       new UserManagerScreenHandler::ProfileUpdateObserver(
           g_browser_process->profile_manager(), this));
 }
 
 UserManagerScreenHandler::~UserManagerScreenHandler() {
   ScreenlockBridge::Get()->SetLockHandler(NULL);
 }
 
 void UserManagerScreenHandler::ShowBannerMessage(
@@ skipping 55 matching lines @@
       g_browser_process->profile_manager()->GetProfileInfoCache();
   const size_t profile_index = GetIndexOfProfileWithEmailAndName(
       info_cache, base::UTF8ToUTF16(user_email), base::string16());
   DCHECK_LT(profile_index, info_cache.GetNumberOfProfiles());
 
   authenticating_profile_index_ = profile_index;
   ReportAuthenticationResult(true, ProfileMetrics::AUTH_LOCAL);
 }
 
 void UserManagerScreenHandler::HandleInitialize(const base::ListValue* args) {
+  // If the URL has a hash parameter, store it for later.
+  base::string16 url_hash;
+  if (args->GetString(0, &url_hash))
+    url_hash_ = url_hash;
+
   SendUserList();
   web_ui()->CallJavascriptFunction("cr.ui.Oobe.showUserManagerScreen",
       base::FundamentalValue(IsGuestModeEnabled()));
   desktop_type_ = chrome::GetHostDesktopTypeForNativeView(
       web_ui()->GetWebContents()->GetNativeView());
 
   ScreenlockBridge::Get()->SetLockHandler(this);
 }
 
 void UserManagerScreenHandler::HandleAddUser(const base::ListValue* args) {
-  profiles::CreateAndSwitchToNewProfile(desktop_type_,
-                                        base::Bind(&OnSwitchToProfileComplete),
-                                        ProfileMetrics::ADD_NEW_USER_MANAGER);
+  profiles::CreateAndSwitchToNewProfile(
+      desktop_type_,
+      base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
+                 weak_ptr_factory_.GetWeakPtr()),
+      ProfileMetrics::ADD_NEW_USER_MANAGER);
 }
 
 void UserManagerScreenHandler::HandleAuthenticatedLaunchUser(
     const base::ListValue* args) {
   base::string16 email_address;
   if (!args->GetString(0, &email_address))
     return;
 
   base::string16 display_name;
   if (!args->GetString(1, &display_name))
@@ skipping 58 matching lines @@
 
   g_browser_process->profile_manager()->ScheduleProfileForDeletion(
       profile_path,
       base::Bind(&OpenNewWindowForProfile, desktop_type_));
   ProfileMetrics::LogProfileDeleteUser(
       ProfileMetrics::DELETE_PROFILE_USER_MANAGER);
 }
 
 void UserManagerScreenHandler::HandleLaunchGuest(const base::ListValue* args) {
   if (IsGuestModeEnabled()) {
-    profiles::SwitchToGuestProfile(desktop_type_,
-                                   base::Bind(&OnSwitchToProfileComplete));
     ProfileMetrics::LogProfileSwitchUser(ProfileMetrics::SWITCH_PROFILE_GUEST);
+    profiles::SwitchToGuestProfile(
+        desktop_type_,
+        base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
+                   weak_ptr_factory_.GetWeakPtr()));
   } else {
     // The UI should have prevented the user from allowing the selection of
     // guest mode.
     NOTREACHED();
   }
 }
 
 void UserManagerScreenHandler::HandleLaunchUser(const base::ListValue* args) {
   base::string16 email_address;
   base::string16 display_name;
@@ skipping 17 matching lines @@
   // It's possible that a user breaks into the user-manager page using the
   // JavaScript Inspector and causes a "locked" profile to call this
   // unauthenticated version of "launch" instead of the proper one.  Thus,
   // we have to validate in (secure) C++ code that it really is a profile
   // not needing authentication.  If it is, just ignore the "launch" request.
   if (info_cache.ProfileIsSigninRequiredAtIndex(profile_index))
     return;
   ProfileMetrics::LogProfileAuthResult(ProfileMetrics::AUTH_UNNECESSARY);
 
   base::FilePath path = info_cache.GetPathOfProfileAtIndex(profile_index);
-  profiles::SwitchToProfile(path,
-                            desktop_type_,
-                            false,  /* reuse any existing windows */
-                            base::Bind(&OnSwitchToProfileComplete),
-                            ProfileMetrics::SWITCH_PROFILE_MANAGER);
+  profiles::SwitchToProfile(
+      path,
+      desktop_type_,
+      false,  /* reuse any existing windows */
+      base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
+                 weak_ptr_factory_.GetWeakPtr()),
+      ProfileMetrics::SWITCH_PROFILE_MANAGER);
 }
 
 void UserManagerScreenHandler::HandleAttemptUnlock(
     const base::ListValue* args) {
   std::string email;
   CHECK(args->GetString(0, &email));
   GetScreenlockRouter(email)->OnAuthAttempted(GetAuthType(email), "");
 }
 
 void UserManagerScreenHandler::HandleHardlockUserPod(
@@ skipping 223 matching lines @@
   ProfileMetrics::LogProfileAuthResult(auth);
   password_attempt_.clear();
 
   if (success) {
     ProfileInfoCache& info_cache =
         g_browser_process->profile_manager()->GetProfileInfoCache();
     info_cache.SetProfileSigninRequiredAtIndex(
         authenticating_profile_index_, false);
     base::FilePath path = info_cache.GetPathOfProfileAtIndex(
         authenticating_profile_index_);
-    profiles::SwitchToProfile(path, desktop_type_, true,
-                              base::Bind(&OnSwitchToProfileComplete),
-                              ProfileMetrics::SWITCH_PROFILE_UNLOCK);
+    profiles::SwitchToProfile(
+        path,
+        desktop_type_,
+        true,
+        base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
+                   weak_ptr_factory_.GetWeakPtr()),
+        ProfileMetrics::SWITCH_PROFILE_UNLOCK);
   } else {
     web_ui()->CallJavascriptFunction(
         "cr.ui.Oobe.showSignInError",
         base::FundamentalValue(0),
         base::StringValue(
             l10n_util::GetStringUTF8(IDS_LOGIN_ERROR_AUTHENTICATING)),
         base::StringValue(""),
         base::FundamentalValue(0));
   }
 }
+
+void UserManagerScreenHandler::OnBrowserWindowReady(Browser* browser) {
+  chrome::HideUserManager();
+  if (url_hash_ ==

[noms (inactive), 2014/09/12 14:44:16]

Why don't you just save the hash as an std::string the first time?

[Mike Lerman, 2014/09/15 13:44:04]

Because that's too easy!

Done.

+      base::UTF8ToUTF16(profiles::kUserManagerSelectProfileTaskManager)) {
+    base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(&chrome::ShowTaskManager, browser));
+  } else if (url_hash_ ==
+      base::UTF8ToUTF16(profiles::kUserManagerSelectProfileAboutChrome)) {
+    if (browser) {
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(&chrome::ShowAboutChrome, browser));
+    } else {
+      NOTREACHED();
+    }
+  }
+}
+
+void UserManagerScreenHandler::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_BROWSER_WINDOW_READY:
+      OnBrowserWindowReady(content::Source<Browser>(source).ptr());
+      // Only respond to one Browser Window Ready event.
+      registrar_.Remove(this,
+                        chrome::NOTIFICATION_BROWSER_WINDOW_READY,
+                        content::NotificationService::AllSources());
+    break;
+    default:
+      NOTREACHED();
+  }
+}
+
+// This callback is run after switching to a new profile has finished. This
+// means either a new browser has been created (but not the window), or an
+// existing one has been found. The HideUserManager task needs to be posted
+// since closing the User Manager before the window is created can flakily
+// cause Chrome to close.
+void UserManagerScreenHandler::OnSwitchToProfileComplete(
+    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());
+  }
+}