Allow chromedriver to set local state preferences.

chrome/test/webdriver/webdriver_capabilities_parser.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/webdriver_capabilities_parser.h"
 
 #include "base/base64.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 15 matching lines @@
   return new Error(kBadRequest, base::StringPrintf(
       "%s must be of type %s, not %s. Received: %s",
       name.c_str(), GetJsonTypeName(type),
       GetJsonTypeName(option->GetType()),
       JsonStringifyForDisplay(option).c_str()));
 }
 
 }  // namespace
 
 Capabilities::Capabilities()
-    : command(CommandLine::NO_PROGRAM),
+    : cert_revocation_checking(true),
+      command(CommandLine::NO_PROGRAM),
       detach(false),
       load_async(false),
       native_events(false),
       verbose(false) { }
 
 Capabilities::~Capabilities() { }
 
 CapabilitiesParser::CapabilitiesParser(
     const base::DictionaryValue* capabilities_dict,
     const FilePath& root_path,
@@ skipping 24 matching lines @@
   std::map<std::string, Parser> parser_map;
   if (legacy_options) {
     parser_map["chrome.binary"] = &CapabilitiesParser::ParseBinary;
     parser_map["chrome.channel"] = &CapabilitiesParser::ParseChannel;
     parser_map["chrome.detach"] = &CapabilitiesParser::ParseDetach;
     parser_map["chrome.extensions"] = &CapabilitiesParser::ParseExtensions;
     parser_map["chrome.loadAsync"] = &CapabilitiesParser::ParseLoadAsync;
     parser_map["chrome.nativeEvents"] = &CapabilitiesParser::ParseNativeEvents;
     parser_map["chrome.profile"] = &CapabilitiesParser::ParseProfile;
     parser_map["chrome.switches"] = &CapabilitiesParser::ParseArgs;
+    parser_map["chrome.noWebsiteTestingDefaults"] =
+        &CapabilitiesParser::ParseNoWebsiteTestingDefaults;
     parser_map["chrome.verbose"] = &CapabilitiesParser::ParseVerbose;
   } else {
     parser_map["args"] = &CapabilitiesParser::ParseArgs;
     parser_map["binary"] = &CapabilitiesParser::ParseBinary;
     parser_map["channel"] = &CapabilitiesParser::ParseChannel;
     parser_map["detach"] = &CapabilitiesParser::ParseDetach;
     parser_map["extensions"] = &CapabilitiesParser::ParseExtensions;
     parser_map["loadAsync"] = &CapabilitiesParser::ParseLoadAsync;
     parser_map["nativeEvents"] = &CapabilitiesParser::ParseNativeEvents;
     parser_map["profile"] = &CapabilitiesParser::ParseProfile;
+    parser_map["noWebsiteTestingDefaults"] =
+        &CapabilitiesParser::ParseNoWebsiteTestingDefaults;
     parser_map["verbose"] = &CapabilitiesParser::ParseVerbose;
   }
 
   base::DictionaryValue::key_iterator key_iter = options->begin_keys();
   for (; key_iter != options->end_keys(); ++key_iter) {
     if (parser_map.find(*key_iter) == parser_map.end()) {
       LOG(WARNING) << "Ignoring unrecognized capability: " << *key_iter;
       continue;
     }
     Value* option = NULL;
@@ skipping 34 matching lines @@
 
 Error* CapabilitiesParser::ParseBinary(const Value* option) {
   FilePath::StringType path;
   if (!option->GetAsString(&path)) {
     return CreateBadInputError("binary path", Value::TYPE_STRING, option);
   }
   caps_->command.SetProgram(FilePath(path));
   return NULL;
 }
 
+Error* CapabilitiesParser::ParseCertRevocationChecking(

[Huyen, 2011/12/09 23:56:55]

did you forget to map this function to the parser_map? i don't see an entry for
it in the constructor.

[kkania, 2011/12/10 00:37:44]

Forgot to delete this. I decided I didn't like this idea.

+    const base::Value* option) {
+  if (!option->GetAsBoolean(&caps_->cert_revocation_checking))
+    return CreateBadInputError("cert revocation checking",
+                               Value::TYPE_BOOLEAN, option);
+  return NULL;
+}
+
 Error* CapabilitiesParser::ParseChannel(const Value* option) {
   if (!option->GetAsString(&caps_->channel))
     return CreateBadInputError("channel", Value::TYPE_STRING, option);
   return NULL;
 }
 
 Error* CapabilitiesParser::ParseDetach(const Value* option) {
   if (!option->GetAsBoolean(&caps_->detach))
     return CreateBadInputError("detach", Value::TYPE_BOOLEAN, option);
   return NULL;
@@ skipping 40 matching lines @@
   if (!option->GetAsString(&profile_base64))
     return CreateBadInputError("profile", Value::TYPE_STRING, option);
   std::string error_msg;
   caps_->profile = root_.AppendASCII("profile");
   if (!DecodeAndWriteFile(caps_->profile, profile_base64, true /* unzip */,
                           &error_msg))
     return new Error(kUnknownError, "unable to unpack profile: " + error_msg);
   return NULL;
 }
 
+Error* CapabilitiesParser::ParseNoWebsiteTestingDefaults(const Value* option) {
+  if (!option->GetAsBoolean(&caps_->no_website_testing_defaults))
+    return CreateBadInputError("noWebsiteTestingDefaults",
+                               Value::TYPE_BOOLEAN, option);
+  return NULL;
+}
+
 Error* CapabilitiesParser::ParseVerbose(const Value* option) {
   if (!option->GetAsBoolean(&caps_->verbose))
     return CreateBadInputError("verbose", Value::TYPE_BOOLEAN, option);
   return NULL;
 }
 
 bool CapabilitiesParser::DecodeAndWriteFile(
     const FilePath& path,
     const std::string& base64,
     bool unzip,
@@ skipping 16 matching lines @@
   } else {
     if (!file_util::WriteFile(path, data.c_str(), data.length())) {
       *error_msg = "Could not write file";
       return false;
     }
   }
   return true;
 }
 
 }  // namespace webdriver