Lazily load extension API schemas

chrome/common/extensions/features/simple_feature.cc

 // Copyright (c) 2012 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/common/extensions/features/simple_feature.h"
 
 #include <map>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 117 matching lines @@
   std::set<std::string> string_set;
   ParseSet(value, property, &string_set);
   for (std::set<std::string>::iterator iter = string_set.begin();
        iter != string_set.end(); ++iter) {
     T enum_value = static_cast<T>(0);
     ParseEnum(*iter, &enum_value, mapping);
     enum_set->insert(enum_value);
   }
 }
 
+void ParseURLPatterns(const DictionaryValue* value,
+                      const std::string& key,
+                      URLPatternSet* set) {
+  const ListValue* matches = NULL;
+  if (value->GetList(key, &matches)) {
+    for (size_t i = 0; i < matches->GetSize(); ++i) {
+      std::string pattern;
+      DCHECK(matches->GetString(i, &pattern));
+      set->AddPattern(URLPattern(URLPattern::SCHEME_ALL, pattern));
+    }
+  }
+}
+
 // Gets a human-readable name for the given extension type.
 std::string GetDisplayTypeName(Manifest::Type type) {
   switch (type) {
     case Manifest::TYPE_UNKNOWN:
       return "unknown";
     case Manifest::TYPE_EXTENSION:
       return "extension";
     case Manifest::TYPE_HOSTED_APP:
       return "hosted app";
     case Manifest::TYPE_LEGACY_PACKAGED_APP:
@@ skipping 17 matching lines @@
     platform_(UNSPECIFIED_PLATFORM),
     min_manifest_version_(0),
     max_manifest_version_(0),
     channel_(VersionInfo::CHANNEL_UNKNOWN) {
 }
 
 SimpleFeature::SimpleFeature(const SimpleFeature& other)
     : whitelist_(other.whitelist_),
       extension_types_(other.extension_types_),
       contexts_(other.contexts_),
+      matches_(other.matches_),
       location_(other.location_),
       platform_(other.platform_),
       min_manifest_version_(other.min_manifest_version_),
       max_manifest_version_(other.max_manifest_version_),
       channel_(other.channel_) {
 }
 
 SimpleFeature::~SimpleFeature() {
 }
 
 bool SimpleFeature::Equals(const SimpleFeature& other) const {
   return whitelist_ == other.whitelist_ &&
       extension_types_ == other.extension_types_ &&
       contexts_ == other.contexts_ &&
+      matches_ == other.matches_ &&
       location_ == other.location_ &&
       platform_ == other.platform_ &&
       min_manifest_version_ == other.min_manifest_version_ &&
       max_manifest_version_ == other.max_manifest_version_ &&
       channel_ == other.channel_;
 }
 
 void SimpleFeature::Parse(const DictionaryValue* value) {
+  ParseURLPatterns(value, "matches", &matches_);
   ParseSet(value, "whitelist", &whitelist_);
   ParseEnumSet<Manifest::Type>(value, "extension_types", &extension_types_,
                                 g_mappings.Get().extension_types);
   ParseEnumSet<Context>(value, "contexts", &contexts_,
                         g_mappings.Get().contexts);
   ParseEnum<Location>(value, "location", &location_,
                       g_mappings.Get().locations);
   ParseEnum<Platform>(value, "platform", &platform_,
                       g_mappings.Get().platforms);
   value->GetInteger("min_manifest_version", &min_manifest_version_);
@@ skipping 48 matching lines @@
 
   if (channel_ <  Feature::GetCurrentChannel())
     return CreateAvailability(UNSUPPORTED_CHANNEL, type);
 
   return CreateAvailability(IS_AVAILABLE, type);
 }
 
 Feature::Availability SimpleFeature::IsAvailableToContext(
     const Extension* extension,
     SimpleFeature::Context context,
+    const GURL& url,
     SimpleFeature::Platform platform) const {
-  Availability result = IsAvailableToManifest(
-      extension->id(),
-      extension->GetType(),
-      ConvertLocation(extension->location()),
-      extension->manifest_version(),
-      platform);
-  if (!result.is_available())
-    return result;
+  if (extension) {
+    Availability result = IsAvailableToManifest(
+        extension->id(),
+        extension->GetType(),
+        ConvertLocation(extension->location()),
+        extension->manifest_version(),
+        platform);
+    if (!result.is_available())
+      return result;
+  }
 
-  if (!contexts_.empty() &&
-      contexts_.find(context) == contexts_.end()) {
-    return CreateAvailability(INVALID_CONTEXT, extension->GetType());
+  if (!contexts_.empty() && contexts_.find(context) == contexts_.end()) {
+    return extension ?
+        CreateAvailability(INVALID_CONTEXT, extension->GetType()) :
+        CreateAvailability(INVALID_CONTEXT);
   }
 
+  if (!matches_.is_empty() && !matches_.MatchesURL(url))
+    return CreateAvailability(INVALID_URL, url);
+
   return CreateAvailability(IS_AVAILABLE);
 }
 
 std::string SimpleFeature::GetAvailabilityMessage(
-    AvailabilityResult result, Manifest::Type type) const {
+    AvailabilityResult result, Manifest::Type type, const GURL& url) const {
   switch (result) {
     case IS_AVAILABLE:
       return "";
     case NOT_FOUND_IN_WHITELIST:
       return base::StringPrintf(
           "'%s' is not allowed for specified extension ID.",
           name().c_str());
+    case INVALID_URL:

[not at google - send to devlin, 2013/03/22 22:10:12]

CHECK(url..)?

[cduvall, 2013/03/22 22:52:29]

Done.

+      return base::StringPrintf("'%s' is not allowed on %s.",
+                                name().c_str(), url.spec().c_str());
     case INVALID_TYPE: {
       std::string allowed_type_names;
       // Turn the set of allowed types into a vector so that it's easier to
       // inject the appropriate separator into the display string.
       std::vector<Manifest::Type> extension_types(
           extension_types_.begin(), extension_types_.end());
       for (size_t i = 0; i < extension_types.size(); i++) {
         // Pluralize type name.
         allowed_type_names += GetDisplayTypeName(extension_types[i]) + "s";
         if (i == extension_types_.size() - 2) {
@@ skipping 45 matching lines @@
           GetChannelName(GetCurrentChannel()).c_str());
   }
 
   NOTREACHED();
   return "";
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result) const {
   return Availability(
-      result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN));
+      result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL()));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result, Manifest::Type type) const {
-  return Availability(result, GetAvailabilityMessage(result, type));
+  return Availability(result, GetAvailabilityMessage(result, type, GURL()));
+}
+
+Feature::Availability SimpleFeature::CreateAvailability(
+    AvailabilityResult result,
+    const GURL& url) const {
+  return Availability(
+      result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, url));
 }
 
 std::set<Feature::Context>* SimpleFeature::GetContexts() {
   return &contexts_;
 }
 
 bool SimpleFeature::IsIdInWhitelist(const std::string& extension_id) const {
   // An empty whitelist means the absence of a whitelist, rather than a
   // whitelist that allows no ID through. This could be surprising behavior, so
   // we force the caller to handle it explicitly. A DCHECK should be sufficient
@@ skipping 19 matching lines @@
   DCHECK(id_hash.length() == base::kSHA1Length);
   const std::string hexencoded_id_hash = base::HexEncode(id_hash.c_str(),
       id_hash.length());
   if (whitelist_.find(hexencoded_id_hash) != whitelist_.end())
     return true;
 
   return false;
 }
 
 }  // namespace extensions