Removing command_execution_timeout_ms in favor of action_max_timeout_ms.

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 72 matching lines @@
     server_->SignalAppLaunch(server_version);
   }
 
  private:
   AutomationProxy* server_;
 };
 
 }  // anonymous namespace
 
 
-AutomationProxy::AutomationProxy(int command_execution_timeout_ms,
+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),
-      command_execution_timeout_(
-          TimeDelta::FromMilliseconds(command_execution_timeout_ms)),
+      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(command_execution_timeout_ms, 0);
+  DCHECK_GE(action_timeout_ms, 0);
   listener_thread_id_ = base::PlatformThread::CurrentId();
   InitializeHandleTracker();
   InitializeThread();
 }
 
 AutomationProxy::~AutomationProxy() {
   // Destruction order is important. Thread has to outlive the channel and
   // tracker has to outlive the thread since we access the tracker inside
   // AutomationMessageFilter::OnMessageReceived.
   Disconnect();
@@ skipping 43 matching lines @@
     shutdown_event_.get()));
   channel_->AddFilter(new AutomationMessageFilter(this));
 }
 
 void AutomationProxy::InitializeHandleTracker() {
   tracker_.reset(new AutomationHandleTracker());
 }
 
 AutomationLaunchResult AutomationProxy::WaitForAppLaunch() {
   AutomationLaunchResult result = AUTOMATION_SUCCESS;
-  if (app_launched_.TimedWait(command_execution_timeout_)) {
+  if (app_launched_.TimedWait(action_timeout_)) {
     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()) {
@@ skipping 19 matching lines @@
   }
   server_version_ = version_string;
   app_launched_.Signal();
 }
 
 bool AutomationProxy::WaitForProcessLauncherThreadToGoIdle() {
   return Send(new AutomationMsg_WaitForProcessLauncherThreadToGoIdle());
 }
 
 bool AutomationProxy::WaitForInitialLoads() {
-  return initial_loads_complete_.TimedWait(command_execution_timeout_);
+  return initial_loads_complete_.TimedWait(action_timeout_);
 }
 
 bool AutomationProxy::WaitForInitialNewTabUILoad(int* load_time) {
-  if (new_tab_ui_load_complete_.TimedWait(command_execution_timeout_)) {
+  if (new_tab_ui_load_complete_.TimedWait(action_timeout_)) {
     *load_time = new_tab_ui_load_time_;
     new_tab_ui_load_complete_.Reset();
     return true;
   }
   return false;
 }
 
 void AutomationProxy::SignalInitialLoads() {
   initial_loads_complete_.Signal();
 }
@@ skipping 209 matching lines @@
 base::file_handle_mapping_vector AutomationProxy::fds_to_map() const {
   base::file_handle_mapping_vector map;
   const int ipcfd = channel_->GetClientFileDescriptor();
   if (ipcfd > -1)
     map.push_back(std::make_pair(ipcfd, kPrimaryIPCChannel + 3));
   return map;
 }
 #endif  // defined(OS_POSIX)
 
 bool AutomationProxy::Send(IPC::Message* message) {
+  return Send(message,
+    static_cast<int>(action_timeout_.InMilliseconds()));
+}
+
+bool AutomationProxy::Send(IPC::Message* message, int timeout_ms) {
   if (!channel_.get()) {
     LOG(ERROR) << "Automation channel has been closed; dropping message!";
     delete message;
     return false;
   }
 
-  bool success = channel_->SendWithTimeout(message,
-                                           command_execution_timeout_ms());
+  bool success = channel_->SendWithTimeout(message, timeout_ms);
 
   if (!success && disconnect_on_failure_) {
     // Send failed (possibly due to a timeout). Browser is likely in a weird
     // state, and further IPC requests are extremely likely to fail (possibly
     // timeout, which would make tests slower). Disconnect the channel now
     // to avoid the slowness.
     LOG(ERROR) << "Disconnecting channel after error!";
     Disconnect();
   }
 
@@ skipping 78 matching lines @@
   // If message sending unsuccessful or test failed, return false.
   return sent && success;
 }
 #endif
 
 bool AutomationProxy::ResetToDefaultTheme() {
   return Send(new AutomationMsg_ResetToDefaultTheme());
 }
 
 bool AutomationProxy::SendJSONRequest(const std::string& request,
+                                      int timeout_ms,
                                       std::string* response) {
   bool result = false;
-  if (!SendAutomationJSONRequest(this, request, response, &result))
+  if (!SendAutomationJSONRequest(this, request, timeout_ms, response, &result))
     return false;
   return result;
 }