chrome.webRequest support for ExtensionSettings

chrome/browser/extensions/policy_handlers.cc

 // Copyright 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/browser/extensions/policy_handlers.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 268 matching lines @@
   if (!CheckAndGetValue(policies, errors, &policy_value))
     return false;
   if (!policy_value)
     return true;
 
   // |policy_value| is expected to conform to the defined schema. But it's
   // not strictly valid since there are additional restrictions.
   const base::DictionaryValue* dict_value = NULL;
   DCHECK(policy_value->IsType(base::Value::Type::DICTIONARY));
   policy_value->GetAsDictionary(&dict_value);
+  const int extension_scheme_mask =
+      URLPattern::GetValidSchemeMaskForExtensions();
 
   for (base::DictionaryValue::Iterator it(*dict_value); !it.IsAtEnd();
        it.Advance()) {
     DCHECK(it.key() == schema_constants::kWildcard ||
            crx_file::id_util::IdIsValid(it.key()));
     DCHECK(it.value().IsType(base::Value::Type::DICTIONARY));
 
     // Extracts sub dictionary.
     const base::DictionaryValue* sub_dict = NULL;
     it.value().GetAsDictionary(&sub_dict);
@@ skipping 15 matching lines @@
           return false;
         }
         // Verifies that update URL is valid.
         if (!GURL(update_url).is_valid()) {
           errors->AddError(
               policy_name(), IDS_POLICY_INVALID_UPDATE_URL_ERROR, it.key());
           return false;
         }
       }
     }
+    const base::ListValue* unparsed_urls;
+    // Host keys that don't support user defined paths.
+    const std::string host_keys[] = {schema_constants::kRuntimeBlockedHosts,
+                                     schema_constants::kRuntimeAllowedHosts};
+    for (const auto& key : host_keys) {
+      if (sub_dict->GetList(key, &unparsed_urls)) {
+        for (size_t i = 0; i < unparsed_urls->GetSize(); ++i) {
+          std::string unparsed_url;
+          unparsed_urls->GetString(i, &unparsed_url);
+          URLPattern pattern = URLPattern(extension_scheme_mask);
+          URLPattern::ParseResult parse_result = pattern.Parse(
+              unparsed_url, URLPattern::ALLOW_WILDCARD_FOR_EFFECTIVE_TLD);
+          // These keys don't support paths due to how we track the initiator
+          // of a webRequest and cookie security policy. We expect a valid
+          // pattern to return a PARSE_ERROR_EMPTY_PATH.
+          if (parse_result == URLPattern::PARSE_ERROR_EMPTY_PATH) {
+            // Add a wildcard path to the URL as it should match any path.
+            parse_result =
+                pattern.Parse(unparsed_url + "/*",
+                              URLPattern::ALLOW_WILDCARD_FOR_EFFECTIVE_TLD);
+          } else if (parse_result == URLPattern::PARSE_SUCCESS) {
+            // The user supplied a path, notify them that this is not supported.
+            if (unparsed_url != "<all_urls>") {
+              errors->AddError(
+                  policy_name(), it.key(),
+                  "Your URL pattern '" + unparsed_url + "' for attribute " +
+                      key + " contains a path. Paths are not supported, " +
+                      "please remove it and try again.");
+              return false;
+            }
+          }
+          // Any other issue with parsing the URL.
+          if (parse_result != URLPattern::PARSE_SUCCESS) {
+            errors->AddError(policy_name(), it.key(),
+                             "Invalid URL pattern '" + unparsed_url +
+                                 "' for attribute " + key);
+          }
+        }
+      }
+    }
   }
 
   return true;
 }
 
 void ExtensionSettingsPolicyHandler::ApplyPolicySettings(
     const policy::PolicyMap& policies,
     PrefValueMap* prefs) {
   std::unique_ptr<base::Value> policy_value;
   if (!CheckAndGetValue(policies, NULL, &policy_value) || !policy_value)
     return;
   prefs->SetValue(pref_names::kExtensionManagement, std::move(policy_value));
 }
 
 }  // namespace extensions