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),
+    channel_has_been_set_(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_),
+      channel_has_been_set_(other.channel_has_been_set_) {
 }
 
 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_ &&
+      channel_has_been_set_ == other.channel_has_been_set_;
 }
 
 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);
+
+  // The "trunk" channel uses VersionInfo::CHANNEL_UNKNOWN, so we need to keep
+  // track of whether the channel has been set or not separately.
+  channel_has_been_set_ |= value->HasKey("channel");
+  if (!channel_has_been_set_ && dependencies_.empty())
+    return name() + ": Must supply a value for channel or dependencies.";

[not at google - send to devlin, 2013/06/12 22:34:18]

Maybe we should assert that Parse can only be called once, then we wouldn't need
this check and we can just use "value->HasKey('channel') ||
dependencies_.empty()".

In fact it looks like Parse only ever gets set once, so we could make Parse and
the constructor private then add a Create method (I guess you'd need to make the
FeatureFactory stuff return a scoped_ptr<Feature> rather than a Feature, and use
whether Create returns NULL as a signal to whether it succeeded).

[cduvall, 2013/06/13 01:02:28]

Parse is actually called multiple times on the same Feature to inherit the
parent properties. See base_feature_provider.cc when it goes through the stack
of parent features. Do we want to implement this a different way so that Parse
is only called once?

+
   if (matches_.is_empty() && contexts_.count(WEB_PAGE_CONTEXT) != 0) {
     return name() + ": Allowing web_page contexts requires supplying a value " +
         "for matches.";
   }
+
   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 (channel_has_been_set_ && 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 {
@@ 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_;
+}
+
+void SimpleFeature::SetHasParent(bool has_parent) {
+  has_parent_ = 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