Convert cookie and download automation commands to the JSON interface.

chrome/browser/automation/testing_automation_provider.cc

 // Copyright (c) 2012 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 <set>
 #include <string>
 #include <vector>
@@ skipping 355 matching lines @@
   IPC_BEGIN_MESSAGE_MAP_EX(TestingAutomationProvider,
                            message,
                            deserialize_success)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CloseBrowser, CloseBrowser)
     IPC_MESSAGE_HANDLER(AutomationMsg_ActivateTab, ActivateTab)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_AppendTab, AppendTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetMachPortCount, GetMachPortCount)
     IPC_MESSAGE_HANDLER(AutomationMsg_ActiveTabIndex, GetActiveTabIndex)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CloseTab, CloseTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetCookies, GetCookies)
-    IPC_MESSAGE_HANDLER(AutomationMsg_SetCookie, SetCookie)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(
         AutomationMsg_NavigateToURLBlockUntilNavigationsComplete,
         NavigateToURLBlockUntilNavigationsComplete)
     IPC_MESSAGE_HANDLER(AutomationMsg_NavigationAsync, NavigationAsync)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_Reload, Reload)
     IPC_MESSAGE_HANDLER(AutomationMsg_BrowserWindowCount, GetBrowserWindowCount)
     IPC_MESSAGE_HANDLER(AutomationMsg_NormalBrowserWindowCount,
                         GetNormalBrowserWindowCount)
     IPC_MESSAGE_HANDLER(AutomationMsg_BrowserWindow, GetBrowserWindow)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowExecuteCommandAsync,
                         ExecuteBrowserCommandAsync)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WindowExecuteCommand,
                         ExecuteBrowserCommand)
     IPC_MESSAGE_HANDLER(AutomationMsg_TerminateSession, TerminateSession)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowViewBounds, WindowGetViewBounds)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetWindowBounds, SetWindowBounds)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowMouseMove, WindowSimulateMouseMove)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowKeyPress, WindowSimulateKeyPress)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabCount, GetTabCount)
     IPC_MESSAGE_HANDLER(AutomationMsg_Type, GetType)
     IPC_MESSAGE_HANDLER(AutomationMsg_Tab, GetTab)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabTitle, GetTabTitle)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabIndex, GetTabIndex)
     IPC_MESSAGE_HANDLER(AutomationMsg_TabURL, GetTabURL)
-    IPC_MESSAGE_HANDLER(AutomationMsg_ShelfVisibility, GetShelfVisibility)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_DomOperation,
                                     ExecuteJavascript)
-    IPC_MESSAGE_HANDLER(AutomationMsg_DownloadDirectory, GetDownloadDirectory)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_OpenNewBrowserWindowOfType,
                                     OpenNewBrowserWindowOfType)
     IPC_MESSAGE_HANDLER(AutomationMsg_WindowForBrowser, GetWindowForBrowser)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForTabToBeRestored,
                                     WaitForTabToBeRestored)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetSecurityState, GetSecurityState)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetPageType, GetPageType)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetMetricEventDuration,
                         GetMetricEventDuration)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_ActionOnSSLBlockingPage,
                                     ActionOnSSLBlockingPage)
     IPC_MESSAGE_HANDLER(AutomationMsg_BringBrowserToFront, BringBrowserToFront)
-    IPC_MESSAGE_HANDLER(AutomationMsg_IsMenuCommandEnabled,
-                        IsMenuCommandEnabled)
     IPC_MESSAGE_HANDLER(AutomationMsg_OpenFindInPage,
                         HandleOpenFindInPageRequest)
     IPC_MESSAGE_HANDLER(AutomationMsg_FindWindowVisibility,
                         GetFindWindowVisibility)
     IPC_MESSAGE_HANDLER(AutomationMsg_BookmarkBarVisibility,
                         GetBookmarkBarVisibility)
     IPC_MESSAGE_HANDLER(AutomationMsg_GetBookmarksAsJSON,
                         GetBookmarksAsJSON)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForBookmarkModelToLoad,
                                     WaitForBookmarkModelToLoad)
@@ skipping 11 matching lines @@
                         RemoveBookmark)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(
         AutomationMsg_WaitForBrowserWindowCountToBecome,
         WaitForBrowserWindowCountToBecome)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(
         AutomationMsg_GoBackBlockUntilNavigationsComplete,
         GoBackBlockUntilNavigationsComplete)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(
         AutomationMsg_GoForwardBlockUntilNavigationsComplete,
         GoForwardBlockUntilNavigationsComplete)
-    IPC_MESSAGE_HANDLER(AutomationMsg_SetShelfVisibility, SetShelfVisibility)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_SendJSONRequest,
                                     SendJSONRequestWithBrowserIndex)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(
         AutomationMsg_SendJSONRequestWithBrowserHandle,
         SendJSONRequestWithBrowserHandle)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForTabCountToBecome,
                                     WaitForTabCountToBecome)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForInfoBarCount,
                                     WaitForInfoBarCount)
     IPC_MESSAGE_HANDLER(AutomationMsg_ResetToDefaultTheme, ResetToDefaultTheme)
@@ skipping 107 matching lines @@
 }
 
 void TestingAutomationProvider::GetCookies(const GURL& url, int handle,
                                            int* value_size,
                                            std::string* value) {
   WebContents* contents = tab_tracker_->ContainsHandle(handle) ?
       tab_tracker_->GetResource(handle)->GetWebContents() : NULL;
   automation_util::GetCookies(url, contents, value_size, value);
 }
 
-void TestingAutomationProvider::SetCookie(const GURL& url,
-                                          const std::string& value,
-                                          int handle,
-                                          int* response_value) {
-  WebContents* contents = tab_tracker_->ContainsHandle(handle) ?
-      tab_tracker_->GetResource(handle)->GetWebContents() : NULL;
-  automation_util::SetCookie(url, value, contents, response_value);
-}
-
 void TestingAutomationProvider::NavigateToURLBlockUntilNavigationsComplete(
     int handle, const GURL& url, int number_of_navigations,
     IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
 
     // Simulate what a user would do. Activate the tab and then navigate.
     // We could allow navigating in a background tab in future.
     Browser* browser = FindAndActivateTab(tab);
 
@@ skipping 496 matching lines @@
                                           GURL* url) {
   *success = false;
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     // Return what the user would see in the location bar.
     *url = tab->GetActiveEntry()->GetVirtualURL();
     *success = true;
   }
 }
 
-void TestingAutomationProvider::GetShelfVisibility(int handle, bool* visible) {
-  *visible = false;
-
-  if (browser_tracker_->ContainsHandle(handle)) {
-    Browser* browser = browser_tracker_->GetResource(handle);
-    if (browser) {
-      *visible = browser->window()->IsDownloadShelfVisible();
-    }
-  }
-}
-
 void TestingAutomationProvider::ExecuteJavascriptInRenderViewFrame(
     const string16& frame_xpath,
     const string16& script,
     IPC::Message* reply_message,
     RenderViewHost* render_view_host) {
   // 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.
   render_view_host->ExecuteJavascriptInWebFrame(
@@ skipping 14 matching lines @@
     Send(reply_message);
     return;
   }
 
   new DomOperationMessageSender(this, reply_message, false);
   ExecuteJavascriptInRenderViewFrame(WideToUTF16Hack(frame_xpath),
                                      WideToUTF16Hack(script), reply_message,
                                      web_contents->GetRenderViewHost());
 }
 
-void TestingAutomationProvider::GetDownloadDirectory(
-    int handle, FilePath* download_directory) {
-  if (tab_tracker_->ContainsHandle(handle)) {
-    NavigationController* tab = tab_tracker_->GetResource(handle);
-    DownloadManager* dlm =
-        BrowserContext::GetDownloadManager(tab->GetBrowserContext());
-    *download_directory =
-        DownloadPrefs::FromDownloadManager(dlm)->DownloadPath();
-  }
-}
-
 // Sample json input: { "command": "OpenNewBrowserWindowWithNewProfile" }
 // Sample output: {}
 void TestingAutomationProvider::OpenNewBrowserWindowWithNewProfile(
     base::DictionaryValue* args, IPC::Message* reply_message) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   new BrowserOpenedWithNewProfileNotificationObserver(this, reply_message);
   profile_manager->CreateMultiProfileAsync(string16(), string16());
 }
 
 // Sample json input: { "command": "GetMultiProfileInfo" }
@@ skipping 174 matching lines @@
 void TestingAutomationProvider::BringBrowserToFront(int browser_handle,
                                                     bool* success) {
   *success = false;
   if (browser_tracker_->ContainsHandle(browser_handle)) {
     Browser* browser = browser_tracker_->GetResource(browser_handle);
     browser->window()->Activate();
     *success = true;
   }
 }
 
-void TestingAutomationProvider::IsMenuCommandEnabled(int browser_handle,
-                                                     int message_num,
-                                                     bool* menu_item_enabled) {
-  *menu_item_enabled = false;
-  if (browser_tracker_->ContainsHandle(browser_handle)) {
-    Browser* browser = browser_tracker_->GetResource(browser_handle);
-    *menu_item_enabled = chrome::IsCommandEnabled(browser, message_num);
-  }
-}
-
 void TestingAutomationProvider::HandleOpenFindInPageRequest(
     const IPC::Message& message, int handle) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     chrome::FindInPage(browser, false, false);
   }
 }
 
 void TestingAutomationProvider::GetFindWindowVisibility(int handle,
                                                         bool* visible) {
@@ skipping 259 matching lines @@
       chrome::ExecuteCommand(browser, IDC_FORWARD);
       return;
     }
   }
 
   AutomationMsg_GoForwardBlockUntilNavigationsComplete::WriteReplyParams(
       reply_message, AUTOMATION_MSG_NAVIGATION_ERROR);
   Send(reply_message);
 }
 
-void TestingAutomationProvider::SetShelfVisibility(int handle, bool visible) {
-  if (browser_tracker_->ContainsHandle(handle)) {
-    Browser* browser = browser_tracker_->GetResource(handle);
-    if (browser) {
-      if (visible)
-        browser->window()->GetDownloadShelf()->Show();
-      else
-        browser->window()->GetDownloadShelf()->Close();
-    }
-  }
-}
-
 void TestingAutomationProvider::BuildJSONHandlerMaps() {
   // Map json commands to their handlers.
   handler_map_["ApplyAccelerator"] =
       &TestingAutomationProvider::ExecuteBrowserCommandAsyncJSON;
   handler_map_["RunCommand"] =
       &TestingAutomationProvider::ExecuteBrowserCommandJSON;
   handler_map_["IsMenuCommandEnabled"] =
       &TestingAutomationProvider::IsMenuCommandEnabledJSON;
   handler_map_["ActivateTab"] =
       &TestingAutomationProvider::ActivateTabJSON;
@@ skipping 30 matching lines @@
   handler_map_["ExecuteJavascriptInRenderView"] =
       &TestingAutomationProvider::ExecuteJavascriptInRenderView;
   handler_map_["GoForward"] =
       &TestingAutomationProvider::GoForward;
   handler_map_["GoBack"] =
       &TestingAutomationProvider::GoBack;
   handler_map_["Reload"] =
       &TestingAutomationProvider::ReloadJSON;
   handler_map_["CaptureEntirePage"] =
       &TestingAutomationProvider::CaptureEntirePageJSON;
+  handler_map_["SetDownloadShelfVisible"] =
+      &TestingAutomationProvider::SetDownloadShelfVisibleJSON;
+  handler_map_["IsDownloadShelfVisible"] =
+      &TestingAutomationProvider::IsDownloadShelfVisibleJSON;
+  handler_map_["GetDownloadDirectory"] =
+      &TestingAutomationProvider::GetDownloadDirectoryJSON;
   handler_map_["GetCookies"] =
       &TestingAutomationProvider::GetCookiesJSON;
   handler_map_["DeleteCookie"] =
       &TestingAutomationProvider::DeleteCookieJSON;
   handler_map_["SetCookie"] =
       &TestingAutomationProvider::SetCookieJSON;
+  handler_map_["GetCookiesInBrowserContext"] =
+      &TestingAutomationProvider::GetCookiesInBrowserContext;
+  handler_map_["DeleteCookieInBrowserContext"] =
+      &TestingAutomationProvider::DeleteCookieInBrowserContext;
+  handler_map_["SetCookieInBrowserContext"] =
+      &TestingAutomationProvider::SetCookieInBrowserContext;
   handler_map_["GetTabIds"] =
       &TestingAutomationProvider::GetTabIds;
   handler_map_["GetViews"] =
       &TestingAutomationProvider::GetViews;
   handler_map_["IsTabIdValid"] =
       &TestingAutomationProvider::IsTabIdValid;
   handler_map_["DoesAutomationObjectExist"] =
       &TestingAutomationProvider::DoesAutomationObjectExist;
   handler_map_["CloseTab"] =
       &TestingAutomationProvider::CloseTabJSON;
@@ skipping 1140 matching lines @@
   } else if (action == "cancel") {
     selected_item->AddObserver(new AutomationProviderDownloadUpdatedObserver(
         this, reply_message, false));
     selected_item->Cancel(true);
   } else {
     AutomationJSONReply(this, reply_message)
         .SendError(StringPrintf("Invalid action '%s' given.", action.c_str()));
   }
 }
 
+void TestingAutomationProvider::SetDownloadShelfVisibleJSON(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  Browser* browser;
+  std::string error_msg;
+  bool is_visible;
+  if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
+    reply.SendError(error_msg);
+    return;
+  }
+  if (!args->GetBoolean("is_visible", &is_visible)) {
+    reply.SendError("'is_visible' missing or invalid.");
+    return;
+  }
+  if (is_visible) {
+    browser->window()->GetDownloadShelf()->Show();
+  } else {
+    browser->window()->GetDownloadShelf()->Close();
+  }
+  reply.SendSuccess(NULL);
+}
+
+void TestingAutomationProvider::IsDownloadShelfVisibleJSON(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  Browser* browser;
+  std::string error_msg;
+  if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
+    reply.SendError(error_msg);
+    return;
+  }
+  DictionaryValue dict;
+  dict.SetBoolean("is_visible", browser->window()->IsDownloadShelfVisible());
+  reply.SendSuccess(&dict);
+}
+
+void TestingAutomationProvider::GetDownloadDirectoryJSON(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  WebContents* web_contents;
+  std::string error;
+  if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
+    reply.SendError(error);
+    return;
+  }
+  DownloadManager* dlm =
+      BrowserContext::GetDownloadManager(
+          web_contents->GetController().GetBrowserContext());
+  DictionaryValue dict;
+  dict.SetString("path",
+      DownloadPrefs::FromDownloadManager(dlm)->DownloadPath().value());
+  reply.SendSuccess(&dict);
+}
+
 // Sample JSON input { "command": "LoadSearchEngineInfo" }
 void TestingAutomationProvider::LoadSearchEngineInfo(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   TemplateURLService* url_model =
       TemplateURLServiceFactory::GetForProfile(browser->profile());
   if (url_model->loaded()) {
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
     return;
@@ skipping 3742 matching lines @@
 void TestingAutomationProvider::DeleteCookieJSON(
     DictionaryValue* args, IPC::Message* reply_message) {
   automation_util::DeleteCookieJSON(this, args, reply_message);
 }
 
 void TestingAutomationProvider::SetCookieJSON(
     DictionaryValue* args, IPC::Message* reply_message) {
   automation_util::SetCookieJSON(this, args, reply_message);
 }
 
+void TestingAutomationProvider::GetCookiesInBrowserContext(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  WebContents* web_contents;
+  std::string value, url_string;
+  int windex, value_size;
+  if (!args->GetInteger("windex", &windex)) {
+    reply.SendError("'windex' missing or invalid.");
+    return;
+  }
+  web_contents = automation_util::GetWebContentsAt(windex, 0);
+  if (!web_contents) {
+    reply.SendError("'windex' does not refer to a browser window.");
+    return;
+  }
+  if (!args->GetString("url", &url_string)) {
+    reply.SendError("'url' missing or invalid.");
+    return;
+  }
+  GURL url(url_string);
+  if (!url.is_valid()) {
+    reply.SendError("Invalid url.");
+    return;
+  }
+  automation_util::GetCookies(url, web_contents, &value_size, &value);
+  if (value_size == -1) {
+    reply.SendError(
+        StringPrintf("Unable to retrieve cookies for url=%s.",
+                     url_string.c_str()));
+    return;
+  }
+  DictionaryValue dict;
+  dict.SetString("cookies", value);
+  reply.SendSuccess(&dict);
+}
+
+void TestingAutomationProvider::DeleteCookieInBrowserContext(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  WebContents* web_contents;
+  std::string cookie_name, error, url_string;
+  int windex;
+  bool success = false;
+  if (!args->GetInteger("windex", &windex)) {
+    reply.SendError("'windex' missing or invalid.");
+    return;
+  }
+  web_contents = automation_util::GetWebContentsAt(windex, 0);
+  if (!web_contents) {
+    reply.SendError("'windex' does not refer to a browser window.");
+    return;
+  }
+  if (!args->GetString("cookie_name", &cookie_name)) {
+    reply.SendError("'cookie_name' missing or invalid.");
+    return;
+  }
+  if (!args->GetString("url", &url_string)) {
+    reply.SendError("'url' missing or invalid.");
+    return;
+  }
+  GURL url(url_string);
+  if (!url.is_valid()) {
+    reply.SendError("Invalid url.");
+    return;
+  }
+  automation_util::DeleteCookie(url, cookie_name, web_contents, &success);
+  if (!success) {
+    reply.SendError(
+        StringPrintf("Failed to delete cookie with name=%s for url=%s.",
+                     cookie_name.c_str(), url_string.c_str()));
+    return;
+  }
+  reply.SendSuccess(NULL);
+}
+
+void TestingAutomationProvider::SetCookieInBrowserContext(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  WebContents* web_contents;
+  std::string value, error, url_string;
+  int windex, response_value = -1;
+  if (!args->GetInteger("windex", &windex)) {
+    reply.SendError("'windex' missing or invalid.");
+    return;
+  }
+  web_contents = automation_util::GetWebContentsAt(windex, 0);
+  if (!web_contents) {
+    reply.SendError("'windex' does not refer to a browser window.");
+    return;
+  }
+  if (!args->GetString("value", &value)) {
+    reply.SendError("'value' missing or invalid.");
+    return;
+  }
+  if (!args->GetString("url", &url_string)) {
+    reply.SendError("'url' missing or invalid.");
+    return;
+  }
+  GURL url(url_string);
+  if (!url.is_valid()) {
+    reply.SendError("Invalid url.");
+    return;
+  }
+  automation_util::SetCookie(url, value, web_contents, &response_value);
+  if (response_value != 1) {
+    reply.SendError(
+        StringPrintf("Unable set cookie for url=%s.", url_string.c_str()));
+    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 = chrome::GetTabContentsAt(browser, i)->restore_tab_helper()->
           session_id().id();
       id_list->Append(Value::CreateIntegerValue(id));
@@ skipping 317 matching lines @@
 void TestingAutomationProvider::OnRemoveProvider() {
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
   if (chrome::GetActiveWebContents(browser) != tab)
     chrome::ActivateTabAt(browser, chrome::GetIndexOfTab(browser, tab), true);
 }