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 1679 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_["GetTabCookies"] =
+      &TestingAutomationProvider::GetTabCookiesJSON;
+  handler_map_["DeleteTabCookie"] =
+      &TestingAutomationProvider::DeleteTabCookieJSON;
+  handler_map_["SetTabCookie"] =
+      &TestingAutomationProvider::SetTabCookieJSON;
   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 1122 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)->download_path().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 3709 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::GetTabCookiesJSON(DictionaryValue* args,
+                                                  IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  WebContents* web_contents;
+  std::string value, error, url_string;
+  int value_size = -1;
+  if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
+    reply.SendError(error);
+    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::DeleteTabCookieJSON(
+    DictionaryValue* args,
+    IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  WebContents* web_contents;
+  std::string cookie_name, error, url_string;
+  bool success = false;
+  if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
+    reply.SendError(error);
+    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::SetTabCookieJSON(DictionaryValue* args,

[Nirnimesh, 2012/07/20 02:19:46]

What is setTabCookie for? I thought cookies were keyed against URLs, not tabs.

[craigdh, 2012/07/20 15:27:43]

If you think of a better name, let me know. The name is to differentiate these
commands, which set a cookie in the context of a tab, and the chromedriver
functions, which take a different set of parameters and set the cookie in the
context of a profile. They all take a url that the cookie is applicable to.

[craigdh, 2012/07/20 18:49:59]

How about 'SetCookieInTab'?

+                                                 IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  WebContents* web_contents;
+  std::string value, error, url_string;
+  int response_value = -1;
+  if (!GetTabFromJSONArgs(args, &web_contents, &error)) {
+    reply.SendError(error);
+    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);
 }