extensions/common/manifest_handler.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/common/manifest_handler.h"
   6
   7 #include <map>
   8
   9 #include "base/logging.h"
  10 #include "base/stl_util.h"
  11 #include "extensions/common/extension.h"
  12 #include "extensions/common/permissions/manifest_permission.h"
  13 #include "extensions/common/permissions/manifest_permission_set.h"
  14
  15 namespace extensions {
  16
  17 namespace {
  18
  19 static base::LazyInstance<ManifestHandlerRegistry> g_registry =
  20     LAZY_INSTANCE_INITIALIZER;
  21 static ManifestHandlerRegistry* g_registry_override = NULL;
  22
  23 ManifestHandlerRegistry* GetRegistry() {
  24   if (!g_registry_override)
  25     return g_registry.Pointer();
  26   return g_registry_override;
  27 }
  28
  29 }  // namespace
  30
  31 ManifestHandler::ManifestHandler() {
  32 }
  33
  34 ManifestHandler::~ManifestHandler() {
  35 }
  36
  37 bool ManifestHandler::Validate(const Extension* extension,
  38                                std::string* error,
  39                                std::vector<InstallWarning>* warnings) const {
  40   return true;
  41 }
  42
  43 bool ManifestHandler::AlwaysParseForType(Manifest::Type type) const {
  44   return false;
  45 }
  46
  47 bool ManifestHandler::AlwaysValidateForType(Manifest::Type type) const {
  48   return false;
  49 }
  50
  51 const std::vector<std::string> ManifestHandler::PrerequisiteKeys() const {
  52   return std::vector<std::string>();
  53 }
  54
  55 void ManifestHandler::Register() {
  56   linked_ptr<ManifestHandler> this_linked(this);
  57   const std::vector<std::string> keys = Keys();
  58   for (size_t i = 0; i < keys.size(); ++i)
  59     GetRegistry()->RegisterManifestHandler(keys[i], this_linked);
  60 }
  61
  62 ManifestPermission* ManifestHandler::CreatePermission() {
  63   return NULL;
  64 }
  65
  66 ManifestPermission* ManifestHandler::CreateInitialRequiredPermission(
  67     const Extension* extension) {
  68   return NULL;
  69 }
  70
  71 // static
  72 void ManifestHandler::FinalizeRegistration() {
  73   GetRegistry()->Finalize();
  74 }
  75
  76 // static
  77 bool ManifestHandler::IsRegistrationFinalized() {
  78   return GetRegistry()->is_finalized_;
  79 }
  80
  81 // static
  82 bool ManifestHandler::ParseExtension(Extension* extension, string16* error) {
  83   return GetRegistry()->ParseExtension(extension, error);
  84 }
  85
  86 // static
  87 bool ManifestHandler::ValidateExtension(const Extension* extension,
  88                                         std::string* error,
  89                                         std::vector<InstallWarning>* warnings) {
  90   return GetRegistry()->ValidateExtension(extension, error, warnings);
  91 }
  92
  93 // static
  94 ManifestPermission* ManifestHandler::CreatePermission(const std::string& name) {
  95   return GetRegistry()->CreatePermission(name);
  96 }
  97
  98 // static
  99 void ManifestHandler::AddExtensionInitialRequiredPermissions(
 100     const Extension* extension, ManifestPermissionSet* permission_set) {
 101   return GetRegistry()->AddExtensionInitialRequiredPermissions(extension,
 102                                                                permission_set);
 103 }
 104
 105 // static
 106 const std::vector<std::string> ManifestHandler::SingleKey(
 107     const std::string& key) {
 108   return std::vector<std::string>(1, key);
 109 }
 110
 111 ManifestHandlerRegistry::ManifestHandlerRegistry() : is_finalized_(false) {
 112 }
 113
 114 ManifestHandlerRegistry::~ManifestHandlerRegistry() {
 115 }
 116
 117 void ManifestHandlerRegistry::Finalize() {
 118   CHECK(!is_finalized_);
 119   SortManifestHandlers();
 120   is_finalized_ = true;
 121 }
 122
 123 void ManifestHandlerRegistry::RegisterManifestHandler(
 124     const std::string& key, linked_ptr<ManifestHandler> handler) {
 125   CHECK(!is_finalized_);
 126   handlers_[key] = handler;
 127 }
 128
 129 bool ManifestHandlerRegistry::ParseExtension(Extension* extension,
 130                                              string16* error) {
 131   std::map<int, ManifestHandler*> handlers_by_priority;
 132   for (ManifestHandlerMap::iterator iter = handlers_.begin();
 133        iter != handlers_.end(); ++iter) {
 134     ManifestHandler* handler = iter->second.get();
 135     if (extension->manifest()->HasPath(iter->first) ||
 136         handler->AlwaysParseForType(extension->GetType())) {
 137       handlers_by_priority[priority_map_[handler]] = handler;
 138     }
 139   }
 140   for (std::map<int, ManifestHandler*>::iterator iter =
 141            handlers_by_priority.begin();
 142        iter != handlers_by_priority.end(); ++iter) {
 143     if (!(iter->second)->Parse(extension, error))
 144       return false;
 145   }
 146   return true;
 147 }
 148
 149 bool ManifestHandlerRegistry::ValidateExtension(
 150     const Extension* extension,
 151     std::string* error,
 152     std::vector<InstallWarning>* warnings) {
 153   std::set<ManifestHandler*> handlers;
 154   for (ManifestHandlerMap::iterator iter = handlers_.begin();
 155        iter != handlers_.end(); ++iter) {
 156     ManifestHandler* handler = iter->second.get();
 157     if (extension->manifest()->HasPath(iter->first) ||
 158         handler->AlwaysValidateForType(extension->GetType())) {
 159       handlers.insert(handler);
 160     }
 161   }
 162   for (std::set<ManifestHandler*>::iterator iter = handlers.begin();
 163        iter != handlers.end(); ++iter) {
 164     if (!(*iter)->Validate(extension, error, warnings))
 165       return false;
 166   }
 167   return true;
 168 }
 169
 170 ManifestPermission* ManifestHandlerRegistry::CreatePermission(
 171     const std::string& name) {
 172   ManifestHandlerMap::const_iterator it = handlers_.find(name);
 173   if (it == handlers_.end())
 174     return NULL;
 175
 176   return it->second->CreatePermission();
 177 }
 178
 179 void ManifestHandlerRegistry::AddExtensionInitialRequiredPermissions(
 180     const Extension* extension, ManifestPermissionSet* permission_set) {
 181   for (ManifestHandlerMap::const_iterator it = handlers_.begin();
 182       it != handlers_.end(); ++it) {
 183     ManifestPermission* permission =
 184         it->second->CreateInitialRequiredPermission(extension);
 185     if (permission) {
 186       permission_set->insert(permission);
 187     }
 188   }
 189 }
 190
 191 // static
 192 ManifestHandlerRegistry* ManifestHandlerRegistry::SetForTesting(
 193     ManifestHandlerRegistry* new_registry) {
 194   ManifestHandlerRegistry* old_registry = GetRegistry();
 195   if (new_registry != g_registry.Pointer())
 196     g_registry_override = new_registry;
 197   else
 198     g_registry_override = NULL;
 199   return old_registry;
 200 }
 201
 202 void ManifestHandlerRegistry::SortManifestHandlers() {
 203   std::set<ManifestHandler*> unsorted_handlers;
 204   for (ManifestHandlerMap::const_iterator iter = handlers_.begin();
 205        iter != handlers_.end(); ++iter) {
 206     unsorted_handlers.insert(iter->second.get());
 207   }
 208
 209   int priority = 0;
 210   while (true) {
 211     std::set<ManifestHandler*> next_unsorted_handlers;
 212     for (std::set<ManifestHandler*>::const_iterator iter =
 213              unsorted_handlers.begin();
 214          iter != unsorted_handlers.end(); ++iter) {
 215       ManifestHandler* handler = *iter;
 216       const std::vector<std::string>& prerequisites =
 217           handler->PrerequisiteKeys();
 218       int unsatisfied = prerequisites.size();
 219       for (size_t i = 0; i < prerequisites.size(); ++i) {
 220         ManifestHandlerMap::const_iterator prereq_iter =
 221             handlers_.find(prerequisites[i]);
 222         // If the prerequisite does not exist, crash.
 223         CHECK(prereq_iter != handlers_.end())
 224             << "Extension manifest handler depends on unrecognized key "
 225             << prerequisites[i];
 226         // Prerequisite is in our map.
 227         if (ContainsKey(priority_map_, prereq_iter->second.get()))
 228           unsatisfied--;
 229       }
 230       if (unsatisfied == 0) {
 231         priority_map_[handler] = priority;
 232         priority++;
 233       } else {
 234         // Put in the list for next time.
 235         next_unsorted_handlers.insert(handler);
 236       }
 237     }
 238     if (next_unsorted_handlers.size() == unsorted_handlers.size())
 239       break;
 240     unsorted_handlers.swap(next_unsorted_handlers);
 241   }
 242
 243   // If there are any leftover unsorted handlers, they must have had
 244   // circular dependencies.
 245   CHECK(unsorted_handlers.size() == 0) << "Extension manifest handlers have "
 246                                        << "circular dependencies!";
 247 }
 248
 249 }  // namespace extensions