Implemented the rest of loading/parsing logic for extension i18n:...

chrome/browser/extensions/extension_file_util.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_file_util.h"
 
+#include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/json_value_serializer.h"
 #include "net/base/file_stream.h"
@@ skipping 70 matching lines @@
 
   if (!MoveDirSafely(src_dir, version_dir)) {
     *error = "Could not move extension directory into profile.";
     return false;
   }
 
   scoped_version_dir.Take();
   return true;
 }
 
-Extension* LoadExtension(const FilePath& extension_path, bool require_key,
+Extension* LoadExtension(const FilePath& extension_path,
+                         bool require_key,
                          std::string* error) {
   FilePath manifest_path =
       extension_path.AppendASCII(Extension::kManifestFilename);
   if (!file_util::PathExists(manifest_path)) {
     *error = extension_manifest_errors::kInvalidManifest;
     return NULL;
   }
 
   JSONFileValueSerializer serializer(manifest_path);
   scoped_ptr<Value> root(serializer.Deserialize(error));
   if (!root.get())
     return NULL;
 
   if (!root->IsType(Value::TYPE_DICTIONARY)) {
     *error = extension_manifest_errors::kInvalidManifest;
     return NULL;
   }
 
+  DictionaryValue* manifest = static_cast<DictionaryValue*>(root.get());
+  ExtensionMessageBundle* message_bundle =
+    LoadLocaleInfo(extension_path, *manifest, error);
+  if (!message_bundle && !error->empty())
+    return NULL;
+
   scoped_ptr<Extension> extension(new Extension(extension_path));
-  if (!extension->InitFromValue(*static_cast<DictionaryValue*>(root.get()),
-                                require_key, error))
+  // Assign message bundle to extension.
+  extension->set_message_bundle(message_bundle);
+  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.
@@ skipping 82 matching lines @@
     for (std::vector<std::string>::const_iterator iter = icon_paths.begin();
          iter != icon_paths.end(); ++iter) {
       if (!file_util::PathExists(extension->GetResourcePath(*iter))) {
         *error = StringPrintf("Could not load icon '%s' for page action.",
                               iter->c_str());
         return false;
       }
     }
   }
 
-  // Load locale information if available.
-  FilePath locale_path =
-      extension->path().AppendASCII(Extension::kLocaleFolder);
-  if (file_util::PathExists(locale_path)) {
-    if (!extension_l10n_util::AddValidLocales(locale_path,
-                                              extension,
-                                              error)) {
-      return false;
-    }
-
-    if (!extension_l10n_util::ValidateDefaultLocale(extension)) {
-      *error = extension_manifest_errors::kLocalesNoDefaultLocaleSpecified;
-      return false;
-    }
-  }
-
   // Check children of extension root to see if any of them start with _ and is
   // not on the reserved list.
   if (!CheckForIllegalFilenames(extension->path(), error)) {
     return false;
   }
 
   return true;
 }
 
 void UninstallExtension(const std::string& id, const FilePath& extensions_dir) {
@@ skipping 57 matching lines @@
       LOG(WARNING) << "Invalid extension ID encountered in extensions "
                       "directory: " << extension_id;
       LOG(INFO) << "Deleting invalid extension directory "
                 << WideToASCII(extension_path.ToWStringHack()) << ".";
       file_util::Delete(extension_path, true);  // Recursive.
       continue;
     }
   }
 }
 
+ExtensionMessageBundle* LoadLocaleInfo(const FilePath& extension_path,
+                                       const DictionaryValue& manifest,
+                                       std::string* error) {
+  error->clear();
+  // Load locale information if available.
+  FilePath locale_path = extension_path.AppendASCII(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;
+
+  std::string default_locale =
+    extension_l10n_util::GetDefaultLocaleFromManifest(manifest, error);
+  if (default_locale.empty() ||
+      locales.find(default_locale) == locales.end()) {
+    *error = extension_manifest_errors::kLocalesNoDefaultLocaleSpecified;
+    return NULL;
+  }
+
+  // We can't call g_browser_process->GetApplicationLocale() since we are not
+  // on the main thread.
+  static std::string app_locale = l10n_util::GetApplicationLocale(L"");
+  if (locales.find(app_locale) == locales.end())
+    app_locale = "";
+  ExtensionMessageBundle* message_bundle =
+    extension_l10n_util::LoadMessageCatalogs(locale_path,
+                                             default_locale,
+                                             app_locale,
+                                             error);
+  return message_bundle;
+}
+
 bool CheckForIllegalFilenames(const FilePath& extension_path,
                               std::string* error) {
   // Reserved underscore names.
   static const char* reserved_names[] = {
     Extension::kLocaleFolder
   };
   static std::set<std::string> reserved_underscore_names(
     reserved_names, reserved_names + arraysize(reserved_names));
 
   // Enumerate all files and directories in the extension root.
@@ skipping 19 matching lines @@
         "Filenames starting with \"_\" are reserved for use by the system",
         filename.c_str());
       return false;
     }
   }
 
   return true;
 }
 
 }  // extension_file_util