Lazily load API schemas from resource files and convert all APIs to features

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 123 matching lines @@
     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)) {
+    set->ClearPatterns();
     for (size_t i = 0; i < matches->GetSize(); ++i) {
       std::string pattern;
       CHECK(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) {
@@ skipping 26 matching lines @@
   return base::HexEncode(id_hash.c_str(), id_hash.length());
 }
 
 }  // namespace
 
 SimpleFeature::SimpleFeature()
   : location_(UNSPECIFIED_LOCATION),
     platform_(UNSPECIFIED_PLATFORM),
     min_manifest_version_(0),
     max_manifest_version_(0),
-    channel_(VersionInfo::CHANNEL_UNKNOWN) {
+    channel_(VersionInfo::CHANNEL_UNKNOWN),
+    has_parent_(false) {
 }
 
 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_) {
+      channel_(other.channel_),
+      has_parent_(other.has_parent_) {
 }
 
 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_;
+      channel_ == other.channel_ &&
+      has_parent_ == other.has_parent_;
 }
 
 std::string SimpleFeature::Parse(const DictionaryValue* value) {
   ParseURLPatterns(value, "matches", &matches_);
   ParseSet(value, "whitelist", &whitelist_);
   ParseSet(value, "dependencies", &dependencies_);
   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_);
   value->GetInteger("max_manifest_version", &max_manifest_version_);
   ParseEnum<VersionInfo::Channel>(
       value, "channel", &channel_,
       g_mappings.Get().channels);
   if (matches_.is_empty() && contexts_.count(WEB_PAGE_CONTEXT) != 0) {
     return name() + ": Allowing web_page contexts requires supplying a value " +
         "for matches.";
   }
+  has_parent_ = value->HasKey("parent");
   return std::string();
 }
 
 Feature::Availability SimpleFeature::IsAvailableToManifest(
     const std::string& extension_id,
     Manifest::Type type,
     Location location,
     int manifest_version,
     Platform platform) const {
   // Component extensions can access any feature.
@@ skipping 30 matching lines @@
 
   if (platform_ != UNSPECIFIED_PLATFORM && platform_ != platform)
     return CreateAvailability(INVALID_PLATFORM, type);
 
   if (min_manifest_version_ != 0 && manifest_version < min_manifest_version_)
     return CreateAvailability(INVALID_MIN_MANIFEST_VERSION, type);
 
   if (max_manifest_version_ != 0 && manifest_version > max_manifest_version_)
     return CreateAvailability(INVALID_MAX_MANIFEST_VERSION, type);
 
-  if (channel_ <  Feature::GetCurrentChannel())
+  if (dependencies_.empty() && channel_ <  Feature::GetCurrentChannel())

[not at google - send to devlin, 2013/05/24 19:09:18]

why this change? if we're merging in our parent's feature data then... well I
don't really know what it achieves.

[cduvall, 2013/05/30 00:50:51]

This is different than the parent features. This is so if this feature has any
dependencies (like manifest:... or permission:...), the channel will be used
from there. This allows the channel to not be specified on APIs with
dependencies. Otherwise, the channel defaults to "dev" I believe.

[not at google - send to devlin, 2013/05/30 16:38:51]

Oh ok. I think I made a comment like this earlier - we should ensure that either
there is a channel specified or there are dependencies. Not default to some
channel. That might be a change in assumptions? Tests would probably need
updating in any case. But that check can be done on construction (parsing) of
the feature though, it doesn't need to be on every call to
IsAvailableToManifest.

[cduvall, 2013/06/12 01:22:19]

Done.

     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 {
@@ skipping 114 matching lines @@
 
 std::set<Feature::Context>* SimpleFeature::GetContexts() {
   return &contexts_;
 }
 
 bool SimpleFeature::IsInternal() const {
   NOTREACHED();
   return false;
 }
 
+bool SimpleFeature::HasParent() const {
+  return has_parent_;
+}
+
 bool SimpleFeature::IsIdInWhitelist(const std::string& extension_id) const {
   // Belt-and-suspenders philosophy here. We should be pretty confident by this
   // point that we've validated the extension ID format, but in case something
   // slips through, we avoid a class of attack where creative ID manipulation
   // leads to hash collisions.
   if (extension_id.length() != 32)  // 128 bits / 4 = 32 mpdecimal characters
     return false;
 
   if (whitelist_.find(extension_id) != whitelist_.end() ||
       whitelist_.find(HashExtensionId(extension_id)) != whitelist_.end())
     return true;
 
   return false;
 }
 
 }  // namespace extensions