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 133 matching lines @@
   }
 
   virtual std::string GetHTMLContents() { return contents_; }
 
  private:
   const std::string contents_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationInterstitialPage);
 };
 
-Browser* GetBrowserAt(int index) {
-  if (index < 0)
-    return NULL;
-  BrowserList::const_iterator iter = BrowserList::begin();
-  for (; (iter != BrowserList::end()) && (index > 0); ++iter, --index) {}
-  if (iter == BrowserList::end())
-    return NULL;
-  return *iter;
-}
-
-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);
-}
-
 }  // 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 585 matching lines @@
   *window_count = static_cast<int>(BrowserList::size());
 }
 
 void TestingAutomationProvider::GetNormalBrowserWindowCount(int* window_count) {
   *window_count = static_cast<int>(
       BrowserList::GetBrowserCountForType(profile_, Browser::TYPE_NORMAL));
 }
 
 void TestingAutomationProvider::GetBrowserWindow(int index, int* handle) {
   *handle = 0;
-  Browser* browser = GetBrowserAt(index);
-  if (browser)
-    *handle = browser_tracker_->Add(browser);
+  if (index >= 0 && index < static_cast<int>(BrowserList::size()))
+    *handle = browser_tracker_->Add(*(BrowserList::begin() + index));
 }
 
 void TestingAutomationProvider::FindNormalBrowserWindow(int* handle) {
   *handle = 0;
   Browser* browser = BrowserList::FindBrowserWithType(profile_,
                                                       Browser::TYPE_NORMAL,
                                                       false);
   if (browser)
     *handle = browser_tracker_->Add(browser);
 }
@@ skipping 115 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) {
+    reply.SendError(
+        "Both 'tab_id' and 'tab_handle' were specified. Only one is allowed");
+    return;
+  } else if (!has_id && !has_handle) {
+    reply.SendError("Either 'tab_id' or 'tab_handle' must be specified");
     return;
   }
-  NavigationController* controller = tab_tracker_->GetResource(tab_handle);
+  if (has_id && !args->GetInteger("tab_id", &id_or_handle)) {
+    reply.SendError("'tab_id' is invalid");
+    return;
+  }
+  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");
 }
 
 void TestingAutomationProvider::NavigateToURL(
     DictionaryValue* args,
     IPC::Message* reply_message) {
-  int browser_index = 0, tab_index = 0, navigation_count = 0;
-  std::string url;
-  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");
+  int navigation_count;
+  std::string url, error;
+  Browser* browser;
+  TabContents* tab_contents;
+  if (!GetBrowserAndTabFromJSONArgs(args, &browser, &tab_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   if (!args->GetString("url", &url)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'url' missing or invalid");
     return;
   }
   if (!args->GetInteger("navigation_count", &navigation_count)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'navigation_count' 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;
-  }
   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) {
+  string16 frame_xpath, javascript;
+  std::string error;
+  TabContents* tab_contents;
+  if (!GetTabFromJSONArgs(args, &tab_contents, &error)) {
+    AutomationJSONReply(this, reply_message).SendError(error);
+    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;
+  }
+
+  // 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(
+    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)) {
+    reply.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)) {
+    reply.SendError("'url' missing or invalid");
+    return;
+  }
+  if (!args->GetString("name", &name)) {
+    reply.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)) {
+    reply.SendError("'url' missing or invalid");
+    return;
+  }
+  if (!args->GetString("cookie", &cookie)) {
+    reply.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);
 }