Manifest handler for all keys background-related.

chrome/common/extensions/manifest_handler_unittest.cc

 // Copyright (c) 2013 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 <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_builder.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
+namespace {
+
+std::vector<std::string> SingleKey(const std::string& key) {
+  return std::vector<std::string>(1, key);
+}
+
+}  // namespace
+
 class ManifestHandlerTest : public testing::Test {
  public:
   class ParsingWatcher {
    public:
     // Called when a manifest handler parses.
     void Record(const std::string& name) {
       parsed_names_.push_back(name);
     }
 
     const std::vector<std::string>& parsed_names() {
@@ skipping 17 matching lines @@
     }
 
    private:
     // The order of manifest handlers that we watched parsing.
     std::vector<std::string> parsed_names_;
   };
 
   class TestManifestHandler : public ManifestHandler {
    public:
     TestManifestHandler(const std::string& name,
+                        const std::vector<std::string>& keys,
                         const std::vector<std::string>& prereqs,
                         ParsingWatcher* watcher)
-        : name_(name), prereqs_(prereqs), watcher_(watcher) {
+        : name_(name), keys_(keys), prereqs_(prereqs), watcher_(watcher) {
     }
 
     virtual bool Parse(Extension* extension, string16* error) OVERRIDE {
       watcher_->Record(name_);
       return true;
     }
 
-    virtual const std::vector<std::string>& PrerequisiteKeys() OVERRIDE {
+    virtual const std::vector<std::string> PrerequisiteKeys() const OVERRIDE {
       return prereqs_;
     }
 
    protected:
     std::string name_;
+    std::vector<std::string> keys_;
     std::vector<std::string> prereqs_;
     ParsingWatcher* watcher_;
+
+   private:
+    virtual const std::vector<std::string> Keys() const OVERRIDE {
+      return keys_;
+    }
   };
 
   class FailingTestManifestHandler : public TestManifestHandler {
    public:
     FailingTestManifestHandler(const std::string& name,
-                               const std::vector<std::string> prereqs,
+                               const std::vector<std::string>& keys,
+                               const std::vector<std::string>& prereqs,
                                ParsingWatcher* watcher)
-        : TestManifestHandler(name, prereqs, watcher) {
+        : TestManifestHandler(name, keys, prereqs, watcher) {
     }
     virtual bool Parse(Extension* extension, string16* error) OVERRIDE {
       *error = ASCIIToUTF16(name_);
       return false;
     }
   };
 
   class AlwaysParseTestManifestHandler : public TestManifestHandler {
    public:
     AlwaysParseTestManifestHandler(const std::string& name,
-                                   const std::vector<std::string> prereqs,
+                                   const std::vector<std::string>& keys,
+                                   const std::vector<std::string>& prereqs,
                                    ParsingWatcher* watcher)
-        : TestManifestHandler(name, prereqs, watcher) {
+        : TestManifestHandler(name, keys, prereqs, watcher) {
     }
 
-    virtual bool AlwaysParseForType(Manifest::Type type) OVERRIDE {
+    virtual bool AlwaysParseForType(Manifest::Type type) const OVERRIDE {
       return true;
     }
   };
 
  protected:
   virtual void TearDown() OVERRIDE {
     ManifestHandler::ClearRegistryForTesting();
   }
 };
 
 TEST_F(ManifestHandlerTest, DependentHandlers) {
   ParsingWatcher watcher;
   std::vector<std::string> prereqs;
-  ManifestHandler::Register(
-      "a", make_linked_ptr(new TestManifestHandler("A", prereqs, &watcher)));
-  ManifestHandler::Register(
-      "b", make_linked_ptr(new TestManifestHandler("B", prereqs, &watcher)));
-  ManifestHandler::Register(
-      "j", make_linked_ptr(new TestManifestHandler("J", prereqs, &watcher)));
-  ManifestHandler::Register(
-      "k", make_linked_ptr(
-          new AlwaysParseTestManifestHandler("K", prereqs, &watcher)));
+  (new TestManifestHandler("A", SingleKey("a"), prereqs, &watcher))->Register();
+  (new TestManifestHandler("B", SingleKey("b"), prereqs, &watcher))->Register();
+  (new TestManifestHandler("J", SingleKey("j"), prereqs, &watcher))->Register();
+  (new AlwaysParseTestManifestHandler("K", SingleKey("k"), prereqs, &watcher))->
+      Register();
   prereqs.push_back("c.d");
-  linked_ptr<TestManifestHandler> handler_c2(
-      new TestManifestHandler("C.EZ", prereqs, &watcher));
-  ManifestHandler::Register("c.e", handler_c2);
-  ManifestHandler::Register("c.z", handler_c2);
+  std::vector<std::string> keys;
+  keys.push_back("c.e");
+  keys.push_back("c.z");
+  (new TestManifestHandler("C.EZ", keys, prereqs, &watcher))->Register();
   prereqs.clear();
   prereqs.push_back("b");
   prereqs.push_back("k");
-  ManifestHandler::Register(
-      "c.d", make_linked_ptr(new TestManifestHandler(
-          "C.D", prereqs, &watcher)));
+  (new TestManifestHandler("C.D", SingleKey("c.d"), prereqs, &watcher))->
+      Register();
 
   scoped_refptr<Extension> extension = ExtensionBuilder()
       .SetManifest(DictionaryBuilder()
                    .Set("name", "no name")
                    .Set("version", "0")
                    .Set("manifest_version", 2)
                    .Set("a", 1)
                    .Set("b", 2)
                    .Set("c", DictionaryBuilder()
                         .Set("d", 3)
@@ skipping 25 matching lines @@
   scoped_refptr<Extension> extension = Extension::Create(
       base::FilePath(),
       Manifest::INVALID_LOCATION,
       *manifest_a,
       Extension::NO_FLAGS,
       &error);
   EXPECT_TRUE(extension);
 
   // Register a handler for "a" that fails.
   ParsingWatcher watcher;
-  ManifestHandler::Register(
-      "a", make_linked_ptr(new FailingTestManifestHandler(
-          "A", std::vector<std::string>(), &watcher)));
+  (new FailingTestManifestHandler(
+      "A", SingleKey("a"), std::vector<std::string>(), &watcher))->Register();
 
   extension = Extension::Create(
       base::FilePath(),
       Manifest::INVALID_LOCATION,
       *manifest_a,
       Extension::NO_FLAGS,
       &error);
   EXPECT_FALSE(extension);
   EXPECT_EQ("A", error);
 }
 
 }  // namespace extensions