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 "testing/gtest/include/gtest/gtest.h"
 
+using extensions::Feature;

[not at google - send to devlin, 2012/12/12 17:42:41]

this file is in the extensions namespace, this shouldn't be necessary

[justinlin, 2012/12/14 12:26:26]

Done.

+
 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();
+  virtual SimpleFeature* GetFeature(const std::string& name) OVERRIDE {

[not at google - send to devlin, 2012/12/12 17:42:41]

Feature etc

[justinlin, 2012/12/14 12:26:26]

I changed the method signature, but I think the others should stay
SimpleFeature. Otherwise, I'd have to expose a lot of accessors/mutators in
Feature, which I don't think makes sense.

This unit test file is really just to test SimpleFeature anyway.

+    SimpleFeature* result = new SimpleFeature();
     result->set_name(name);
     result->extension_types()->insert(Extension::TYPE_EXTENSION);
     result->contexts()->insert(context_);
     to_destroy_.push_back(make_linked_ptr(result));
     return result;
   }
 
  private:
   std::vector<linked_ptr<Feature> > to_destroy_;
   Feature::Context context_;
@@ skipping 303 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 = api->GetFeature("bookmarks");
+  SimpleFeature* bookmarks_create = 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(
         Feature::BLESSED_EXTENSION_CONTEXT));
 
     EXPECT_EQ(Feature::UNSPECIFIED_LOCATION, feature->location());
@@ skipping 101 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