Implement ComplexFeature to support permission features with multiple rules.

chrome/common/extensions/api/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 "chrome/common/extensions/api/extension_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/features/simple_feature.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 namespace {
 
 class TestFeatureProvider : public FeatureProvider {
  public:
   explicit TestFeatureProvider(Feature::Context context)
       : context_(context) {
   }
 
   virtual Feature* GetFeature(const std::string& name) OVERRIDE {
-    Feature* result = new Feature();
+    SimpleFeature* result = new SimpleFeature();
     result->set_name(name);
     result->extension_types()->insert(Extension::TYPE_EXTENSION);
-    result->contexts()->insert(context_);
+    result->GetContexts()->insert(context_);
     to_destroy_.push_back(make_linked_ptr(result));
     return result;
   }
 
  private:
   std::vector<linked_ptr<Feature> > to_destroy_;
   Feature::Context context_;
 };
 
 TEST(ExtensionAPI, Creation) {
@@ skipping 300 matching lines @@
     std::string api_name = api->GetAPINameFromFullName(test_data[i].input,
                                                        &child_name);
     EXPECT_EQ(test_data[i].api_name, api_name) << test_data[i].input;
     EXPECT_EQ(test_data[i].child_name, child_name) << test_data[i].input;
   }
 }
 
 TEST(ExtensionAPI, DefaultConfigurationFeatures) {
   scoped_ptr<ExtensionAPI> api(ExtensionAPI::CreateWithDefaultConfiguration());
 
-  Feature* bookmarks = api->GetFeature("bookmarks");
-  Feature* bookmarks_create = api->GetFeature("bookmarks.create");
+  SimpleFeature* bookmarks =
+      static_cast<SimpleFeature*>(api->GetFeature("bookmarks"));
+  SimpleFeature* bookmarks_create =
+      static_cast<SimpleFeature*>(api->GetFeature("bookmarks.create"));
 
   struct {
-    Feature* feature;
+    SimpleFeature* feature;
     // TODO(aa): More stuff to test over time.
   } test_data[] = {
     { bookmarks },
     { bookmarks_create }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
-    Feature* feature = test_data[i].feature;
+    SimpleFeature* feature = test_data[i].feature;
     ASSERT_TRUE(feature) << i;
 
     EXPECT_TRUE(feature->whitelist()->empty());
     EXPECT_TRUE(feature->extension_types()->empty());
 
-    EXPECT_EQ(1u, feature->contexts()->size());
-    EXPECT_TRUE(feature->contexts()->count(
+    EXPECT_EQ(1u, feature->GetContexts()->size());
+    EXPECT_TRUE(feature->GetContexts()->count(
         Feature::BLESSED_EXTENSION_CONTEXT));
 
     EXPECT_EQ(Feature::UNSPECIFIED_LOCATION, feature->location());
     EXPECT_EQ(Feature::UNSPECIFIED_PLATFORM, feature->platform());
     EXPECT_EQ(0, feature->min_manifest_version());
     EXPECT_EQ(0, feature->max_manifest_version());
   }
 }
 
 TEST(ExtensionAPI, FeaturesRequireContexts) {
@@ skipping 94 matching lines @@
   GetDictionaryFromList(dict, "parameters", 0, &sub_dict);
   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
   EXPECT_EQ("test.foo.TestType", type);
   GetDictionaryFromList(dict, "parameters", 1, &sub_dict);
   EXPECT_TRUE(sub_dict->GetString("$ref", &type));
   EXPECT_EQ("fully.qualified.Type", type);
 }
 
 }  // namespace
 }  // namespace extensions