Cleanup: remove use_existing_browser infrastructure from ui_test.

chrome/test/ui/ui_test.cc

 // Copyright (c) 2010 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/test/ui/ui_test.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #include <sys/types.h>
 #endif
@@ skipping 59 matching lines @@
     L"NOTE: This test is expected to fail if breakpad is not built in "
     L"or if chromium is not running headless (try CHROME_HEADLESS=1).";
 #else
     L"NOTE: Crash service not ported to this platform!";
 #endif
 bool UITestBase::in_process_renderer_ = false;
 bool UITestBase::no_sandbox_ = false;
 bool UITestBase::full_memory_dump_ = false;
 bool UITestBase::safe_plugins_ = false;
 bool UITestBase::show_error_dialogs_ = true;
-bool UITestBase::default_use_existing_browser_ = false;
 bool UITestBase::dump_histograms_on_exit_ = false;
 bool UITestBase::enable_dcheck_ = false;
 bool UITestBase::silent_dump_on_dcheck_ = false;
 bool UITestBase::disable_breakpad_ = false;
 int UITestBase::timeout_ms_ = 20 * 60 * 1000;
 std::wstring UITestBase::js_flags_ = L"";
 std::wstring UITestBase::log_level_ = L"";
 
 // Specify the time (in milliseconds) that the ui_tests should wait before
 // timing out. This is used to specify longer timeouts when running under Purify
@@ skipping 20 matching lines @@
       expected_errors_(0),
       expected_crashes_(0),
       homepage_(L"about:blank"),
       wait_for_initial_loads_(true),
       dom_automation_enabled_(false),
       process_(base::kNullProcessHandle),
       process_id_(-1),
       show_window_(false),
       clear_profile_(true),
       include_testing_id_(true),
-      use_existing_browser_(default_use_existing_browser_),
       enable_file_cookies_(true),
       profile_type_(UITestBase::DEFAULT_THEME),
       shutdown_type_(UITestBase::WINDOW_CLOSE),
       test_start_time_(Time::NowFromSystemTime()),
       command_execution_timeout_ms_(kCommandExecutionTimeout),
       action_timeout_ms_(kWaitForActionMsec),
       action_max_timeout_ms_(kWaitForActionMaxMsec),
       sleep_timeout_ms_(kWaitForActionMsec),
       terminate_timeout_ms_(kWaitForTerminateMsec) {
   PathService::Get(chrome::DIR_APP, &browser_directory_);
   PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory_);
 }
 
 UITestBase::UITestBase(MessageLoop::Type msg_loop_type)
     : launch_arguments_(CommandLine::ARGUMENTS_ONLY),
       expected_errors_(0),
       expected_crashes_(0),
       homepage_(L"about:blank"),
       wait_for_initial_loads_(true),
       dom_automation_enabled_(false),
       process_(base::kNullProcessHandle),
       process_id_(-1),
       show_window_(false),
       clear_profile_(true),
       include_testing_id_(true),
-      use_existing_browser_(default_use_existing_browser_),
       enable_file_cookies_(true),
       profile_type_(UITestBase::DEFAULT_THEME),
       shutdown_type_(UITestBase::WINDOW_CLOSE),
       test_start_time_(Time::NowFromSystemTime()),
       command_execution_timeout_ms_(kCommandExecutionTimeout),
       action_timeout_ms_(kWaitForActionMsec),
       action_max_timeout_ms_(kWaitForActionMaxMsec),
       sleep_timeout_ms_(kWaitForActionMsec),
       terminate_timeout_ms_(kWaitForTerminateMsec) {
   PathService::Get(chrome::DIR_APP, &browser_directory_);
   PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory_);
 }
 
 UITestBase::~UITestBase() {
 }
 
 void UITestBase::SetUp() {
-  if (!use_existing_browser_) {
-    AssertAppNotRunning(L"Please close any other instances "
-                        L"of the app before testing.");
-  }
+  AssertAppNotRunning(L"Please close any other instances "
+                      L"of the app before testing.");
 
   InitializeTimeouts();
   JavaScriptExecutionController::set_timeout(action_max_timeout_ms_);
   LaunchBrowserAndServer();
 }
 
 void UITestBase::TearDown() {
   CloseBrowserAndServer();
 
   // Make sure that we didn't encounter any assertion failures
@@ skipping 215 matching lines @@
     // If we're using the complex theme data, we need to write the
     // user_data_dir_ to our preferences file.
     if (profile_type_ == UITestBase::COMPLEX_THEME) {
       RewritePreferencesFile(user_data_dir_);
     }
 
     // Update the history file to include recent dates.
     UpdateHistoryDates();
   }
 
-  ASSERT_TRUE(LaunchBrowserHelper(arguments, use_existing_browser_, false,
-                                  &process_));
+  ASSERT_TRUE(LaunchBrowserHelper(arguments, false, &process_));
   process_id_ = base::GetProcId(process_);
 }
 
 bool UITestBase::LaunchAnotherBrowserBlockUntilClosed(
     const CommandLine& cmdline) {
-  return LaunchBrowserHelper(cmdline, false, true, NULL);
+  return LaunchBrowserHelper(cmdline, true, NULL);
 }
 
 void UITestBase::QuitBrowser() {
   if (SESSION_ENDING == shutdown_type_) {
     TerminateBrowser();
     return;
   }
 
   // There's nothing to do here if the browser is not running.
   if (IsBrowserRunning()) {
@@ skipping 650 matching lines @@
     } else {
       EXPECT_NE(generated_file_size, original_file_size);
       EXPECT_FALSE(file_util::ContentsEqual(generated_file, original_file));
     }
   }
   if (delete_generated_file)
     EXPECT_TRUE(file_util::DieFileDie(generated_file, false));
 }
 
 bool UITestBase::LaunchBrowserHelper(const CommandLine& arguments,
-                                 bool use_existing_browser,
-                                 bool wait,
-                                 base::ProcessHandle* process) {
+                                     bool wait,
+                                     base::ProcessHandle* process) {
   FilePath command = browser_directory_.Append(
       FilePath::FromWStringHack(chrome::kBrowserProcessExecutablePath));
   CommandLine command_line(command);
 
   // Add any explicit command line flags passed to the process.
   std::wstring extra_chrome_flags =
       CommandLine::ForCurrentProcess()->GetSwitchValue(kExtraChromeFlagsSwitch);
   if (!extra_chrome_flags.empty()) {
     // Split by spaces and append to command line
     std::vector<std::wstring> flags;
@@ skipping 14 matching lines @@
                                      ASCIIToWide(kUITestType));
 
   // We need cookies on file:// for things like the page cycler.
   if (enable_file_cookies_)
     command_line.AppendSwitch(switches::kEnableFileCookies);
 
   if (dom_automation_enabled_)
     command_line.AppendSwitch(switches::kDomAutomationController);
 
   if (include_testing_id_) {
-    if (use_existing_browser) {
-      // TODO(erikkay): The new switch depends on a browser instance already
-      // running, it won't open a new browser window if it's not.  We could fix
-      // this by passing an url (e.g. about:blank) on the command line, but
-      // I decided to keep using the old switch in the existing use case to
-      // minimize changes in behavior.
-      command_line.AppendSwitchWithValue(switches::kAutomationClientChannelID,
-                                         ASCIIToWide(server_->channel_id()));
-    } else {
-      command_line.AppendSwitchWithValue(switches::kTestingChannelID,
-                                         ASCIIToWide(server_->channel_id()));
-    }
+    command_line.AppendSwitchWithValue(switches::kTestingChannelID,
+                                       ASCIIToWide(server_->channel_id()));
   }
 
   if (!show_error_dialogs_ &&
       !CommandLine::ForCurrentProcess()->HasSwitch(kEnableErrorDialogs)) {
     command_line.AppendSwitch(switches::kNoErrorDialogs);
   }
   if (in_process_renderer_)
     command_line.AppendSwitch(switches::kSingleProcess);
   if (no_sandbox_)
     command_line.AppendSwitch(switches::kNoSandbox);
@@ skipping 63 matching lines @@
     command_line.PrependWrapper(ASCIIToWide(browser_wrapper));
     LOG(INFO) << "BROWSER_WRAPPER was set, prefixing command_line with "
               << browser_wrapper;
   }
 
   bool started = base::LaunchApp(command_line.argv(),
                                  server_->fds_to_map(),
                                  wait,
                                  process);
 #endif
-  if (!started)
-    return false;
 
-  if (use_existing_browser) {
-#if defined(OS_WIN)
-    DWORD pid = 0;
-    HWND hwnd = FindWindowEx(HWND_MESSAGE, NULL, chrome::kMessageWindowClass,
-                             user_data_dir_.value().c_str());
-    GetWindowThreadProcessId(hwnd, &pid);
-    // This mode doesn't work if we wound up launching a new browser ourselves.
-    EXPECT_NE(pid, base::GetProcId(*process));
-    CloseHandle(*process);
-    *process = OpenProcess(SYNCHRONIZE, false, pid);
-#else
-  // TODO(port): above code is very Windows-specific; we need to
-  // figure out and abstract out how we'll handle finding any existing
-  // running process, etc. on other platforms.
-  NOTIMPLEMENTED();
-#endif
-  }
-
-  return true;
+  return started;
 }
 
 void UITestBase::UpdateHistoryDates() {
   // Migrate the times in the segment_usage table to yesterday so we get
   // actual thumbnails on the NTP.
   sql::Connection db;
   FilePath history =
       user_data_dir_.AppendASCII("Default").AppendASCII("History");
   // Not all test profiles have a history file.
   if (!file_util::PathExists(history))
@@ skipping 289 matching lines @@
     set_ui_test_name(ASCIIToWide(test_name));
   }
   UITestBase::SetUp();
   PlatformTest::SetUp();
 }
 
 void UITest::TearDown() {
   UITestBase::TearDown();
   PlatformTest::TearDown();
 }