[Extensions] Break up BaseFeatureProvider, create JSONFeatureProvider

chrome/common/extensions/api/common_extension_api_unittest.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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/features/api_feature.h"
-#include "extensions/common/features/base_feature_provider.h"
+#include "extensions/common/features/json_feature_provider.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/test_util.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 using test_util::BuildExtension;
@@ skipping 132 matching lines @@
       .AppendASCII("extension_api_unittest")
       .AppendASCII("api_features.json");
 
   std::string api_features_str;
   ASSERT_TRUE(base::ReadFileToString(
       api_features_path, &api_features_str)) << "api_features.json";
 
   std::unique_ptr<base::DictionaryValue> value(
       static_cast<base::DictionaryValue*>(
           base::JSONReader::Read(api_features_str).release()));
-  BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
+  JSONFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
          iter.Advance()) {
       if (iter.key().find(".") == std::string::npos)
         api.RegisterSchemaResource(iter.key(), 0);
     }
 
@@ skipping 73 matching lines @@
       .AppendASCII("extension_api_unittest")
       .AppendASCII("api_features.json");
 
   std::string api_features_str;
   ASSERT_TRUE(base::ReadFileToString(
       api_features_path, &api_features_str)) << "api_features.json";
 
   std::unique_ptr<base::DictionaryValue> value(
       static_cast<base::DictionaryValue*>(
           base::JSONReader::Read(api_features_str).release()));
-  BaseFeatureProvider api_feature_provider(*value, CreateAPIFeature);
+  JSONFeatureProvider api_feature_provider(*value, CreateAPIFeature);
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     ExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (base::DictionaryValue::Iterator iter(*value); !iter.IsAtEnd();
          iter.Advance()) {
       if (iter.key().find(".") == std::string::npos)
         api.RegisterSchemaResource(iter.key(), 0);
     }
 
@@ skipping 409 matching lines @@
 
   struct {
     base::DictionaryValue* api_features;
     bool expect_success;
   } test_data[] = {
     { api_features1.get(), true },
     { api_features2.get(), false }
   };
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
-    BaseFeatureProvider api_feature_provider(*test_data[i].api_features,
+    JSONFeatureProvider api_feature_provider(*test_data[i].api_features,
                                              CreateAPIFeature);
     Feature* feature = api_feature_provider.GetFeature("test");
     EXPECT_EQ(test_data[i].expect_success, feature != NULL) << i;
   }
 }
 
 static void GetDictionaryFromList(const base::DictionaryValue* schema,
                                   const std::string& list_name,
                                   const int list_index,
                                   const base::DictionaryValue** out) {
@@ skipping 140 matching lines @@
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("pageAction",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
 }
 
 }  // namespace extensions