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