Remove the rest of HostDesktopType from c/b/ui/browser_finder.h

chrome/browser/ui/startup/startup_browser_creator_browsertest.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 <stddef.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 68 matching lines @@
 #include "base/win/windows_version.h"
 #endif
 
 using extensions::Extension;
 
 namespace {
 
 // Check that there are two browsers. Find the one that is not |browser|.
 Browser* FindOneOtherBrowser(Browser* browser) {
   // There should only be one other browser.
-  EXPECT_EQ(2u, chrome::GetBrowserCount(browser->profile(),
-                                        browser->host_desktop_type()));
+  EXPECT_EQ(2u, chrome::GetBrowserCount(browser->profile()));
 
   // Find the new browser.
   Browser* other_browser = NULL;
   for (auto* b : *BrowserList::GetInstance()) {
     if (b != browser)
       other_browser = b;
   }
   return other_browser;
 }
 
@@ skipping 68 matching lines @@
                const Extension** out_app_extension) {
     ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(app_name.c_str())));
 
     ExtensionService* service = extensions::ExtensionSystem::Get(
         browser()->profile())->extension_service();
     *out_app_extension = service->GetExtensionById(
         last_loaded_extension_id(), false);
     ASSERT_TRUE(*out_app_extension);
 
     // Code that opens a new browser assumes we start with exactly one.
-    ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
-                                          browser()->host_desktop_type()));
+    ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile()));
   }
 
   void SetAppLaunchPref(const std::string& app_id,
                         extensions::LaunchType launch_type) {
     extensions::SetLaunchType(browser()->profile(), app_id, launch_type);
   }
 
   Browser* FindOneOtherBrowserForProfile(Profile* profile,
                                          Browser* not_this_browser) {
     for (auto* browser : *BrowserList::GetInstance()) {
@@ skipping 134 matching lines @@
     {
       StartupBrowserCreatorImpl launch(base::FilePath(), dummy, first_run);
       ASSERT_TRUE(launch.Launch(profile, std::vector<GURL>(), false,
                                 host_desktop_type));
     }
 
     // Find the new browser and ensure that it has only the specified URLs this
     // time. Both the original browser created by the fixture and the one
     // created above have been closed, so the new browser is the only one
     // remaining.
-    new_browser = FindTabbedBrowser(profile, true, host_desktop_type);
+    new_browser = chrome::FindTabbedBrowser(profile, true);
     ASSERT_TRUE(new_browser);
     ASSERT_EQ(static_cast<int>(urls.size()),
               new_browser->tab_strip_model()->count());
   }
 
   g_browser_process->ReleaseModule();
 }
 
 // Verify that startup URLs aren't used when the process already exists
 // and has other tabbed browser windows.  This is the common case of starting a
@@ skipping 131 matching lines @@
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kAppId, extension_app->id());
   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
   StartupBrowserCreatorImpl launch(base::FilePath(), command_line, first_run);
   ASSERT_TRUE(launch.Launch(browser()->profile(), std::vector<GURL>(), false,
                             browser()->host_desktop_type()));
 
   // When an app shortcut is open and the pref indicates a tab should
   // open, the tab is open in a new browser window.  Expect a new window.
-  ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile(),
-                                        browser()->host_desktop_type()));
+  ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile()));
 
   Browser* new_browser = FindOneOtherBrowser(browser());
   ASSERT_TRUE(new_browser);
 
   // The tab should be in a tabbed window.
   EXPECT_TRUE(new_browser->is_type_tabbed());
 
   // The browser's app_name should not include the app's ID: It is in a
   // normal browser.
   EXPECT_EQ(
@@ skipping 293 matching lines @@
   last_opened_profiles.push_back(default_profile);
   last_opened_profiles.push_back(other_profile);
   browser_creator.Start(dummy, profile_manager->user_data_dir(),
                         default_profile, last_opened_profiles);
 
   // urls1 were opened in a browser for default_profile, and urls2 were opened
   // in a browser for other_profile.
   Browser* new_browser = NULL;
   // |browser()| is still around at this point, even though we've closed its
   // window. Thus the browser count for default_profile is 2.
-  ASSERT_EQ(2u, chrome::GetBrowserCount(default_profile,
-                                        browser()->host_desktop_type()));
+  ASSERT_EQ(2u, chrome::GetBrowserCount(default_profile));
   new_browser = FindOneOtherBrowserForProfile(default_profile, browser());
   ASSERT_TRUE(new_browser);
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   if (IsWindows10OrNewer()) {
     // The new browser should have the welcome tab and the URL for the profile.
     ASSERT_EQ(2, tab_strip->count());
     EXPECT_EQ(GURL(internals::GetWelcomePageURL()),
               tab_strip->GetWebContentsAt(0)->GetURL());
     EXPECT_EQ(urls1[0], tab_strip->GetWebContentsAt(1)->GetURL());
   } else {
     // The new browser should have only the desired URL for the profile.
     ASSERT_EQ(1, tab_strip->count());
     EXPECT_EQ(urls1[0], tab_strip->GetWebContentsAt(0)->GetURL());
   }
 
-  ASSERT_EQ(1u, chrome::GetBrowserCount(other_profile,
-                                        browser()->host_desktop_type()));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(other_profile));
   new_browser = FindOneOtherBrowserForProfile(other_profile, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ(urls2[0], tab_strip->GetWebContentsAt(0)->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, PRE_UpdateWithTwoProfiles) {
   // Simulate a browser restart by creating the profiles in the PRE_ part.
   ProfileManager* profile_manager = g_browser_process->profile_manager();
@@ skipping 91 matching lines @@
   while (SessionRestore::IsRestoring(profile1) ||
          SessionRestore::IsRestoring(profile2))
     base::MessageLoop::current()->RunUntilIdle();
 
   // The startup URLs are ignored, and instead the last open sessions are
   // restored.
   EXPECT_TRUE(profile1->restored_last_session());
   EXPECT_TRUE(profile2->restored_last_session());
 
   Browser* new_browser = NULL;
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile1,
-                                        browser()->host_desktop_type()));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile1));
   new_browser = FindOneOtherBrowserForProfile(profile1, NULL);
   ASSERT_TRUE(new_browser);
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ("/empty.html", tab_strip->GetWebContentsAt(0)->GetURL().path());
 
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile2,
-                                        browser()->host_desktop_type()));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile2));
   new_browser = FindOneOtherBrowserForProfile(profile2, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ("/form.html", tab_strip->GetWebContentsAt(0)->GetURL().path());
 }
 
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest,
                        ProfilesWithoutPagesNotLaunched) {
 #if defined(OS_WIN) && defined(USE_ASH)
@@ skipping 48 matching lines @@
   // Open a page with profile_last.
   Browser* browser_last = new Browser(
       Browser::CreateParams(Browser::TYPE_TABBED, profile_last,
                             browser()->host_desktop_type()));
   chrome::NewTab(browser_last);
   ui_test_utils::NavigateToURL(browser_last,
                                embedded_test_server()->GetURL("/empty.html"));
   CloseBrowserAsynchronously(browser_last);
 
   // Close the main browser.
-  chrome::HostDesktopType original_desktop_type =
-      browser()->host_desktop_type();
   CloseBrowserAsynchronously(browser());
 
   // Do a simple non-process-startup browser launch.
   base::CommandLine dummy(base::CommandLine::NO_PROGRAM);
 
   StartupBrowserCreator browser_creator;
   std::vector<Profile*> last_opened_profiles;
   last_opened_profiles.push_back(profile_home1);
   last_opened_profiles.push_back(profile_home2);
   last_opened_profiles.push_back(profile_last);
   last_opened_profiles.push_back(profile_urls);
   browser_creator.Start(dummy, profile_manager->user_data_dir(), profile_home1,
                         last_opened_profiles);
 
   while (SessionRestore::IsRestoring(default_profile) ||
          SessionRestore::IsRestoring(profile_home1) ||
          SessionRestore::IsRestoring(profile_home2) ||
          SessionRestore::IsRestoring(profile_last) ||
          SessionRestore::IsRestoring(profile_urls))
     base::MessageLoop::current()->RunUntilIdle();
 
   Browser* new_browser = NULL;
   // The last open profile (the profile_home1 in this case) will always be
   // launched, even if it will open just the NTP (and the welcome page on
   // relevant platforms).
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home1, original_desktop_type));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home1));
   new_browser = FindOneOtherBrowserForProfile(profile_home1, NULL);
   ASSERT_TRUE(new_browser);
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   if (IsWindows10OrNewer()) {
     // The new browser should have the welcome tab and the NTP.
     ASSERT_EQ(2, tab_strip->count());
     EXPECT_EQ(GURL(internals::GetWelcomePageURL()),
               tab_strip->GetWebContentsAt(0)->GetURL());
     EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
               tab_strip->GetWebContentsAt(1)->GetURL());
   } else {
     // The new browser should have only the NTP.
     ASSERT_EQ(1, tab_strip->count());
     EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
               tab_strip->GetWebContentsAt(0)->GetURL());
   }
 
   // profile_urls opened the urls.
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_urls, original_desktop_type));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_urls));
   new_browser = FindOneOtherBrowserForProfile(profile_urls, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ(urls[0], tab_strip->GetWebContentsAt(0)->GetURL());
 
   // profile_last opened the last open pages.
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_last, original_desktop_type));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_last));
   new_browser = FindOneOtherBrowserForProfile(profile_last, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ("/empty.html", tab_strip->GetWebContentsAt(0)->GetURL().path());
 
   // profile_home2 was not launched since it would've only opened the home page.
-  ASSERT_EQ(0u, chrome::GetBrowserCount(profile_home2, original_desktop_type));
+  ASSERT_EQ(0u, chrome::GetBrowserCount(profile_home2));
 }
 
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, ProfilesLaunchedAfterCrash) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshBrowserTests))
     return;
 #endif
 
@@ skipping 67 matching lines @@
 
   // No profiles are getting restored, since they all display the crash info
   // bar.
   EXPECT_FALSE(SessionRestore::IsRestoring(profile_home));
   EXPECT_FALSE(SessionRestore::IsRestoring(profile_last));
   EXPECT_FALSE(SessionRestore::IsRestoring(profile_urls));
 
   // The profile which normally opens the home page displays the new tab page.
   // The welcome page is also shown for relevant platforms.
   Browser* new_browser = NULL;
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home,
-                                        browser()->host_desktop_type()));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home));
   new_browser = FindOneOtherBrowserForProfile(profile_home, NULL);
   ASSERT_TRUE(new_browser);
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   if (IsWindows10OrNewer()) {
     // The new browser should have the welcome tab and the NTP.
     ASSERT_EQ(2, tab_strip->count());
     EXPECT_EQ(GURL(internals::GetWelcomePageURL()),
               tab_strip->GetWebContentsAt(0)->GetURL());
     EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
               tab_strip->GetWebContentsAt(1)->GetURL());
   } else {
     // The new browser should have only the NTP.
     ASSERT_EQ(1, tab_strip->count());
     EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
               tab_strip->GetWebContentsAt(0)->GetURL());
   }
   EnsureRestoreUIWasShown(tab_strip->GetWebContentsAt(0));
 
   // The profile which normally opens last open pages displays the new tab page.
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_last,
-                                        browser()->host_desktop_type()));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_last));
   new_browser = FindOneOtherBrowserForProfile(profile_last, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
             tab_strip->GetWebContentsAt(0)->GetURL());
   EnsureRestoreUIWasShown(tab_strip->GetWebContentsAt(0));
 
   // The profile which normally opens URLs displays the new tab page.
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_urls,
-                                        browser()->host_desktop_type()));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_urls));
   new_browser = FindOneOtherBrowserForProfile(profile_urls, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
             tab_strip->GetWebContentsAt(0)->GetURL());
   EnsureRestoreUIWasShown(tab_strip->GetWebContentsAt(0));
 
 #if !defined(OS_MACOSX) && !defined(GOOGLE_CHROME_BUILD)
   // Each profile should have one session restore bubble shown, so we should
@@ skipping 512 matching lines @@
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ("title1.html",
             tab_strip->GetWebContentsAt(0)->GetURL().ExtractFileName());
 }
 #endif  // defined(ENABLE_CONFIGURATION_POLICY)
 
 #endif  // !defined(OS_LINUX) || !defined(GOOGLE_CHROME_BUILD) ||
         // defined(ENABLE_CONFIGURATION_POLICY)
 
 #endif  // !defined(OS_CHROMEOS)