Return the full cookie details in TestingAutomationProvider and pass around

chrome/test/webdriver/automation.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/test/webdriver/automation.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 296 matching lines @@
   int windex = 0, tab_index = 0;
   if (!GetIndicesForTab(tab_id, &windex, &tab_index)) {
     *success = false;
     return;
   }
 
   *success = SendGetTabTitleJSONRequest(
       automation(), windex, tab_index, tab_title);
 }
 
-void Automation::GetCookies(int tab_id,
-                            const GURL& gurl,
-                            std::string* cookies,
+void Automation::GetCookies(const std::string& url,
+                            ListValue** cookies,
                             bool* success) {
+  *success = SendGetCookiesJSONRequest(automation(), url, cookies);
+}
+
+void Automation::GetCookiesDeprecated(int tab_id,
+                                      const GURL& gurl,
+                                      std::string* cookies,
+                                      bool* success) {
   int windex = 0, tab_index = 0;
   if (!GetIndicesForTab(tab_id, &windex, &tab_index)) {
     *success = false;
     return;
   }
 
-  *success = SendGetCookiesJSONRequest(
+  *success = SendGetCookiesJSONRequestDeprecated(
       automation(), windex, gurl.possibly_invalid_spec(), cookies);
 }
 
-void Automation::DeleteCookie(int tab_id,
-                              const GURL& gurl,
+void Automation::DeleteCookie(const std::string& url,
                               const std::string& cookie_name,
                               bool* success) {
+  *success = SendDeleteCookieJSONRequest(automation(), url, cookie_name);
+}
+
+void Automation::DeleteCookieDeprecated(int tab_id,
+                                        const GURL& gurl,
+                                        const std::string& cookie_name,
+                                        bool* success) {
   int windex = 0, tab_index = 0;
   if (!GetIndicesForTab(tab_id, &windex, &tab_index)) {
     *success = false;
     return;
   }
 
-  *success = SendDeleteCookieJSONRequest(
+  *success = SendDeleteCookieJSONRequestDeprecated(
       automation(),
       windex,
       gurl.possibly_invalid_spec(),
       cookie_name);
 }
 
-void Automation::SetCookie(int tab_id,
-                           const GURL& gurl,
-                           const std::string& cookie,
+void Automation::SetCookie(const std::string& url,
+                           DictionaryValue* cookie_dict,
                            bool* success) {
+  *success = SendSetCookieJSONRequest(automation(), url, cookie_dict);
+}
+
+void Automation::SetCookieDeprecated(int tab_id,
+                                     const GURL& gurl,
+                                     const std::string& cookie,
+                                     bool* success) {
   int windex = 0, tab_index = 0;
   if (!GetIndicesForTab(tab_id, &windex, &tab_index)) {
     *success = false;
     return;
   }
 
-  *success = SendSetCookieJSONRequest(
+  *success = SendSetCookieJSONRequestDeprecated(
       automation(),
       windex,
       gurl.possibly_invalid_spec(),
       cookie);
 }
 
 void Automation::GetTabIds(std::vector<int>* tab_ids,
                            bool* success) {
   *success = SendGetTabIdsJSONRequest(automation(), tab_ids);
 }
 
 void Automation::DoesTabExist(int tab_id, bool* does_exist, bool* success) {
   *success = SendIsTabIdValidJSONRequest(automation(), tab_id, does_exist);
 }
 
 void Automation::CloseTab(int tab_id, bool* success) {
   int windex = 0, tab_index = 0;
   if (!GetIndicesForTab(tab_id, &windex, &tab_index)) {
     *success = false;
     return;
   }
 
   *success = SendCloseTabJSONRequest(automation(), windex, tab_index);
 }
 
-void Automation::GetVersion(std::string* version) {
+void Automation::GetBrowserVersion(std::string* version) {
   *version = automation()->server_version();
 }
 
 void Automation::WaitForAllTabsToStopLoading(bool* success) {
   *success = SendWaitForAllTabsToStopLoadingJSONRequest(automation());
 }
 
 AutomationProxy* Automation::automation() const {
   return launcher_->automation();
 }
 
 bool Automation::GetIndicesForTab(
     int tab_id, int* browser_index, int* tab_index) {
   if (!SendGetIndicesFromTabIdJSONRequest(automation(), tab_id,
                                           browser_index, tab_index)) {
     LOG(ERROR) << "Could not get browser and tab indices for WebDriver tab id";
     return false;
   }
   return true;
 }
 
 }  // namespace webdriver