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

chrome/common/extensions/extension.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.h"
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 303 matching lines @@
   scoped_ptr<extensions::Manifest> manifest(
       new extensions::Manifest(
           location,
           scoped_ptr<DictionaryValue>(value.DeepCopy())));
 
   if (!InitExtensionID(manifest.get(), path, explicit_id, flags, &error)) {
     *utf8_error = UTF16ToUTF8(error);
     return NULL;
   }
 
-  std::vector<std::string> install_warnings;
+  InstallWarningVector install_warnings;
   manifest->ValidateManifest(utf8_error, &install_warnings);
   if (!utf8_error->empty())
     return NULL;
 
   scoped_refptr<Extension> extension = new Extension(path, manifest.Pass());
   extension->install_warnings_.swap(install_warnings);
 
   if (!extension->InitFromValue(flags, &error)) {
     *utf8_error = UTF16ToUTF8(error);
     return NULL;
@@ skipping 68 matching lines @@
 
 const std::string& Extension::id() const {
   return manifest_->extension_id();
 }
 
 const std::string Extension::VersionString() const {
   return version()->GetString();
 }
 
 void Extension::AddInstallWarnings(
-    const std::vector<std::string>& new_warnings) {
+    const InstallWarningVector& new_warnings) {
   install_warnings_.insert(install_warnings_.end(),
                            new_warnings.begin(), new_warnings.end());
 }
 
 // static
 bool Extension::IsExtension(const FilePath& file_name) {
   return file_name.MatchesExtension(chrome::kExtensionFileExtension);
 }
 
 // static
@@ skipping 916 matching lines @@
         manifest_version < 1) {
       *error = ASCIIToUTF16(errors::kInvalidManifestVersion);
       return false;
     }
   }
 
   manifest_version_ = manifest_->GetManifestVersion();
   if (creation_flags_ & REQUIRE_MODERN_MANIFEST_VERSION &&
       manifest_version_ < kModernManifestVersion &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
-                switches::kAllowLegacyExtensionManifests)) {
-    *error = ASCIIToUTF16(errors::kInvalidManifestVersion);
-    return false;
+          switches::kAllowLegacyExtensionManifests)) {
+      *error = ASCIIToUTF16(errors::kInvalidManifestVersion);
+      return false;
+  }
+
+  if (location() == LOAD && manifest_version_ == 1) {
+    install_warnings_.push_back(Extension::InstallWarning(
+        Extension::InstallWarning::FORMAT_HTML,
+        l10n_util::GetStringFUTF8(
+            IDS_EXTENSION_MANIFEST_VERSION_OLD,
+            ASCIIToUTF16("<a href='http://code.google.com/chrome/extensions/"
+                         "manifestVersion.html'>"),
+            ASCIIToUTF16("</a>"))));
   }
 
   return true;
 }
 
 bool Extension::LoadHomepageURL(string16* error) {
   if (!manifest_->HasKey(keys::kHomepageURL))
     return true;
   std::string tmp;
   if (!manifest_->GetString(keys::kHomepageURL, &tmp)) {
@@ skipping 1871 matching lines @@
         extensions::Feature::Availability availability =
             feature->IsAvailableToManifest(
                 id(),
                 GetType(),
                 extensions::Feature::ConvertLocation(location()),
                 manifest_version());
         if (availability != extensions::Feature::IS_AVAILABLE) {
           // Don't fail, but warn the developer that the manifest contains
           // unrecognized permissions. This may happen legitimately if the
           // extensions requests platform- or channel-specific permissions.
-          install_warnings_.push_back(feature->GetErrorMessage(availability));
+          install_warnings_.push_back(
+              InstallWarning(InstallWarning::FORMAT_TEXT,
+                             feature->GetErrorMessage(availability)));
           continue;
         }
 
         if (permission->id() == ExtensionAPIPermission::kExperimental) {
           if (!CanSpecifyExperimentalPermission()) {
             *error = ASCIIToUTF16(errors::kExperimentalFlagRequired);
             return false;
           }
         }
 
@@ skipping 25 matching lines @@
             pattern.SetValidSchemes(
                 pattern.valid_schemes() & ~URLPattern::SCHEME_FILE);
         }
 
         host_permissions->AddPattern(pattern);
         continue;
       }
 
       // It's probably an unknown API permission. Do not throw an error so
       // extensions can retain backwards compatability (http://crbug.com/42742).
-      install_warnings_.push_back(base::StringPrintf(
-          "Permission '%s' is unknown or URL pattern is malformed.",
-          permission_str.c_str()));
+      install_warnings_.push_back(InstallWarning(
+          InstallWarning::FORMAT_TEXT,
+          base::StringPrintf(
+              "Permission '%s' is unknown or URL pattern is malformed.",
+              permission_str.c_str())));
     }
   }
   return true;
 }
 
 bool Extension::CanSilentlyIncreasePermissions() const {
   return location() != INTERNAL;
 }
 
 bool Extension::CanSpecifyHostPermission(const URLPattern& pattern,
@@ skipping 420 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions