Add a warning when developing an extension that uses old manifest version.

chrome/common/extensions/extension_file_util.cc

 // Copyright (c) 2012 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/extension_file_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 134 matching lines @@
 
   scoped_refptr<Extension> extension(Extension::Create(extension_path,
                                                        location,
                                                        *manifest,
                                                        flags,
                                                        extension_id,
                                                        error));
   if (!extension.get())
     return NULL;
 
-  std::vector<std::string> warnings;
+  Extension::InstallWarningVector warnings;
   if (!ValidateExtension(extension.get(), error, &warnings))
     return NULL;
   extension->AddInstallWarnings(warnings);
 
   return extension;
 }
 
 DictionaryValue* LoadManifest(const FilePath& extension_path,
                               std::string* error) {
   FilePath manifest_path =
@@ skipping 57 matching lines @@
     // that aren't available in the utility process where this check
     // needs to run.
 
     result.push_back(current);
   }
   return result;
 }
 
 bool ValidateExtension(const Extension* extension,
                        std::string* error,
-                       std::vector<std::string>* warnings) {
+                       Extension::InstallWarningVector* warnings) {
   // Validate icons exist.
   for (ExtensionIconSet::IconMap::const_iterator iter =
            extension->icons().map().begin();
        iter != extension->icons().map().end();
        ++iter) {
     const FilePath path = extension->GetResource(iter->second).GetFilePath();
     if (!file_util::PathExists(path)) {
       *error =
           l10n_util::GetStringFUTF8(IDS_EXTENSION_LOAD_ICON_FAILED,
                                     UTF8ToUTF16(iter->second));
@@ skipping 167 matching lines @@
     if (!private_keys.empty()) {
       // Only print one of the private keys because l10n_util doesn't have a way
       // to translate a list of strings.
       *error = l10n_util::GetStringFUTF8(
           IDS_EXTENSION_CONTAINS_PRIVATE_KEY,
           private_keys.front().LossyDisplayName());
       return false;
     }
   } else {
     for (size_t i = 0; i < private_keys.size(); ++i) {
-      warnings->push_back(l10n_util::GetStringFUTF8(
-          IDS_EXTENSION_CONTAINS_PRIVATE_KEY,
-          private_keys[i].LossyDisplayName()));
+      warnings->push_back(Extension::InstallWarning(
+          Extension::InstallWarning::FORMAT_TEXT,
+          l10n_util::GetStringFUTF8(
+              IDS_EXTENSION_CONTAINS_PRIVATE_KEY,
+              private_keys[i].LossyDisplayName())));
     }
     // Only warn; don't block loading the extension.
   }
   return true;
 }
 
 void GarbageCollectExtensions(
     const FilePath& install_directory,
     const std::map<std::string, FilePath>& extension_paths) {
   // Nothing to clean up if it doesn't exist.
@@ skipping 346 matching lines @@
     return temp_path;
 
   return FilePath();
 }
 
 void DeleteFile(const FilePath& path, bool recursive) {
   file_util::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util