Return the full cookie details in TestingAutomationProvider and pass around

chrome/test/webdriver/session.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/session_manager.h"
 
 #include <sstream>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 296 matching lines @@
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::MouseDrag,
       current_target_.window_id,
       start,
       end,
       &success));
   return success;
 }
 
-bool Session::GetCookies(const GURL& url, std::string* cookies) {
+bool Session::GetCookies(const std::string& url, ListValue** cookies) {
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::GetCookies,
+      url,
+      cookies,
+      &success));
+  return success;
+}
+
+bool Session::GetCookiesDeprecated(const GURL& url, std::string* cookies) {
+  bool success = false;
+  RunSessionTask(NewRunnableMethod(
+      automation_.get(),
+      &Automation::GetCookiesDeprecated,
       current_target_.window_id,
       url,
       cookies,
       &success));
   return success;
 }
 
-bool Session::GetCookieByName(const GURL& url,
-                              const std::string& cookie_name,
-                              std::string* cookie) {
+bool Session::GetCookieByNameDeprecated(const GURL& url,
+                                        const std::string& cookie_name,
+                                        std::string* cookie) {
   std::string cookies;
-  if (!GetCookies(url, &cookies))
+  if (!GetCookiesDeprecated(url, &cookies))
     return false;
 
   std::string namestr = cookie_name + "=";
   std::string::size_type idx = cookies.find(namestr);
   if (idx != std::string::npos) {
     cookies.erase(0, idx + namestr.length());
     *cookie = cookies.substr(0, cookies.find(";"));
   } else {
     cookie->clear();
   }
 
   return true;
 }
 
-bool Session::DeleteCookie(const GURL& url, const std::string& cookie_name) {
+bool Session::DeleteCookie(const std::string& url,
+                           const std::string& cookie_name) {
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::DeleteCookie,
+      url,
+      cookie_name,
+      &success));
+  return success;
+}
+
+bool Session::DeleteCookieDeprecated(const GURL& url,
+                                     const std::string& cookie_name) {
+  bool success = false;
+  RunSessionTask(NewRunnableMethod(
+      automation_.get(),
+      &Automation::DeleteCookieDeprecated,
       current_target_.window_id,
       url,
       cookie_name,
       &success));
   return success;
 }
 
-bool Session::SetCookie(const GURL& url, const std::string& cookie) {
+bool Session::SetCookie(const std::string& url, DictionaryValue* cookie_dict) {
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::SetCookie,
+      url,
+      cookie_dict,
+      &success));
+  return success;
+}
+
+bool Session::SetCookieDeprecated(const GURL& url, const std::string& cookie) {
+  bool success = false;
+  RunSessionTask(NewRunnableMethod(
+      automation_.get(),
+      &Automation::SetCookieDeprecated,
       current_target_.window_id,
       url,
       cookie,
       &success));
   return success;
 }
 
 bool Session::GetWindowIds(std::vector<int>* window_ids) {
   bool success = false;
   RunSessionTask(NewRunnableMethod(
@@ skipping 113 matching lines @@
       // session.
       // TODO(kkania): This will cause us problems if GetWindowIds fails for a
       // reason other than the channel is disconnected. Look into having
       // |GetWindowIds| tell us if it just closed the last window.
       Terminate();
     }
   }
   return success;
 }
 
-std::string Session::GetVersion() {
+std::string Session::GetBrowserVersion() {
   std::string version;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
-      &Automation::GetVersion,
+      &Automation::GetBrowserVersion,
       &version));
   return version;
 }
 
+bool Session::CompareBrowserVersion(int client_build_no,
+                                    int client_patch_no,
+                                    bool* is_newer_or_equal) {
+  std::string version = GetBrowserVersion();
+  std::vector<std::string> split_version;
+  base::SplitString(version, '.', &split_version);
+  if (split_version.size() != 4)
+    return false;
+  int build_no, patch_no;
+  if (!base::StringToInt(split_version[2], &build_no) ||
+      !base::StringToInt(split_version[3], &patch_no)) {
+    return false;
+  }
+  if (build_no < client_build_no)
+    *is_newer_or_equal = false;
+  else if (build_no > client_build_no)
+    *is_newer_or_equal = true;
+  else
+    *is_newer_or_equal = patch_no >= client_patch_no;
+  return true;
+}
+
 ErrorCode Session::FindElement(const FrameId& frame_id,
                                const WebElementId& root_element,
                                const std::string& locator,
                                const std::string& query,
                                WebElementId* element) {
   std::vector<WebElementId> elements;
   ErrorCode code = FindElementsHelper(
       frame_id, root_element, locator, query, true, &elements);
   if (code == kSuccess)
     *element = elements[0];
@@ skipping 345 matching lines @@
   if (!loc_dict->GetInteger("x", &x) ||
       !loc_dict->GetInteger("y", &y)) {
     LOG(ERROR) << "Location atom returned bad coordinate dictionary";
     code = kUnknownError;
   }
   *location = gfx::Point(x, y);
   return kSuccess;
 }
 
 }  // namespace webdriver