src/chrome/test/automation/proxy_launcher.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/test/automation/proxy_launcher.h"
   6
   7 #include <vector>
   8
   9 #include "base/environment.h"
  10 #include "base/file_util.h"
  11 #include "base/files/file_enumerator.h"
  12 #include "base/process/kill.h"
  13 #include "base/process/launch.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_split.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/test/test_file_util.h"
  19 #include "base/test/test_timeouts.h"
  20 #include "chrome/app/chrome_command_ids.h"
  21 #include "chrome/common/automation_constants.h"
  22 #include "chrome/common/chrome_constants.h"
  23 #include "chrome/common/chrome_switches.h"
  24 #include "chrome/common/logging_chrome.h"
  25 #include "chrome/common/url_constants.h"
  26 #include "chrome/test/automation/automation_proxy.h"
  27 #include "chrome/test/base/chrome_process_util.h"
  28 #include "chrome/test/base/test_launcher_utils.h"
  29 #include "chrome/test/base/test_switches.h"
  30 #include "chrome/test/ui/ui_test.h"
  31 #include "content/public/common/process_type.h"
  32 #include "ipc/ipc_channel.h"
  33 #include "ipc/ipc_descriptors.h"
  34 #include "sql/connection.h"
  35
  36 #if defined(OS_POSIX)
  37 #include <signal.h>
  38 #include "base/posix/global_descriptors.h"
  39 #endif
  40
  41 namespace {
  42
  43 // Passed as value of kTestType.
  44 const char kUITestType[] = "ui";
  45
  46 // Copies the contents of the given source directory to the given dest
  47 // directory. This is somewhat different than CopyDirectory in base which will
  48 // copies "source/" to "dest/source/". This version will copy "source/*" to
  49 // "dest/*", overwriting existing files as necessary.
  50 //
  51 // This also kicks the files out of the memory cache for the startup tests.
  52 // TODO(brettw) bug 237904: This is the wrong place for this code. It means all
  53 // startup tests other than the "cold" ones run more slowly than necessary.
  54 bool CopyDirectoryContentsNoCache(const base::FilePath& source,
  55                                   const base::FilePath& dest) {
  56   base::FileEnumerator en(source, false,
  57       base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES);
  58   for (base::FilePath cur = en.Next(); !cur.empty(); cur = en.Next()) {
  59     base::FileEnumerator::FileInfo info = en.GetInfo();
  60     if (info.IsDirectory()) {
  61       if (!base::CopyDirectory(cur, dest, true))
  62         return false;
  63     } else {
  64       if (!base::CopyFile(cur, dest.Append(cur.BaseName())))
  65         return false;
  66     }
  67   }
  68
  69   // Kick out the profile files, this must happen after SetUp which creates the
  70   // profile. It might be nicer to use EvictFileFromSystemCacheWrapper from
  71   // UITest which will retry on failure.
  72   base::FileEnumerator kickout(dest, true, base::FileEnumerator::FILES);
  73   for (base::FilePath cur = kickout.Next(); !cur.empty(); cur = kickout.Next())
  74     base::EvictFileFromSystemCacheWithRetry(cur);
  75   return true;
  76 }
  77
  78 // We want to have a current history database when we start the browser so
  79 // things like the NTP will have thumbnails.  This method updates the dates
  80 // in the history to be more recent.
  81 void UpdateHistoryDates(const base::FilePath& user_data_dir) {
  82   // Migrate the times in the segment_usage table to yesterday so we get
  83   // actual thumbnails on the NTP.
  84   sql::Connection db;
  85   base::FilePath history =
  86       user_data_dir.AppendASCII("Default").AppendASCII("History");
  87   // Not all test profiles have a history file.
  88   if (!base::PathExists(history))
  89     return;
  90
  91   ASSERT_TRUE(db.Open(history));
  92   base::Time yesterday = base::Time::Now() - base::TimeDelta::FromDays(1);
  93   std::string yesterday_str = base::Int64ToString(yesterday.ToInternalValue());
  94   std::string query = base::StringPrintf(
  95       "UPDATE segment_usage "
  96       "SET time_slot = %s "
  97       "WHERE id IN (SELECT id FROM segment_usage WHERE time_slot > 0);",
  98       yesterday_str.c_str());
  99   ASSERT_TRUE(db.Execute(query.c_str()));
 100   db.Close();
 101   file_util::EvictFileFromSystemCache(history);
 102 }
 103
 104 }  // namespace
 105
 106 // ProxyLauncher functions
 107
 108 #if defined(OS_WIN)
 109 const char ProxyLauncher::kDefaultInterfaceId[] = "ChromeTestingInterface";
 110 #elif defined(OS_POSIX)
 111 const char ProxyLauncher::kDefaultInterfaceId[] =
 112     "/var/tmp/ChromeTestingInterface";
 113 #endif
 114
 115 ProxyLauncher::ProxyLauncher()
 116     : process_(base::kNullProcessHandle),
 117       process_id_(-1),
 118       shutdown_type_(WINDOW_CLOSE),
 119       no_sandbox_(CommandLine::ForCurrentProcess()->HasSwitch(
 120                       switches::kNoSandbox)),
 121       full_memory_dump_(CommandLine::ForCurrentProcess()->HasSwitch(
 122                             switches::kFullMemoryCrashReport)),
 123       show_error_dialogs_(CommandLine::ForCurrentProcess()->HasSwitch(
 124                               switches::kEnableErrorDialogs)),
 125       enable_dcheck_(CommandLine::ForCurrentProcess()->HasSwitch(
 126                          switches::kEnableDCHECK)),
 127       silent_dump_on_dcheck_(CommandLine::ForCurrentProcess()->HasSwitch(
 128                                  switches::kSilentDumpOnDCHECK)),
 129       disable_breakpad_(CommandLine::ForCurrentProcess()->HasSwitch(
 130                             switches::kDisableBreakpad)),
 131       js_flags_(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 132                     switches::kJavaScriptFlags)),
 133       log_level_(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 134                      switches::kLoggingLevel)) {
 135 }
 136
 137 ProxyLauncher::~ProxyLauncher() {}
 138
 139 bool ProxyLauncher::WaitForBrowserLaunch(bool wait_for_initial_loads) {
 140   AutomationLaunchResult app_launched = automation_proxy_->WaitForAppLaunch();
 141   EXPECT_EQ(AUTOMATION_SUCCESS, app_launched)
 142       << "Error while awaiting automation ping from browser process";
 143   if (app_launched != AUTOMATION_SUCCESS)
 144     return false;
 145
 146   if (wait_for_initial_loads) {
 147     if (!automation_proxy_->WaitForInitialLoads()) {
 148       LOG(ERROR) << "WaitForInitialLoads failed.";
 149       return false;
 150     }
 151   } else {
 152 #if defined(OS_WIN)
 153     // TODO(phajdan.jr): Get rid of this Sleep when logging_chrome_uitest
 154     // stops "relying" on it.
 155     base::PlatformThread::Sleep(TestTimeouts::action_timeout());
 156 #endif
 157   }
 158
 159   return true;
 160 }
 161
 162 bool ProxyLauncher::LaunchBrowserAndServer(const LaunchState& state,
 163                                            bool wait_for_initial_loads) {
 164   // Set up IPC testing interface as a server.
 165   automation_proxy_.reset(CreateAutomationProxy(
 166       TestTimeouts::action_max_timeout()));
 167
 168   if (!LaunchBrowser(state))
 169     return false;
 170
 171   if (!WaitForBrowserLaunch(wait_for_initial_loads))
 172     return false;
 173
 174   return true;
 175 }
 176
 177 bool ProxyLauncher::ConnectToRunningBrowser(bool wait_for_initial_loads) {
 178   // Set up IPC testing interface as a client.
 179   automation_proxy_.reset(CreateAutomationProxy(
 180                               TestTimeouts::action_max_timeout()));
 181
 182   return WaitForBrowserLaunch(wait_for_initial_loads);
 183 }
 184
 185 void ProxyLauncher::CloseBrowserAndServer() {
 186   QuitBrowser();
 187
 188   // Suppress spammy failures that seem to be occurring when running
 189   // the UI tests in single-process mode.
 190   // TODO(jhughes): figure out why this is necessary at all, and fix it
 191   AssertAppNotRunning(
 192       base::StringPrintf(
 193           "Unable to quit all browser processes. Original PID %d",
 194           process_id_));
 195
 196   DisconnectFromRunningBrowser();
 197 }
 198
 199 void ProxyLauncher::DisconnectFromRunningBrowser() {
 200   automation_proxy_.reset();  // Shut down IPC testing interface.
 201 }
 202
 203 bool ProxyLauncher::LaunchBrowser(const LaunchState& state) {
 204   if (state.clear_profile || !temp_profile_dir_.IsValid()) {
 205     if (temp_profile_dir_.IsValid() && !temp_profile_dir_.Delete()) {
 206       LOG(ERROR) << "Failed to delete temporary directory.";
 207       return false;
 208     }
 209
 210     if (!temp_profile_dir_.CreateUniqueTempDir()) {
 211       LOG(ERROR) << "Failed to create temporary directory.";
 212       return false;
 213     }
 214
 215     if (!test_launcher_utils::OverrideUserDataDir(user_data_dir())) {
 216       LOG(ERROR) << "Failed to override user data directory.";
 217       return false;
 218     }
 219   }
 220
 221   if (!state.template_user_data.empty()) {
 222     // Recursively copy the template directory to the user_data_dir.
 223     if (!CopyDirectoryContentsNoCache(state.template_user_data,
 224                                       user_data_dir())) {
 225       LOG(ERROR) << "Failed to copy user data directory template.";
 226       return false;
 227     }
 228
 229     // Update the history file to include recent dates.
 230     UpdateHistoryDates(user_data_dir());
 231   }
 232
 233   // Optionally do any final setup of the test environment.
 234   if (!state.setup_profile_callback.is_null())
 235     state.setup_profile_callback.Run();
 236
 237   if (!LaunchBrowserHelper(state, true, false, &process_)) {
 238     LOG(ERROR) << "LaunchBrowserHelper failed.";
 239     return false;
 240   }
 241   process_id_ = base::GetProcId(process_);
 242
 243   return true;
 244 }
 245
 246 void ProxyLauncher::QuitBrowser() {
 247   // If we have already finished waiting for the browser to exit
 248   // (or it hasn't launched at all), there's nothing to do here.
 249   if (process_ == base::kNullProcessHandle || !automation_proxy_.get())
 250     return;
 251
 252   if (SESSION_ENDING == shutdown_type_) {
 253     TerminateBrowser();
 254     return;
 255   }
 256
 257   base::TimeTicks quit_start = base::TimeTicks::Now();
 258
 259   if (WINDOW_CLOSE == shutdown_type_) {
 260     int window_count = 0;
 261     EXPECT_TRUE(automation()->GetBrowserWindowCount(&window_count));
 262
 263     // Synchronously close all but the last browser window. Closing them
 264     // one-by-one may help with stability.
 265     while (window_count > 1) {
 266       scoped_refptr<BrowserProxy> browser_proxy =
 267           automation()->GetBrowserWindow(0);
 268       EXPECT_TRUE(browser_proxy.get());
 269       if (browser_proxy.get()) {
 270         EXPECT_TRUE(browser_proxy->RunCommand(IDC_CLOSE_WINDOW));
 271         EXPECT_TRUE(automation()->GetBrowserWindowCount(&window_count));
 272       } else {
 273         break;
 274       }
 275     }
 276
 277     // Close the last window asynchronously, because the browser may
 278     // shutdown faster than it will be able to send a synchronous response
 279     // to our message.
 280     scoped_refptr<BrowserProxy> browser_proxy =
 281         automation()->GetBrowserWindow(0);
 282     EXPECT_TRUE(browser_proxy.get());
 283     if (browser_proxy.get()) {
 284       EXPECT_TRUE(browser_proxy->is_valid());
 285       EXPECT_TRUE(browser_proxy->ApplyAccelerator(IDC_CLOSE_WINDOW));
 286       browser_proxy = NULL;
 287     }
 288   } else if (USER_QUIT == shutdown_type_) {
 289     scoped_refptr<BrowserProxy> browser_proxy =
 290         automation()->GetBrowserWindow(0);
 291     EXPECT_TRUE(browser_proxy.get());
 292     if (browser_proxy.get()) {
 293       EXPECT_TRUE(browser_proxy->RunCommandAsync(IDC_EXIT));
 294     }
 295   } else {
 296     NOTREACHED() << "Invalid shutdown type " << shutdown_type_;
 297   }
 298
 299   ChromeProcessList processes = GetRunningChromeProcesses(process_id_);
 300
 301   // Now, drop the automation IPC channel so that the automation provider in
 302   // the browser notices and drops its reference to the browser process.
 303   if (automation_proxy_.get())
 304     automation_proxy_->Disconnect();
 305
 306   // Wait for the browser process to quit. It should quit once all tabs have
 307   // been closed.
 308   int exit_code = -1;
 309   EXPECT_TRUE(WaitForBrowserProcessToQuit(
 310                   TestTimeouts::action_max_timeout(), &exit_code));
 311   EXPECT_EQ(0, exit_code);  // Expect a clean shutdown.
 312
 313   browser_quit_time_ = base::TimeTicks::Now() - quit_start;
 314
 315   // Ensure no child processes are left dangling.
 316   TerminateAllChromeProcesses(processes);
 317 }
 318
 319 void ProxyLauncher::TerminateBrowser() {
 320   // If we have already finished waiting for the browser to exit
 321   // (or it hasn't launched at all), there's nothing to do here.
 322   if (process_ == base::kNullProcessHandle || !automation_proxy_.get())
 323     return;
 324
 325   base::TimeTicks quit_start = base::TimeTicks::Now();
 326
 327 #if defined(OS_WIN) && !defined(USE_AURA)
 328   scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
 329   ASSERT_TRUE(browser.get());
 330   ASSERT_TRUE(browser->TerminateSession());
 331 #endif  // defined(OS_WIN)
 332
 333   ChromeProcessList processes = GetRunningChromeProcesses(process_id_);
 334
 335   // Now, drop the automation IPC channel so that the automation provider in
 336   // the browser notices and drops its reference to the browser process.
 337   if (automation_proxy_.get())
 338     automation_proxy_->Disconnect();
 339
 340 #if defined(OS_POSIX)
 341   EXPECT_EQ(kill(process_, SIGTERM), 0);
 342 #endif  // OS_POSIX
 343
 344   int exit_code = -1;
 345   EXPECT_TRUE(WaitForBrowserProcessToQuit(
 346                   TestTimeouts::action_max_timeout(), &exit_code));
 347   EXPECT_EQ(0, exit_code);  // Expect a clean shutdown.
 348
 349   browser_quit_time_ = base::TimeTicks::Now() - quit_start;
 350
 351   // Ensure no child processes are left dangling.
 352   TerminateAllChromeProcesses(processes);
 353 }
 354
 355 void ProxyLauncher::AssertAppNotRunning(const std::string& error_message) {
 356   std::string final_error_message(error_message);
 357
 358   ChromeProcessList processes = GetRunningChromeProcesses(process_id_);
 359   if (!processes.empty()) {
 360     final_error_message += " Leftover PIDs: [";
 361     for (ChromeProcessList::const_iterator it = processes.begin();
 362          it != processes.end(); ++it) {
 363       final_error_message += base::StringPrintf(" %d", *it);
 364     }
 365     final_error_message += " ]";
 366   }
 367   ASSERT_TRUE(processes.empty()) << final_error_message;
 368 }
 369
 370 bool ProxyLauncher::WaitForBrowserProcessToQuit(
 371     base::TimeDelta timeout,
 372     int* exit_code) {
 373 #ifdef WAIT_FOR_DEBUGGER_ON_OPEN
 374   timeout = base::TimeDelta::FromSeconds(500);
 375 #endif
 376   bool success = false;
 377
 378   // Only wait for exit if the "browser, please terminate" message had a
 379   // chance of making it through.
 380   if (!automation_proxy_->channel_disconnected_on_failure())
 381     success = base::WaitForExitCodeWithTimeout(process_, exit_code, timeout);
 382
 383   base::CloseProcessHandle(process_);
 384   process_ = base::kNullProcessHandle;
 385   process_id_ = -1;
 386
 387   return success;
 388 }
 389
 390 void ProxyLauncher::PrepareTestCommandline(CommandLine* command_line,
 391                                            bool include_testing_id) {
 392   // Add any explicit command line flags passed to the process.
 393   CommandLine::StringType extra_chrome_flags =
 394       CommandLine::ForCurrentProcess()->GetSwitchValueNative(
 395           switches::kExtraChromeFlags);
 396   if (!extra_chrome_flags.empty()) {
 397     // Split by spaces and append to command line.
 398     std::vector<CommandLine::StringType> flags;
 399     base::SplitStringAlongWhitespace(extra_chrome_flags, &flags);
 400     for (size_t i = 0; i < flags.size(); ++i)
 401       command_line->AppendArgNative(flags[i]);
 402   }
 403
 404   // Also look for extra flags in environment.
 405   scoped_ptr<base::Environment> env(base::Environment::Create());
 406   std::string extra_from_env;
 407   if (env->GetVar("EXTRA_CHROME_FLAGS", &extra_from_env)) {
 408     std::vector<std::string> flags;
 409     base::SplitStringAlongWhitespace(extra_from_env, &flags);
 410     for (size_t i = 0; i < flags.size(); ++i)
 411       command_line->AppendArg(flags[i]);
 412   }
 413
 414   // No default browser check, it would create an info-bar (if we are not the
 415   // default browser) that could conflicts with some tests expectations.
 416   command_line->AppendSwitch(switches::kNoDefaultBrowserCheck);
 417
 418   // This is a UI test.
 419   command_line->AppendSwitchASCII(switches::kTestType, kUITestType);
 420
 421   // Tell the browser to use a temporary directory just for this test
 422   // if it is not already set.
 423   if (command_line->GetSwitchValuePath(switches::kUserDataDir).empty()) {
 424     command_line->AppendSwitchPath(switches::kUserDataDir, user_data_dir());
 425   }
 426
 427   if (include_testing_id)
 428     command_line->AppendSwitchASCII(switches::kTestingChannelID,
 429                                     PrefixedChannelID());
 430
 431   if (!show_error_dialogs_)
 432     command_line->AppendSwitch(switches::kNoErrorDialogs);
 433   if (no_sandbox_)
 434     command_line->AppendSwitch(switches::kNoSandbox);
 435   if (full_memory_dump_)
 436     command_line->AppendSwitch(switches::kFullMemoryCrashReport);
 437   if (enable_dcheck_)
 438     command_line->AppendSwitch(switches::kEnableDCHECK);
 439   if (silent_dump_on_dcheck_)
 440     command_line->AppendSwitch(switches::kSilentDumpOnDCHECK);
 441   if (disable_breakpad_)
 442     command_line->AppendSwitch(switches::kDisableBreakpad);
 443
 444   if (!js_flags_.empty())
 445     command_line->AppendSwitchASCII(switches::kJavaScriptFlags, js_flags_);
 446   if (!log_level_.empty())
 447     command_line->AppendSwitchASCII(switches::kLoggingLevel, log_level_);
 448
 449   command_line->AppendSwitch(switches::kMetricsRecordingOnly);
 450
 451   if (!CommandLine::ForCurrentProcess()->HasSwitch(
 452           switches::kEnableErrorDialogs))
 453     command_line->AppendSwitch(switches::kEnableLogging);
 454
 455 #ifdef WAIT_FOR_DEBUGGER_ON_OPEN
 456   command_line->AppendSwitch(switches::kDebugOnStart);
 457 #endif
 458
 459   // Force the app to always exit when the last browser window is closed.
 460   command_line->AppendSwitch(switches::kDisableZeroBrowsersOpenForTests);
 461
 462   // Allow file:// access on ChromeOS.
 463   command_line->AppendSwitch(switches::kAllowFileAccess);
 464
 465   // The tests assume that file:// URIs can freely access other file:// URIs.
 466   command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
 467 }
 468
 469 bool ProxyLauncher::LaunchBrowserHelper(const LaunchState& state,
 470                                         bool main_launch,
 471                                         bool wait,
 472                                         base::ProcessHandle* process) {
 473   CommandLine command_line(state.command);
 474
 475   // Add command line arguments that should be applied to all UI tests.
 476   PrepareTestCommandline(&command_line, state.include_testing_id);
 477
 478   // Sometimes one needs to run the browser under a special environment
 479   // (e.g. valgrind) without also running the test harness (e.g. python)
 480   // under the special environment.  Provide a way to wrap the browser
 481   // commandline with a special prefix to invoke the special environment.
 482   const char* browser_wrapper = getenv("BROWSER_WRAPPER");
 483   if (browser_wrapper) {
 484 #if defined(OS_WIN)
 485     command_line.PrependWrapper(ASCIIToWide(browser_wrapper));
 486 #elif defined(OS_POSIX)
 487     command_line.PrependWrapper(browser_wrapper);
 488 #endif
 489     VLOG(1) << "BROWSER_WRAPPER was set, prefixing command_line with "
 490             << browser_wrapper;
 491   }
 492
 493   if (main_launch)
 494     browser_launch_time_ = base::TimeTicks::Now();
 495
 496   base::LaunchOptions options;
 497   options.wait = wait;
 498
 499 #if defined(OS_WIN)
 500   options.start_hidden = !state.show_window;
 501 #elif defined(OS_POSIX)
 502   int ipcfd = -1;
 503   file_util::ScopedFD ipcfd_closer(&ipcfd);
 504   base::FileHandleMappingVector fds;
 505   if (main_launch && automation_proxy_.get()) {
 506     ipcfd = automation_proxy_->channel()->TakeClientFileDescriptor();
 507     fds.push_back(std::make_pair(ipcfd,
 508         kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
 509     options.fds_to_remap = &fds;
 510   }
 511 #endif
 512
 513   return base::LaunchProcess(command_line, options, process);
 514 }
 515
 516 AutomationProxy* ProxyLauncher::automation() const {
 517   EXPECT_TRUE(automation_proxy_.get());
 518   return automation_proxy_.get();
 519 }
 520
 521 base::FilePath ProxyLauncher::user_data_dir() const {
 522   EXPECT_TRUE(temp_profile_dir_.IsValid());
 523   return temp_profile_dir_.path();
 524 }
 525
 526 base::ProcessHandle ProxyLauncher::process() const {
 527   return process_;
 528 }
 529
 530 base::ProcessId ProxyLauncher::process_id() const {
 531   return process_id_;
 532 }
 533
 534 base::TimeTicks ProxyLauncher::browser_launch_time() const {
 535   return browser_launch_time_;
 536 }
 537
 538 base::TimeDelta ProxyLauncher::browser_quit_time() const {
 539   return browser_quit_time_;
 540 }
 541
 542 // NamedProxyLauncher functions
 543
 544 NamedProxyLauncher::NamedProxyLauncher(const std::string& channel_id,
 545                                        bool launch_browser,
 546                                        bool disconnect_on_failure)
 547     : channel_id_(channel_id),
 548       launch_browser_(launch_browser),
 549       disconnect_on_failure_(disconnect_on_failure) {
 550 }
 551
 552 AutomationProxy* NamedProxyLauncher::CreateAutomationProxy(
 553     base::TimeDelta execution_timeout) {
 554   AutomationProxy* proxy = new AutomationProxy(execution_timeout,
 555                                                disconnect_on_failure_);
 556   proxy->InitializeChannel(channel_id_, true);
 557   return proxy;
 558 }
 559
 560 bool NamedProxyLauncher::InitializeConnection(const LaunchState& state,
 561                                               bool wait_for_initial_loads) {
 562   if (launch_browser_) {
 563 #if defined(OS_POSIX)
 564     // Because we are waiting on the existence of the testing file below,
 565     // make sure there isn't one already there before browser launch.
 566     if (!base::DeleteFile(base::FilePath(channel_id_), false)) {
 567       LOG(ERROR) << "Failed to delete " << channel_id_;
 568       return false;
 569     }
 570 #endif
 571
 572     if (!LaunchBrowser(state)) {
 573       LOG(ERROR) << "Failed to LaunchBrowser";
 574       return false;
 575     }
 576   }
 577
 578   // Wait for browser to be ready for connections.
 579   bool channel_initialized = false;
 580   base::TimeDelta sleep_time = base::TimeDelta::FromMilliseconds(
 581       automation::kSleepTime);
 582   for (base::TimeDelta wait_time = base::TimeDelta();
 583        wait_time < TestTimeouts::action_max_timeout();
 584        wait_time += sleep_time) {
 585     channel_initialized = IPC::Channel::IsNamedServerInitialized(channel_id_);
 586     if (channel_initialized)
 587       break;
 588     base::PlatformThread::Sleep(sleep_time);
 589   }
 590   if (!channel_initialized) {
 591     LOG(ERROR) << "Failed to wait for testing channel presence.";
 592     return false;
 593   }
 594
 595   if (!ConnectToRunningBrowser(wait_for_initial_loads)) {
 596     LOG(ERROR) << "Failed to ConnectToRunningBrowser";
 597     return false;
 598   }
 599   return true;
 600 }
 601
 602 void NamedProxyLauncher::TerminateConnection() {
 603   if (launch_browser_)
 604     CloseBrowserAndServer();
 605   else
 606     DisconnectFromRunningBrowser();
 607 }
 608
 609 std::string NamedProxyLauncher::PrefixedChannelID() const {
 610   std::string channel_id;
 611   channel_id.append(automation::kNamedInterfacePrefix).append(channel_id_);
 612   return channel_id;
 613 }
 614
 615 // AnonymousProxyLauncher functions
 616
 617 AnonymousProxyLauncher::AnonymousProxyLauncher(bool disconnect_on_failure)
 618     : disconnect_on_failure_(disconnect_on_failure) {
 619   channel_id_ = AutomationProxy::GenerateChannelID();
 620 }
 621
 622 AutomationProxy* AnonymousProxyLauncher::CreateAutomationProxy(
 623     base::TimeDelta execution_timeout) {
 624   AutomationProxy* proxy = new AutomationProxy(execution_timeout,
 625                                                disconnect_on_failure_);
 626   proxy->InitializeChannel(channel_id_, false);
 627   return proxy;
 628 }
 629
 630 bool AnonymousProxyLauncher::InitializeConnection(const LaunchState& state,
 631                                                   bool wait_for_initial_loads) {
 632   return LaunchBrowserAndServer(state, wait_for_initial_loads);
 633 }
 634
 635 void AnonymousProxyLauncher::TerminateConnection() {
 636   CloseBrowserAndServer();
 637 }
 638
 639 std::string AnonymousProxyLauncher::PrefixedChannelID() const {
 640   return channel_id_;
 641 }