Improve pyautolib errors.

chrome/test/pyautolib/pyautolib.cc

 // Copyright (c) 2012 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 "base/base_paths.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
@@ skipping 86 matching lines @@
 }
 
 AutomationProxy* PyUITestBase::automation() const {
   AutomationProxy* automation_proxy = UITestBase::automation();
   if (!automation_proxy) {
     LOG(FATAL) << "The automation proxy is NULL.";
   }
   return automation_proxy;
 }
 
-scoped_refptr<BrowserProxy> PyUITestBase::GetBrowserWindow(int window_index) {

[Nirnimesh, 2012/08/15 00:11:21]

A few files in functional dir are using this.

[craigdh, 2012/08/15 00:50:58]

Any tests still using it should be failing, my previous cl removed it from
pyautolib.i, I just forgot to remove the implementation.

Update: looks like one test managed to land while I was converting everything
over. I'll add it to this cl.

-  return automation()->GetBrowserWindow(window_index);
-}
-
 std::string PyUITestBase::_SendJSONRequest(int window_index,
                                            const std::string& request,
                                            int timeout) {
   std::string response;
   bool success;
-  AutomationMessageSender* automation_sender = automation();
+  AutomationProxy* automation_sender = automation();
   base::TimeTicks time = base::TimeTicks::Now();
 
   if (!automation_sender) {
-    ErrorResponse("The automation proxy does not exist", request, &response);
+    ErrorResponse("Automation proxy does not exist", request, &response);
+  } else if (!automation_sender->channel()) {
+    ErrorResponse("Chrome automation IPC channel was found already broken",
+                  request, &response);
   } else if (!automation_sender->Send(
       new AutomationMsg_SendJSONRequest(window_index, request, &response,
                                         &success),
       timeout)) {
     RequestFailureResponse(request, base::TimeTicks::Now() - time,
                            base::TimeDelta::FromMilliseconds(timeout),
                            &response);
   }
   return response;
 }
 
 void PyUITestBase::ErrorResponse(
     const std::string& error_string,
     const std::string& request,
     std::string* response) {
   base::DictionaryValue error_dict;
   std::string error_msg = StringPrintf("%s for %s", error_string.c_str(),
                                        request.c_str());
   LOG(ERROR) << "Error during automation: " << error_msg;
   error_dict.SetString("error", error_msg);
+  error_dict.SetBoolean("is_interface_error", true);
   base::JSONWriter::Write(&error_dict, response);
 }
 
 void PyUITestBase::RequestFailureResponse(
     const std::string& request,
     const base::TimeDelta& duration,
     const base::TimeDelta& timeout,
     std::string* response) {
   // TODO(craigdh): Determine timeout directly from IPC's Send().
   if (duration >= timeout) {
     ErrorResponse(
-        StringPrintf("Request timed out after %d seconds",
+        StringPrintf("Chrome automation timed out after %d seconds",
                      static_cast<int>(duration.InSeconds())),
         request, response);
   } else {
     // TODO(craigdh): Determine specific cause.
-    ErrorResponse("Chrome failed to respond", request, response);
+    ErrorResponse(
+        "Chrome automation failed prior to timing out, did chrome crash?",
+        request, response);
   }
 }