Revert 190836 "Implement API features for the Extension API feat..."

trunk/src/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"
 #include "chrome/common/extensions/features/manifest_feature.h"
 #include "chrome/common/extensions/features/permission_feature.h"
 #include "grit/common_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace extensions {
 
 namespace {
 
 template<class FeatureClass>
 SimpleFeature* CreateFeature() {
   return new FeatureClass();
 }
 
 struct Static {
   Static()
-      : api_features(
-            LoadProvider("api",
-                         &CreateFeature<APIFeature>,
-                         IDR_EXTENSION_API_FEATURES)),
-        manifest_features(
+      : manifest_features(
             LoadProvider("manifest",
                          &CreateFeature<ManifestFeature>,
                          IDR_EXTENSION_MANIFEST_FEATURES)),
         permission_features(
             LoadProvider("permissions",
                          &CreateFeature<PermissionFeature>,
                          IDR_EXTENSION_PERMISSION_FEATURES)) {
   }
 
-  scoped_ptr<BaseFeatureProvider> api_features;
   scoped_ptr<BaseFeatureProvider> manifest_features;
   scoped_ptr<BaseFeatureProvider> permission_features;
 
  private:
   scoped_ptr<BaseFeatureProvider> LoadProvider(
       const std::string& debug_string,
       BaseFeatureProvider::FeatureFactory factory,
       int resource_id) {
     const std::string& features_file =
         ResourceBundle::GetSharedInstance().GetRawDataResource(
@@ skipping 14 matching lines @@
       value_as_dict.reset(new DictionaryValue());
     }
     return make_scoped_ptr(new BaseFeatureProvider(*value_as_dict, factory));
   }
 };
 
 bool ParseFeature(const DictionaryValue* value,
                   const std::string& name,
                   SimpleFeature* feature) {
   feature->set_name(name);
-  std::string error = feature->Parse(value);
-  if (!error.empty())
-    LOG(ERROR) << error;
-  return error.empty();
+  feature->Parse(value);
+
+  if (feature->extension_types()->empty()) {
+    LOG(ERROR) << name << ": Simple features must specify at least one "
+               << "value for extension_types.";
+    return false;
+  }
+
+  if (!feature->GetContexts()->empty()) {
+    LOG(ERROR) << name << ": Simple features do not support contexts.";
+    return false;
+  }
+
+  return true;
 }
 
 base::LazyInstance<Static> g_static = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BaseFeatureProvider::BaseFeatureProvider(const DictionaryValue& root,
                                          FeatureFactory factory)
     : factory_(factory ? factory :
                static_cast<FeatureFactory>(&CreateFeature<SimpleFeature>)) {
@@ skipping 40 matching lines @@
       LOG(ERROR) << iter.key() << ": Feature description must be dictionary or"
                  << " list of dictionaries.";
     }
   }
 }
 
 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();
 }
 
 std::set<std::string> BaseFeatureProvider::GetAllFeatureNames() const {
   std::set<std::string> result;
   for (FeatureMap::const_iterator iter = features_.begin();
        iter != features_.end(); ++iter) {
     result.insert(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