Don't waste time on browser that crashed before connecting to the IPC channel.

chrome/test/automation/automation_proxy.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/automation_proxy.h"
 
 #include <gtest/gtest.h>
 
 #include <sstream>
 
@@ skipping 15 matching lines @@
 #if defined(OS_WIN)
 // TODO(port): Enable when dialog_delegate is ported.
 #include "views/window/dialog_delegate.h"
 #endif
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
 
+const char kChannelErrorVersionString[] = "***CHANNEL_ERROR***";
+
 // This object allows messages received on the background thread to be
 // properly triaged.
 class AutomationMessageFilter : public IPC::ChannelProxy::MessageFilter {
  public:
   explicit AutomationMessageFilter(AutomationProxy* server) : server_(server) {}
 
   // Return true to indicate that the message was handled, or false to let
   // the message be handled in the default way.
-  virtual bool OnMessageReceived(const IPC::Message& message) {
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(AutomationMessageFilter, message)
       IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_Hello,
                                   OnAutomationHello(message))
       IPC_MESSAGE_HANDLER_GENERIC(
         AutomationMsg_InitialLoadsComplete, server_->SignalInitialLoads())
       IPC_MESSAGE_HANDLER(AutomationMsg_InitialNewTabUILoadComplete,
                           NewTabLoaded)
       IPC_MESSAGE_HANDLER_GENERIC(
         AutomationMsg_InvalidateHandle, server_->InvalidateHandle(message))
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
 
     return handled;
   }
 
-  virtual void OnFilterAdded(IPC::Channel* channel) {
+  virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
     server_->SetChannel(channel);
   }
 
-  virtual void OnFilterRemoved() {
+  virtual void OnFilterRemoved() OVERRIDE {
     server_->ResetChannel();
   }
 
+  virtual void OnChannelError() OVERRIDE {
+    server_->SignalAppLaunch(kChannelErrorVersionString);
+    server_->SignalNewTabUITab(-1);
+  }
+
+ private:
   void NewTabLoaded(int load_time) {
     server_->SignalNewTabUITab(load_time);
   }
 
   void OnAutomationHello(const IPC::Message& hello_message) {
     std::string server_version;
     void* iter = NULL;
     if (!hello_message.ReadString(&iter, &server_version)) {
       // We got an AutomationMsg_Hello from an old automation provider
       // that doesn't send version info. Leave server_version as an empty
       // string to signal a version mismatch.
       LOG(ERROR) << "Pre-versioning protocol detected in automation provider.";
     }
 
     server_->SignalAppLaunch(server_version);
   }
 
- private:
   AutomationProxy* server_;
+
+  DISALLOW_COPY_AND_ASSIGN(AutomationMessageFilter);
 };
 
 }  // anonymous namespace
 
 
 AutomationProxy::AutomationProxy(int action_timeout_ms,
                                  bool disconnect_on_failure)
     : app_launched_(true, false),
       initial_loads_complete_(true, false),
       new_tab_ui_load_complete_(true, false),
       shutdown_event_(new base::WaitableEvent(true, false)),
-      app_launch_signaled_(0),
       perform_version_check_(false),
       disconnect_on_failure_(disconnect_on_failure),
       action_timeout_(
           TimeDelta::FromMilliseconds(action_timeout_ms)),
       listener_thread_id_(0) {
   // base::WaitableEvent::TimedWait() will choke if we give it a negative value.
   // Zero also seems unreasonable, since we need to wait for IPC, but at
   // least it is legal... ;-)
   DCHECK_GE(action_timeout_ms, 0);
   listener_thread_id_ = base::PlatformThread::CurrentId();
@@ skipping 53 matching lines @@
   channel_->AddFilter(new AutomationMessageFilter(this));
 }
 
 void AutomationProxy::InitializeHandleTracker() {
   tracker_.reset(new AutomationHandleTracker());
 }
 
 AutomationLaunchResult AutomationProxy::WaitForAppLaunch() {
   AutomationLaunchResult result = AUTOMATION_SUCCESS;
   if (app_launched_.TimedWait(action_timeout_)) {
-    if (perform_version_check_) {
+    if (server_version_ == kChannelErrorVersionString) {
+      result = AUTOMATION_CHANNEL_ERROR;
+    } else if (perform_version_check_) {
       // Obtain our own version number and compare it to what the automation
       // provider sent.
       chrome::VersionInfo version_info;
       DCHECK(version_info.is_valid());
 
       // Note that we use a simple string comparison since we expect the version
       // to be a punctuated numeric string. Consider using base/Version if we
       // ever need something more complicated here.
       if (server_version_ != version_info.Version()) {
         result = AUTOMATION_VERSION_MISMATCH;
       }
     }
   } else {
     result = AUTOMATION_TIMEOUT;
   }
   return result;
 }
 
 void AutomationProxy::SignalAppLaunch(const std::string& version_string) {
-  // The synchronization of the reading / writing of server_version_ is a bit
-  // messy but does work as long as SignalAppLaunch is only called once.
-  // Review this if we ever want an AutomationProxy instance to launch
-  // multiple AutomationProviders.
-  app_launch_signaled_++;
-  if (app_launch_signaled_ > 1) {
-    NOTREACHED();
-    LOG(ERROR) << "Multiple AutomationMsg_Hello messages received";
-    return;
-  }
   server_version_ = version_string;
   app_launched_.Signal();
 }
 
 bool AutomationProxy::WaitForProcessLauncherThreadToGoIdle() {
   return Send(new AutomationMsg_WaitForProcessLauncherThreadToGoIdle());
 }
 
 bool AutomationProxy::WaitForInitialLoads() {
   return initial_loads_complete_.TimedWait(action_timeout_);
@@ skipping 334 matching lines @@
 }
 
 bool AutomationProxy::SendJSONRequest(const std::string& request,
                                       int timeout_ms,
                                       std::string* response) {
   bool result = false;
   if (!SendAutomationJSONRequest(this, request, timeout_ms, response, &result))
     return false;
   return result;
 }