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,
  83                                      base::string16* error) {
  84   return GetRegistry()->ParseExtension(extension, error);
  85 }
  86
  87 // static
  88 bool ManifestHandler::ValidateExtension(const Extension* extension,
  89                                         std::string* error,
  90                                         std::vector<InstallWarning>* warnings) {
  91   return GetRegistry()->ValidateExtension(extension, error, warnings);
  92 }
  93
  94 // static
  95 ManifestPermission* ManifestHandler::CreatePermission(const std::string& name) {
  96   return GetRegistry()->CreatePermission(name);
  97 }
  98
  99 // static
 100 void ManifestHandler::AddExtensionInitialRequiredPermissions(
 101     const Extension* extension, ManifestPermissionSet* permission_set) {
 102   return GetRegistry()->AddExtensionInitialRequiredPermissions(extension,
 103                                                                permission_set);
 104 }
 105
 106 // static
 107 const std::vector<std::string> ManifestHandler::SingleKey(
 108     const std::string& key) {
 109   return std::vector<std::string>(1, key);
 110 }
 111
 112 ManifestHandlerRegistry::ManifestHandlerRegistry() : is_finalized_(false) {
 113 }
 114
 115 ManifestHandlerRegistry::~ManifestHandlerRegistry() {
 116 }
 117
 118 void ManifestHandlerRegistry::Finalize() {
 119   CHECK(!is_finalized_);
 120   SortManifestHandlers();
 121   is_finalized_ = true;
 122 }
 123
 124 void ManifestHandlerRegistry::RegisterManifestHandler(
 125     const std::string& key, linked_ptr<ManifestHandler> handler) {
 126   CHECK(!is_finalized_);
 127   handlers_[key] = handler;
 128 }
 129
 130 bool ManifestHandlerRegistry::ParseExtension(Extension* extension,
 131                                              base::string16* error) {
 132   std::map<int, ManifestHandler*> handlers_by_priority;
 133   for (ManifestHandlerMap::iterator iter = handlers_.begin();
 134        iter != handlers_.end(); ++iter) {
 135     ManifestHandler* handler = iter->second.get();
 136     if (extension->manifest()->HasPath(iter->first) ||
 137         handler->AlwaysParseForType(extension->GetType())) {
 138       handlers_by_priority[priority_map_[handler]] = handler;
 139     }
 140   }
 141   for (std::map<int, ManifestHandler*>::iterator iter =
 142            handlers_by_priority.begin();
 143        iter != handlers_by_priority.end(); ++iter) {
 144     if (!(iter->second)->Parse(extension, error))
 145       return false;
 146   }
 147   return true;
 148 }
 149
 150 bool ManifestHandlerRegistry::ValidateExtension(
 151     const Extension* extension,
 152     std::string* error,
 153     std::vector<InstallWarning>* warnings) {
 154   std::set<ManifestHandler*> handlers;
 155   for (ManifestHandlerMap::iterator iter = handlers_.begin();
 156        iter != handlers_.end(); ++iter) {
 157     ManifestHandler* handler = iter->second.get();
 158     if (extension->manifest()->HasPath(iter->first) ||
 159         handler->AlwaysValidateForType(extension->GetType())) {
 160       handlers.insert(handler);
 161     }
 162   }
 163   for (std::set<ManifestHandler*>::iterator iter = handlers.begin();
 164        iter != handlers.end(); ++iter) {
 165     if (!(*iter)->Validate(extension, error, warnings))
 166       return false;
 167   }
 168   return true;
 169 }
 170
 171 ManifestPermission* ManifestHandlerRegistry::CreatePermission(
 172     const std::string& name) {
 173   ManifestHandlerMap::const_iterator it = handlers_.find(name);
 174   if (it == handlers_.end())
 175     return NULL;
 176
 177   return it->second->CreatePermission();
 178 }
 179
 180 void ManifestHandlerRegistry::AddExtensionInitialRequiredPermissions(
 181     const Extension* extension, ManifestPermissionSet* permission_set) {
 182   for (ManifestHandlerMap::const_iterator it = handlers_.begin();
 183       it != handlers_.end(); ++it) {
 184     ManifestPermission* permission =
 185         it->second->CreateInitialRequiredPermission(extension);
 186     if (permission) {
 187       permission_set->insert(permission);
 188     }
 189   }
 190 }
 191
 192 // static
 193 ManifestHandlerRegistry* ManifestHandlerRegistry::SetForTesting(
 194     ManifestHandlerRegistry* new_registry) {
 195   ManifestHandlerRegistry* old_registry = GetRegistry();
 196   if (new_registry != g_registry.Pointer())
 197     g_registry_override = new_registry;
 198   else
 199     g_registry_override = NULL;
 200   return old_registry;
 201 }
 202
 203 void ManifestHandlerRegistry::SortManifestHandlers() {
 204   std::set<ManifestHandler*> unsorted_handlers;
 205   for (ManifestHandlerMap::const_iterator iter = handlers_.begin();
 206        iter != handlers_.end(); ++iter) {
 207     unsorted_handlers.insert(iter->second.get());
 208   }
 209
 210   int priority = 0;
 211   while (true) {
 212     std::set<ManifestHandler*> next_unsorted_handlers;
 213     for (std::set<ManifestHandler*>::const_iterator iter =
 214              unsorted_handlers.begin();
 215          iter != unsorted_handlers.end(); ++iter) {
 216       ManifestHandler* handler = *iter;
 217       const std::vector<std::string>& prerequisites =
 218           handler->PrerequisiteKeys();
 219       int unsatisfied = prerequisites.size();
 220       for (size_t i = 0; i < prerequisites.size(); ++i) {
 221         ManifestHandlerMap::const_iterator prereq_iter =
 222             handlers_.find(prerequisites[i]);
 223         // If the prerequisite does not exist, crash.
 224         CHECK(prereq_iter != handlers_.end())
 225             << "Extension manifest handler depends on unrecognized key "
 226             << prerequisites[i];
 227         // Prerequisite is in our map.
 228         if (ContainsKey(priority_map_, prereq_iter->second.get()))
 229           unsatisfied--;
 230       }
 231       if (unsatisfied == 0) {
 232         priority_map_[handler] = priority;
 233         priority++;
 234       } else {
 235         // Put in the list for next time.
 236         next_unsorted_handlers.insert(handler);
 237       }
 238     }
 239     if (next_unsorted_handlers.size() == unsorted_handlers.size())
 240       break;
 241     unsorted_handlers.swap(next_unsorted_handlers);
 242   }
 243
 244   // If there are any leftover unsorted handlers, they must have had
 245   // circular dependencies.
 246   CHECK_EQ(unsorted_handlers.size(), std::set<ManifestHandler*>::size_type(0))
 247       << "Extension manifest handlers have circular dependencies!";
 248 }
 249
 250 }  // namespace extensions