Convert ChromeDriver to use only the JSON automation interface.

chrome/browser/automation/testing_automation_provider.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/browser/automation/testing_automation_provider.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 152 matching lines @@
 
 TabContents* GetTabContentsAt(int browser_index, int tab_index) {
   if (tab_index < 0)
     return NULL;
   Browser* browser = GetBrowserAt(browser_index);
   if (!browser || tab_index >= browser->tab_count())
     return NULL;
   return browser->GetTabContentsAt(tab_index);
 }
 
+bool GetBrowserFromJSONArgs(

[Paweł Hajdan Jr., 2011/03/05 11:44:56]

Could you move those helpers to automation_provider_json.cc? I'd like to avoid
cluttering this file which is already too big.

[kkania, 2011/03/07 04:31:51]

Done.

+    DictionaryValue* args,
+    Browser** browser,
+    std::string* error) {
+  int browser_index = 0;
+  if (!args->GetInteger("windex", &browser_index)) {
+    *error = "'windex' missing or invalid";

[Paweł Hajdan Jr., 2011/03/05 11:44:56]

It seems that we should be appending to |error| rather than overwriting it,
given how it is used in GetBrowserAndTabFromJSONArgs (same |error| for both
calls).

[kkania, 2011/03/07 04:31:51]

The error is only set if the func returns false, in which case
GetBrowserAndTabsFromJSONArgs below cannot not overwrite an error.

+    return false;
+  }
+  *browser = GetBrowserAt(browser_index);
+  if (!*browser) {
+    *error = "Cannot locate browser from given index";
+    return false;
+  }
+  return true;
+}
+
+bool GetTabFromJSONArgs(
+    DictionaryValue* args,
+    TabContents** tab,
+    std::string* error) {
+  int browser_index = 0, tab_index = 0;
+  if (!args->GetInteger("windex", &browser_index)) {
+    *error = "'windex' missing or invalid";
+    return false;
+  }
+  if (!args->GetInteger("tab_index", &tab_index)) {
+    *error = "'tab_index' missing or invalid";
+    return false;
+  }
+  *tab = GetTabContentsAt(browser_index, tab_index);
+  if (!*tab) {
+    *error = "Cannot locate tab from given indices";
+    return false;
+  }
+  return true;
+}
+
+bool GetBrowserAndTabFromJSONArgs(
+    DictionaryValue* args,
+    Browser** browser,
+    TabContents** tab,
+    std::string* error) {
+  return GetBrowserFromJSONArgs(args, browser, error) &&
+         GetTabFromJSONArgs(args, tab, error);
+}
+
 }  // namespace
 
 TestingAutomationProvider::TestingAutomationProvider(Profile* profile)
     : AutomationProvider(profile),
 #if defined(TOOLKIT_VIEWS)
       popup_menu_waiter_(NULL),
 #endif
       redirect_query_(0) {
   BrowserList::AddObserver(this);
   registrar_.Add(this, NotificationType::SESSION_END,
@@ skipping 723 matching lines @@
                             ((flags & ui::EF_CONTROL_DOWN) ==
                              ui::EF_CONTROL_DOWN),
                             ((flags & ui::EF_SHIFT_DOWN) ==
                              ui::EF_SHIFT_DOWN),
                             ((flags & ui::EF_ALT_DOWN) ==
                              ui::EF_ALT_DOWN),
                             ((flags & ui::EF_COMMAND_DOWN) ==
                              ui::EF_COMMAND_DOWN));
 }
 
-void TestingAutomationProvider::WebkitMouseClick(Browser* browser,
-                                                 DictionaryValue* args,
+void TestingAutomationProvider::WebkitMouseClick(DictionaryValue* args,
                                                  IPC::Message* reply_message) {
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+
   WebKit::WebMouseEvent mouse_event;
-
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
-  int button_flags;
-  if (!args->GetInteger("button_flags", &button_flags)) {
+  int button;
+  if (!args->GetInteger("button", &button)) {
     AutomationJSONReply(this, reply_message)
         .SendError("Mouse button missing or invalid");
     return;
   }
-
-  if (button_flags == ui::EF_LEFT_BUTTON_DOWN) {
+  if (button == automation::kLeftButton) {
     mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
-  } else if (button_flags == ui::EF_RIGHT_BUTTON_DOWN) {
+  } else if (button == automation::kRightButton) {
     mouse_event.button = WebKit::WebMouseEvent::ButtonRight;
-  } else if (button_flags == ui::EF_MIDDLE_BUTTON_DOWN) {
+  } else if (button == automation::kMiddleButton) {
     mouse_event.button = WebKit::WebMouseEvent::ButtonMiddle;
   } else {
     AutomationJSONReply(this, reply_message)
         .SendError("Invalid button press requested");
     return;
   }
 
-  TabContents* tab_contents = browser->GetSelectedTabContents();
   mouse_event.type = WebKit::WebInputEvent::MouseDown;
   mouse_event.clickCount = 1;
 
   tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
 
   mouse_event.type = WebKit::WebInputEvent::MouseUp;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type);
   tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
 }
 
-void TestingAutomationProvider::WebkitMouseMove(Browser* browser,
-                                                DictionaryValue* args,
-                                                IPC::Message* reply_message) {
+void TestingAutomationProvider::WebkitMouseMove(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+
   WebKit::WebMouseEvent mouse_event;
-
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
-  TabContents* tab_contents = browser->GetSelectedTabContents();
   mouse_event.type = WebKit::WebInputEvent::MouseMove;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type);
   tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
 }
 
-void TestingAutomationProvider::WebkitMouseDrag(Browser* browser,
-                                                DictionaryValue* args,
+void TestingAutomationProvider::WebkitMouseDrag(DictionaryValue* args,
                                                 IPC::Message* reply_message) {
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+
   WebKit::WebMouseEvent mouse_event;
   int start_x, start_y, end_x, end_y;
-
   if (!args->GetInteger("start_x", &start_x) ||
       !args->GetInteger("start_y", &start_y) ||
       !args->GetInteger("end_x", &end_x) ||
       !args->GetInteger("end_y", &end_y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("Invalid start/end positions");
     return;
   }
 
   mouse_event.type = WebKit::WebInputEvent::MouseMove;
-  TabContents* tab_contents = browser->GetSelectedTabContents();
   // Step 1- Move the mouse to the start position.
   mouse_event.x = start_x;
   mouse_event.y = start_y;
   tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
 
   // Step 2- Left click mouse down, the mouse button is fixed.
   mouse_event.type = WebKit::WebInputEvent::MouseDown;
   mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
   tab_contents->render_view_host()->ForwardMouseEvent(mouse_event);
@@ skipping 1108 matching lines @@
   }
 
   // Map json commands to their handlers.
   std::map<std::string, JsonHandler> handler_map;
   handler_map["WaitForAllTabsToStopLoading"] =
       &TestingAutomationProvider::WaitForAllTabsToStopLoading;
   handler_map["GetIndicesFromTab"] =
       &TestingAutomationProvider::GetIndicesFromTab;
   handler_map["NavigateToURL"] =
       &TestingAutomationProvider::NavigateToURL;
+  handler_map["ExecuteJavascript"] =
+      &TestingAutomationProvider::ExecuteJavascriptJSON;
+  handler_map["GoForward"] =
+      &TestingAutomationProvider::GoForward;
+  handler_map["GoBack"] =
+      &TestingAutomationProvider::GoBack;
+  handler_map["Reload"] =
+      &TestingAutomationProvider::ReloadJSON;
+  handler_map["GetTabURL"] =
+      &TestingAutomationProvider::GetTabURLJSON;
+  handler_map["GetTabTitle"] =
+      &TestingAutomationProvider::GetTabTitleJSON;
+  handler_map["GetCookies"] =
+      &TestingAutomationProvider::GetCookiesJSON;
+  handler_map["DeleteCookie"] =
+      &TestingAutomationProvider::DeleteCookieJSON;
+  handler_map["SetCookie"] =
+      &TestingAutomationProvider::SetCookieJSON;
+  handler_map["GetTabIds"] =
+      &TestingAutomationProvider::GetTabIds;
+  handler_map["IsTabIdValid"] =
+      &TestingAutomationProvider::IsTabIdValid;
+  handler_map["CloseTab"] =
+      &TestingAutomationProvider::CloseTabJSON;
+  handler_map["WebkitMouseMove"] =
+      &TestingAutomationProvider::WebkitMouseMove;
+  handler_map["WebkitMouseClick"] =
+      &TestingAutomationProvider::WebkitMouseClick;
+  handler_map["WebkitMouseDrag"] =
+      &TestingAutomationProvider::WebkitMouseDrag;
+  handler_map["SendWebkitKeyEvent"] =
+      &TestingAutomationProvider::SendWebkitKeyEvent;
+  handler_map["ActivateTab"] =
+      &TestingAutomationProvider::ActivateTabJSON;
 #if defined(OS_CHROMEOS)
   handler_map["LoginAsGuest"] = &TestingAutomationProvider::LoginAsGuest;
   handler_map["Login"] = &TestingAutomationProvider::Login;
   handler_map["Logout"] = &TestingAutomationProvider::Logout;
   handler_map["ScreenLock"] = &TestingAutomationProvider::ScreenLock;
   handler_map["ScreenUnlock"] = &TestingAutomationProvider::ScreenUnlock;
 #endif  // defined(OS_CHROMEOS)
 
   std::map<std::string, BrowserJsonHandler> browser_handler_map;
   browser_handler_map["DisablePlugin"] =
@@ skipping 122 matching lines @@
   browser_handler_map["RemoveNTPMostVisitedThumbnail"] =
       &TestingAutomationProvider::RemoveNTPMostVisitedThumbnail;
   browser_handler_map["UnpinNTPMostVisitedThumbnail"] =
       &TestingAutomationProvider::UnpinNTPMostVisitedThumbnail;
   browser_handler_map["RestoreAllNTPMostVisitedThumbnails"] =
       &TestingAutomationProvider::RestoreAllNTPMostVisitedThumbnails;
 
   browser_handler_map["KillRendererProcess"] =
       &TestingAutomationProvider::KillRendererProcess;
 
-  browser_handler_map["SendKeyEventToActiveTab"] =
-      &TestingAutomationProvider::SendKeyEventToActiveTab;
-
   browser_handler_map["GetNTPThumbnailMode"] =
       &TestingAutomationProvider::GetNTPThumbnailMode;
   browser_handler_map["SetNTPThumbnailMode"] =
       &TestingAutomationProvider::SetNTPThumbnailMode;
   browser_handler_map["GetNTPMenuMode"] =
       &TestingAutomationProvider::GetNTPMenuMode;
   browser_handler_map["SetNTPMenuMode"] =
       &TestingAutomationProvider::SetNTPMenuMode;
 
-  browser_handler_map["WebkitMouseMove"] =
-      &TestingAutomationProvider::WebkitMouseMove;
-  browser_handler_map["WebkitMouseClick"] =
-      &TestingAutomationProvider::WebkitMouseClick;
-  browser_handler_map["WebkitMouseDrag"] =
-      &TestingAutomationProvider::WebkitMouseDrag;
-
   if (handler_map.find(std::string(command)) != handler_map.end()) {
     (this->*handler_map[command])(dict_value, reply_message);
   } else if (browser_handler_map.find(std::string(command)) !=
              browser_handler_map.end()) {
     Browser* browser = NULL;
     if (!browser_tracker_->ContainsHandle(handle) ||
         !(browser = browser_tracker_->GetResource(handle))) {
       AutomationJSONReply(this, reply_message).SendError("No browser object.");
       return;
     }
@@ skipping 2268 matching lines @@
   if (!base::OpenProcessHandle(static_cast<base::ProcessId>(pid), &process)) {
     AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
         "Failed to open process handle for pid %d", pid));
     return;
   }
   new RendererProcessClosedObserver(this, reply_message);
   base::KillProcess(process, 0, false);
   base::CloseProcessHandle(process);
 }
 
-void TestingAutomationProvider::SendKeyEventToActiveTab(
-    Browser* browser,
+void TestingAutomationProvider::SendWebkitKeyEvent(
     DictionaryValue* args,
     IPC::Message* reply_message) {
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+
   int type, modifiers;
   bool is_system_key;
   string16 unmodified_text, text;
   std::string key_identifier;
   NativeWebKeyboardEvent event;
   if (!args->GetInteger("type", &type)) {
     AutomationJSONReply reply(this, reply_message);
     reply.SendError("'type' missing or invalid.");
     return;
   }
@@ skipping 65 matching lines @@
     event.modifiers |= WebKit::WebInputEvent::ControlKey;
   if (modifiers & automation::kAltKeyMask)
     event.modifiers |= WebKit::WebInputEvent::AltKey;
   if (modifiers & automation::kMetaKeyMask)
     event.modifiers |= WebKit::WebInputEvent::MetaKey;
 
   event.isSystemKey = is_system_key;
   event.timeStampSeconds = base::Time::Now().ToDoubleT();
   event.skip_in_browser = true;
   new InputEventAckNotificationObserver(this, reply_message, event.type);
-  browser->GetSelectedTabContents()->render_view_host()->
-    ForwardKeyboardEvent(event);
+  tab_contents->render_view_host()->ForwardKeyboardEvent(event);
 }
 
 // Sample JSON input: { "command": "GetNTPThumbnailMode" }
 // For output, refer to GetNTPThumbnailMode() in
 // chrome/test/pyautolib/pyauto.py.
 void TestingAutomationProvider::GetNTPThumbnailMode(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   const int shown_sections = ShownSectionsHandler::GetShownSections(
@@ skipping 124 matching lines @@
 void TestingAutomationProvider::WaitForAllTabsToStopLoading(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   new AllTabsStoppedLoadingObserver(this, reply_message);
 }
 
 void TestingAutomationProvider::GetIndicesFromTab(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
-  int tab_handle = 0;
-  if (!args->GetInteger("tab_handle", &tab_handle) ||
-      !tab_tracker_->ContainsHandle(tab_handle)) {
-    reply.SendError("'tab_handle' missing or invalid");
+  int id_or_handle = 0;
+  bool has_id = args->HasKey("tab_id");
+  bool has_handle = args->HasKey("tab_handle");
+  if (!(has_id ^ has_handle)) {

[Paweł Hajdan Jr., 2011/03/05 11:44:56]

Oh, that looks complicated. Why is it needed (the logic for _both_ id and
handle)?

[kkania, 2011/03/07 04:31:51]

ok, i wrote it in simpler language

+    reply.SendError("Either 'tab_id' or 'tab_handle' must be supplied");
     return;
   }
-  NavigationController* controller = tab_tracker_->GetResource(tab_handle);
+  if (has_id && !args->GetInteger("tab_id", &id_or_handle)) {
+    reply.SendError("'tab_id' is invalid");
+  }
+  if (has_handle && (!args->GetInteger("tab_handle", &id_or_handle) ||
+      !tab_tracker_->ContainsHandle(id_or_handle))) {
+    reply.SendError("'tab_handle' is invalid");
+    return;
+  }
+  int id = id_or_handle;
+  if (has_handle)
+    id = tab_tracker_->GetResource(id_or_handle)->session_id().id();
   BrowserList::const_iterator iter = BrowserList::begin();
   int browser_index = 0;
   for (; iter != BrowserList::end(); ++iter, ++browser_index) {
     Browser* browser = *iter;
     for (int tab_index = 0; tab_index < browser->tab_count(); ++tab_index) {
-      if (browser->GetTabContentsAt(tab_index) == controller->tab_contents()) {
+      TabContents* tab = browser->GetTabContentsAt(tab_index);
+      if (tab->controller().session_id().id() == id) {
         DictionaryValue dict;
         dict.SetInteger("windex", browser_index);
         dict.SetInteger("tab_index", tab_index);
         reply.SendSuccess(&dict);
         return;
       }
     }
   }
   reply.SendError("Could not find tab among current browser windows");
 }
@@ skipping 30 matching lines @@
         .SendError("Cannot locate tab or browser to navigate");
     return;
   }
   new NavigationNotificationObserver(
       &tab_contents->controller(), this, reply_message,
       navigation_count, false, true);
   browser->OpenURLFromTab(
       tab_contents, GURL(url), GURL(), CURRENT_TAB, PageTransition::TYPED);
 }
 
+void TestingAutomationProvider::ExecuteJavascriptJSON(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  int browser_index = 0, tab_index = 0;
+  string16 frame_xpath, javascript;
+  if (!args->GetInteger("windex", &browser_index)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'windex' missing or invalid");
+    return;
+  }
+  if (!args->GetInteger("tab_index", &tab_index)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'tab_index' missing or invalid");
+    return;
+  }
+  if (!args->GetString("frame_xpath", &frame_xpath)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'frame_xpath' missing or invalid");
+    return;
+  }
+  if (!args->GetString("javascript", &javascript)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'javascript' missing or invalid");
+    return;
+  }
+  Browser* browser = GetBrowserAt(browser_index);
+  TabContents* tab_contents = GetTabContentsAt(browser_index, tab_index);
+  if (!browser || !tab_contents) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("Cannot locate tab or browser to navigate");
+    return;
+  }
+
+  // Set the routing id of this message with the controller.
+  // This routing id needs to be remembered for the reverse
+  // communication while sending back the response of
+  // this javascript execution.
+  std::string set_automation_id;
+  base::SStringPrintf(&set_automation_id,
+                      "window.domAutomationController.setAutomationId(%d);",
+                      reply_message->routing_id());
+
+  new ExecuteJavascriptObserver(this, reply_message);
+  tab_contents->render_view_host()->ExecuteJavascriptInWebFrame(
+      frame_xpath, UTF8ToUTF16(set_automation_id));
+  tab_contents->render_view_host()->ExecuteJavascriptInWebFrame(
+      frame_xpath, javascript);
+}
+
+void TestingAutomationProvider::GoForward(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+  NavigationController& controller = tab_contents->controller();
+  if (!controller.CanGoForward()) {
+    DictionaryValue dict;
+    dict.SetBoolean("did_go_forward", false);
+    AutomationJSONReply(this, reply_message).SendSuccess(&dict);
+    return;
+  }
+  new NavigationNotificationObserver(&controller, this, reply_message,
+                                     1, false, true);
+  controller.GoForward();
+}
+
+void TestingAutomationProvider::GoBack(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+  NavigationController& controller = tab_contents->controller();
+  if (!controller.CanGoBack()) {
+    DictionaryValue dict;
+    dict.SetBoolean("did_go_back", false);
+    AutomationJSONReply(this, reply_message).SendSuccess(&dict);
+    return;
+  }
+  new NavigationNotificationObserver(&controller, this, reply_message,
+                                     1, false, true);
+  controller.GoBack();
+}
+
+void TestingAutomationProvider::ReloadJSON(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    return;
+  }
+  NavigationController& controller = tab_contents->controller();
+  new NavigationNotificationObserver(&controller, this, reply_message,
+                                     1, false, true);
+  controller.Reload(false);
+}
+
+void TestingAutomationProvider::GetTabURLJSON(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  DictionaryValue dict;
+  dict.SetString("url", tab_contents->GetURL().possibly_invalid_spec());
+  reply.SendSuccess(&dict);
+}
+
+void TestingAutomationProvider::GetTabTitleJSON(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  DictionaryValue dict;
+  dict.SetString("title", tab_contents->GetTitle());
+  reply.SendSuccess(&dict);
+}
+
+void TestingAutomationProvider::GetCookiesJSON(

[Paweł Hajdan Jr., 2011/03/05 11:44:56]

I'm pretty sure this JSON cookie code duplicates some existing code. Could you
avoid that, i.e. either share that code or migrate things to JSON (probably not
possible yet because of the reference build)?

[kkania, 2011/03/07 04:31:51]

Yes, it does. Although really the only thing that is duplicated is posting a
task to an already shared function. Most of the work is in extracting and
packing args. I am not sure it is worth it. But, I was planning on migrating the
other function to JSON anyways, according to the 4-step plan I laid out in an
earlier CL you approved.

[Paweł Hajdan Jr., 2011/03/07 21:03:39]

The migration may be non-trivial, and I may have missed some parts of earlier
CLs. To be really safe here, can we avoid the duplication? Also, there is a
possible issue with the Task here that the original code probably doesn't have.

+    DictionaryValue* args, IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  Browser* browser;
+  std::string error;
+  if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  std::string url;
+  if (!args->GetString("url", &url)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'url' missing or invalid");
+    return;
+  }
+
+  // Since we are running on the UI thread don't call GetURLRequestContext().
+  scoped_refptr<URLRequestContextGetter> context_getter =
+      browser->profile()->GetRequestContext();
+
+  std::string cookies;
+  base::WaitableEvent event(true /* manual reset */,
+                            false /* not initially signaled */);
+  Task* task = NewRunnableFunction(
+      &GetCookiesOnIOThread,
+      GURL(url), context_getter, &event, &cookies);
+  if (!BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, task)) {
+    reply.SendError("Couldn't post task to get the cookies");
+    return;
+  }
+  event.Wait();
+
+  DictionaryValue dict;
+  dict.SetString("cookies", cookies);
+  reply.SendSuccess(&dict);
+}
+
+void TestingAutomationProvider::DeleteCookieJSON(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  Browser* browser;
+  std::string error;
+  if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  std::string url, name;
+  if (!args->GetString("url", &url)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'url' missing or invalid");
+    return;
+  }
+  if (!args->GetString("name", &name)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'name' missing or invalid");
+    return;
+  }
+
+  // Since we are running on the UI thread don't call GetURLRequestContext().
+  scoped_refptr<URLRequestContextGetter> context_getter =
+      browser->profile()->GetRequestContext();
+
+  base::WaitableEvent event(true /* manual reset */,
+                            false /* not initially signaled */);
+  Task* task = NewRunnableFunction(
+      &DeleteCookieOnIOThread,
+      GURL(url), name, context_getter, &event);
+  if (!BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, task)) {
+    reply.SendError("Couldn't post task to delete the cookie");
+    return;
+  }
+  event.Wait();
+  reply.SendSuccess(NULL);
+}
+
+void TestingAutomationProvider::SetCookieJSON(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  Browser* browser;
+  std::string error;
+  if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  std::string url, cookie;
+  if (!args->GetString("url", &url)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'url' missing or invalid");
+    return;
+  }
+  if (!args->GetString("cookie", &cookie)) {
+    AutomationJSONReply(this, reply_message)
+        .SendError("'cookie' missing or invalid");
+    return;
+  }
+
+  // Since we are running on the UI thread don't call GetURLRequestContext().
+  scoped_refptr<URLRequestContextGetter> context_getter =
+      browser->profile()->GetRequestContext();
+
+  base::WaitableEvent event(true /* manual reset */,
+                            false /* not initially signaled */);
+  bool success = false;
+  Task* task = NewRunnableFunction(
+      &SetCookieOnIOThread,
+      GURL(url), cookie, context_getter, &event, &success);
+  if (!BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, task)) {
+    reply.SendError("Couldn't post task to set the cookie");
+    return;
+  }
+  event.Wait();
+
+  if (!success) {
+    reply.SendError("Could not set the cookie");
+    return;
+  }
+  reply.SendSuccess(NULL);
+}
+
+void TestingAutomationProvider::GetTabIds(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  ListValue* id_list = new ListValue();
+  BrowserList::const_iterator iter = BrowserList::begin();
+  for (; iter != BrowserList::end(); ++iter) {
+    Browser* browser = *iter;
+    for (int i = 0; i < browser->tab_count(); ++i) {
+      int id = browser->GetTabContentsAt(i)->controller().session_id().id();
+      id_list->Append(Value::CreateIntegerValue(id));
+    }
+  }
+  DictionaryValue dict;
+  dict.Set("ids", id_list);
+  AutomationJSONReply(this, reply_message).SendSuccess(&dict);
+}
+
+void TestingAutomationProvider::IsTabIdValid(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  int id;
+  if (!args->GetInteger("id", &id)) {
+    reply.SendError("'id' missing or invalid");
+    return;
+  }
+  bool is_valid = false;
+  BrowserList::const_iterator iter = BrowserList::begin();
+  for (; iter != BrowserList::end(); ++iter) {
+    Browser* browser = *iter;
+    for (int i = 0; i < browser->tab_count(); ++i) {
+      TabContents* tab = browser->GetTabContentsAt(i);
+      if (tab->controller().session_id().id() == id) {
+        is_valid = true;
+        break;
+      }
+    }
+  }
+  DictionaryValue dict;
+  dict.SetBoolean("is_valid", is_valid);
+  reply.SendSuccess(&dict);
+}
+
+void TestingAutomationProvider::CloseTabJSON(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  Browser* browser;
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetBrowserAndTabFromJSONArgs(args, &browser, &tab_contents, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  browser->CloseTabContents(tab_contents);
+  reply.SendSuccess(NULL);
+}
+
+void TestingAutomationProvider::ActivateTabJSON(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  Browser* browser;
+  TabContents* tab_contents;
+  std::string error;
+  if (!GetBrowserAndTabFromJSONArgs(args, &browser, &tab_contents, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  browser->SelectTabContentsAt(
+      browser->GetIndexOfController(&tab_contents->controller()), true);
+  reply.SendSuccess(NULL);
+}
+
 void TestingAutomationProvider::WaitForTabCountToBecome(
     int browser_handle,
     int target_tab_count,
     IPC::Message* reply_message) {
   if (!browser_tracker_->ContainsHandle(browser_handle)) {
     AutomationMsg_WaitForTabCountToBecome::WriteReplyParams(reply_message,
                                                             false);
     Send(reply_message);
     return;
   }
@@ skipping 145 matching lines @@
     // If you change this, update Observer for NotificationType::SESSION_END
     // below.
     MessageLoop::current()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &TestingAutomationProvider::OnRemoveProvider));
   }
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   AutomationProviderList::GetInstance()->RemoveProvider(this);
 }