Parse messages.json in ExtensionUnpacker (like we do for manifest)....

chrome/common/extensions/extension_unpacker.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/common/extensions/extension_unpacker.h"
 
 #include "base/file_util.h"
 #include "base/scoped_handle.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/values.h"
 #include "net/base/file_stream.h"
 #include "chrome/browser/extensions/extension_file_util.h"
 #include "chrome/common/common_param_traits.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/common/zip.h"
 #include "ipc/ipc_message_utils.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "webkit/glue/image_decoder.h"
 
+namespace errors = extension_manifest_errors;
+namespace keys = extension_manifest_keys;
+
 namespace {
 // The name of a temporary directory to install an extension into for
 // validation before finalizing install.
 const char kTempExtensionName[] = "TEMP_INSTALL";
 
 // The file to write our decoded images to, relative to the extension_path.
 const char kDecodedImagesFilename[] = "DECODED_IMAGES";
 
 // Errors
 const char* kCouldNotCreateDirectoryError =
@@ skipping 44 matching lines @@
     }
   }
 
   return false;
 }
 
 DictionaryValue* ExtensionUnpacker::ReadManifest() {
   FilePath manifest_path =
       temp_install_dir_.AppendASCII(Extension::kManifestFilename);
   if (!file_util::PathExists(manifest_path)) {
-    SetError(extension_manifest_errors::kInvalidManifest);
+    SetError(errors::kInvalidManifest);
     return NULL;
   }
 
   JSONFileValueSerializer serializer(manifest_path);
   std::string error;
   scoped_ptr<Value> root(serializer.Deserialize(&error));
   if (!root.get()) {
     SetError(error);
     return NULL;
   }
 
   if (!root->IsType(Value::TYPE_DICTIONARY)) {
-    SetError(extension_manifest_errors::kInvalidManifest);
+    SetError(errors::kInvalidManifest);
     return NULL;
   }
 
   return static_cast<DictionaryValue*>(root.release());
 }
 
+bool ExtensionUnpacker::ReadAllMessageCatalogs(
+    const std::string& default_locale) {
+  FilePath locales_path =
+    temp_install_dir_.AppendASCII(Extension::kLocaleFolder);
+
+  // Treat all folders under _locales as valid locales.
+  file_util::FileEnumerator locales(locales_path,
+                                    false,
+                                    file_util::FileEnumerator::DIRECTORIES);
+
+  FilePath locale_path = locales.Next();
+  do {
+    // Since we use this string as a key in a DictionaryValue, be paranoid about
+    // skipping any strings with '.'. This happens sometimes, for example with
+    // '.svn' directories.
+    FilePath relative_path;
+    // message_path was created from temp_install_dir. This should never fail.
+    if (!temp_install_dir_.AppendRelativePath(locale_path, &relative_path))
+      NOTREACHED();
+    std::wstring subdir(relative_path.ToWStringHack());
+    if (std::find(subdir.begin(), subdir.end(), L'.') != subdir.end())
+      continue;
+
+    FilePath messages_path =
+      locale_path.AppendASCII(Extension::kMessagesFilename);
+
+    if (!ReadMessageCatalog(messages_path))
+      return false;
+  } while (!(locale_path = locales.Next()).empty());
+
+  return true;
+}
+
 bool ExtensionUnpacker::Run() {
   LOG(INFO) << "Installing extension " << extension_path_.value();
 
   // <profile>/Extensions/INSTALL_TEMP/<version>
   temp_install_dir_ =
       extension_path_.DirName().AppendASCII(kTempExtensionName);
   if (!file_util::CreateDirectory(temp_install_dir_)) {
     SetError(kCouldNotCreateDirectoryError);
     return false;
   }
@@ skipping 27 matching lines @@
   }
 
   // Decode any images that the browser needs to display.
   std::set<FilePath> image_paths = extension.GetBrowserImages();
   for (std::set<FilePath>::iterator it = image_paths.begin();
        it != image_paths.end(); ++it) {
     if (!AddDecodedImage(*it))
       return false;  // Error was already reported.
   }
 
+  // Parse all message catalogs (if any).
+  parsed_catalogs_.reset(new DictionaryValue);
+  if (!extension.default_locale().empty()) {
+    if (!ReadAllMessageCatalogs(extension.default_locale()))
+      return false;  // Error was already reported.
+  }
+
   return true;
 }
 
 bool ExtensionUnpacker::DumpImagesToFile() {
   IPC::Message pickle;  // We use a Message so we can use WriteParam.
   IPC::WriteParam(&pickle, decoded_images_);
 
   FilePath path = extension_path_.DirName().AppendASCII(kDecodedImagesFilename);
   if (!file_util::WriteFile(path, static_cast<const char*>(pickle.data()),
                             pickle.size())) {
@@ skipping 27 matching lines @@
   SkBitmap image_bitmap = DecodeImage(temp_install_dir_.Append(path));
   if (image_bitmap.isNull()) {
     SetError(kCouldNotDecodeImageError);
     return false;
   }
 
   decoded_images_.push_back(MakeTuple(image_bitmap, path));
   return true;
 }
 
+bool ExtensionUnpacker::ReadMessageCatalog(const FilePath& message_path) {
+  std::string error;
+  JSONFileValueSerializer serializer(message_path);
+  DictionaryValue* root =
+    static_cast<DictionaryValue*>(serializer.Deserialize(&error));
+  if (!root) {
+    std::string messages_file = WideToASCII(message_path.ToWStringHack());
+    if (error.empty()) {
+      // If file is missing, Deserialize will fail with empty error.
+      SetError(StringPrintf("%s %s", errors::kLocalesMessagesFileMissing,
+                            messages_file.c_str()));
+    } else {
+      SetError(StringPrintf("%s: %s", messages_file.c_str(), error.c_str()));
+    }
+    return false;
+  }
+
+  FilePath relative_path;
+  // message_path was created from temp_install_dir. This should never fail.
+  if (!temp_install_dir_.AppendRelativePath(message_path, &relative_path))
+    NOTREACHED();
+
+  parsed_catalogs_->Set(relative_path.DirName().ToWStringHack(), root);
+
+  return true;
+}
+
 void ExtensionUnpacker::SetError(const std::string &error) {
   error_message_ = error;
 }