Load extensions features file separately when needed

chrome/common/extensions/features/base_feature_provider.cc

Index: chrome/common/extensions/features/base_feature_provider.cc
diff --git a/chrome/common/extensions/features/base_feature_provider.cc b/chrome/common/extensions/features/base_feature_provider.cc
index 45c564f237daac9b91377226290b09d6145b9a73..506e1b6e7a569758b9c7ec4b71371584d041a70f 100644
--- a/chrome/common/extensions/features/base_feature_provider.cc
+++ b/chrome/common/extensions/features/base_feature_provider.cc
@@ -22,53 +22,89 @@ SimpleFeature* CreateFeature() {
   return new FeatureClass();
 }
 
-struct Static {
-  Static()
-      : api_features(
-            LoadProvider("api",
-                         &CreateFeature<APIFeature>,
-                         IDR_EXTENSION_API_FEATURES)),
-        manifest_features(
-            LoadProvider("manifest",
-                         &CreateFeature<ManifestFeature>,
-                         IDR_EXTENSION_MANIFEST_FEATURES)),
-        permission_features(
-            LoadProvider("permissions",
-                         &CreateFeature<PermissionFeature>,
-                         IDR_EXTENSION_PERMISSION_FEATURES)) {
+class LazyFeatureProvider : public FeatureProvider {
+ public:
+  LazyFeatureProvider(const std::string& name,
+                      BaseFeatureProvider::FeatureFactory factory,
+                      int resource_id)
+      : name_(name),
+        factory_(factory),
+        resource_id_(resource_id) {
+  }
+
+  virtual Feature* GetFeature(const std::string& name) {
+    return GetBaseFeatureProvider()->GetFeature(name);
   }
 
-  scoped_ptr<BaseFeatureProvider> api_features;
-  scoped_ptr<BaseFeatureProvider> manifest_features;
-  scoped_ptr<BaseFeatureProvider> permission_features;
+  virtual std::set<std::string> GetAllFeatureNames() {
+    return GetBaseFeatureProvider()->GetAllFeatureNames();
+  }
 
  private:
-  scoped_ptr<BaseFeatureProvider> LoadProvider(
-      const std::string& debug_string,
-      BaseFeatureProvider::FeatureFactory factory,
-      int resource_id) {
+  BaseFeatureProvider* GetBaseFeatureProvider() {
+    if (!features_)
+      features_ = LoadProvider();
+    return features_.get();
+  }
+
+  scoped_ptr<BaseFeatureProvider> LoadProvider() {
     const std::string& features_file =
         ResourceBundle::GetSharedInstance().GetRawDataResource(
-            resource_id).as_string();
+            resource_id_).as_string();
     int error_code = 0;
     std::string error_message;
     scoped_ptr<Value> value(base::JSONReader::ReadAndReturnError(
         features_file, base::JSON_PARSE_RFC,
         &error_code, &error_message));
-    DCHECK(value) << "Could not load features: " << debug_string << " "
-                  << error_message;
+    DCHECK(value) << "Could not load features: " << name_ << " "
+        << error_message;
     scoped_ptr<DictionaryValue> value_as_dict;
     if (value) {
-      CHECK(value->IsType(Value::TYPE_DICTIONARY)) << debug_string;
+      CHECK(value->IsType(Value::TYPE_DICTIONARY)) << name_;
       value_as_dict.reset(static_cast<DictionaryValue*>(value.release()));
     } else {
       // http://crbug.com/176381
       value_as_dict.reset(new DictionaryValue());
     }
-    return make_scoped_ptr(new BaseFeatureProvider(*value_as_dict, factory));
+    return make_scoped_ptr(new BaseFeatureProvider(*value_as_dict, factory_));
   }
+
+  std::string name_;
+  BaseFeatureProvider::FeatureFactory factory_;
+  int resource_id_;
+  scoped_ptr<BaseFeatureProvider> features_;
 };
 
+struct Static {
+  Static() {
+    lazy_feature_providers["api"] = make_linked_ptr(
+        new LazyFeatureProvider("api",
+                                &CreateFeature<APIFeature>,
+                                IDR_EXTENSION_API_FEATURES));
+    lazy_feature_providers["permission"] = make_linked_ptr(
+        new LazyFeatureProvider("permission",
+                                &CreateFeature<PermissionFeature>,
+                                IDR_EXTENSION_PERMISSION_FEATURES));
+    lazy_feature_providers["manifest"] = make_linked_ptr(
+        new LazyFeatureProvider("manifest",
+                                &CreateFeature<ManifestFeature>,
+                                IDR_EXTENSION_MANIFEST_FEATURES));
+  }
+
+  typedef std::map<std::string, linked_ptr<LazyFeatureProvider> >
+      LazyFeatureProviderMap;
+
+  LazyFeatureProvider* LazyGetFeatures(const std::string& name) {
+    LazyFeatureProviderMap::iterator it = lazy_feature_providers.find(name);
+    CHECK(it != lazy_feature_providers.end());
+    return it->second.get();
+  }
+
+  LazyFeatureProviderMap lazy_feature_providers;
+};
+
+base::LazyInstance<Static> g_static = LAZY_INSTANCE_INITIALIZER;
+
 bool ParseFeature(const DictionaryValue* value,
                   const std::string& name,
                   SimpleFeature* feature) {
@@ -79,8 +115,6 @@ bool ParseFeature(const DictionaryValue* value,
   return error.empty();
 }
 
-base::LazyInstance<Static> g_static = LAZY_INSTANCE_INITIALIZER;
-
 }  // namespace
 
 BaseFeatureProvider::BaseFeatureProvider(const DictionaryValue& root,
@@ -137,21 +171,12 @@ BaseFeatureProvider::~BaseFeatureProvider() {
 }
 
 // static
-BaseFeatureProvider* BaseFeatureProvider::GetAPIFeatures() {
-  return g_static.Get().api_features.get();
-}
-
-// static
-BaseFeatureProvider* BaseFeatureProvider::GetManifestFeatures() {
-  return g_static.Get().manifest_features.get();
-}
-
-// static
-BaseFeatureProvider* BaseFeatureProvider::GetPermissionFeatures() {
-  return g_static.Get().permission_features.get();
+FeatureProvider* BaseFeatureProvider::GetByName(
+    const std::string& name) {
+  return g_static.Get().LazyGetFeatures(name);
 }
 
-std::set<std::string> BaseFeatureProvider::GetAllFeatureNames() const {
+std::set<std::string> BaseFeatureProvider::GetAllFeatureNames() {
   std::set<std::string> result;
   for (FeatureMap::const_iterator iter = features_.begin();
        iter != features_.end(); ++iter) {