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

chrome/common/extensions/features/base_feature_provider.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/base_feature_provider.h"
 
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "chrome/common/extensions/features/api_feature.h"
 #include "chrome/common/extensions/features/complex_feature.h"
@@ skipping 18 matching lines @@
                       int resource_id)
       : name_(name),
         factory_(factory),
         resource_id_(resource_id) {
   }
 
   virtual Feature* GetFeature(const std::string& name) OVERRIDE {
     return GetBaseFeatureProvider()->GetFeature(name);
   }
 
-  virtual std::set<std::string> GetAllFeatureNames() OVERRIDE {
+  virtual std::vector<std::string> GetAllFeatureNames() OVERRIDE {
     return GetBaseFeatureProvider()->GetAllFeatureNames();
   }
 
+  virtual std::vector<std::string> GetAllTopLevelFeatureNames() OVERRIDE {
+    return GetBaseFeatureProvider()->GetAllTopLevelFeatureNames();
+  }
+
  private:
   BaseFeatureProvider* GetBaseFeatureProvider() {
     if (!features_)
       features_ = LoadProvider();
     return features_.get();
   }
 
   scoped_ptr<BaseFeatureProvider> LoadProvider() {
     const std::string& features_file =
         ResourceBundle::GetSharedInstance().GetRawDataResource(
@@ skipping 47 matching lines @@
     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) {

[not at google - send to devlin, 2013/05/23 00:09:40]

perhaps:

std::string error;
std::string parent_name;
if (value->GetString("parent", &parent_name)) {
  const DictionaryValue* parent = NULL;
  // I guess we assume it's not a complex feature.
  CHECK(root->GetDictionaryWithoutPathExpansion(parent_name, &parent));
  scoped_ptr<DictionaryValue> value_with_parent(value->DeepCopy());
  value_with_parent->MergeDictionary(parent);
  error = feature->Parse(value_with_parent.get());
} else {
  error = feature->Parse(value);
}
feature->set_name(name);
if (!error.empty())
  LOG(ERROR) << error;
return error.empty();


something along those lines.

I guess you wouldn't be able to namespace the parent features, but that's nbd.
It'd just make a lot of this other code simpler.

[cduvall, 2013/05/24 03:13:49]

Done.

   feature->set_name(name);
   std::string error = feature->Parse(value);
   if (!error.empty())
     LOG(ERROR) << error;
   return error.empty();
 }
 
+bool ParseFeature(const DictionaryValue* value,
+                  SimpleFeature* feature) {
+  std::string error = feature->Parse(value);
+  if (!error.empty())
+    LOG(ERROR) << error;
+  return error.empty();
+}
+
+bool MaybeParseParentFeature(const DictionaryValue& root,
+                             const DictionaryValue* feature_dict,
+                             SimpleFeature* feature) {
+  std::string parent;
+  const DictionaryValue* value;
+  if (!feature_dict->GetString("parent", &parent))
+    return true;
+  if (!root.GetDictionary(parent, &value))
+    return false;
+  return ParseFeature(value, feature);
+}
+
 }  // namespace
 
 BaseFeatureProvider::BaseFeatureProvider(const DictionaryValue& root,
                                          FeatureFactory factory)
     : factory_(factory ? factory :
                static_cast<FeatureFactory>(&CreateFeature<SimpleFeature>)) {
   for (DictionaryValue::Iterator iter(root); !iter.IsAtEnd(); iter.Advance()) {
     if (iter.value().GetType() == Value::TYPE_DICTIONARY) {
       linked_ptr<SimpleFeature> feature((*factory_)());
 
-      if (!ParseFeature(static_cast<const DictionaryValue*>(&iter.value()),
-                        iter.key(),
-                        feature.get()))
+      const DictionaryValue* feature_dict =
+          static_cast<const DictionaryValue*>(&iter.value());

[not at google - send to devlin, 2013/05/23 00:09:40]

this could be a bit more straightforward by changing ParseFeature, commented
above.

[cduvall, 2013/05/24 03:13:49]

Done.

+      if (!MaybeParseParentFeature(root, feature_dict, feature.get()))
+        continue;
+      if (!ParseFeature(feature_dict, iter.key(), feature.get()))
         continue;
 
       features_[iter.key()] = feature;
     } else if (iter.value().GetType() == Value::TYPE_LIST) {
       // This is a complex feature.
       const ListValue* list = static_cast<const ListValue*>(&iter.value());
       CHECK_GT(list->GetSize(), 0UL);
 
       scoped_ptr<ComplexFeature::FeatureList> features(
           new ComplexFeature::FeatureList());
 
       // Parse and add all SimpleFeatures from the list.
       for (ListValue::const_iterator list_iter = list->begin();
            list_iter != list->end(); ++list_iter) {
         if ((*list_iter)->GetType() != Value::TYPE_DICTIONARY) {
           LOG(ERROR) << iter.key() << ": Feature rules must be dictionaries.";
           continue;
         }
 
+        const DictionaryValue* feature_dict =
+            static_cast<const DictionaryValue*>(*list_iter);
         scoped_ptr<SimpleFeature> feature((*factory_)());
-        if (!ParseFeature(static_cast<const DictionaryValue*>(*list_iter),
-                          iter.key(),
-                          feature.get()))
+        if (!MaybeParseParentFeature(root, feature_dict, feature.get()))
+          continue;
+        if (!ParseFeature(feature_dict, iter.key(), feature.get()))
           continue;
 
         features->push_back(feature.release());
       }
 
       linked_ptr<ComplexFeature> feature(new ComplexFeature(features.Pass()));
       feature->set_name(iter.key());
 
       features_[iter.key()] = feature;
     } else {
       LOG(ERROR) << iter.key() << ": Feature description must be dictionary or"
                  << " list of dictionaries.";
     }
   }
 }
 
 BaseFeatureProvider::~BaseFeatureProvider() {
 }
 
 // static
 FeatureProvider* BaseFeatureProvider::GetByName(
     const std::string& name) {
   return g_static.Get().LazyGetFeatures(name);
 }
 
-std::set<std::string> BaseFeatureProvider::GetAllFeatureNames() {
-  std::set<std::string> result;
+std::vector<std::string> BaseFeatureProvider::GetAllTopLevelFeatureNames() {
+  std::vector<std::string> result;
   for (FeatureMap::const_iterator iter = features_.begin();
        iter != features_.end(); ++iter) {
-    result.insert(iter->first);
+    if (!iter->second->HasParent())
+      result.push_back(iter->first);
   }
   return result;
 }
+
+std::vector<std::string> BaseFeatureProvider::GetAllFeatureNames() {
+  std::vector<std::string> result;
+  for (FeatureMap::const_iterator iter = features_.begin();
+       iter != features_.end(); ++iter) {
+    result.push_back(iter->first);
+  }
+  return result;
+}
 
 Feature* BaseFeatureProvider::GetFeature(const std::string& name) {
   FeatureMap::iterator iter = features_.find(name);
   if (iter != features_.end())
     return iter->second.get();
   else
     return NULL;
 }
 
 }  // namespace