Move chrome::HostDesktopType to ui::HostDesktopType

chrome/browser/ui/startup/startup_browser_creator_impl.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 "chrome/browser/ui/startup/startup_browser_creator_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "apps/app_restore_service.h"
@@ skipping 275 matching lines @@
       is_first_run_(is_first_run == chrome::startup::IS_FIRST_RUN),
       welcome_run_type_(WelcomeRunType::NONE) {
 }
 
 StartupBrowserCreatorImpl::~StartupBrowserCreatorImpl() {
 }
 
 bool StartupBrowserCreatorImpl::Launch(Profile* profile,
                                        const std::vector<GURL>& urls_to_open,
                                        bool process_startup,
-                                       chrome::HostDesktopType desktop_type) {
+                                       ui::HostDesktopType desktop_type) {
   UMA_HISTOGRAM_COUNTS_100("Startup.BrowserLaunchURLCount",
       static_cast<base::HistogramBase::Sample>(urls_to_open.size()));
   RecordRapporOnStartupURLs(urls_to_open);
 
   DCHECK(profile);
   profile_ = profile;
 
   if (AppListService::HandleLaunchCommandLine(command_line_, profile))
     return true;
 
   if (command_line_.HasSwitch(switches::kAppId)) {
     std::string app_id = command_line_.GetSwitchValueASCII(switches::kAppId);
     const Extension* extension = GetPlatformApp(profile, app_id);
     // If |app_id| is a disabled or terminated platform app we handle it
     // specially here, otherwise it will be handled below.
     if (extension) {
       RecordCmdLineAppHistogram(extensions::Manifest::TYPE_PLATFORM_APP);
       AppLaunchParams params(profile, extension,
                              extensions::LAUNCH_CONTAINER_NONE, NEW_WINDOW,
                              extensions::SOURCE_COMMAND_LINE);
       params.command_line = command_line_;
       params.current_directory = cur_dir_;
       // If we are being launched from the command line, default to native
       // desktop.
-      params.desktop_type = chrome::HOST_DESKTOP_TYPE_NATIVE;
+      params.desktop_type = ui::HOST_DESKTOP_TYPE_NATIVE;
       ::OpenApplicationWithReenablePrompt(params);
       return true;
     }
   }
 
   // Open the required browser windows and tabs. First, see if
   // we're being run as an application window. If so, the user
   // opened an app shortcut.  Don't restore tabs or open initial
   // URLs in that case. The user should see the window as an app,
   // not as chrome.
@@ skipping 148 matching lines @@
       WebContents* app_tab = ::OpenAppShortcutWindow(profile, url);
       return (app_tab != NULL);
     }
   }
   return false;
 }
 
 void StartupBrowserCreatorImpl::ProcessLaunchURLs(
     bool process_startup,
     const std::vector<GURL>& urls_to_open,
-    chrome::HostDesktopType desktop_type) {
+    ui::HostDesktopType desktop_type) {
   // If we're starting up in "background mode" (no open browser window) then
   // don't open any browser windows, unless kAutoLaunchAtStartup is also
   // specified.
   if (process_startup &&
       command_line_.HasSwitch(switches::kNoStartupWindow) &&
       !command_line_.HasSwitch(switches::kAutoLaunchAtStartup)) {
     return;
   }
 
   // Determine whether or not this launch must include the welcome page.
@@ skipping 47 matching lines @@
   }
 
   // Session startup didn't occur, open the urls.
   Browser* browser = NULL;
   std::vector<GURL> adjusted_urls = urls_to_open;
   if (adjusted_urls.empty()) {
     AddStartupURLs(&adjusted_urls);
   } else if (!command_line_.HasSwitch(switches::kOpenInNewWindow)) {
     // Always open a list of urls in a window on the native desktop.
     browser = chrome::FindTabbedBrowser(profile_, false,
-                                        chrome::HOST_DESKTOP_TYPE_NATIVE);
+                                        ui::HOST_DESKTOP_TYPE_NATIVE);
   }
   // This will launch a browser; prevent session restore.
   StartupBrowserCreator::in_synchronous_profile_launch_ = true;
   browser =
       OpenURLsInBrowser(browser, process_startup, adjusted_urls, desktop_type);
   StartupBrowserCreator::in_synchronous_profile_launch_ = false;
   AddInfoBarsIfNecessary(browser, is_process_startup);
 }
 
 bool StartupBrowserCreatorImpl::ProcessStartupURLs(
     const std::vector<GURL>& urls_to_open,
-    chrome::HostDesktopType desktop_type) {
+    ui::HostDesktopType desktop_type) {
   VLOG(1) << "StartupBrowserCreatorImpl::ProcessStartupURLs";
   SessionStartupPref pref =
       StartupBrowserCreator::GetSessionStartupPref(command_line_, profile_);
   if (pref.type == SessionStartupPref::LAST)
     VLOG(1) << "Pref: last";
   else if (pref.type == SessionStartupPref::URLS)
     VLOG(1) << "Pref: urls";
   else if (pref.type == SessionStartupPref::DEFAULT)
     VLOG(1) << "Pref: default";
 
@@ skipping 34 matching lines @@
 #endif
 
     // Optionally include the welcome page.
     std::vector<GURL> adjusted_urls(urls_to_open);
     if (welcome_run_type_ == WelcomeRunType::FIRST_TAB) {
       adjusted_urls.insert(adjusted_urls.begin(),
                            internals::GetWelcomePageURL());
     }
 
     // The startup code only executes for browsers launched in desktop mode.
-    // i.e. HOST_DESKTOP_TYPE_NATIVE. Ash should never get here.
+    // i.e. ui::HOST_DESKTOP_TYPE_NATIVE. Ash should never get here.
     Browser* browser = SessionRestore::RestoreSession(
         profile_, NULL, desktop_type, restore_behavior, adjusted_urls);
 
     AddInfoBarsIfNecessary(browser, chrome::startup::IS_PROCESS_STARTUP);
     return true;
   }
 
   Browser* browser = ProcessSpecifiedURLs(urls_to_open, desktop_type);
   if (!browser)
     return false;
 
   AddInfoBarsIfNecessary(browser, chrome::startup::IS_PROCESS_STARTUP);
 
   // Session restore may occur if the startup preference is "last" or if the
   // crash infobar is displayed. Otherwise, it's safe for the DOM storage system
   // to start deleting leftover data.
   if (pref.type != SessionStartupPref::LAST &&
       !HasPendingUncleanExit(profile_)) {
     content::BrowserContext::GetDefaultStoragePartition(profile_)->
         GetDOMStorageContext()->StartScavengingUnusedSessionStorage();
   }
 
   return true;
 }
 
 Browser* StartupBrowserCreatorImpl::ProcessSpecifiedURLs(
     const std::vector<GURL>& urls_to_open,
-    chrome::HostDesktopType desktop_type) {
+    ui::HostDesktopType desktop_type) {
   SessionStartupPref pref =
       StartupBrowserCreator::GetSessionStartupPref(command_line_, profile_);
   StartupTabs tabs;
   // Pinned tabs should not be displayed when chrome is launched in incognito
   // mode. Also, no pages should be opened automatically if the session
   // crashed. Otherwise it might trigger another crash, locking the user out of
   // chrome. The crash infobar is shown in this case.
   if (!IncognitoModePrefs::ShouldLaunchIncognito(command_line_,
                                                  profile_->GetPrefs()) &&
       !HasPendingUncleanExit(profile_)) {
@@ skipping 50 matching lines @@
       tab.url = urls[i];
       tabs->push_back(tab);
     }
   }
 }
 
 Browser* StartupBrowserCreatorImpl::OpenURLsInBrowser(
     Browser* browser,
     bool process_startup,
     const std::vector<GURL>& urls,
-    chrome::HostDesktopType desktop_type) {
+    ui::HostDesktopType desktop_type) {
   StartupTabs tabs;
   UrlsToTabs(urls, &tabs);
   return OpenTabsInBrowser(browser, process_startup, tabs, desktop_type);
 }
 
 Browser* StartupBrowserCreatorImpl::OpenTabsInBrowser(
     Browser* browser,
     bool process_startup,
     const StartupTabs& tabs,
-    chrome::HostDesktopType desktop_type) {
+    ui::HostDesktopType desktop_type) {
   DCHECK(!tabs.empty());
 
   // If we don't yet have a profile, try to use the one we're given from
   // |browser|. While we may not end up actually using |browser| (since it
   // could be a popup window), we can at least use the profile.
   if (!profile_ && browser)
     profile_ = browser->profile();
 
   if (!browser || !browser->is_type_tabbed())
     browser = new Browser(Browser::CreateParams(profile_, desktop_type));
@@ skipping 227 matching lines @@
 #endif  // !OS_WIN
 }
 
 void StartupBrowserCreatorImpl::RecordRapporOnStartupURLs(
     const std::vector<GURL>& urls_to_open) {
   for (const GURL& url : urls_to_open) {
     rappor::SampleDomainAndRegistryFromGURL(g_browser_process->rappor_service(),
                                             "Startup.BrowserLaunchURL", url);
   }
 }