Enable permission warnings from ManifestHandlers.

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/logging.h"
 #include "base/stl_util.h"
@@ skipping 39 matching lines @@
   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)
     GetRegistry()->RegisterManifestHandler(keys[i], this_linked);
 }
 
+void ManifestHandler::AddPermissionWarningMessages(
+    const Extension* extension,
+    std::vector<string16>& messages) const {
+  // Nothing by default
+}
+
+void ManifestHandler::AddPermissionWarningMessagesDetails(
+    const Extension* extension,
+    std::vector<string16>& messages) const {
+  // Nothing by default
+}
+
 // static
 void ManifestHandler::FinalizeRegistration() {
   GetRegistry()->Finalize();
 }
 
 // static
 bool ManifestHandler::IsRegistrationFinalized() {
   return GetRegistry()->is_finalized_;
 }
 
 // static
 bool ManifestHandler::ParseExtension(Extension* extension, string16* error) {
   return GetRegistry()->ParseExtension(extension, error);
 }
 
 // static
 bool ManifestHandler::ValidateExtension(const Extension* extension,
                                         std::string* error,
                                         std::vector<InstallWarning>* warnings) {
   return GetRegistry()->ValidateExtension(extension, error, warnings);
 }
 
 // static
+std::vector<string16> ManifestHandler::
+    GetExtensionPermissionWarningMessages(const Extension* extension) {
+  return GetRegistry()->GetExtensionPermissionWarningMessages(extension);
+}
+
+// static
+std::vector<string16> ManifestHandler::
+    GetExtensionPermissionWarningMessagesDetails(const Extension* extension) {
+  return GetRegistry()->GetExtensionPermissionWarningMessagesDetails(extension);
+}
+
+// static
 const std::vector<std::string> ManifestHandler::SingleKey(
     const std::string& key) {
   return std::vector<std::string>(1, key);
 }
 
 ManifestHandlerRegistry::ManifestHandlerRegistry() : is_finalized_(false) {
 }
 
 ManifestHandlerRegistry::~ManifestHandlerRegistry() {
 }
@@ skipping 44 matching lines @@
     }
   }
   for (std::set<ManifestHandler*>::iterator iter = handlers.begin();
        iter != handlers.end(); ++iter) {
     if (!(*iter)->Validate(extension, error, warnings))
       return false;
   }
   return true;
 }
 
+std::vector<string16> ManifestHandlerRegistry::
+    GetExtensionPermissionWarningMessages(const Extension* extension) {
+  std::vector<string16> result;
+  for (ManifestHandlerMap::iterator iter = handlers_.begin();
+       iter != handlers_.end(); ++iter) {
+    ManifestHandler* handler = iter->second.get();
+    handler->AddPermissionWarningMessages(extension, result);
+  }
+  return result;
+}
+
+std::vector<string16> ManifestHandlerRegistry::
+    GetExtensionPermissionWarningMessagesDetails(const Extension* extension) {
+  std::vector<string16> result;
+  for (ManifestHandlerMap::iterator iter = handlers_.begin();
+       iter != handlers_.end(); ++iter) {
+    ManifestHandler* handler = iter->second.get();
+    handler->AddPermissionWarningMessagesDetails(extension, result);
+  }
+  return result;
+}
+
 // static
 ManifestHandlerRegistry* ManifestHandlerRegistry::SetForTesting(
     ManifestHandlerRegistry* new_registry) {
   ManifestHandlerRegistry* old_registry = GetRegistry();
   if (new_registry != g_registry.Pointer())
     g_registry_override = new_registry;
   else
     g_registry_override = NULL;
   return old_registry;
 }
@@ skipping 39 matching lines @@
     unsorted_handlers.swap(next_unsorted_handlers);
   }
 
   // If there are any leftover unsorted handlers, they must have had
   // circular dependencies.
   CHECK(unsorted_handlers.size() == 0) << "Extension manifest handlers have "
                                        << "circular dependencies!";
 }
 
 }  // namespace extensions