Manifest handler for all keys background-related.

chrome/common/extensions/manifest_handler.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 "chrome/common/extensions/manifest_handler.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/linked_ptr.h"
 #include "base/stl_util.h"
 #include "chrome/common/extensions/manifest.h"
 
 namespace extensions {
 
 namespace {
 
 class ManifestHandlerRegistry {
  public:
   ManifestHandlerRegistry() : is_sorted_(false) {
@@ skipping 108 matching lines @@
   // circular dependencies.
   CHECK(unsorted_handlers.size() == 0) << "Extension manifest handlers have "
                                        << "circular dependencies!";
 
   is_sorted_ = true;
 }
 
 static base::LazyInstance<ManifestHandlerRegistry> g_registry =
     LAZY_INSTANCE_INITIALIZER;
 
-static base::LazyInstance<std::vector<std::string> > g_empty_string_vector =
-    LAZY_INSTANCE_INITIALIZER;
-
 }  // namespace
 
 ManifestHandler::ManifestHandler() {
 }
 
 ManifestHandler::~ManifestHandler() {
 }
 
-bool ManifestHandler::AlwaysParseForType(Manifest::Type type) {
+bool ManifestHandler::AlwaysParseForType(Manifest::Type type) const {
   return false;
 }
 
-const std::vector<std::string>& ManifestHandler::PrerequisiteKeys() {
-  return g_empty_string_vector.Get();
+const std::vector<std::string> ManifestHandler::PrerequisiteKeys() const {
+  return std::vector<std::string>();
+}
+
+void ManifestHandler::Register() {
+  linked_ptr<ManifestHandler> this_linked(this);
+  const std::vector<std::string> keys = Keys();
+  for (size_t i = 0; i < keys.size(); ++i)
+    g_registry.Get().RegisterManifestHandler(keys[i], this_linked);
 }
 
 // static
-void ManifestHandler::Register(const std::string& key,
-                               linked_ptr<ManifestHandler> handler) {
-  g_registry.Get().RegisterManifestHandler(key, handler);
+void ManifestHandler::ClearRegistryForTesting() {
+  g_registry.Get().ClearForTesting();
 }
 
 // static
 bool ManifestHandler::ParseExtension(Extension* extension, string16* error) {
   return g_registry.Get().ParseExtension(extension, error);
 }
 
 // static
-void ManifestHandler::ClearRegistryForTesting() {
-  g_registry.Get().ClearForTesting();
+const std::vector<std::string> ManifestHandler::SingleKey(
+    const std::string& key) {
+  return std::vector<std::string>(1, key);
 }
 
 }  // namespace extensions