Remove kDefaultHostDesktopType from browser_finder.cc.

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 "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/api/infobars/infobar_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_impl.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.h"
 #include "chrome/browser/ui/startup/startup_browser_creator_impl.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/sync_promo/sync_promo_ui.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 30 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()));
+    ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
+                                          browser()->host_desktop_type()));
   }
 
   void SetAppLaunchPref(const std::string& app_id,
                         extensions::ExtensionPrefs::LaunchType launch_type) {
     ExtensionService* service = extensions::ExtensionSystem::Get(
         browser()->profile())->extension_service();
     service->extension_prefs()->SetLaunchType(app_id, launch_type);
   }
 
   // Check that there are two browsers.  Find the one that is not |browser()|.
   void FindOneOtherBrowser(Browser** out_other_browser) {
     // There should only be one other browser.
-    ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile()));
+    ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile(),
+                                          browser()->host_desktop_type()));
 
     // Find the new browser.
     Browser* other_browser = NULL;
   for (chrome::BrowserIterator it; !it.done() && !other_browser; it.Next()) {
       if (*it != browser())
         other_browser = *it;
     }
     ASSERT_TRUE(other_browser);
     ASSERT_TRUE(other_browser != browser());
     *out_other_browser = other_browser;
@@ skipping 207 matching lines @@
 
   CommandLine command_line(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));
 
   // 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()));
+  ASSERT_EQ(2u, chrome::GetBrowserCount(browser()->profile(),
+                                        browser()->host_desktop_type()));
 
   Browser* new_browser = NULL;
   ASSERT_NO_FATAL_FAILURE(FindOneOtherBrowser(&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 261 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, &return_code);
 
   // 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));
+  ASSERT_EQ(2u, chrome::GetBrowserCount(default_profile,
+                                        browser()->host_desktop_type()));
   new_browser = FindOneOtherBrowserForProfile(default_profile, browser());
   ASSERT_TRUE(new_browser);
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ(urls1[0], tab_strip->GetWebContentsAt(0)->GetURL());
 
-  ASSERT_EQ(1u, chrome::GetBrowserCount(other_profile));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(other_profile,
+                                        browser()->host_desktop_type()));
   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, UpdateWithTwoProfiles) {
   // Make StartupBrowserCreator::WasRestarted() return true.
   StartupBrowserCreator::was_restarted_read_ = false;
@@ skipping 44 matching lines @@
   while (SessionRestore::IsRestoring(profile1) ||
          SessionRestore::IsRestoring(profile2))
     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));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile1,
+                                        browser()->host_desktop_type()));
   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(GURL(chrome::kAboutBlankURL),
             tab_strip->GetWebContentsAt(0)->GetURL());
 
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile2));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile2,
+                                        browser()->host_desktop_type()));
   new_browser = FindOneOtherBrowserForProfile(profile2, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   EXPECT_EQ(GURL(chrome::kAboutBlankURL),
             tab_strip->GetWebContentsAt(0)->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest,
                        ProfilesWithoutPagesNotLaunched) {
@@ skipping 32 matching lines @@
   std::vector<GURL> urls;
   urls.push_back(ui_test_utils::GetTestUrl(
       base::FilePath(base::FilePath::kCurrentDirectory),
       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 
   SessionStartupPref pref_urls(SessionStartupPref::URLS);
   pref_urls.urls = urls;
   SessionStartupPref::SetStartupPref(profile_urls, pref_urls);
 
   // Close the browser.
+  chrome::HostDesktopType original_desktop_type =
+      browser()->host_desktop_type();
   browser()->window()->Close();
 
   // Do a simple non-process-startup browser launch.
   CommandLine dummy(CommandLine::NO_PROGRAM);
 
   int return_code;
   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, &return_code);
 
   while (SessionRestore::IsRestoring(default_profile) ||
          SessionRestore::IsRestoring(profile_home1) ||
          SessionRestore::IsRestoring(profile_home2) ||
          SessionRestore::IsRestoring(profile_last) ||
          SessionRestore::IsRestoring(profile_urls))
     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 home page.
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home1));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home1, original_desktop_type));
   new_browser = FindOneOtherBrowserForProfile(profile_home1, NULL);
   ASSERT_TRUE(new_browser);
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   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));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_urls, original_desktop_type));
   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));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_last, original_desktop_type));
   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::kAboutBlankURL),
             tab_strip->GetWebContentsAt(0)->GetURL());
 
   // profile_home2 was not launched since it would've only opened the home page.
-  ASSERT_EQ(0u, chrome::GetBrowserCount(profile_home2));
+  ASSERT_EQ(0u, chrome::GetBrowserCount(profile_home2, original_desktop_type));
 }
 
 IN_PROC_BROWSER_TEST_F(StartupBrowserCreatorTest, ProfilesLaunchedAfterCrash) {
   // After an unclean exit, all profiles will be launched. However, they won't
   // open any pages automatically.
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   // Create 3 profiles.
   base::FilePath dest_path1 = profile_manager->user_data_dir().Append(
@@ skipping 47 matching lines @@
                         last_opened_profiles, &return_code);
 
   // 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.
   Browser* new_browser = NULL;
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_home,
+                                        browser()->host_desktop_type()));
   new_browser = FindOneOtherBrowserForProfile(profile_home, NULL);
   ASSERT_TRUE(new_browser);
   TabStripModel* tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   content::WebContents* web_contents = tab_strip->GetWebContentsAt(0);
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), web_contents->GetURL());
   EXPECT_EQ(1U,
             InfoBarService::FromWebContents(web_contents)->GetInfoBarCount());
 
   // The profile which normally opens last open pages displays the new tab page.
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_last));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_last,
+                                        browser()->host_desktop_type()));
   new_browser = FindOneOtherBrowserForProfile(profile_last, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   web_contents = tab_strip->GetWebContentsAt(0);
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), web_contents->GetURL());
   EXPECT_EQ(1U,
             InfoBarService::FromWebContents(web_contents)->GetInfoBarCount());
 
   // The profile which normally opens URLs displays the new tab page.
-  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_urls));
+  ASSERT_EQ(1u, chrome::GetBrowserCount(profile_urls,
+                                        browser()->host_desktop_type()));
   new_browser = FindOneOtherBrowserForProfile(profile_urls, NULL);
   ASSERT_TRUE(new_browser);
   tab_strip = new_browser->tab_strip_model();
   ASSERT_EQ(1, tab_strip->count());
   web_contents = tab_strip->GetWebContentsAt(0);
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), web_contents->GetURL());
   EXPECT_EQ(1U,
             InfoBarService::FromWebContents(web_contents)->GetInfoBarCount());
 }
 #endif  // !OS_CHROMEOS