Change timeout for all ChromeDriver automation calls to infinite

chrome/test/automation/automation_json_requests.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.

[kkania, 2011/06/07 22:55:28]

overall stuff (I put it here because many people miss it if its in the overall
description):

-set BUG=82457
-let's move the base::kTimeoutMs from here to webdriver/automation.cc. Just make
all the Send*Request functions that need a custom timeout take an int timeout_ms
arg.

 // 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_json_requests.h"
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/test/test_timeouts.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome/test/automation/automation_proxy.h"
 #include "content/common/json_value_serializer.h"
 
 namespace {
-
 bool SendAutomationJSONRequest(AutomationMessageSender* sender,
                                const DictionaryValue& request_dict,
                                DictionaryValue* reply_dict,
+                               int timeout_ms,
                                std::string* error_msg) {
   std::string request, reply;
   base::JSONWriter::Write(&request_dict, false, &request);
   bool success = false;
-  int timeout_ms = TestTimeouts::action_max_timeout_ms();
   base::Time before_sending = base::Time::Now();
   if (!SendAutomationJSONRequest(
           sender, request, timeout_ms, &reply, &success)) {
     int64 elapsed_ms = (base::Time::Now() - before_sending).InMilliseconds();
     std::string command;
     request_dict.GetString("command", &command);
     if (elapsed_ms >= timeout_ms) {
       *error_msg = base::StringPrintf(
           "Chrome did not respond to '%s'. Request may have timed out. "
               "Elapsed time was %" PRId64 " ms. Request timeout was %d ms. "
@@ skipping 30 matching lines @@
         error.c_str(),
         request.c_str());
     LOG(ERROR) << "JSON request failed: " << command << "\n"
                << "    with error: " << error;
     return false;
   }
   reply_dict->MergeDictionary(dict);
   return true;
 }
 
+bool SendAutomationJSONRequest(AutomationMessageSender* sender,
+                               const DictionaryValue& request_dict,
+                               DictionaryValue* reply_dict,
+                               std::string* error_msg) {
+  int timeout_ms = TestTimeouts::action_max_timeout_ms();

[kkania, 2011/06/07 22:55:28]

make this one call sender->Send(msg) instead of sender->Send(msg, timeout); we
should have never used action_max_timeout_ms in this file.

+  return SendAutomationJSONRequest(sender, request_dict,
+                            reply_dict, timeout_ms, error_msg);
+}
 }  // namespace
 
 WebKeyEvent::WebKeyEvent(automation::KeyEventTypes type,
                          ui::KeyboardCode key_code,
                          const std::string& unmodified_text,
                          const std::string& modified_text,
                          int modifiers)
     : type(type),
       key_code(key_code),
       unmodified_text(unmodified_text),
@@ skipping 55 matching lines @@
     int navigation_count,
     AutomationMsg_NavigationResponseValues* nav_response,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "NavigateToURL");
   dict.SetInteger("windex", browser_index);
   dict.SetInteger("tab_index", tab_index);
   dict.SetString("url", url.possibly_invalid_spec());
   dict.SetInteger("navigation_count", navigation_count);
   DictionaryValue reply_dict;
-  if (!SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg))
+  if (!SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                 base::kNoTimeout, error_msg)) {
     return false;
+  }
   int response = 0;
   if (!reply_dict.GetInteger("result", &response))
     return false;
   *nav_response = static_cast<AutomationMsg_NavigationResponseValues>(response);
   return true;
 }
 
 bool SendExecuteJavascriptJSONRequest(
     AutomationMessageSender* sender,
     int browser_index,
     int tab_index,
     const std::string& frame_xpath,
     const std::string& javascript,
     Value** result,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "ExecuteJavascript");
   dict.SetInteger("windex", browser_index);
   dict.SetInteger("tab_index", tab_index);
   dict.SetString("frame_xpath", frame_xpath);
   dict.SetString("javascript", javascript);
   DictionaryValue reply_dict;
-  if (!SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg))
+  if (!SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                 base::kNoTimeout, error_msg)) {
     return false;
+  }
 
   std::string json;
   if (!reply_dict.GetString("result", &json)) {
     LOG(ERROR) << "Executed javascript but received no 'result'";
     return false;
   }
   // Wrap |json| in an array before deserializing because valid JSON has an
   // array or an object as the root.
   json.insert(0, "[");
   json.append("]");
@@ skipping 11 matching lines @@
 bool SendGoForwardJSONRequest(
     AutomationMessageSender* sender,
     int browser_index,
     int tab_index,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "GoForward");
   dict.SetInteger("windex", browser_index);
   dict.SetInteger("tab_index", tab_index);
   DictionaryValue reply_dict;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, error_msg);
 }
 
 bool SendGoBackJSONRequest(
     AutomationMessageSender* sender,
     int browser_index,
     int tab_index,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "GoBack");
   dict.SetInteger("windex", browser_index);
   dict.SetInteger("tab_index", tab_index);
   DictionaryValue reply_dict;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, error_msg);
 }
 
 bool SendReloadJSONRequest(
     AutomationMessageSender* sender,
     int browser_index,
     int tab_index,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "Reload");
   dict.SetInteger("windex", browser_index);
   dict.SetInteger("tab_index", tab_index);
   DictionaryValue reply_dict;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, error_msg);
 }
 
 bool SendCaptureEntirePageJSONRequest(
     AutomationMessageSender* sender,
     int browser_index,
     int tab_index,
     const FilePath& path,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "CaptureEntirePage");
   dict.SetInteger("windex", browser_index);
   dict.SetInteger("tab_index", tab_index);
   dict.SetString("path", path.value());
   DictionaryValue reply_dict;
 
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, error_msg);
 }
 
 bool SendGetTabURLJSONRequest(
     AutomationMessageSender* sender,
     int browser_index,
     int tab_index,
     std::string* url,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "GetTabURL");
@@ skipping 23 matching lines @@
 
 bool SendGetCookiesJSONRequest(
     AutomationMessageSender* sender,
     const std::string& url,
     ListValue** cookies,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "GetCookies");
   dict.SetString("url", url);
   DictionaryValue reply_dict;
-  if (!SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg))
+  if (!SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                 base::kNoTimeout, error_msg))
     return false;
   Value* cookies_unscoped_value;
   if (!reply_dict.Remove("cookies", &cookies_unscoped_value))
     return false;
   scoped_ptr<Value> cookies_value(cookies_unscoped_value);
   if (!cookies_value->IsType(Value::TYPE_LIST))
     return false;
   *cookies = static_cast<ListValue*>(cookies_value.release());
   return true;
 }
 
 bool SendGetCookiesJSONRequestDeprecated(
     AutomationMessageSender* sender,
     int browser_index,
     const std::string& url,
     std::string* cookies) {
   DictionaryValue dict;
   dict.SetString("command", "GetCookies");
   dict.SetInteger("windex", browser_index);
   dict.SetString("url", url);
   DictionaryValue reply_dict;
   std::string error_msg;
-  if (!SendAutomationJSONRequest(sender, dict, &reply_dict, &error_msg))
+  if (!SendAutomationJSONRequest(sender, dict, &reply_dict,

[kkania, 2011/06/07 22:55:28]

you can forget adding custom timeout to the deprecated requests in this file

+                                 base::kNoTimeout, &error_msg)) {
     return false;
+  }
   return reply_dict.GetString("cookies", cookies);
 }
 
 bool SendDeleteCookieJSONRequest(
     AutomationMessageSender* sender,
     const std::string& url,
     const std::string& cookie_name,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "DeleteCookie");
   dict.SetString("url", url);
   dict.SetString("name", cookie_name);
   DictionaryValue reply_dict;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, error_msg);
 }
 
 bool SendDeleteCookieJSONRequestDeprecated(
     AutomationMessageSender* sender,
     int browser_index,
     const std::string& url,
     const std::string& cookie_name) {
   DictionaryValue dict;
   dict.SetString("command", "DeleteCookie");
   dict.SetInteger("windex", browser_index);
   dict.SetString("url", url);
   dict.SetString("name", cookie_name);
   DictionaryValue reply_dict;
   std::string error_msg;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, &error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, &error_msg);
 }
 
 bool SendSetCookieJSONRequest(
     AutomationMessageSender* sender,
     const std::string& url,
     DictionaryValue* cookie_dict,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "SetCookie");
   dict.SetString("url", url);
   dict.Set("cookie", cookie_dict->DeepCopy());
   DictionaryValue reply_dict;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, error_msg);
 }
 
 bool SendSetCookieJSONRequestDeprecated(
     AutomationMessageSender* sender,
     int browser_index,
     const std::string& url,
     const std::string& cookie) {
   DictionaryValue dict;
   dict.SetString("command", "SetCookie");
   dict.SetInteger("windex", browser_index);
   dict.SetString("url", url);
   dict.SetString("cookie", cookie);
   DictionaryValue reply_dict;
   std::string error_msg;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, &error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, &error_msg);
 }
 
 bool SendGetTabIdsJSONRequest(
     AutomationMessageSender* sender,
     std::vector<int>* tab_ids,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "GetTabIds");
   DictionaryValue reply_dict;
   if (!SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg))
@@ skipping 189 matching lines @@
   return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
 }
 
 bool SendGetAppModalDialogMessageJSONRequest(
     AutomationMessageSender* sender,
     std::string* message,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "GetAppModalDialogMessage");
   DictionaryValue reply_dict;
-  if (!SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg))
+  if (!SendAutomationJSONRequest(sender, dict, &reply_dict,

[kkania, 2011/06/07 22:55:28]

I don't think need custom timeout here

+                                 base::kNoTimeout, error_msg)) {
     return false;
+  }
   return reply_dict.GetString("message", message);
 }
 
 bool SendAcceptOrDismissAppModalDialogJSONRequest(
     AutomationMessageSender* sender,
     bool accept,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "AcceptOrDismissAppModalDialog");
   dict.SetBoolean("accept", accept);
   DictionaryValue reply_dict;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, error_msg);

[kkania, 2011/06/07 22:55:28]

or here

 }
 
 bool SendAcceptPromptAppModalDialogJSONRequest(
     AutomationMessageSender* sender,
     const std::string& prompt_text,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "AcceptOrDismissAppModalDialog");
   dict.SetBoolean("accept", true);
   dict.SetString("prompt_text", prompt_text);
   DictionaryValue reply_dict;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, error_msg);

[kkania, 2011/06/07 22:55:28]

or here

 }
 
 bool SendWaitForAllTabsToStopLoadingJSONRequest(
     AutomationMessageSender* sender,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "WaitForAllTabsToStopLoading");
   DictionaryValue reply_dict;
-  return SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg);
+  return SendAutomationJSONRequest(sender, dict, &reply_dict,
+                                   base::kNoTimeout, error_msg);
 }
 
 bool SendGetChromeDriverAutomationVersion(
     AutomationMessageSender* sender,
     int* version,
     std::string* error_msg) {
   DictionaryValue dict;
   dict.SetString("command", "GetChromeDriverAutomationVersion");
   DictionaryValue reply_dict;
   if (!SendAutomationJSONRequest(sender, dict, &reply_dict, error_msg))
     return false;
   return reply_dict.GetInteger("version", version);
 }