Switch to using .pak files for locale data on Windows.

ui/base/resource/resource_bundle.cc

 // Copyright (c) 2011 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 "ui/base/resource/resource_bundle.h"
 
+#include "base/command_line.h"
+#include "base/file_util.h"
 #include "base/logging.h"
+#include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/string_piece.h"
 #include "base/synchronization/lock.h"
 #include "build/build_config.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/data_pack.h"
+#include "ui/base/ui_base_paths.h"
+#include "ui/base/ui_base_switches.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image/image.h"
 
 namespace ui {
 
 namespace {
 
 // Font sizes relative to base font.
 #if defined(OS_CHROMEOS) && defined(CROS_FONTS_USING_BCI)
@@ skipping 42 matching lines @@
 
 /* static */
 void ResourceBundle::InitSharedInstanceForTest(const FilePath& path) {
   DCHECK(g_shared_instance_ == NULL) << "ResourceBundle initialized twice";
   g_shared_instance_ = new ResourceBundle();
 
   g_shared_instance_->LoadTestResources(path);
 }
 
 /* static */
+DataPack* ResourceBundle::LoadResourcesDataPak(const FilePath& path) {
+  DataPack* datapack = new DataPack;
+  bool success = datapack->Load(path);
+  if (!success) {
+    delete datapack;
+    datapack = NULL;
+  }
+  return datapack;
+}
+
+/* static */
 std::string ResourceBundle::ReloadSharedInstance(
     const std::string& pref_locale) {
   DCHECK(g_shared_instance_ != NULL) << "ResourceBundle not initialized";
 
   g_shared_instance_->UnloadLocaleResources();
   return g_shared_instance_->LoadLocaleResources(pref_locale);
 }
 
 /* static */
 void ResourceBundle::AddDataPackToSharedInstance(const FilePath& path) {
   DCHECK(g_shared_instance_ != NULL) << "ResourceBundle not initialized";
   g_shared_instance_->data_packs_.push_back(new LoadedDataPack(path));
 }
 
 /* static */
 void ResourceBundle::CleanupSharedInstance() {
   if (g_shared_instance_) {
     delete g_shared_instance_;
     g_shared_instance_ = NULL;
   }
 }
 
 /* static */
 ResourceBundle& ResourceBundle::GetSharedInstance() {
   // Must call InitSharedInstance before this function.
   CHECK(g_shared_instance_ != NULL);
   return *g_shared_instance_;
 }
 
+#if !defined(OS_MACOSX)
+/* static */
+FilePath ResourceBundle::GetLocaleFilePath(const std::string& app_locale) {
+  FilePath locale_file_path;
+  PathService::Get(ui::DIR_LOCALES, &locale_file_path);
+  if (locale_file_path.empty())
+    return locale_file_path;
+  if (app_locale.empty())
+    return FilePath();
+  locale_file_path = locale_file_path.AppendASCII(app_locale + ".pak");
+  if (!file_util::PathExists(locale_file_path))
+    return FilePath();
+  return locale_file_path;
+}
+#endif
+
+std::string ResourceBundle::LoadLocaleResources(
+    const std::string& pref_locale) {
+  DCHECK(!locale_resources_data_.get()) << "locale.pak already loaded";
+  std::string app_locale = l10n_util::GetApplicationLocale(pref_locale);
+  FilePath locale_file_path;
+  CommandLine *command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kLocalePak)) {
+    locale_file_path =
+      command_line->GetSwitchValuePath(switches::kLocalePak);
+  } else {
+    locale_file_path = GetLocaleFilePath(app_locale);
+  }
+  if (locale_file_path.empty()) {
+    // It's possible that there is no locale.pak.
+    NOTREACHED();
+    return std::string();
+  }
+  locale_resources_data_.reset(LoadResourcesDataPak(locale_file_path));
+  CHECK(locale_resources_data_.get()) << "failed to load locale.pak";
+  return app_locale;
+}
+
+void ResourceBundle::UnloadLocaleResources() {
+  locale_resources_data_.reset();
+}
+
+string16 ResourceBundle::GetLocalizedString(int message_id) {
+  // If for some reason we were unable to load a resource pak, return an empty
+  // string (better than crashing).
+  if (!locale_resources_data_.get()) {
+    LOG(WARNING) << "locale resources are not loaded";
+    return string16();
+  }
+
+  base::StringPiece data;
+  if (!locale_resources_data_->GetStringPiece(message_id, &data)) {
+    // Fall back on the main data pack (shouldn't be any strings here except in
+    // unittests).
+    data = GetRawDataResource(message_id);
+    if (data.empty()) {
+      NOTREACHED() << "unable to find resource: " << message_id;
+      return string16();
+    }
+  }
+
+  // Data pack encodes strings as UTF16.
+  DCHECK_EQ(data.length() % 2, 0U);
+  string16 msg(reinterpret_cast<const char16*>(data.data()),
+               data.length() / 2);
+  return msg;
+}
+
 SkBitmap* ResourceBundle::GetBitmapNamed(int resource_id) {
   const SkBitmap* bitmap =
       static_cast<const SkBitmap*>(GetImageNamed(resource_id));
   return const_cast<SkBitmap*>(bitmap);
 }
 
 gfx::Image& ResourceBundle::GetImageNamed(int resource_id) {
   // Check to see if the image is already in the cache.
   {
     base::AutoLock lock_scope(*lock_);
@@ skipping 72 matching lines @@
 
 void ResourceBundle::ReloadFonts() {
   base::AutoLock lock_scope(*lock_);
   base_font_.reset();
   LoadFontsIfNecessary();
 }
 
 ResourceBundle::ResourceBundle()
     : lock_(new base::Lock),
       resources_data_(NULL),
-      large_icon_resources_data_(NULL),
-      locale_resources_data_(NULL) {
+      large_icon_resources_data_(NULL) {
 }
 
 void ResourceBundle::FreeImages() {
   STLDeleteContainerPairSecondPointers(images_.begin(),
                                        images_.end());
   images_.clear();
 }
 
 void ResourceBundle::LoadFontsIfNecessary() {
   lock_->AssertAcquired();
@@ skipping 86 matching lines @@
 }
 
 RefCountedStaticMemory* ResourceBundle::LoadedDataPack::GetStaticMemory(
     int resource_id) const {
   if (!data_pack_.get())
     return NULL;
   return data_pack_->GetStaticMemory(resource_id);
 }
 
 }  // namespace ui