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

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/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 "net/base/file_stream.h"
 
+namespace errors = extension_manifest_errors;
+
 namespace extension_file_util {
 
 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";
 
 bool MoveDirSafely(const FilePath& source_dir, const FilePath& dest_dir) {
   if (file_util::PathExists(dest_dir)) {
     if (!file_util::Delete(dest_dir, true))
@@ skipping 234 matching lines @@
   if (!extension->background_url().is_empty()) {
     const std::string page_path = extension->background_url().path();
     const FilePath path = extension->GetResource(page_path).GetFilePath();
     if (!file_util::PathExists(path)) {
       *error = StringPrintf("Could not load background page '%s'.",
                             WideToUTF8(path.ToWStringHack()).c_str());
       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.
   if (!CheckForIllegalFilenames(extension->path(), error)) {
     return false;
   }
 
   return true;
 }
 
 void UninstallExtension(const std::string& id, const FilePath& extensions_dir) {
@@ skipping 92 matching lines @@
     app_locale = "";
   ExtensionMessageBundle* message_bundle =
     extension_l10n_util::LoadMessageCatalogs(locale_path,
                                              default_locale,
                                              app_locale,
                                              locales,
                                              error);
   return message_bundle;
 }
 
+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().AppendASCII(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) {
+    if (default_locale.empty() && path_exists) {
+      *error = errors::kLocalesNoDefaultLocaleSpecified;
+      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);
+
+    FilePath locale_path = locales.Next();
+    if (locale_path.empty()) {
+      *error = errors::kLocalesTreeMissing;
+      return false;
+    }
+
+    const FilePath default_locale_path = path.AppendASCII(default_locale);
+    bool has_default_locale_message_file = false;
+    do {
+      // Skip any strings with '.'. This happens sometimes, for example with
+      // '.svn' directories.
+      FilePath relative_path;
+      if (!extension.path().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 (!file_util::PathExists(messages_path)) {
+        *error = StringPrintf(
+            "%s %s", errors::kLocalesMessagesFileMissing,
+            WideToUTF8(messages_path.ToWStringHack()).c_str());
+        return false;
+      }
+
+      if (locale_path == default_locale_path)
+        has_default_locale_message_file = true;
+    } while (!(locale_path = locales.Next()).empty());
+
+    // Only message file for default locale has to exist.
+    if (!has_default_locale_message_file) {
+      *error = errors::kLocalesNoDefaultMessages;
+      return false;
+    }
+  }
+
+  return true;
+}
+
 bool CheckForIllegalFilenames(const FilePath& extension_path,
                               std::string* error) {
   // Reserved underscore names.
   static const char* reserved_names[] = {
     Extension::kLocaleFolder,
     "__MACOSX"
   };
   static std::set<std::string> reserved_underscore_names(
     reserved_names, reserved_names + arraysize(reserved_names));
 
@@ skipping 20 matching lines @@
         "Filenames starting with \"_\" are reserved for use by the system.",
         filename.c_str());
       return false;
     }
   }
 
   return true;
 }
 
 }  // namespace extension_file_util