Let pyauto create an attached webdriver instance to manipulate web pages.

chrome/test/automation/proxy_launcher.cc

 // Copyright (c) 2011 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/automation/proxy_launcher.h"
 
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
@@ skipping 501 matching lines @@
 }
 
 AutomationProxy* NamedProxyLauncher::CreateAutomationProxy(
     int execution_timeout) {
   AutomationProxy* proxy = new AutomationProxy(execution_timeout,
                                                disconnect_on_failure_);
   proxy->InitializeChannel(channel_id_, true);
   return proxy;
 }
 
-void NamedProxyLauncher::InitializeConnection(const LaunchState& state,
+bool NamedProxyLauncher::InitializeConnection(const LaunchState& state,
                                               bool wait_for_initial_loads) {
   if (launch_browser_) {
 #if defined(OS_POSIX)
     // Because we are waiting on the existence of the testing file below,
     // make sure there isn't one already there before browser launch.
-    EXPECT_TRUE(file_util::Delete(FilePath(channel_id_), false));
+    if (!file_util::Delete(FilePath(channel_id_), false)) {
+      LOG(ERROR) << "Failed to delete " << channel_id_;
+      return false;
+    }
 #endif
 
-    // Set up IPC testing interface as a client.
-    ASSERT_TRUE(LaunchBrowser(state));
+    if (!LaunchBrowser(state)) {
+      LOG(ERROR) << "Failed to LaunchBrowser";
+      return false;
+    }
   }
 
   // Wait for browser to be ready for connections.
   bool channel_initialized = false;
   for (int wait_time = 0;
        wait_time < TestTimeouts::action_max_timeout_ms();
        wait_time += automation::kSleepTime) {
     channel_initialized = IPC::Channel::IsNamedServerInitialized(channel_id_);
     if (channel_initialized)
       break;
     base::PlatformThread::Sleep(automation::kSleepTime);
   }
-  EXPECT_TRUE(channel_initialized);
+  if (!channel_initialized) {
+    LOG(ERROR) << "Failed to wait for testing channel presence.";
+    return false;
+  }
 
-  ASSERT_TRUE(ConnectToRunningBrowser(wait_for_initial_loads));
+  if (!ConnectToRunningBrowser(wait_for_initial_loads)) {
+    LOG(ERROR) << "Failed to ConnectToRunningBrowser";
+    return false;
+  }
+  return true;
 }
 
 void NamedProxyLauncher::TerminateConnection() {
   if (launch_browser_)
     CloseBrowserAndServer();
   else
     DisconnectFromRunningBrowser();
 }
 
 std::string NamedProxyLauncher::PrefixedChannelID() const {
@@ skipping 10 matching lines @@
 }
 
 AutomationProxy* AnonymousProxyLauncher::CreateAutomationProxy(
     int execution_timeout) {
   AutomationProxy* proxy = new AutomationProxy(execution_timeout,
                                                disconnect_on_failure_);
   proxy->InitializeChannel(channel_id_, false);
   return proxy;
 }
 
-void AnonymousProxyLauncher::InitializeConnection(const LaunchState& state,
+bool AnonymousProxyLauncher::InitializeConnection(const LaunchState& state,
                                                   bool wait_for_initial_loads) {
-  ASSERT_TRUE(LaunchBrowserAndServer(state, wait_for_initial_loads));
+  return LaunchBrowserAndServer(state, wait_for_initial_loads);
 }
 
 void AnonymousProxyLauncher::TerminateConnection() {
   CloseBrowserAndServer();
 }
 
 std::string AnonymousProxyLauncher::PrefixedChannelID() const {
   return channel_id_;
 }