Add desktop type context to most existing instances of FindTabbedBrowser.

chrome/browser/profiles/profile_manager.cc

 // Copyright (c) 2012 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 <set>
 
 #include "chrome/browser/profiles/profile_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 135 matching lines @@
 }
 
 void QueueProfileDirectoryForDeletion(const FilePath& path) {
   ProfilesToDelete().push_back(path);
 }
 
 // Called upon completion of profile creation. This function takes care of
 // launching a new browser window and signing the user in to their Google
 // account.
 void OnOpenWindowForNewProfile(
+    chrome::HostDesktopType desktop_type,
     const ProfileManager::CreateCallback& callback,
     Profile* profile,
     Profile::CreateStatus status) {
   if (status == Profile::CREATE_STATUS_INITIALIZED) {
+
     ProfileManager::FindOrCreateNewWindowForProfile(
         profile,
         chrome::startup::IS_PROCESS_STARTUP,
         chrome::startup::IS_FIRST_RUN,
+        desktop_type,
         false);
   }
   if (!callback.is_null())
     callback.Run(profile, status);
 }
 
 #if defined(OS_CHROMEOS)
 void CheckCryptohomeIsMounted(chromeos::DBusMethodCallStatus call_status,
                               bool is_mounted) {
   if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
@@ skipping 93 matching lines @@
       this,
       chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
       content::NotificationService::AllSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED,
       content::NotificationService::AllSources());
 
   if (ProfileShortcutManager::IsFeatureEnabled() && !user_data_dir.empty())
     profile_shortcut_manager_.reset(ProfileShortcutManager::Create(
-                                   this));
+                                    this));
 }
 
 ProfileManager::~ProfileManager() {
 }
 
 FilePath ProfileManager::GetDefaultProfileDir(
     const FilePath& user_data_dir) {
   FilePath default_profile_dir(user_data_dir);
   default_profile_dir =
       default_profile_dir.AppendASCII(chrome::kInitialProfile);
@@ skipping 217 matching lines @@
 Profile* ProfileManager::GetProfileByPath(const FilePath& path) const {
   ProfilesInfoMap::const_iterator iter = profiles_info_.find(path);
   return (iter == profiles_info_.end()) ? NULL : iter->second->profile.get();
 }
 
 // static
 void ProfileManager::FindOrCreateNewWindowForProfile(
     Profile* profile,
     chrome::startup::IsProcessStartup process_startup,
     chrome::startup::IsFirstRun is_first_run,
+    chrome::HostDesktopType desktop_type,
     bool always_create) {
   DCHECK(profile);
 
   if (!always_create) {
-    Browser* browser = browser::FindTabbedBrowser(profile, false);
+    Browser* browser = browser::FindTabbedBrowser(profile, false, desktop_type);
     if (browser) {
       browser->window()->Activate();
       return;
     }
   }
 
   content::RecordAction(UserMetricsAction("NewWindow"));
   CommandLine command_line(CommandLine::NO_PROGRAM);
   int return_code;
   StartupBrowserCreator browser_creator;
@@ skipping 265 matching lines @@
   new_path = new_path.Append(profile_name);
 #endif
   local_state->SetInteger(prefs::kProfilesNumCreated, ++next_directory);
   return new_path;
 }
 
 // static
 void ProfileManager::CreateMultiProfileAsync(
     const string16& name,
     const string16& icon_url,
-    const CreateCallback& callback) {
+    const CreateCallback& callback,
+    chrome::HostDesktopType desktop_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   FilePath new_path = profile_manager->GenerateNextProfileDirectoryPath();
 
   profile_manager->CreateProfileAsync(new_path,
                                       base::Bind(&OnOpenWindowForNewProfile,
-                                          callback),
-                                      name, icon_url);
+                                                 desktop_type,
+                                                 callback),
+                                      name,
+                                      icon_url);
 }
 
 // static
 void ProfileManager::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kProfileLastUsed, "");
   prefs->RegisterIntegerPref(prefs::kProfilesNumCreated, 1);
   prefs->RegisterListPref(prefs::kProfilesLastActive);
 }
 
 size_t ProfileManager::GetNumberOfProfiles() {
@@ skipping 88 matching lines @@
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (!logged_in_ &&
       (!command_line.HasSwitch(switches::kTestType) ||
        command_line.HasSwitch(switches::kLoginProfile))) {
     go_off_the_record = true;
   }
 #endif
   return go_off_the_record;
 }
 
-void ProfileManager::ScheduleProfileForDeletion(const FilePath& profile_dir) {
+void ProfileManager::ScheduleProfileForDeletion(
+    const FilePath& profile_dir,
+    chrome::HostDesktopType desktop_type) {

[Ben Goodger (Google), 2012/10/03 19:16:56]

it's unfortunate to have ProfileManager have to know about HDT. To me this
implies a layering violation in this code. Not your fault. But it seems like if
this gesture originates in UI-land, PM should have a notification/observer
whatever back to UI-land saying that the operation completed with N params and
do with this info as you wish. Then ui-land could open the new window. WDYT? Can
you file a bug/drop a comment here to that effect?

[robertshield, 2012/10/03 19:58:17]

Yeah, that would be much better. ProfileManager really shouldn't be opening
windows. Filed a bug at http://crbug.com/153864 to move
OnOpenWindowForNewProfile out of here.

   DCHECK(IsMultipleProfilesEnabled());
 
   // If we're deleting the last profile, then create a new profile in its
   // place.
   ProfileInfoCache& cache = GetProfileInfoCache();
   if (cache.GetNumberOfProfiles() == 1) {
     FilePath new_path = GenerateNextProfileDirectoryPath();
 
-    CreateProfileAsync(new_path, base::Bind(&OnOpenWindowForNewProfile,
-                       CreateCallback()), string16(), string16());
+    // TODO(robertshield): This desktop type needs to come from the invoker,
+    // currently that involves plumbing this through web UI.
+    chrome::HostDesktopType desktop_type = chrome::HOST_DESKTOP_TYPE_NATIVE;
+    CreateProfileAsync(new_path,
+                       base::Bind(&OnOpenWindowForNewProfile,
+                                  desktop_type,
+                                  CreateCallback()),
+                       string16(),
+                       string16());
   }
 
   // Update the last used profile pref before closing browser windows. This way
   // the correct last used profile is set for any notification observers.
   PrefService* local_state = g_browser_process->local_state();
   std::string last_profile = local_state->GetString(prefs::kProfileLastUsed);
   if (profile_dir.BaseName().MaybeAsASCII() == last_profile) {
     for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
       FilePath cur_path = cache.GetPathOfProfileAtIndex(i);
       if (cur_path != profile_dir) {
@@ skipping 75 matching lines @@
 ProfileManager::ProfileInfo::ProfileInfo(
     Profile* profile,
     bool created)
     : profile(profile),
       created(created) {
 }
 
 ProfileManager::ProfileInfo::~ProfileInfo() {
   ProfileDestroyer::DestroyProfileWhenAppropriate(profile.release());
 }