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 b702d6266b3916ada73dd0d9d77100c2468814be..a70999459ffc5fc9c4c25326eb3df3b37b3c6ac8 100644
--- a/chrome/common/extensions/features/base_feature_provider.cc
+++ b/chrome/common/extensions/features/base_feature_provider.cc
@@ -22,25 +22,29 @@ 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)) {
+struct LazyFeatureProvider : public FeatureProvider {

[not at google - send to devlin, 2013/04/10 02:06:22]

I don't think this needs to be a struct. The member variables should be private
(and be name_, factory_, etc too).

[cduvall, 2013/04/10 02:26:12]

Done.

+  LazyFeatureProvider(const std::string& name_,
+                      BaseFeatureProvider::FeatureFactory factory_,
+                      int resource_id_)
+      : name(name_),
+        factory(factory_),
+        resource_id(resource_id_) {
+  }
+
+  BaseFeatureProvider* GetBaseFeatureProvider() {
+    if (!features)
+      features.reset(LoadProvider(name, factory, resource_id).release());

[not at google - send to devlin, 2013/04/10 02:06:22]

shouldn't need the release/reset here. features = LoadProvider(...) should work.

[cduvall, 2013/04/10 02:26:12]

Done.

+    return features.get();
   }
 
-  scoped_ptr<BaseFeatureProvider> api_features;
-  scoped_ptr<BaseFeatureProvider> manifest_features;
-  scoped_ptr<BaseFeatureProvider> permission_features;
+  virtual Feature* GetFeature(const std::string& name) {
+    return GetBaseFeatureProvider()->GetFeature(name);
+  }
+
+  std::string name;
+  BaseFeatureProvider::FeatureFactory factory;
+  int resource_id;
+  scoped_ptr<BaseFeatureProvider> features;
 
  private:
   scoped_ptr<BaseFeatureProvider> LoadProvider(
@@ -69,6 +73,38 @@ struct Static {
   }
 };
 
+struct Static {
+  Static() {
+    lazy_feature_providers["api"] = linked_ptr<LazyFeatureProvider>(

[not at google - send to devlin, 2013/04/10 02:06:22]

make_linked_ptr?

[cduvall, 2013/04/10 02:26:12]

Done.

+        new LazyFeatureProvider("api",
+                                &CreateFeature<APIFeature>,
+                                IDR_EXTENSION_API_FEATURES));
+    lazy_feature_providers["permission"] = linked_ptr<LazyFeatureProvider>(
+        new LazyFeatureProvider("permission",
+                                &CreateFeature<PermissionFeature>,
+                                IDR_EXTENSION_PERMISSION_FEATURES));
+    lazy_feature_providers["manifest"] = linked_ptr<LazyFeatureProvider>(
+        new LazyFeatureProvider("manifest",
+                                &CreateFeature<ManifestFeature>,
+                                IDR_EXTENSION_MANIFEST_FEATURES));
+  }
+
+  LazyFeatureProvider* LazyGetFeatures(const std::string& name) {
+    CHECK(lazy_feature_providers.count(name) > 0);
+    return lazy_feature_providers[name].get();

[not at google - send to devlin, 2013/04/10 02:06:22]

use find, it = lazy_feature_providers.find(..); CHECK(it != end()); return
it->second;

[cduvall, 2013/04/10 02:26:12]

Done.

+  }
+
+  BaseFeatureProvider* GetFeatures(const std::string& name) {
+    return LazyGetFeatures(name)->GetBaseFeatureProvider();
+  }
+
+  typedef std::map<std::string, linked_ptr<LazyFeatureProvider> >
+      LazyFeatureProviderMap;
+  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,18 +171,15 @@ BaseFeatureProvider::~BaseFeatureProvider() {
 }
 
 // static
-BaseFeatureProvider* BaseFeatureProvider::GetAPIFeatures() {
-  return g_static.Get().api_features.get();
-}
-
-// static
-BaseFeatureProvider* BaseFeatureProvider::GetManifestFeatures() {
-  return g_static.Get().manifest_features.get();
+BaseFeatureProvider* BaseFeatureProvider::GetFeaturesByName(
+    const std::string& name) {
+  return g_static.Get().GetFeatures(name);
 }
 
 // static
-BaseFeatureProvider* BaseFeatureProvider::GetPermissionFeatures() {
-  return g_static.Get().permission_features.get();
+FeatureProvider* BaseFeatureProvider::LazyGetFeaturesByName(
+    const std::string& name) {
+  return g_static.Get().LazyGetFeatures(name);
 }
 
 std::set<std::string> BaseFeatureProvider::GetAllFeatureNames() const {