extensions: Internationalize error code messages.

chrome/browser/extensions/extension_creator.cc

 // Copyright (c) 2009 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/browser/extensions/extension_creator.h"
 
 #include <vector>
 #include <string>
 
+#include "app/l10n_util.h"
 #include "base/crypto/rsa_private_key.h"
 #include "base/crypto/signature_creator.h"
 #include "base/file_util.h"
 #include "base/scoped_handle.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/sandboxed_extension_unpacker.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/zip.h"
+#include "grit/generated_resources.h"
 
 namespace {
   const int kRSAKeySize = 1024;
 };
 
 bool ExtensionCreator::InitializeInput(
     const FilePath& extension_dir,
     const FilePath& private_key_path,
     const FilePath& private_key_output_path) {
   // Validate input |extension_dir|.
   if (extension_dir.value().empty() ||
       !file_util::DirectoryExists(extension_dir)) {
-    error_message_ = "Input directory must exist.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_DIRECTORY_NO_EXISTS);
     return false;
   }
 
   // Validate input |private_key| (if provided).
   if (!private_key_path.value().empty() &&
       !file_util::PathExists(private_key_path)) {
-    error_message_ = "Input value for private key must be a valid path.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_INVALID_PATH);
     return false;
   }
 
   // If an |output_private_key| path is given, make sure it doesn't over-write
   // an existing private key.
   if (private_key_path.value().empty() &&
       !private_key_output_path.value().empty() &&
       file_util::PathExists(private_key_output_path)) {
-      error_message_ = "A private key for specified extension already exists. "
-                       "Reuse that key or delete it first.";
+      error_message_ =
+          l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_EXISTS);
       return false;
   }
 
   // Load the extension once. We don't really need it, but this does a lot of
   // useful validation of the structure.
   scoped_ptr<Extension> extension(
       extension_file_util::LoadExtension(extension_dir,
                                          false,  // key not required
                                          &error_message_));
   if (!extension.get())
     return false;  // LoadExtension already set error_message_.
 
   return true;
 }
 
 base::RSAPrivateKey* ExtensionCreator::ReadInputKey(const FilePath&
     private_key_path) {
   if (!file_util::PathExists(private_key_path)) {
-    error_message_ = "Input value for private key must exist.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_NO_EXISTS);
     return false;
   }
 
   std::string private_key_contents;
   if (!file_util::ReadFileToString(private_key_path,
       &private_key_contents)) {
-    error_message_ = "Failed to read private key.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_READ);
     return false;
   }
 
   std::string private_key_bytes;
   if (!Extension::ParsePEMKeyBytes(private_key_contents,
        &private_key_bytes)) {
-    error_message_ = "Invalid private key.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_INVALID);
     return false;
   }
 
   return base::RSAPrivateKey::CreateFromPrivateKeyInfo(
       std::vector<uint8>(private_key_bytes.begin(), private_key_bytes.end()));
 }
 
 base::RSAPrivateKey* ExtensionCreator::GenerateKey(const FilePath&
     output_private_key_path) {
   scoped_ptr<base::RSAPrivateKey> key_pair(
       base::RSAPrivateKey::Create(kRSAKeySize));
   if (!key_pair.get()) {
-    error_message_ = "Yikes! Failed to generate random RSA private key.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_GENERATE);
     return NULL;
   }
 
   std::vector<uint8> private_key_vector;
   if (!key_pair->ExportPrivateKey(&private_key_vector)) {
-    error_message_ = "Failed to export private key.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_EXPORT);
     return NULL;
   }
   std::string private_key_bytes(
       reinterpret_cast<char*>(&private_key_vector.front()),
       private_key_vector.size());
 
   std::string private_key;
   if (!Extension::ProducePEM(private_key_bytes, &private_key)) {
-    error_message_ = "Failed to output private key.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_OUTPUT);
     return NULL;
   }
   std::string pem_output;
   if (!Extension::FormatPEMForFileOutput(private_key, &pem_output,
        false)) {
-    error_message_ = "Failed to output private key.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_OUTPUT);
     return NULL;
   }
 
   if (!output_private_key_path.empty()) {
     if (-1 == file_util::WriteFile(output_private_key_path,
         pem_output.c_str(), pem_output.size())) {
-      error_message_ = "Failed to write private key.";
+      error_message_ =
+          l10n_util::GetStringUTF8(IDS_EXTENSION_PRIVATE_KEY_FAILED_TO_OUTPUT);
       return NULL;
     }
   }
 
   return key_pair.release();
 }
 
 bool ExtensionCreator::CreateZip(const FilePath& extension_dir,
                                  const FilePath& temp_path,
                                  FilePath* zip_path) {
   *zip_path = temp_path.Append(FILE_PATH_LITERAL("extension.zip"));
 
   if (!Zip(extension_dir, *zip_path, false)) {  // no hidden files
-    error_message_ = "Failed to create temporary zip file during packaging.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_FAILED_DURING_PACKAGING);
     return false;
   }
 
   return true;
 }
 
 bool ExtensionCreator::SignZip(const FilePath& zip_path,
                                base::RSAPrivateKey* private_key,
                                std::vector<uint8>* signature) {
   scoped_ptr<base::SignatureCreator> signature_creator(
       base::SignatureCreator::Create(private_key));
   ScopedStdioHandle zip_handle(file_util::OpenFile(zip_path, "rb"));
   size_t buffer_size = 1 << 16;
   scoped_array<uint8> buffer(new uint8[buffer_size]);
   int bytes_read = -1;
   while ((bytes_read = fread(buffer.get(), 1, buffer_size,
        zip_handle.get())) > 0) {
     if (!signature_creator->Update(buffer.get(), bytes_read)) {
-      error_message_ = "Error while signing extension.";
+      error_message_ =
+          l10n_util::GetStringUTF8(IDS_EXTENSION_ERROR_WHILE_SIGNING);
       return false;
     }
   }
   zip_handle.Close();
 
   signature_creator->Final(signature);
   return true;
 }
 
 bool ExtensionCreator::WriteCRX(const FilePath& zip_path,
                                 base::RSAPrivateKey* private_key,
                                 const std::vector<uint8>& signature,
                                 const FilePath& crx_path) {
   if (file_util::PathExists(crx_path))
     file_util::Delete(crx_path, false);
   ScopedStdioHandle crx_handle(file_util::OpenFile(crx_path, "wb"));
 
   std::vector<uint8> public_key;
   if (!private_key->ExportPublicKey(&public_key)) {
-    error_message_ = "Failed to export public key.";
+    error_message_ =
+        l10n_util::GetStringUTF8(IDS_EXTENSION_PUBLIC_KEY_FAILED_TO_EXPORT);
     return false;
   }
 
   SandboxedExtensionUnpacker::ExtensionHeader header;
   memcpy(&header.magic, SandboxedExtensionUnpacker::kExtensionHeaderMagic,
          SandboxedExtensionUnpacker::kExtensionHeaderMagicSize);
   header.version = SandboxedExtensionUnpacker::kCurrentVersion;
   header.key_size = public_key.size();
   header.signature_size = signature.size();
 
@@ skipping 54 matching lines @@
   bool result = false;
   if (CreateZip(extension_dir, temp_dir.path(), &zip_path) &&
       SignZip(zip_path, key_pair.get(), &signature) &&
       WriteCRX(zip_path, key_pair.get(), signature, crx_path)) {
     result = true;
   }
 
   file_util::Delete(zip_path, false);
   return result;
 }