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 19 matching lines @@
       JsonStringifyForDisplay(option).c_str()));
 }
 
 }  // namespace
 
 Capabilities::Capabilities()
     : command(CommandLine::NO_PROGRAM),
       detach(false),
       load_async(false),
       native_events(false),
+      no_website_testing_defaults(false),
       verbose(false) { }
 
 Capabilities::~Capabilities() { }
 
 CapabilitiesParser::CapabilitiesParser(
     const base::DictionaryValue* capabilities_dict,
     const FilePath& root_path,
     Capabilities* capabilities)
     : dict_(capabilities_dict),
       root_(root_path),
@@ skipping 21 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 94 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