[Extensions] Add extension feature generation code

extensions/common/features/simple_feature.cc

 // Copyright 2014 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 "extensions/common/features/simple_feature.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ skipping 292 matching lines @@
   std::map<std::string, Feature::Context> contexts;
   std::map<std::string, SimpleFeature::Location> locations;
   std::map<std::string, Feature::Platform> platforms;
   std::map<std::string, version_info::Channel> channels;
 };
 
 SimpleFeature::SimpleFeature()
     : location_(UNSPECIFIED_LOCATION),
       min_manifest_version_(0),
       max_manifest_version_(0),
-      component_extensions_auto_granted_(true) {}
+      component_extensions_auto_granted_(true),
+      is_internal_(false) {}
 
 SimpleFeature::~SimpleFeature() {}
 
 std::string SimpleFeature::Parse(const base::DictionaryValue* dictionary) {
   static base::LazyInstance<SimpleFeature::Mappings> mappings =
       LAZY_INSTANCE_INITIALIZER;
 
   no_parent_ = false;
   for (base::DictionaryValue::Iterator it(*dictionary);
       !it.IsAtEnd();
@@ skipping 252 matching lines @@
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result,
     version_info::Channel channel) const {
   return Availability(
       result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL(),
                                      UNSPECIFIED_CONTEXT, channel));
 }
 
 bool SimpleFeature::IsInternal() const {
-  return false;
+  return is_internal_;
 }
 
 bool SimpleFeature::IsIdInBlacklist(const std::string& extension_id) const {
   return IsIdInList(extension_id, blacklist_);
 }
 
 bool SimpleFeature::IsIdInWhitelist(const std::string& extension_id) const {
   return IsIdInList(extension_id, whitelist_);
 }
 
@@ skipping 55 matching lines @@
 // static
 bool SimpleFeature::IsValidExtensionId(const std::string& extension_id) {
   // 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.
   // 128 bits / 4 = 32 mpdecimal characters
   return (extension_id.length() == 32);
 }
 
+void SimpleFeature::set_matches(const std::vector<std::string>& matches) {
+  matches_.ClearPatterns();
+  for (const std::string& pattern : matches)
+    matches_.AddPattern(URLPattern(URLPattern::SCHEME_ALL, pattern));
+}
+
 }  // namespace extensions