Move page action manifest parsing out of Extension; the first multi-key manifest handler.

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/memory/linked_ptr.h"
 
 namespace extensions {
 
 namespace {
 
 class ManifestHandlerRegistry {
  public:
   void RegisterManifestHandler(const std::string& key,
                                ManifestHandler* handler);
+  void RegisterManifestMultiKeyHandler(ManifestMultiKeyHandler* handler);
   ManifestHandler* GetManifestHandler(const std::string& key);
+  ManifestMultiKeyHandler* GetManifestMultiKeyHandler(
+      const ManifestMultiKeyHandler::KeySet& key_set);
   std::vector<std::string> GetManifestHandlerKeys();
+  std::vector<ManifestMultiKeyHandler::KeySet>
+      GetManifestMultiKeyHandlerKeySets();
 
  private:
   friend struct base::DefaultLazyInstanceTraits<ManifestHandlerRegistry>;
   typedef std::map<std::string, linked_ptr<ManifestHandler> >
       ManifestHandlerMap;
+  typedef std::map<ManifestMultiKeyHandler::KeySet,
+                   linked_ptr<ManifestMultiKeyHandler> >
+      ManifestMultiKeyHandlerMap;
 
   ManifestHandlerMap handlers_;
+  ManifestMultiKeyHandlerMap multi_key_handlers_;
 };
 
 void ManifestHandlerRegistry::RegisterManifestHandler(
     const std::string& key, ManifestHandler* handler) {
   handlers_[key] = make_linked_ptr(handler);
 }
 
+void ManifestHandlerRegistry::RegisterManifestMultiKeyHandler(
+    ManifestMultiKeyHandler* handler) {
+  multi_key_handlers_[handler->key_set()] = make_linked_ptr(handler);
+}
+
 ManifestHandler* ManifestHandlerRegistry::GetManifestHandler(
     const std::string& key) {
   ManifestHandlerMap::iterator iter = handlers_.find(key);
   if (iter != handlers_.end())
     return iter->second.get();
   // TODO(yoz): The NOTREACHED only makes sense as long as
   // GetManifestHandlerKeys is how we're getting the available
   // manifest handlers.
   NOTREACHED();
   return NULL;
 }
 
+ManifestMultiKeyHandler* ManifestHandlerRegistry::GetManifestMultiKeyHandler(
+    const ManifestMultiKeyHandler::KeySet& key_set) {
+  ManifestMultiKeyHandlerMap::iterator iter = multi_key_handlers_.find(key_set);
+  if (iter != multi_key_handlers_.end())
+    return iter->second.get();
+  // TODO(yoz): The NOTREACHED only makes sense as long as
+  // GetManifestMultiKeyHandlerKeySets is how we're getting the available
+  // manifest handlers.
+  NOTREACHED();
+  return NULL;
+}
+
 std::vector<std::string> ManifestHandlerRegistry::GetManifestHandlerKeys() {
   std::vector<std::string> keys;
   for (ManifestHandlerMap::iterator iter = handlers_.begin();
        iter != handlers_.end(); ++iter) {
     keys.push_back(iter->first);
   }
   return keys;
 }
 
+std::vector<ManifestMultiKeyHandler::KeySet>
+ManifestHandlerRegistry::GetManifestMultiKeyHandlerKeySets() {
+  std::vector<ManifestMultiKeyHandler::KeySet> key_sets;
+  for (ManifestMultiKeyHandlerMap::iterator iter = multi_key_handlers_.begin();
+       iter != multi_key_handlers_.end(); ++iter) {
+    key_sets.push_back(iter->first);
+  }
+  return key_sets;
+}
+
 static base::LazyInstance<ManifestHandlerRegistry> g_registry =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 ManifestHandler::ManifestHandler() {
 }
 
 ManifestHandler::~ManifestHandler() {
 }
@@ skipping 11 matching lines @@
 // static
 ManifestHandler* ManifestHandler::Get(const std::string& key) {
   return g_registry.Get().GetManifestHandler(key);
 }
 
 // static
 std::vector<std::string> ManifestHandler::GetKeys() {
   return g_registry.Get().GetManifestHandlerKeys();
 }
 
+ManifestMultiKeyHandler::ManifestMultiKeyHandler() {
+}
+
+ManifestMultiKeyHandler::~ManifestMultiKeyHandler() {
+}
+
+// static
+void ManifestMultiKeyHandler::Register(ManifestMultiKeyHandler* handler) {
+  g_registry.Get().RegisterManifestMultiKeyHandler(handler);
+}
+
+// static
+ManifestMultiKeyHandler* ManifestMultiKeyHandler::Get(const KeySet& key_set) {
+  return g_registry.Get().GetManifestMultiKeyHandler(key_set);
+}
+
+// static
+std::vector<ManifestMultiKeyHandler::KeySet>
+ManifestMultiKeyHandler::GetKeySets() {
+  return g_registry.Get().GetManifestMultiKeyHandlerKeySets();
+}
+
 }  // namespace extensions