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