Reland of Deduplicate Monochrome locale .paks

ui/base/resource/resource_bundle.cc

 // Copyright (c) 2012 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 <stdint.h>
 
 #include <limits>
 #include <utility>
@@ skipping 193 matching lines @@
   std::string result = g_shared_instance_->LoadLocaleResources(pref_locale);
   g_shared_instance_->InitDefaultFontList();
   return result;
 }
 
 // static
 void ResourceBundle::InitSharedInstanceWithPakFileRegion(
     base::File pak_file,
     const base::MemoryMappedFile::Region& region) {
   InitSharedInstance(NULL);
-  std::unique_ptr<DataPack> data_pack(new DataPack(SCALE_FACTOR_100P));
+  auto data_pack = base::MakeUnique<DataPack>(SCALE_FACTOR_100P);
   if (!data_pack->LoadFromFileRegion(std::move(pak_file), region)) {
-    NOTREACHED() << "failed to load pak file";
+    LOG(WARNING) << "failed to load pak file";
+    NOTREACHED();
     return;
   }
   g_shared_instance_->locale_resources_data_ = std::move(data_pack);
   g_shared_instance_->InitDefaultFontList();
 }
 
 // static
 void ResourceBundle::InitSharedInstanceWithPakPath(const base::FilePath& path) {
   InitSharedInstance(NULL);
   g_shared_instance_->LoadTestResources(path, path);
@@ skipping 14 matching lines @@
   return g_shared_instance_ != NULL;
 }
 
 // static
 ResourceBundle& ResourceBundle::GetSharedInstance() {
   // Must call InitSharedInstance before this function.
   CHECK(g_shared_instance_ != NULL);
   return *g_shared_instance_;
 }
 
+void ResourceBundle::LoadSecondaryLocaleDataWithPakFileRegion(
+    base::File pak_file,
+    const base::MemoryMappedFile::Region& region) {
+  auto data_pack = base::MakeUnique<DataPack>(SCALE_FACTOR_100P);
+  if (!data_pack->LoadFromFileRegion(std::move(pak_file), region)) {
+    LOG(WARNING) << "failed to load secondary pak file";
+    NOTREACHED();
+    return;
+  }
+  secondary_locale_resources_data_ = std::move(data_pack);
+}
+
 #if !defined(OS_ANDROID)
 bool ResourceBundle::LocaleDataPakExists(const std::string& locale) {
   return !GetLocaleFilePath(locale, true).empty();
 }
 #endif  // !defined(OS_ANDROID)
 
 void ResourceBundle::AddDataPackFromPath(const base::FilePath& path,
                                          ScaleFactor scale_factor) {
   AddDataPackFromPathInternal(path, scale_factor, false);
 }
@@ skipping 121 matching lines @@
   } else {
     locale_resources_data_.reset(new DataPack(ui::SCALE_FACTOR_NONE));
   }
   // This is necessary to initialize ICU since we won't be calling
   // LoadLocaleResources in this case.
   l10n_util::GetApplicationLocale(std::string());
 }
 
 void ResourceBundle::UnloadLocaleResources() {
   locale_resources_data_.reset();
+  secondary_locale_resources_data_.reset();
 }
 
 void ResourceBundle::OverrideLocalePakForTest(const base::FilePath& pak_path) {
   overridden_pak_path_ = pak_path;
 }
 
 void ResourceBundle::OverrideLocaleStringResource(
     int message_id,
     const base::string16& string) {
   overridden_locale_strings_[message_id] = string;
@@ skipping 142 matching lines @@
     return it->second;
 
   // If for some reason we were unable to load the resources , return an empty
   // string (better than crashing).
   if (!locale_resources_data_.get()) {
     LOG(WARNING) << "locale resources are not loaded";
     return base::string16();
   }
 
   base::StringPiece data;
+  ResourceHandle::TextEncodingType encoding =
+      locale_resources_data_->GetTextEncodingType();
   if (!locale_resources_data_->GetStringPiece(static_cast<uint16_t>(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 base::string16();
+    if (secondary_locale_resources_data_.get() &&
+        secondary_locale_resources_data_->GetStringPiece(
+            static_cast<uint16_t>(message_id), &data)) {
+      // Fall back on the secondary locale pak if it exists.
+      encoding = secondary_locale_resources_data_->GetTextEncodingType();
+    } else {
+      // Fall back on the main data pack (shouldn't be any strings here except
+      // in unittests).
+      data = GetRawDataResource(message_id);
+      if (data.empty()) {
+        LOG(WARNING) << "unable to find resource: " << message_id;
+        NOTREACHED();
+        return base::string16();
+      }
     }
   }
 
   // Strings should not be loaded from a data pack that contains binary data.
-  ResourceHandle::TextEncodingType encoding =
-      locale_resources_data_->GetTextEncodingType();
   DCHECK(encoding == ResourceHandle::UTF16 || encoding == ResourceHandle::UTF8)
       << "requested localized string from binary pack file";
 
   // Data pack encodes strings as either UTF8 or UTF16.
   base::string16 msg;
   if (encoding == ResourceHandle::UTF16) {
     msg = base::string16(reinterpret_cast<const base::char16*>(data.data()),
                          data.length() / 2);
   } else if (encoding == ResourceHandle::UTF8) {
     msg = base::UTF8ToUTF16(data);
   }
   return msg;
 }
 
 base::RefCountedMemory* ResourceBundle::LoadLocalizedResourceBytes(
     int resource_id) {
   {
     base::AutoLock lock_scope(*locale_resources_data_lock_);
     base::StringPiece data;
+
     if (locale_resources_data_.get() &&
         locale_resources_data_->GetStringPiece(
             static_cast<uint16_t>(resource_id), &data) &&
         !data.empty()) {
       return new base::RefCountedStaticMemory(data.data(), data.length());
     }
+
+    if (secondary_locale_resources_data_.get() &&
+        secondary_locale_resources_data_->GetStringPiece(
+            static_cast<uint16_t>(resource_id), &data) &&
+        !data.empty()) {
+      return new base::RefCountedStaticMemory(data.data(), data.length());
+    }
   }
   // Release lock_scope and fall back to main data pack.
   return LoadDataResourceBytes(resource_id);
 }
 
 const gfx::FontList& ResourceBundle::GetFontListWithDelta(
     int size_delta,
     gfx::Font::FontStyle style,
     gfx::Font::Weight weight) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
@@ skipping 320 matching lines @@
 // static
 bool ResourceBundle::DecodePNG(const unsigned char* buf,
                                size_t size,
                                SkBitmap* bitmap,
                                bool* fell_back_to_1x) {
   *fell_back_to_1x = PNGContainsFallbackMarker(buf, size);
   return gfx::PNGCodec::Decode(buf, size, bitmap);
 }
 
 }  // namespace ui