Remove HostDesktopType from profiles

chrome/browser/profiles/profile_window.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/profiles/profile_window.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 101 matching lines @@
   Profile* profile_;
   ProfileManager::CreateCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserAddedForProfileObserver);
 };
 
 void OpenBrowserWindowForProfile(
     ProfileManager::CreateCallback callback,
     bool always_create,
     bool is_new_profile,
-    chrome::HostDesktopType desktop_type,
     Profile* profile,
     Profile::CreateStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (status != Profile::CREATE_STATUS_INITIALIZED)
     return;
 
   chrome::startup::IsProcessStartup is_process_startup =
       chrome::startup::IS_NOT_PROCESS_STARTUP;
   chrome::startup::IsFirstRun is_first_run = chrome::startup::IS_NOT_FIRST_RUN;
@@ skipping 39 matching lines @@
   // up calling LaunchBrowser and opens a new window. If for whatever reason
   // that fails, either something has crashed, or the observer will be cleaned
   // up when a different browser for this profile is opened.
   if (!callback.is_null())
     new BrowserAddedForProfileObserver(profile, callback);
 
   // We already dealt with the case when |always_create| was false and a browser
   // existed, which means that here a browser definitely needs to be created.
   // Passing true for |always_create| means we won't duplicate the code that
   // tries to find a browser.
-  profiles::FindOrCreateNewWindowForProfile(
-      profile,
-      is_process_startup,
-      is_first_run,
-      desktop_type,
-      true);
+  profiles::FindOrCreateNewWindowForProfile(profile, is_process_startup,
+                                            is_first_run, true);
 }
 
 // Called after a |system_profile| is available to be used by the user manager.
 // Based on the value of |tutorial_mode| we determine a url to be displayed
 // by the webui and run the |callback|, if it exists. After opening a profile,
 // perform |profile_open_action|.
 void OnUserManagerSystemProfileCreated(
     const base::FilePath& profile_path_to_focus,
     profiles::UserManagerTutorialMode tutorial_mode,
     profiles::UserManagerProfileSelected profile_open_action,
@@ skipping 65 matching lines @@
     if (entry->GetUserName() == profile_email)
       return entry->GetPath();
   }
   return base::FilePath();
 }
 
 void 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 = chrome::FindTabbedBrowser(profile, false);
     if (browser) {
       browser->window()->Activate();
       return;
     }
   }
 
   content::RecordAction(UserMetricsAction("NewWindow"));
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   StartupBrowserCreator browser_creator;
   browser_creator.LaunchBrowser(
       command_line, profile, base::FilePath(), process_startup, is_first_run);
 }
 
 #if !defined(OS_ANDROID)
 void SwitchToProfile(const base::FilePath& path,
-                     chrome::HostDesktopType desktop_type,
                      bool always_create,
                      ProfileManager::CreateCallback callback,
                      ProfileMetrics::ProfileOpen metric) {
   ProfileMetrics::LogProfileSwitch(metric,
                                    g_browser_process->profile_manager(),
                                    path);
   g_browser_process->profile_manager()->CreateProfileAsync(
       path,
-      base::Bind(&OpenBrowserWindowForProfile,
-                 callback,
-                 always_create,
-                 false,
-                 desktop_type),
-      base::string16(),
-      std::string(),
-      std::string());
+      base::Bind(&OpenBrowserWindowForProfile, callback, always_create, false),
+      base::string16(), std::string(), std::string());
 }
 
-void SwitchToGuestProfile(chrome::HostDesktopType desktop_type,
-                          ProfileManager::CreateCallback callback) {
+void SwitchToGuestProfile(ProfileManager::CreateCallback callback) {
   const base::FilePath& path = ProfileManager::GetGuestProfilePath();
   ProfileMetrics::LogProfileSwitch(ProfileMetrics::SWITCH_PROFILE_GUEST,
                                    g_browser_process->profile_manager(),
                                    path);
   g_browser_process->profile_manager()->CreateProfileAsync(
-      path,
-      base::Bind(&OpenBrowserWindowForProfile,
-                 callback,
-                 false,
-                 false,
-                 desktop_type),
-      base::string16(),
-      std::string(),
-      std::string());
+      path, base::Bind(&OpenBrowserWindowForProfile, callback, false, false),
+      base::string16(), std::string(), std::string());
 }
 #endif
 
 bool HasProfileSwitchTargets(Profile* profile) {
   size_t min_profiles = profile->IsGuestSession() ? 1 : 2;
   size_t number_of_profiles =
       g_browser_process->profile_manager()->GetNumberOfProfiles();
   return number_of_profiles >= min_profiles;
 }
 
-void CreateAndSwitchToNewProfile(chrome::HostDesktopType desktop_type,
-                                 ProfileManager::CreateCallback callback,
+void CreateAndSwitchToNewProfile(ProfileManager::CreateCallback callback,
                                  ProfileMetrics::ProfileAdd metric) {
   ProfileInfoCache& cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
 
   int placeholder_avatar_index = profiles::GetPlaceholderAvatarIndex();
   ProfileManager::CreateMultiProfileAsync(
       cache.ChooseNameForNewProfile(placeholder_avatar_index),
       profiles::GetDefaultAvatarIconUrl(placeholder_avatar_index),
-      base::Bind(&OpenBrowserWindowForProfile,
-                 callback,
-                 true,
-                 true,
-                 desktop_type),
+      base::Bind(&OpenBrowserWindowForProfile, callback, true, true),
       std::string());
   ProfileMetrics::LogProfileAddNewUser(metric);
 }
 
 void GuestBrowserCloseSuccess(const base::FilePath& profile_path) {
   UserManager::Show(base::FilePath(),
                     profiles::USER_MANAGER_NO_TUTORIAL,
                     profiles::USER_MANAGER_SELECT_PROFILE_NO_ACTION);
 }
 
@@ skipping 195 matching lines @@
   PrefService* local_state = g_browser_process->local_state();
   const bool dismissed = local_state->GetBoolean(
       prefs::kProfileAvatarRightClickTutorialDismissed);
 
   // Don't show the tutorial if it's already been dismissed or if right-clicking
   // wouldn't show any targets.
   return !dismissed && HasProfileSwitchTargets(profile);
 }
 
 }  // namespace profiles