Move more extensions hard coded error messages to .grd file.

chrome/common/extensions/extension_file_util.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/scoped_temp_dir.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/json_value_serializer.h"
+#include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/file_stream.h"
 
 namespace errors = extension_manifest_errors;
-namespace keys = extension_manifest_keys;
 
 namespace extension_file_util {
 
 // Validates locale info. Doesn't check if messages.json files are valid.
 static bool ValidateLocaleInfo(const Extension& extension, std::string* error);
 
 const char kInstallDirectoryName[] = "Extensions";
 // TODO(mpcomplete): obsolete. remove after migration period.
 // http://code.google.com/p/chromium/issues/detail?id=19733
 const char kCurrentVersionFileName[] = "Current Version";
@@ skipping 55 matching lines @@
 }
 
 bool InstallExtension(const FilePath& src_dir,
                       const FilePath& version_dir,
                       std::string* error) {
   // If anything fails after this, we want to delete the extension dir.
   ScopedTempDir scoped_version_dir;
   scoped_version_dir.Set(version_dir);
 
   if (!MoveDirSafely(src_dir, version_dir)) {
-    *error = "Could not move extension directory into profile.";
+    *error = l10n_util::GetStringUTF8(
+        IDS_EXTENSION_MOVE_DIRECTORY_TO_PROFILE_FAILED);
     return false;
   }
 
   scoped_version_dir.Take();
   return true;
 }
 
 Extension* LoadExtension(const FilePath& extension_path,
                          bool require_key,
                          std::string* error) {
   FilePath manifest_path =
       extension_path.Append(Extension::kManifestFilename);
   if (!file_util::PathExists(manifest_path)) {
-    *error = extension_manifest_errors::kManifestUnreadable;
+    *error =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
     return NULL;
   }
 
   JSONFileValueSerializer serializer(manifest_path);
   scoped_ptr<Value> root(serializer.Deserialize(error));
   if (!root.get()) {
     if (error->empty()) {
       // If |error| is empty, than the file could not be read.
       // It would be cleaner to have the JSON reader give a specific error
       // in this case, but other code tests for a file error with
       // error->empty().  For now, be consistent.
-      *error = extension_manifest_errors::kManifestUnreadable;
+      *error =
+          l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
     } else {
       *error = StringPrintf("%s  %s",
-                            extension_manifest_errors::kManifestParseError,
+                            errors::kManifestParseError,
                             error->c_str());
     }
     return NULL;
   }
 
   if (!root->IsType(Value::TYPE_DICTIONARY)) {
-    *error = extension_manifest_errors::kInvalidManifest;
+    *error =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_INVALID);
     return NULL;
   }
 
   DictionaryValue* manifest = static_cast<DictionaryValue*>(root.get());
 
   scoped_ptr<Extension> extension(new Extension(extension_path));
 
   if (!extension_l10n_util::LocalizeExtension(extension.get(), manifest, error))
     return NULL;
 
   if (!extension->InitFromValue(*manifest, require_key, error))
     return NULL;
 
   if (!ValidateExtension(extension.get(), error))
     return NULL;
 
   return extension.release();
 }
 
 bool ValidateExtension(Extension* extension, std::string* error) {
   // Validate icons exist.
   for (std::map<int, std::string>::const_iterator iter =
        extension->icons().begin(); iter != extension->icons().end(); ++iter) {
     const FilePath path = extension->GetResource(iter->second).GetFilePath();
     if (!file_util::PathExists(path)) {
-      *error = StringPrintf("Could not load extension icon '%s'.",
-                            iter->second.c_str());
+      *error =
+          l10n_util::GetStringFUTF8(IDS_EXTENSION_LOAD_ICON_FAILED,
+                                    UTF8ToUTF16(iter->second));
       return false;
     }
   }
 
   // Theme resource validation.
   if (extension->IsTheme()) {
     DictionaryValue* images_value = extension->GetThemeImages();
     if (images_value) {
       for (DictionaryValue::key_iterator iter = images_value->begin_keys();
            iter != images_value->end_keys(); ++iter) {
         std::string val;
         if (images_value->GetStringWithoutPathExpansion(*iter, &val)) {
           FilePath image_path = extension->path().AppendASCII(val);
           if (!file_util::PathExists(image_path)) {
-            *error = StringPrintf(
-                "Could not load '%s' for theme.",
-                WideToUTF8(image_path.ToWStringHack()).c_str());
+            *error =
+                l10n_util::GetStringFUTF8(IDS_EXTENSION_INVALID_IMAGE_PATH,
+                    WideToUTF16(image_path.ToWStringHack()));
             return false;
           }
         }
       }
     }
 
     // Themes cannot contain other extension types.
     return true;
   }
 
   // Validate that claimed script resources actually exist.
   for (size_t i = 0; i < extension->content_scripts().size(); ++i) {
     const UserScript& script = extension->content_scripts()[i];
 
     for (size_t j = 0; j < script.js_scripts().size(); j++) {
       const UserScript::File& js_script = script.js_scripts()[j];
       const FilePath& path = ExtensionResource::GetFilePath(
           js_script.extension_root(), js_script.relative_path());
       if (!file_util::PathExists(path)) {
-        *error = StringPrintf(
-            "Could not load javascript '%s' for content script.",
-            WideToUTF8(js_script.relative_path().ToWStringHack()).c_str());
+        *error =
+            l10n_util::GetStringFUTF8(IDS_EXTENSION_LOAD_JAVASCRIPT_FAILED,
+                WideToUTF16(js_script.relative_path().ToWStringHack()));
         return false;
       }
     }
 
     for (size_t j = 0; j < script.css_scripts().size(); j++) {
       const UserScript::File& css_script = script.css_scripts()[j];
       const FilePath& path = ExtensionResource::GetFilePath(
           css_script.extension_root(), css_script.relative_path());
       if (!file_util::PathExists(path)) {
-        *error = StringPrintf(
-            "Could not load css '%s' for content script.",
-            WideToUTF8(css_script.relative_path().ToWStringHack()).c_str());
+        *error =
+            l10n_util::GetStringFUTF8(IDS_EXTENSION_LOAD_CSS_FAILED,
+                WideToUTF16(css_script.relative_path().ToWStringHack()));
         return false;
       }
     }
   }
 
   // Validate claimed plugin paths.
   for (size_t i = 0; i < extension->plugins().size(); ++i) {
     const Extension::PluginInfo& plugin = extension->plugins()[i];
     if (!file_util::PathExists(plugin.path)) {
-      *error = StringPrintf("Could not load '%s' for plugin.",
-                            WideToUTF8(plugin.path.ToWStringHack()).c_str());
+      *error =
+          l10n_util::GetStringFUTF8(
+              IDS_EXTENSION_LOAD_PLUGIN_PATH_FAILED,
+              WideToUTF16(plugin.path.ToWStringHack()));
       return false;
     }
   }
 
   // Validate icon location for page actions.
   ExtensionAction* page_action = extension->page_action();
   if (page_action) {
     std::vector<std::string> icon_paths(*page_action->icon_paths());
     if (!page_action->default_icon_path().empty())
       icon_paths.push_back(page_action->default_icon_path());
     for (std::vector<std::string>::iterator iter = icon_paths.begin();
          iter != icon_paths.end(); ++iter) {
       if (!file_util::PathExists(extension->GetResource(*iter).GetFilePath())) {
-        *error = StringPrintf("Could not load icon '%s' for page action.",
-                              iter->c_str());
+        *error =
+            l10n_util::GetStringFUTF8(
+                IDS_EXTENSION_LOAD_ICON_FOR_PAGE_ACTION_FAILED,
+                UTF8ToUTF16(*iter));
         return false;
       }
     }
   }
 
   // Validate icon location for browser actions.
   // Note: browser actions don't use the icon_paths().
   ExtensionAction* browser_action = extension->browser_action();
   if (browser_action) {
     std::string path = browser_action->default_icon_path();
     if (!path.empty() &&
         !file_util::PathExists(extension->GetResource(path).GetFilePath())) {
-        *error = StringPrintf("Could not load icon '%s' for browser action.",
-                              path.c_str());
+        *error =
+            l10n_util::GetStringFUTF8(
+                IDS_EXTENSION_LOAD_ICON_FOR_BROWSER_ACTION_FAILED,
+                UTF8ToUTF16(path));
         return false;
     }
   }
 
   // Validate background page location.
   if (!extension->background_url().is_empty()) {
     FilePath page_path = ExtensionURLToRelativeFilePath(
         extension->background_url());
     const FilePath path = extension->GetResource(page_path).GetFilePath();
     if (path.empty() || !file_util::PathExists(path)) {
-      *error = StringPrintf("Could not load background page '%s'.",
-                            WideToUTF8(page_path.ToWStringHack()).c_str());
+      *error =
+          l10n_util::GetStringFUTF8(
+              IDS_EXTENSION_LOAD_BACKGROUND_PAGE_FAILED,
+              WideToUTF16(page_path.ToWStringHack()));
       return false;
     }
   }
 
   // Validate locale info.
   if (!ValidateLocaleInfo(*extension, error))
     return false;
 
   // Check children of extension root to see if any of them start with _ and is
   // not on the reserved list.
@@ skipping 106 matching lines @@
   FilePath locale_path = extension_path.Append(Extension::kLocaleFolder);
   if (!file_util::PathExists(locale_path))
     return NULL;
 
   std::set<std::string> locales;
   if (!extension_l10n_util::GetValidLocales(locale_path, &locales, error))
     return NULL;
 
   if (default_locale.empty() ||
       locales.find(default_locale) == locales.end()) {
-    *error = extension_manifest_errors::kLocalesNoDefaultLocaleSpecified;
+    *error = l10n_util::GetStringUTF8(
+        IDS_EXTENSION_LOCALES_NO_DEFAULT_LOCALE_SPECIFIED);
     return NULL;
   }
 
   ExtensionMessageBundle* message_bundle =
       extension_l10n_util::LoadMessageCatalogs(
           locale_path,
           default_locale,
           extension_l10n_util::CurrentLocaleOrDefault(),
           locales,
           error);
 
   return message_bundle;
 }
 
 static bool ValidateLocaleInfo(const Extension& extension, std::string* error) {
   // default_locale and _locales have to be both present or both missing.
   const FilePath path = extension.path().Append(Extension::kLocaleFolder);
   bool path_exists = file_util::PathExists(path);
   std::string default_locale = extension.default_locale();
 
   // If both default locale and _locales folder are empty, skip verification.
   if (default_locale.empty() && !path_exists)
     return true;
 
   if (default_locale.empty() && path_exists) {
-    *error = errors::kLocalesNoDefaultLocaleSpecified;
+    *error = l10n_util::GetStringUTF8(
+        IDS_EXTENSION_LOCALES_NO_DEFAULT_LOCALE_SPECIFIED);
     return false;
   } else if (!default_locale.empty() && !path_exists) {
     *error = errors::kLocalesTreeMissing;
     return false;
   }
 
   // Treat all folders under _locales as valid locales.
   file_util::FileEnumerator locales(path,
                                     false,
                                     file_util::FileEnumerator::DIRECTORIES);
@@ skipping 80 matching lines @@
       UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS);
 
 #if defined(OS_POSIX)
   return FilePath(file_path);
 #elif defined(OS_WIN)
   return FilePath(UTF8ToWide(file_path));
 #endif
 }
 
 }  // namespace extension_file_util