[chromedriver] Enable acceptSslCerts and ignore NULL for proxy.

chrome/test/chromedriver/capabilities.cc

 // Copyright (c) 2013 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/capabilities.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 92 matching lines @@
   } else if (proxy_type == "pac") {
     CommandLine::StringType proxy_pac_url;
     if (!proxy_dict->GetString("proxyAutoconfigUrl", &proxy_pac_url))
       return Status(kUnknownError, "'proxyAutoconfigUrl' must be a string");
     capabilities->command.AppendSwitchNative("proxy-pac-url", proxy_pac_url);
   } else if (proxy_type == "autodetect") {
     capabilities->command.AppendSwitch("proxy-auto-detect");
   } else if (proxy_type == "manual") {
     const char* proxy_servers_options[][2] = {
         {"ftpProxy", "ftp"}, {"httpProxy", "http"}, {"sslProxy", "https"}};
+    const base::Value* option_value = NULL;
     std::string proxy_servers;
     for (size_t i = 0; i < arraysize(proxy_servers_options); ++i) {
-      if (!proxy_dict->HasKey(proxy_servers_options[i][0]))
+      if (!proxy_dict->Get(proxy_servers_options[i][0], &option_value) ||
+          option_value->IsType(base::Value::TYPE_NULL)) {
         continue;
+      }
       std::string value;
-      if (!proxy_dict->GetString(proxy_servers_options[i][0], &value)) {
+      if (!option_value->GetAsString(&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))
+    if (proxy_dict->Get("noProxy", &option_value) &&
+        !option_value->IsType(base::Value::TYPE_NULL)) {
+      if (!option_value->GetAsString(&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())
       capabilities->command.AppendSwitchASCII("proxy-server", proxy_servers);
@@ skipping 98 matching lines @@
        it != parser_map.end(); ++it) {
     const base::Value* capability = NULL;
     if (desired_caps.Get(it->first, &capability)) {
       status = it->second.Run(*capability, this);
       if (status.IsError())
         return status;
     }
   }
   return Status(kOk);
 }