[chromedriver] Apply page load timeout to slow cross-process navigations

chrome/test/chromedriver/window_commands.cc

 // Copyright (c) 2013 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/chromedriver/window_commands.h"
 
 #include <stddef.h>
 
 #include <list>
 #include <string>
@@ skipping 185 matching lines @@
   return web_view->DispatchTouchEvents(events);
 }
 
 }  // namespace
 
 Status ExecuteWindowCommand(
     const WindowCommand& command,
     Session* session,
     const base::DictionaryValue& params,
     scoped_ptr<base::Value>* value) {
+  Timeout timeout;

[samuong, 2016/02/20 00:11:44]

I might have misread how this works, but does timeout.deadline_ == 0 here?

   WebView* web_view = NULL;
   Status status = session->GetTargetWindow(&web_view);
   if (status.IsError())
     return status;
 
   status = web_view->ConnectIfNecessary();
   if (status.IsError())
     return status;
 
   status = web_view->HandleReceivedEvents();
@@ skipping 10 matching lines @@
   }
 
   Status nav_status(kOk);
   for (int attempt = 0; attempt < 3; attempt++) {
     if (attempt == 2) {
       // Switch to main frame and retry command if subframe no longer exists.
       session->SwitchToTopFrame();
     }
 
     nav_status = web_view->WaitForPendingNavigations(
-        session->GetCurrentFrameId(), session->page_load_timeout, true);
+        session->GetCurrentFrameId(),
+        Timeout(session->page_load_timeout, &timeout),

[samuong, 2016/02/20 00:11:44]

...and if so, does that mean that the timeout duration here will also be 0,
since min(session->page_load_timeout, timeout.duration_) == timeout.duration_ ==
0?

[Alexander Semashko, 2016/02/20 00:38:40]

No, the outer timout's duration has effect only if it is set. The first call to
WaitForPendingNavigations will always be allowed to wait for
session->page_load_timeout.

[samuong, 2016/02/22 23:55:35]

Ah right, I misread the way TimeTicks::is_null() works. So the first call to
WaitForPendingNavigations will use session->page_load_timeout, since
timeout->deadline_ is null. This shouldn't cause any problem.

+        true);
     if (nav_status.IsError())
       return nav_status;
 
-    status = command.Run(session, web_view, params, value);
-    if (status.code() == kNoSuchExecutionContext) {
+    status = command.Run(session, web_view, params, value, &timeout);

[samuong, 2016/02/22 23:55:35]

...however the call to command.Run here may or may not set the timeout duration,
depending on which command we're dealing with. In the case of ExecuteGet, it
will set the duration, and if ExecuteGet fails, it'll be retried. So on the
second attempt, we call ExecuteGet again, and this will in turn call
timeout.SetDuration for a second time?

I guess this won't cause an issue since it gets set to the same duration (unless
we're in a debug build and the DCHECKs are enabled...)

[Alexander Semashko, 2016/02/24 12:51:20]

Good catch! I've changed the code so that it's ok to call SetDuration many times
with the same duration.

+    if (status.code() == kNoSuchExecutionContext ||
+        status.code() == kTimeout) {
+      // If the command timed out, let WaitForPendingNavigations cancel
+      // the navigation if there is one.
       continue;
     } else if (status.IsError()) {
       // If the command failed while a new page or frame started loading, retry
       // the command after the pending navigation has completed.
       bool is_pending = false;
       nav_status = web_view->IsPendingNavigation(session->GetCurrentFrameId(),
-                                                 &is_pending);
+                                                 &timeout, &is_pending);
       if (nav_status.IsError())
         return nav_status;
       else if (is_pending)
         continue;
     }
     break;
   }
 
   nav_status = web_view->WaitForPendingNavigations(
-      session->GetCurrentFrameId(), session->page_load_timeout, true);
+      session->GetCurrentFrameId(),
+      Timeout(session->page_load_timeout, &timeout),
+      true);
 
   if (status.IsOk() && nav_status.IsError() &&
       nav_status.code() != kUnexpectedAlertOpen)
     return nav_status;
   if (status.code() == kUnexpectedAlertOpen)
     return Status(kOk);
   return status;
 }
 
 Status ExecuteGet(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
+  timeout->SetDuration(session->page_load_timeout);

[samuong, 2016/02/19 20:18:58]

Is there a need to have a series of subtask timeouts if the "outer" timeout has
the same duration?

[Alexander Semashko, 2016/02/19 23:38:59]

Why not? Anyway, I could'n conceive a better (yet simple) way for
ExecuteWindowCommand to set a timeout specific for a particular command, if
there is one. And it's easy to imagine having a long timeout for e.g. executing
scripts and a small timeout for page loads (for example, testing a web service
in local network with heavy server-side processing), in such a case a hung
navigation is a reason to abort as soon as possible.

[samuong, 2016/02/20 00:11:44]

If the outer and inner timeouts have the same duration, but the outer one has an
earlier start time, doesn't that make the inner sub-task timeout redundant?

[Alexander Semashko, 2016/02/20 00:38:40]

Yeah, it is, only if they have the same duration. But it's different if the
outer one has a long duration. Right now the outer timeout is set only in
ExecuteGet and happen to be the same that ExecuteWindowCommand uses for
preparation. After a while this may change.

[samuong, 2016/02/22 23:55:35]

OK, it's fine if this is the same for now but you want to make it easy to make
them different later.

   std::string url;
   if (!params.GetString("url", &url))
     return Status(kUnknownError, "'url' must be a string");
-  Status status = web_view->Load(url);
+  Status status = web_view->Load(url, timeout);
   if (status.IsError())
     return status;
   session->SwitchToTopFrame();
   return Status(kOk);
 }
 
 Status ExecuteExecuteScript(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::string script;
   if (!params.GetString("script", &script))
     return Status(kUnknownError, "'script' must be a string");
   if (script == ":takeHeapSnapshot") {
     return web_view->TakeHeapSnapshot(value);
   } else if (script == ":startProfile") {
     return web_view->StartProfile();
   } else if (script == ":endProfile") {
     return web_view->EndProfile(value);
   } else {
     const base::ListValue* args;
     if (!params.GetList("args", &args))
       return Status(kUnknownError, "'args' must be a list");
 
     return web_view->CallFunction(session->GetCurrentFrameId(),
                                   "function(){" + script + "}", *args, value);
   }
 }
 
 Status ExecuteExecuteAsyncScript(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::string script;
   if (!params.GetString("script", &script))
     return Status(kUnknownError, "'script' must be a string");
   const base::ListValue* args;
   if (!params.GetList("args", &args))
     return Status(kUnknownError, "'args' must be a list");
 
   return web_view->CallUserAsyncFunction(
       session->GetCurrentFrameId(), "function(){" + script + "}", *args,
       session->script_timeout, value);
 }
 
 Status ExecuteSwitchToFrame(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   const base::Value* id;
   if (!params.Get("id", &id))
     return Status(kUnknownError, "missing 'id'");
 
   if (id->IsType(base::Value::TYPE_NULL)) {
     session->SwitchToTopFrame();
     return Status(kOk);
   }
 
   std::string script;
@@ skipping 50 matching lines @@
   if (status.IsError())
     return status;
   session->SwitchToSubFrame(frame, chrome_driver_id);
   return Status(kOk);
 }
 
 Status ExecuteSwitchToParentFrame(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   session->SwitchToParentFrame();
   return Status(kOk);
 }
 
 Status ExecuteGetTitle(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   const char kGetTitleScript[] = "function() {  return document.title;}";
   base::ListValue args;
   return web_view->CallFunction(std::string(), kGetTitleScript, args, value);
 }
 
 Status ExecuteGetPageSource(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   const char kGetPageSource[] =
       "function() {"
       "  return new XMLSerializer().serializeToString(document);"
       "}";
   base::ListValue args;
   return web_view->CallFunction(
       session->GetCurrentFrameId(), kGetPageSource, args, value);
 }
 
 Status ExecuteFindElement(
     int interval_ms,
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return FindElement(interval_ms, true, NULL, session, web_view, params, value);
 }
 
 Status ExecuteFindElements(
     int interval_ms,
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return FindElement(
       interval_ms, false, NULL, session, web_view, params, value);
 }
 
 Status ExecuteGetCurrentUrl(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::string url;
   Status status = GetUrl(web_view, std::string(), &url);
   if (status.IsError())
     return status;
   if (url == kUnreachableWebDataURL) {
     // https://bugs.chromium.org/p/chromedriver/issues/detail?id=1272
     const BrowserInfo* browser_info = session->chrome->GetBrowserInfo();
     bool is_kitkat_webview = browser_info->browser_name == "webview" &&
                              browser_info->major_version <= 30 &&
                              browser_info->is_android;
@@ skipping 14 matching lines @@
            "for details and workarounds.";
   }
   value->reset(new base::StringValue(url));
   return Status(kOk);
 }
 
 Status ExecuteGoBack(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   Status status = web_view->TraverseHistory(-1);
   if (status.IsError())
     return status;
   session->SwitchToTopFrame();
   return Status(kOk);
 }
 
 Status ExecuteGoForward(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   Status status = web_view->TraverseHistory(1);
   if (status.IsError())
     return status;
   session->SwitchToTopFrame();
   return Status(kOk);
 }
 
 Status ExecuteRefresh(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   Status status = web_view->Reload();
   if (status.IsError())
     return status;
   session->SwitchToTopFrame();
   return Status(kOk);
 }
 
 Status ExecuteMouseMoveTo(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::string element_id;
   bool has_element = params.GetString("element", &element_id);
   int x_offset = 0;
   int y_offset = 0;
   bool has_offset = params.GetInteger("xoffset", &x_offset) &&
       params.GetInteger("yoffset", &y_offset);
   if (!has_element && !has_offset)
     return Status(kUnknownError, "at least an element or offset should be set");
 
   WebPoint location;
@@ skipping 17 matching lines @@
       web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
   if (status.IsOk())
     session->mouse_position = location;
   return status;
 }
 
 Status ExecuteMouseClick(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   MouseButton button;
   Status status = GetMouseButton(params, &button);
   if (status.IsError())
     return status;
   std::list<MouseEvent> events;
   events.push_back(
       MouseEvent(kPressedMouseEventType, button,
                  session->mouse_position.x, session->mouse_position.y,
                  session->sticky_modifiers, 1));
   events.push_back(
       MouseEvent(kReleasedMouseEventType, button,
                  session->mouse_position.x, session->mouse_position.y,
                  session->sticky_modifiers, 1));
   return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
 }
 
 Status ExecuteMouseButtonDown(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   MouseButton button;
   Status status = GetMouseButton(params, &button);
   if (status.IsError())
     return status;
   std::list<MouseEvent> events;
   events.push_back(
       MouseEvent(kPressedMouseEventType, button,
                  session->mouse_position.x, session->mouse_position.y,
                  session->sticky_modifiers, 1));
   return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
 }
 
 Status ExecuteMouseButtonUp(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   MouseButton button;
   Status status = GetMouseButton(params, &button);
   if (status.IsError())
     return status;
   std::list<MouseEvent> events;
   events.push_back(
       MouseEvent(kReleasedMouseEventType, button,
                  session->mouse_position.x, session->mouse_position.y,
                  session->sticky_modifiers, 1));
   return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
 }
 
 Status ExecuteMouseDoubleClick(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   MouseButton button;
   Status status = GetMouseButton(params, &button);
   if (status.IsError())
     return status;
   std::list<MouseEvent> events;
   events.push_back(
       MouseEvent(kPressedMouseEventType, button,
                  session->mouse_position.x, session->mouse_position.y,
                  session->sticky_modifiers, 2));
   events.push_back(
       MouseEvent(kReleasedMouseEventType, button,
                  session->mouse_position.x, session->mouse_position.y,
                  session->sticky_modifiers, 2));
   return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId());
 }
 
 Status ExecuteTouchDown(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return ExecuteTouchEvent(session, web_view, kTouchStart, params);
 }
 
 Status ExecuteTouchUp(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return ExecuteTouchEvent(session, web_view, kTouchEnd, params);
 }
 
 Status ExecuteTouchMove(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return ExecuteTouchEvent(session, web_view, kTouchMove, params);
 }
 
 Status ExecuteTouchScroll(
     Session *session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   if (session->chrome->GetBrowserInfo()->build_no < 2286) {
     // TODO(samuong): remove this once we stop supporting M41.
     return Status(kUnknownCommand, "Touch scroll action requires Chrome 42+");
   }
   WebPoint location = session->mouse_position;
   std::string element;
   if (params.GetString("element", &element)) {
     Status status = GetElementClickableLocation(
         session, web_view, element, &location);
     if (status.IsError())
       return status;
   }
   int xoffset;
   if (!params.GetInteger("xoffset", &xoffset))
     return Status(kUnknownError, "'xoffset' must be an integer");
   int yoffset;
   if (!params.GetInteger("yoffset", &yoffset))
     return Status(kUnknownError, "'yoffset' must be an integer");
   return web_view->SynthesizeScrollGesture(
       location.x, location.y, xoffset, yoffset);
 }
 
 Status ExecuteTouchPinch(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   if (session->chrome->GetBrowserInfo()->build_no < 2286) {
     // TODO(samuong): remove this once we stop supporting M41.
     return Status(kUnknownCommand, "Pinch action requires Chrome 42+");
   }
   WebPoint location;
   if (!params.GetInteger("x", &location.x))
     return Status(kUnknownError, "'x' must be an integer");
   if (!params.GetInteger("y", &location.y))
     return Status(kUnknownError, "'y' must be an integer");
   double scale_factor;
   if (!params.GetDouble("scale", &scale_factor))
     return Status(kUnknownError, "'scale' must be an integer");
   return web_view->SynthesizePinchGesture(location.x, location.y, scale_factor);
 }
 
 Status ExecuteGetActiveElement(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return GetActiveElement(session, web_view, value);
 }
 
 Status ExecuteSendKeysToActiveElement(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   const base::ListValue* key_list;
   if (!params.GetList("value", &key_list))
     return Status(kUnknownError, "'value' must be a list");
   return SendKeysOnWindow(
       web_view, key_list, false, &session->sticky_modifiers);
 }
 
 Status ExecuteGetAppCacheStatus(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return web_view->EvaluateScript(
       session->GetCurrentFrameId(),
       "applicationCache.status",
       value);
 }
 
 Status ExecuteIsBrowserOnline(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return web_view->EvaluateScript(
       session->GetCurrentFrameId(),
       "navigator.onLine",
       value);
 }
 
 Status ExecuteGetStorageItem(
     const char* storage,
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::string key;
   if (!params.GetString("key", &key))
     return Status(kUnknownError, "'key' must be a string");
   base::ListValue args;
   args.Append(new base::StringValue(key));
   return web_view->CallFunction(
       session->GetCurrentFrameId(),
       base::StringPrintf("function(key) { return %s[key]; }", storage),
       args,
       value);
 }
 
 Status ExecuteGetStorageKeys(
     const char* storage,
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   const char script[] =
       "var keys = [];"
       "for (var key in %s) {"
       "  keys.push(key);"
       "}"
       "keys";
   return web_view->EvaluateScript(
       session->GetCurrentFrameId(),
       base::StringPrintf(script, storage),
       value);
 }
 
 Status ExecuteSetStorageItem(
     const char* storage,
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::string key;
   if (!params.GetString("key", &key))
     return Status(kUnknownError, "'key' must be a string");
   std::string storage_value;
   if (!params.GetString("value", &storage_value))
     return Status(kUnknownError, "'value' must be a string");
   base::ListValue args;
   args.Append(new base::StringValue(key));
   args.Append(new base::StringValue(storage_value));
   return web_view->CallFunction(
       session->GetCurrentFrameId(),
       base::StringPrintf("function(key, value) { %s[key] = value; }", storage),
       args,
       value);
 }
 
 Status ExecuteRemoveStorageItem(
     const char* storage,
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::string key;
   if (!params.GetString("key", &key))
     return Status(kUnknownError, "'key' must be a string");
   base::ListValue args;
   args.Append(new base::StringValue(key));
   return web_view->CallFunction(
       session->GetCurrentFrameId(),
       base::StringPrintf("function(key) { %s.removeItem(key) }", storage),
       args,
       value);
 }
 
 Status ExecuteClearStorage(
     const char* storage,
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return web_view->EvaluateScript(
       session->GetCurrentFrameId(),
       base::StringPrintf("%s.clear()", storage),
       value);
 }
 
 Status ExecuteGetStorageSize(
     const char* storage,
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return web_view->EvaluateScript(
       session->GetCurrentFrameId(),
       base::StringPrintf("%s.length", storage),
       value);
 }
 
 Status ExecuteScreenshot(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   Status status = session->chrome->ActivateWebView(web_view->GetId());
   if (status.IsError())
     return status;
 
   std::string screenshot;
   ChromeDesktopImpl* desktop = NULL;
   status = session->chrome->GetAsDesktop(&desktop);
   if (status.IsOk() && !session->force_devtools_screenshot) {
     AutomationExtension* extension = NULL;
     status = desktop->GetAutomationExtension(&extension);
@@ skipping 11 matching lines @@
     return status;
 
   value->reset(new base::StringValue(screenshot));
   return Status(kOk);
 }
 
 Status ExecuteGetCookies(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::list<Cookie> cookies;
   Status status = GetVisibleCookies(web_view, &cookies);
   if (status.IsError())
     return status;
   scoped_ptr<base::ListValue> cookie_list(new base::ListValue());
   for (std::list<Cookie>::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
     cookie_list->Append(CreateDictionaryFrom(*it));
   }
   value->reset(cookie_list.release());
   return Status(kOk);
 }
 
 Status ExecuteAddCookie(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   const base::DictionaryValue* cookie;
   if (!params.GetDictionary("cookie", &cookie))
     return Status(kUnknownError, "missing 'cookie'");
   base::ListValue args;
   args.Append(cookie->DeepCopy());
   scoped_ptr<base::Value> result;
   return web_view->CallFunction(
       session->GetCurrentFrameId(), kAddCookieScript, args, &result);
 }
 
 Status ExecuteDeleteCookie(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::string name;
   if (!params.GetString("name", &name))
     return Status(kUnknownError, "missing 'name'");
   base::DictionaryValue params_url;
   scoped_ptr<base::Value> value_url;
   std::string url;
   Status status = GetUrl(web_view, session->GetCurrentFrameId(), &url);
   if (status.IsError())
     return status;
   return web_view->DeleteCookie(name, url);
 }
 
 Status ExecuteDeleteAllCookies(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::list<Cookie> cookies;
   Status status = GetVisibleCookies(web_view, &cookies);
   if (status.IsError())
     return status;
 
   if (!cookies.empty()) {
     base::DictionaryValue params_url;
     scoped_ptr<base::Value> value_url;
     std::string url;
     status = GetUrl(web_view, session->GetCurrentFrameId(), &url);
     if (status.IsError())
       return status;
     for (std::list<Cookie>::const_iterator it = cookies.begin();
          it != cookies.end(); ++it) {
       status = web_view->DeleteCookie(it->name, url);
       if (status.IsError())
         return status;
     }
   }
 
   return Status(kOk);
 }
 
 Status ExecuteSetLocation(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   const base::DictionaryValue* location = NULL;
   Geoposition geoposition;
   if (!params.GetDictionary("location", &location) ||
       !location->GetDouble("latitude", &geoposition.latitude) ||
       !location->GetDouble("longitude", &geoposition.longitude))
     return Status(kUnknownError, "missing or invalid 'location'");
   if (location->HasKey("accuracy") &&
       !location->GetDouble("accuracy", &geoposition.accuracy)) {
     return Status(kUnknownError, "invalid 'accuracy'");
   } else {
     // |accuracy| is not part of the WebDriver spec yet, so if it is not given
     // default to 100 meters accuracy.
     geoposition.accuracy = 100;
   }
 
   Status status = web_view->OverrideGeolocation(geoposition);
   if (status.IsOk())
     session->overridden_geoposition.reset(new Geoposition(geoposition));
   return status;
 }
 
 Status ExecuteSetNetworkConditions(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   std::string network_name;
   const base::DictionaryValue* conditions = NULL;
   scoped_ptr<NetworkConditions> network_conditions(new NetworkConditions());
   if (params.GetString("network_name", &network_name)) {
     // Get conditions from preset list.
     Status status = FindPresetNetwork(network_name, network_conditions.get());
     if (status.IsError())
       return status;
   } else if (params.GetDictionary("network_conditions", &conditions)) {
     // |latency| is required.
@@ skipping 39 matching lines @@
   session->overridden_network_conditions.reset(
       network_conditions.release());
   return web_view->OverrideNetworkConditions(
       *session->overridden_network_conditions);
 }
 
 Status ExecuteDeleteNetworkConditions(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   // Chrome does not have any command to stop overriding network conditions, so
   // we just override the network conditions with the "No throttling" preset.
   NetworkConditions network_conditions;
   // Get conditions from preset list.
   Status status = FindPresetNetwork("No throttling", &network_conditions);
   if (status.IsError())
     return status;
 
   status = web_view->OverrideNetworkConditions(network_conditions);
   if (status.IsError())
     return status;
 
   // After we've successfully overridden the network conditions with
   // "No throttling", we can delete them from |session|.
   session->overridden_network_conditions.reset();
   return status;
 }
 
 Status ExecuteTakeHeapSnapshot(
     Session* session,
     WebView* web_view,
     const base::DictionaryValue& params,
-    scoped_ptr<base::Value>* value) {
+    scoped_ptr<base::Value>* value,
+    Timeout* timeout) {
   return web_view->TakeHeapSnapshot(value);
 }