Enable (optional) blocking of webrequests in case a PAC script cannot be fetched or is invalid.

chrome/browser/extensions/extension_proxy_api_helpers.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.
 
 // Implementation of helper functions for the Chrome Extensions Proxy Settings
 // API.
 //
 // Throughout this code, we report errors to the user by setting an |error|
 // parameter, if and only if these errors can be cause by invalid input
 // from the extension and we cannot expect that the extensions API has
@@ skipping 54 matching lines @@
   // We can safely assume that this is ASCII due to the allowed enumeration
   // values specified in extension_api.json.
   proxy_config->GetStringASCII(keys::kProxyConfigMode, &proxy_mode);
   if (!ProxyPrefs::StringToProxyMode(proxy_mode, out)) {
     LOG(ERROR) << "Invalid mode for proxy settings: " << proxy_mode;
     return false;
   }
   return true;
 }
 
+bool GetPacMandatoryFromExtensionPref(const DictionaryValue* proxy_config,
+                                      bool* out,
+                                      std::string* error){
+  DictionaryValue* pac_dict = NULL;
+  proxy_config->GetDictionary(keys::kProxyConfigPacScript, &pac_dict);
+  if (!pac_dict)
+    return true;
+
+  bool mandatory_pac = false;
+  if (pac_dict->HasKey(keys::kProxyConfigPacScriptMandatory) &&
+      !pac_dict->GetBoolean(keys::kProxyConfigPacScriptMandatory,
+                            &mandatory_pac)) {
+    LOG(ERROR) << "'pacScript.mandatory' could not be parsed.";

[Bernhard Bauer, 2011/04/15 18:38:47]

Hm, this should already be covered by the JSON schema, no? In that case we
usually set |bad_message_| to true (which kills the extension process).

[battre, 2011/04/26 15:31:30]

I have added a TODO, in order to do this in a separate CL.

+    return false;
+  }
+  *out = mandatory_pac;
+  return true;
+}
+
 bool GetPacUrlFromExtensionPref(const DictionaryValue* proxy_config,
                                 std::string* out,
                                 std::string* error) {
   DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigPacScript, &pac_dict);
   if (!pac_dict)
     return true;
 
   // TODO(battre): Handle UTF-8 URLs (http://crbug.com/72692).
   string16 pac_url16;
@@ skipping 179 matching lines @@
   ListValue* bypass_list = NULL;
   if (!proxy_rules->GetList(keys::kProxyConfigBypassList, &bypass_list)) {
     LOG(ERROR) << "'rules.bypassList' not be parsed.";
     return false;
   }
 
   return JoinUrlList(bypass_list, ",", out, error);
 }
 
 DictionaryValue* CreateProxyConfigDict(ProxyPrefs::ProxyMode mode_enum,
+                                       bool pac_mandatory,
                                        const std::string& pac_url,
                                        const std::string& pac_data,
                                        const std::string& proxy_rules_string,
                                        const std::string& bypass_list,
                                        std::string* error) {
   DictionaryValue* result_proxy_config = NULL;
   switch (mode_enum) {
     case ProxyPrefs::MODE_DIRECT:
       result_proxy_config = ProxyConfigDictionary::CreateDirect();
       break;
     case ProxyPrefs::MODE_AUTO_DETECT:
       result_proxy_config = ProxyConfigDictionary::CreateAutoDetect();
       break;
     case ProxyPrefs::MODE_PAC_SCRIPT: {
       std::string url;
       if (!pac_url.empty()) {
         url = pac_url;
       } else if (!pac_data.empty()) {
         if (!CreateDataURLFromPACScript(pac_data, &url)) {
           *error = "Internal error, at base64 encoding of 'pacScript.data'.";
           return NULL;
         }
       } else {
         *error = "Proxy mode 'pac_script' requires a 'pacScript' field with "
                  "either a 'url' field or a 'data' field.";
         return NULL;
       }
-      result_proxy_config = ProxyConfigDictionary::CreatePacScript(url);
+      result_proxy_config =
+          ProxyConfigDictionary::CreatePacScript(url, pac_mandatory);
       break;
     }
     case ProxyPrefs::MODE_FIXED_SERVERS: {
       if (proxy_rules_string.empty()) {
         *error = "Proxy mode 'fixed_servers' requires a 'rules' field.";
         return NULL;
       }
       result_proxy_config = ProxyConfigDictionary::CreateFixedServers(
           proxy_rules_string, bypass_list);
       break;
@@ skipping 96 matching lines @@
     const ProxyConfigDictionary& proxy_config) {
   ProxyPrefs::ProxyMode mode;
   CHECK(proxy_config.GetMode(&mode) && mode == ProxyPrefs::MODE_PAC_SCRIPT);
 
   scoped_ptr<DictionaryValue> pac_script_dict(new DictionaryValue);
   std::string pac_url;
   if (!proxy_config.GetPacUrl(&pac_url)) {
     LOG(ERROR) << "Invalid proxy configuration. Missing PAC URL.";
     return NULL;
   }
+  bool pac_mandatory = false;
+  if (!proxy_config.GetPacMandatory(&pac_mandatory)) {
+    LOG(ERROR) << "Invalid proxy configuration. Missing PAC mandatory field.";
+    return NULL;
+  }
 
   if (pac_url.find("data") == 0) {
     std::string pac_data;
     if (!CreatePACScriptFromDataURL(pac_url, &pac_data)) {
       LOG(ERROR) << "Cannot decode base64-encoded PAC data URL.";
       return NULL;
     }
     pac_script_dict->SetString(keys::kProxyConfigPacScriptData, pac_data);
   } else {
     pac_script_dict->SetString(keys::kProxyConfigPacScriptUrl, pac_url);
   }
+  pac_script_dict->SetBoolean(keys::kProxyConfigPacScriptMandatory,
+                              pac_mandatory);
   return pac_script_dict.release();
 }
 
 ListValue* TokenizeToStringList(const std::string& in,
                                 const std::string& delims) {
   ListValue* out = new ListValue;
   StringTokenizer entries(in, delims);
   while (entries.GetNext())
     out->Append(Value::CreateStringValue(entries.token()));
   return out;
 }
 
 }  // namespace extension_proxy_api_helpers