[chromedriver] Implement proxy capability.

chrome/test/chromedriver/commands.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/test/chromedriver/commands.h"
 
 #include "base/callback.h"
 #include "base/file_util.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/chrome/chrome.h"
 #include "chrome/test/chromedriver/chrome/chrome_android_impl.h"
 #include "chrome/test/chromedriver/chrome/chrome_desktop_impl.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/chrome/version.h"
 #include "chrome/test/chromedriver/chrome/web_view.h"
 #include "chrome/test/chromedriver/net/net_util.h"
@@ skipping 15 matching lines @@
   os.SetString("version", base::SysInfo::OperatingSystemVersion());
   os.SetString("arch", base::SysInfo::OperatingSystemArchitecture());
 
   base::DictionaryValue info;
   info.Set("build", build.DeepCopy());
   info.Set("os", os.DeepCopy());
   out_value->reset(info.DeepCopy());
   return Status(kOk);
 }
 
+namespace {
+
+// Parse information of proxy, add them as chrome switches to |args_list|.
+Status ParseProxy(const base::DictionaryValue& proxy_dict,

[kkania, 2013/03/29 20:52:46]

Can we factor the capability parsing out into its own file? Sorta like
webdriver_capabilities_parser?

+                  base::ListValue* args_list) {
+  std::string proxy_type;
+  if (!proxy_dict.GetString("proxyType", &proxy_type))
+    return Status(kUnknownError, "'proxyType' must be a string");
+  proxy_type = StringToLowerASCII(proxy_type);
+  if (proxy_type == "direct") {
+    args_list->AppendString("no-proxy-server");
+  } else if (proxy_type == "system") {
+    // Chrome default.
+  } else if (proxy_type == "pac") {
+    std::string proxy_pac_url;
+    if (!proxy_dict.GetString("proxyAutoconfigUrl", &proxy_pac_url))
+      return Status(kUnknownError, "'proxyAutoconfigUrl' must be a string");
+    args_list->AppendString("proxy-pac-url=" + proxy_pac_url);
+  } else if (proxy_type == "autodetect") {
+    args_list->AppendString("proxy-auto-detect");
+  } else if (proxy_type == "manual") {
+    const char* proxy_servers_options[][2] = {
+        {"ftpProxy", "ftp"}, {"httpProxy", "http"}, {"sslProxy", "https"}};
+    std::string proxy_servers;
+    for (size_t i = 0; i < arraysize(proxy_servers_options); ++i) {
+      if (!proxy_dict.HasKey(proxy_servers_options[i][0]))
+        continue;
+      std::string value;
+      if (!proxy_dict.GetString(proxy_servers_options[i][0], &value)) {
+        return Status(
+            kUnknownError,
+            base::StringPrintf("'%s' must be a string",
+                               proxy_servers_options[i][0]));
+      }
+      // Converts into Chrome proxy scheme.
+      // Example: "http=localhost:9000;ftp=localhost:8000".
+      if (!proxy_servers.empty())
+        proxy_servers += ";";
+      proxy_servers += base::StringPrintf(
+          "%s=%s", proxy_servers_options[i][1], value.c_str());
+    }
+
+    std::string proxy_bypass_list;
+    if (proxy_dict.HasKey("noProxy")) {
+      if (!proxy_dict.GetString("noProxy", & proxy_bypass_list))
+        return Status(kUnknownError, "'noProxy' must be a string");
+    }
+
+    if (proxy_servers.empty() && proxy_bypass_list.empty()) {
+      return Status(kUnknownError, "proxyType is 'manual' but no manual "
+                                  "proxy capabilities were found");
+    }
+    if (!proxy_servers.empty())
+      args_list->AppendString("proxy-server=" + proxy_servers);
+    if (!proxy_bypass_list.empty())
+      args_list->AppendString("proxy-bypass-list=" + proxy_bypass_list);
+  } else {
+    return Status(kUnknownError, "unrecognized proxy type:" + proxy_type);
+  }
+  return Status(kOk);
+}
+
+}
+
 Status ExecuteNewSession(
     SessionMap* session_map,
     scoped_refptr<URLRequestContextGetter> context_getter,
     const SyncWebSocketFactory& socket_factory,
     const base::DictionaryValue& params,
     const std::string& session_id,
     scoped_ptr<base::Value>* out_value,
     std::string* out_session_id) {
   int port;
   if (!FindOpenPort(&port))
@@ skipping 48 matching lines @@
     }
 
     const base::Value* extensions = NULL;
     const base::ListValue* extensions_list = NULL;
     if (desired_caps->Get("chromeOptions.extensions", &extensions)
         && !extensions->GetAsList(&extensions_list)) {
       return Status(kUnknownError,
                     "chrome extensions must be a list");
     }
 
+    const base::Value* proxy = NULL;
+    scoped_ptr<base::ListValue> new_args_list;
+    if (desired_caps->Get("chromeOptions.proxy", &proxy)) {
+      const base::DictionaryValue* proxy_dict = NULL;
+      if (!proxy->GetAsDictionary(&proxy_dict))
+        return Status(kUnknownError, "proxy must be a dictionary");
+      new_args_list.reset(args_list->DeepCopy());
+      status = ParseProxy(*proxy_dict, new_args_list.get());
+      if (status.IsError())
+        return status;
+      args_list = new_args_list.get();
+    }
+
     scoped_ptr<ChromeDesktopImpl> chrome_desktop(new ChromeDesktopImpl(
         context_getter, port, socket_factory));
     status = chrome_desktop->Launch(chrome_exe, args_list, extensions_list,
                                     prefs_dict, local_state_dict);
     chrome.reset(chrome_desktop.release());
   }
   if (status.IsError())
     return Status(kSessionNotCreatedException, status.message());
 
   std::list<std::string> web_view_ids;
@@ skipping 33 matching lines @@
     std::string* out_session_id) {
   std::vector<std::string> session_ids;
   session_map->GetKeys(&session_ids);
   for (size_t i = 0; i < session_ids.size(); ++i) {
     scoped_ptr<base::Value> unused_value;
     std::string unused_session_id;
     quit_command.Run(params, session_ids[i], &unused_value, &unused_session_id);
   }
   return Status(kOk);
 }