Remove HostDesktopType from Browser::CreateParams

chrome/browser/ui/browser_commands.cc

 // Copyright 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/browser_commands.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
@@ skipping 180 matching lines @@
       if (disposition == NEW_BACKGROUND_TAB)
         new_tab->WasHidden();
       browser->tab_strip_model()->AddWebContents(
           new_tab, -1, ui::PAGE_TRANSITION_LINK,
           (disposition == NEW_FOREGROUND_TAB) ?
               TabStripModel::ADD_ACTIVE : TabStripModel::ADD_NONE);
       return new_tab;
     }
     case NEW_WINDOW: {
       WebContents* new_tab = current_tab->Clone();
-      Browser* new_browser = new Browser(Browser::CreateParams(
-          browser->profile(), browser->host_desktop_type()));
+      Browser* new_browser =
+          new Browser(Browser::CreateParams(browser->profile()));
       new_browser->tab_strip_model()->AddWebContents(
           new_tab, -1, ui::PAGE_TRANSITION_LINK,
           TabStripModel::ADD_ACTIVE);
       new_browser->window()->Show();
       return new_tab;
     }
     default:
       browser->window()->GetLocationBar()->Revert();
       return current_tab;
   }
@@ skipping 106 matching lines @@
     if (!content::IsSavableURL(
             last_committed_entry ? last_committed_entry->GetURL() : GURL()) ||
         current_tab->ShowingInterstitialPage())
       content_restrictions |= CONTENT_RESTRICTION_SAVE;
     if (current_tab->ShowingInterstitialPage())
       content_restrictions |= CONTENT_RESTRICTION_PRINT;
   }
   return content_restrictions;
 }
 
-void NewEmptyWindow(Profile* profile, HostDesktopType desktop_type) {
+void NewEmptyWindow(Profile* profile) {
   bool incognito = profile->IsOffTheRecord();
   PrefService* prefs = profile->GetPrefs();
   if (incognito) {
     if (IncognitoModePrefs::GetAvailability(prefs) ==
           IncognitoModePrefs::DISABLED) {
       incognito = false;
     }
   } else if (profile->IsGuestSession() ||
              (browser_defaults::kAlwaysOpenIncognitoWindow &&
               IncognitoModePrefs::ShouldLaunchIncognito(
                   *base::CommandLine::ForCurrentProcess(), prefs))) {
     incognito = true;
   }
 
   if (incognito) {
     content::RecordAction(UserMetricsAction("NewIncognitoWindow"));
-    OpenEmptyWindow(profile->GetOffTheRecordProfile(), desktop_type);
+    OpenEmptyWindow(profile->GetOffTheRecordProfile());
   } else {
     content::RecordAction(UserMetricsAction("NewWindow"));
     SessionService* session_service =
         SessionServiceFactory::GetForProfileForSessionRestore(
             profile->GetOriginalProfile());
     if (!session_service ||
         !session_service->RestoreIfNecessary(std::vector<GURL>())) {
-      OpenEmptyWindow(profile->GetOriginalProfile(), desktop_type);
+      OpenEmptyWindow(profile->GetOriginalProfile());
     }
   }
 }
 
-Browser* OpenEmptyWindow(Profile* profile, HostDesktopType desktop_type) {
-  Browser* browser = new Browser(
-      Browser::CreateParams(Browser::TYPE_TABBED, profile, desktop_type));
+Browser* OpenEmptyWindow(Profile* profile) {
+  Browser* browser =
+      new Browser(Browser::CreateParams(Browser::TYPE_TABBED, profile));
   AddTabAt(browser, GURL(), -1, true);
   browser->window()->Show();
   return browser;
 }
 
 void OpenWindowWithRestoredTabs(Profile* profile,
                                 HostDesktopType host_desktop_type) {
   sessions::TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(profile);
   if (service)
     service->RestoreMostRecentEntry(NULL, host_desktop_type);
 }
 
 void OpenURLOffTheRecord(Profile* profile,
-                         const GURL& url,
-                         chrome::HostDesktopType desktop_type) {
-  ScopedTabbedBrowserDisplayer displayer(profile->GetOffTheRecordProfile(),
-                                         desktop_type);
+                         const GURL& url) {
+  ScopedTabbedBrowserDisplayer displayer(profile->GetOffTheRecordProfile());
   AddSelectedTabWithURL(displayer.browser(), url,
       ui::PAGE_TRANSITION_LINK);
 }
 
 bool CanGoBack(const Browser* browser) {
   return browser->tab_strip_model()->GetActiveWebContents()->
       GetController().CanGoBack();
 }
 
 void GoBack(Browser* browser, WindowOpenDisposition disposition) {
@@ skipping 140 matching lines @@
   }
 #endif
 }
 
 void Stop(Browser* browser) {
   content::RecordAction(UserMetricsAction("Stop"));
   browser->tab_strip_model()->GetActiveWebContents()->Stop();
 }
 
 void NewWindow(Browser* browser) {
-  NewEmptyWindow(browser->profile()->GetOriginalProfile(),
-                 browser->host_desktop_type());
+  NewEmptyWindow(browser->profile()->GetOriginalProfile());
 }
 
 void NewIncognitoWindow(Browser* browser) {
-  NewEmptyWindow(browser->profile()->GetOffTheRecordProfile(),
-                 browser->host_desktop_type());
+  NewEmptyWindow(browser->profile()->GetOffTheRecordProfile());
 }
 
 void CloseWindow(Browser* browser) {
   content::RecordAction(UserMetricsAction("CloseWindow"));
   browser->window()->Close();
 }
 
 void NewTab(Browser* browser) {
   content::RecordAction(UserMetricsAction("NewTab"));
   // TODO(asvitkine): This is invoked programmatically from several places.
   // Audit the code and change it so that the histogram only gets collected for
   // user-initiated commands.
   UMA_HISTOGRAM_ENUMERATION("Tab.NewTab", TabStripModel::NEW_TAB_COMMAND,
                             TabStripModel::NEW_TAB_ENUM_COUNT);
 
   if (browser->is_type_tabbed()) {
     AddTabAt(browser, GURL(), -1, true);
     browser->tab_strip_model()->GetActiveWebContents()->RestoreFocus();
   } else {
-    ScopedTabbedBrowserDisplayer displayer(browser->profile(),
-                                           browser->host_desktop_type());
+    ScopedTabbedBrowserDisplayer displayer(browser->profile());
     Browser* b = displayer.browser();
     AddTabAt(b, GURL(), -1, true);
     b->window()->Show();
     // The call to AddBlankTabAt above did not set the focus to the tab as its
     // window was not active, so we have to do it explicitly.
     // See http://crbug.com/6380.
     b->tab_strip_model()->GetActiveWebContents()->RestoreFocus();
   }
 }
 
@@ skipping 86 matching lines @@
     int index = browser->tab_strip_model()->GetIndexOfWebContents(contents);
     pinned = browser->tab_strip_model()->IsTabPinned(index);
     int add_types = TabStripModel::ADD_ACTIVE |
         TabStripModel::ADD_INHERIT_GROUP |
         (pinned ? TabStripModel::ADD_PINNED : 0);
     browser->tab_strip_model()->InsertWebContentsAt(
         index + 1, contents_dupe, add_types);
   } else {
     Browser* new_browser = NULL;
     if (browser->is_app() && !browser->is_type_popup()) {
-      new_browser = new Browser(
-          Browser::CreateParams::CreateForApp(browser->app_name(),
-                                              browser->is_trusted_source(),
-                                              gfx::Rect(),
-                                              browser->profile(),
-                                              browser->host_desktop_type()));
+      new_browser = new Browser(Browser::CreateParams::CreateForApp(
+          browser->app_name(), browser->is_trusted_source(), gfx::Rect(),
+          browser->profile()));
     } else {
       new_browser = new Browser(
-          Browser::CreateParams(browser->type(), browser->profile(),
-                                browser->host_desktop_type()));
+          Browser::CreateParams(browser->type(), browser->profile()));
     }
     // Preserve the size of the original window. The new window has already
     // been given an offset by the OS, so we shouldn't copy the old bounds.
     BrowserWindow* new_window = new_browser->window();
     new_window->SetBounds(gfx::Rect(new_window->GetRestoredBounds().origin(),
                           browser->window()->GetRestoredBounds().size()));
 
     // We need to show the browser now.  Otherwise ContainerWin assumes the
     // WebContents is invisible and won't size it.
     new_browser->window()->Show();
@@ skipping 19 matching lines @@
   // what the user expects to duplicate.
   return contents && !contents->ShowingInterstitialPage() &&
          contents->GetController().GetLastCommittedEntry();
 }
 
 void ConvertPopupToTabbedBrowser(Browser* browser) {
   content::RecordAction(UserMetricsAction("ShowAsTab"));
   TabStripModel* tab_strip = browser->tab_strip_model();
   WebContents* contents =
       tab_strip->DetachWebContentsAt(tab_strip->active_index());
-  Browser* b = new Browser(Browser::CreateParams(browser->profile(),
-                                                 browser->host_desktop_type()));
+  Browser* b = new Browser(Browser::CreateParams(browser->profile()));
   b->tab_strip_model()->AppendWebContents(contents, true);
   b->window()->Show();
 }
 
 void Exit() {
   content::RecordAction(UserMetricsAction("Exit"));
   chrome::AttemptUserExit();
 }
 
 void BookmarkCurrentPageIgnoringExtensionOverrides(Browser* browser) {
@@ skipping 488 matching lines @@
     // window next to the tab being duplicated.
     int index = browser->tab_strip_model()->GetIndexOfWebContents(contents);
     int add_types = TabStripModel::ADD_ACTIVE |
         TabStripModel::ADD_INHERIT_GROUP;
     browser->tab_strip_model()->InsertWebContentsAt(
         index + 1,
         view_source_contents,
         add_types);
   } else {
     Browser* b = new Browser(
-        Browser::CreateParams(Browser::TYPE_TABBED, browser->profile(),
-                              browser->host_desktop_type()));
+        Browser::CreateParams(Browser::TYPE_TABBED, browser->profile()));
 
     // Preserve the size of the original window. The new window has already
     // been given an offset by the OS, so we shouldn't copy the old bounds.
     BrowserWindow* new_window = b->window();
     new_window->SetBounds(gfx::Rect(new_window->GetRestoredBounds().origin(),
                           browser->window()->GetRestoredBounds().size()));
 
     // We need to show the browser now. Otherwise ContainerWin assumes the
     // WebContents is invisible and won't size it.
     b->window()->Show();
@@ skipping 49 matching lines @@
 
 void ConvertTabToAppWindow(Browser* browser,
                            content::WebContents* contents) {
   const GURL& url = contents->GetController().GetLastCommittedEntry()->GetURL();
   std::string app_name = web_app::GenerateApplicationNameFromURL(url);
 
   int index = browser->tab_strip_model()->GetIndexOfWebContents(contents);
   if (index >= 0)
     browser->tab_strip_model()->DetachWebContentsAt(index);
 
-  Browser* app_browser = new Browser(
-      Browser::CreateParams::CreateForApp(app_name,
-                                          true /* trusted_source */,
-                                          gfx::Rect(),
-                                          browser->profile(),
-                                          browser->host_desktop_type()));
+  Browser* app_browser = new Browser(Browser::CreateParams::CreateForApp(
+      app_name, true /* trusted_source */, gfx::Rect(), browser->profile()));
   app_browser->tab_strip_model()->AppendWebContents(contents, true);
 
   contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
   contents->GetRenderViewHost()->SyncRendererPrefs();
   app_browser->window()->Show();
 }
 #endif  // defined(ENABLE_EXTENSIONS)
 
 }  // namespace chrome