manifest_handler.cc 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261
  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. #include "extensions/common/manifest_handler.h"
  5. #include <stddef.h>
  6. #include <map>
  7. #include <vector>
  8. #include "base/check.h"
  9. #include "base/containers/contains.h"
  10. #include "extensions/common/extension.h"
  11. #include "extensions/common/permissions/manifest_permission.h"
  12. #include "extensions/common/permissions/manifest_permission_set.h"
  13. namespace extensions {
  14. namespace {
  15. static base::LazyInstance<ManifestHandlerRegistry>::DestructorAtExit
  16. g_registry = LAZY_INSTANCE_INITIALIZER;
  17. static ManifestHandlerRegistry* g_registry_override = NULL;
  18. } // namespace
  19. ManifestHandler::ManifestHandler() {
  20. }
  21. ManifestHandler::~ManifestHandler() {
  22. }
  23. bool ManifestHandler::Validate(const Extension* extension,
  24. std::string* error,
  25. std::vector<InstallWarning>* warnings) const {
  26. return true;
  27. }
  28. bool ManifestHandler::AlwaysParseForType(Manifest::Type type) const {
  29. return false;
  30. }
  31. bool ManifestHandler::AlwaysValidateForType(Manifest::Type type) const {
  32. return false;
  33. }
  34. const std::vector<std::string> ManifestHandler::PrerequisiteKeys() const {
  35. return std::vector<std::string>();
  36. }
  37. ManifestPermission* ManifestHandler::CreatePermission() {
  38. return NULL;
  39. }
  40. ManifestPermission* ManifestHandler::CreateInitialRequiredPermission(
  41. const Extension* extension) {
  42. return NULL;
  43. }
  44. // static
  45. void ManifestHandler::FinalizeRegistration() {
  46. ManifestHandlerRegistry::Get()->Finalize();
  47. }
  48. // static
  49. bool ManifestHandler::IsRegistrationFinalized() {
  50. return ManifestHandlerRegistry::Get()->is_finalized_;
  51. }
  52. // static
  53. bool ManifestHandler::ParseExtension(Extension* extension,
  54. std::u16string* error) {
  55. return ManifestHandlerRegistry::Get()->ParseExtension(extension, error);
  56. }
  57. // static
  58. bool ManifestHandler::ValidateExtension(const Extension* extension,
  59. std::string* error,
  60. std::vector<InstallWarning>* warnings) {
  61. return ManifestHandlerRegistry::Get()->ValidateExtension(extension, error,
  62. warnings);
  63. }
  64. // static
  65. ManifestPermission* ManifestHandler::CreatePermission(const std::string& name) {
  66. return ManifestHandlerRegistry::Get()->CreatePermission(name);
  67. }
  68. // static
  69. void ManifestHandler::AddExtensionInitialRequiredPermissions(
  70. const Extension* extension, ManifestPermissionSet* permission_set) {
  71. return ManifestHandlerRegistry::Get()->AddExtensionInitialRequiredPermissions(
  72. extension, permission_set);
  73. }
  74. // static
  75. const std::vector<std::string> ManifestHandler::SingleKey(
  76. const std::string& key) {
  77. return std::vector<std::string>(1, key);
  78. }
  79. // static
  80. const size_t ManifestHandlerRegistry::kHandlerMax;
  81. ManifestHandlerRegistry::ManifestHandlerRegistry() : is_finalized_(false) {
  82. }
  83. ManifestHandlerRegistry::~ManifestHandlerRegistry() {
  84. }
  85. void ManifestHandlerRegistry::Finalize() {
  86. CHECK(!is_finalized_);
  87. SortManifestHandlers();
  88. is_finalized_ = true;
  89. }
  90. void ManifestHandlerRegistry::RegisterHandler(
  91. std::unique_ptr<ManifestHandler> handler) {
  92. CHECK(!is_finalized_);
  93. ManifestHandler* raw_handler = handler.get();
  94. owned_manifest_handlers_.push_back(std::move(handler));
  95. for (const char* key : raw_handler->Keys()) {
  96. auto insertion = handlers_.emplace(key, raw_handler);
  97. DCHECK(insertion.second)
  98. << "A ManifestHandler was already registered for key: " << key;
  99. }
  100. }
  101. bool ManifestHandlerRegistry::ParseExtension(Extension* extension,
  102. std::u16string* error) {
  103. std::map<int, ManifestHandler*> handlers_by_priority;
  104. for (ManifestHandlerMap::iterator iter = handlers_.begin();
  105. iter != handlers_.end(); ++iter) {
  106. ManifestHandler* handler = iter->second;
  107. if (extension->manifest()->FindPath(iter->first) ||
  108. handler->AlwaysParseForType(extension->GetType())) {
  109. handlers_by_priority[priority_map_[handler]] = handler;
  110. }
  111. }
  112. for (auto iter = handlers_by_priority.begin();
  113. iter != handlers_by_priority.end(); ++iter) {
  114. if (!(iter->second)->Parse(extension, error))
  115. return false;
  116. }
  117. return true;
  118. }
  119. bool ManifestHandlerRegistry::ValidateExtension(
  120. const Extension* extension,
  121. std::string* error,
  122. std::vector<InstallWarning>* warnings) {
  123. std::set<ManifestHandler*> handlers;
  124. for (ManifestHandlerMap::iterator iter = handlers_.begin();
  125. iter != handlers_.end(); ++iter) {
  126. ManifestHandler* handler = iter->second;
  127. if (extension->manifest()->FindPath(iter->first) ||
  128. handler->AlwaysValidateForType(extension->GetType())) {
  129. handlers.insert(handler);
  130. }
  131. }
  132. for (auto iter = handlers.begin(); iter != handlers.end(); ++iter) {
  133. if (!(*iter)->Validate(extension, error, warnings))
  134. return false;
  135. }
  136. return true;
  137. }
  138. ManifestPermission* ManifestHandlerRegistry::CreatePermission(
  139. const std::string& name) {
  140. ManifestHandlerMap::const_iterator it = handlers_.find(name);
  141. if (it == handlers_.end())
  142. return NULL;
  143. return it->second->CreatePermission();
  144. }
  145. void ManifestHandlerRegistry::AddExtensionInitialRequiredPermissions(
  146. const Extension* extension, ManifestPermissionSet* permission_set) {
  147. for (ManifestHandlerMap::const_iterator it = handlers_.begin();
  148. it != handlers_.end(); ++it) {
  149. std::unique_ptr<ManifestPermission> permission(
  150. it->second->CreateInitialRequiredPermission(extension));
  151. if (permission) {
  152. permission_set->insert(std::move(permission));
  153. }
  154. }
  155. }
  156. // static
  157. ManifestHandlerRegistry* ManifestHandlerRegistry::Get() {
  158. if (!g_registry_override)
  159. return g_registry.Pointer();
  160. return g_registry_override;
  161. }
  162. // static
  163. ManifestHandlerRegistry* ManifestHandlerRegistry::SetForTesting(
  164. ManifestHandlerRegistry* new_registry) {
  165. ManifestHandlerRegistry* old_registry = ManifestHandlerRegistry::Get();
  166. if (new_registry != g_registry.Pointer())
  167. g_registry_override = new_registry;
  168. else
  169. g_registry_override = NULL;
  170. return old_registry;
  171. }
  172. // static
  173. void ManifestHandlerRegistry::ResetForTesting() {
  174. ManifestHandlerRegistry* registry = Get();
  175. registry->priority_map_.clear();
  176. registry->handlers_.clear();
  177. registry->is_finalized_ = false;
  178. }
  179. void ManifestHandlerRegistry::SortManifestHandlers() {
  180. std::vector<ManifestHandler*> unsorted_handlers;
  181. unsorted_handlers.reserve(handlers_.size());
  182. for (const auto& key_value : handlers_) {
  183. unsorted_handlers.push_back(key_value.second);
  184. }
  185. int priority = 0;
  186. while (true) {
  187. std::vector<ManifestHandler*> next_unsorted_handlers;
  188. next_unsorted_handlers.reserve(unsorted_handlers.size());
  189. for (ManifestHandler* handler : unsorted_handlers) {
  190. const std::vector<std::string>& prerequisites =
  191. handler->PrerequisiteKeys();
  192. int unsatisfied = prerequisites.size();
  193. for (const std::string& key : prerequisites) {
  194. ManifestHandlerMap::const_iterator prereq_iter = handlers_.find(key);
  195. // If the prerequisite does not exist, crash.
  196. CHECK(prereq_iter != handlers_.end())
  197. << "Extension manifest handler depends on unrecognized key " << key;
  198. // Prerequisite is in our map.
  199. if (base::Contains(priority_map_, prereq_iter->second))
  200. unsatisfied--;
  201. }
  202. if (unsatisfied == 0) {
  203. priority_map_[handler] = priority;
  204. priority++;
  205. } else {
  206. // Put in the list for next time.
  207. next_unsorted_handlers.push_back(handler);
  208. }
  209. }
  210. if (next_unsorted_handlers.size() == unsorted_handlers.size())
  211. break;
  212. unsorted_handlers.swap(next_unsorted_handlers);
  213. }
  214. // If there are any leftover unsorted handlers, they must have had
  215. // circular dependencies.
  216. CHECK(unsorted_handlers.empty())
  217. << "Extension manifest handlers have circular dependencies!";
  218. }
  219. } // namespace extensions