Select theme resources from ResourceBundle at requested scale factor.

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 <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/string_piece.h"
 #include "base/synchronization/lock.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/layout.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/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace ui {
 
 namespace {
@@ skipping 21 matching lines @@
 
   g_shared_instance_->LoadCommonResources();
   return g_shared_instance_->LoadLocaleResources(pref_locale);
 }
 
 // static
 void ResourceBundle::InitSharedInstanceWithPakFile(const FilePath& path) {
   DCHECK(g_shared_instance_ == NULL) << "ResourceBundle initialized twice";
   g_shared_instance_ = new ResourceBundle(NULL);
 
-  g_shared_instance_->LoadTestResources(path);
+  g_shared_instance_->LoadTestResources(path, path);
 }
 
 // static
 void ResourceBundle::CleanupSharedInstance() {
   if (g_shared_instance_) {
     delete g_shared_instance_;
     g_shared_instance_ = NULL;
   }
 }
 
 // static
 bool ResourceBundle::HasSharedInstance() {
   return g_shared_instance_ != NULL;
 }
 
 // static
 ResourceBundle& ResourceBundle::GetSharedInstance() {
   // Must call InitSharedInstance before this function.
   CHECK(g_shared_instance_ != NULL);
   return *g_shared_instance_;
 }
 
 bool ResourceBundle::LocaleDataPakExists(const std::string& locale) {
   return !GetLocaleFilePath(locale).empty();
 }
 
-void ResourceBundle::AddDataPack(const FilePath& path, float scale_factor) {
+void ResourceBundle::AddDataPack(const FilePath& path,
+                                 ScaleFactor scale_factor) {
   // Do not pass an empty |path| value to this method. If the absolute path is
   // unknown pass just the pack file name.
   DCHECK(!path.empty());
 
   FilePath pack_path = path;
   if (delegate_)
     pack_path = delegate_->GetPathForResourcePack(pack_path, scale_factor);
 
   // Don't try to load empty values or values that are not absolute paths.
   if (pack_path.empty() || !pack_path.IsAbsolute())
     return;
 
   scoped_ptr<DataPack> data_pack(
-      new DataPack(ResourceHandle::kScaleFactor100x));
+      new DataPack(scale_factor));
   if (data_pack->Load(pack_path)) {
     data_packs_.push_back(data_pack.release());
   } else {
     LOG(ERROR) << "Failed to load " << pack_path.value()
                << "\nSome features may not be available.";
   }
 }
 
 #if !defined(OS_MACOSX)
 FilePath ResourceBundle::GetLocaleFilePath(const std::string& app_locale) {
@@ skipping 42 matching lines @@
       locale_file_path = GetLocaleFilePath(app_locale);
     }
   }
 
   if (locale_file_path.empty()) {
     // It's possible that there is no locale.pak.
     return std::string();
   }
 
   scoped_ptr<DataPack> data_pack(
-      new DataPack(ResourceHandle::kScaleFactor100x));
+      new DataPack(SCALE_FACTOR_100P));
   if (!data_pack->Load(locale_file_path)) {
     UMA_HISTOGRAM_ENUMERATION("ResourceBundle.LoadLocaleResourcesError",
                               logging::GetLastSystemErrorCode(), 16000);
     NOTREACHED() << "failed to load locale.pak";
     return std::string();
   }
 
   locale_resources_data_.reset(data_pack.release());
   return app_locale;
 }
 
-void ResourceBundle::LoadTestResources(const FilePath& path) {
+void ResourceBundle::LoadTestResources(const FilePath& path,
+                                       const FilePath& locale_path) {
   // Use the given resource pak for both common and localized resources.
   scoped_ptr<DataPack> data_pack(
-      new DataPack(ResourceHandle::kScaleFactor100x));
-  if (data_pack->Load(path))
+      new DataPack(SCALE_FACTOR_100P));
+  if (!path.empty() && data_pack->Load(path))
     data_packs_.push_back(data_pack.release());
 
-  data_pack.reset(new DataPack(ResourceHandle::kScaleFactor100x));
-  if (data_pack->Load(path))
+  data_pack.reset(new DataPack(ui::SCALE_FACTOR_NONE));
+  if (!locale_path.empty() && data_pack->Load(locale_path)) {
     locale_resources_data_.reset(data_pack.release());
+  } else {
+    locale_resources_data_.reset(
+        new DataPack(ui::SCALE_FACTOR_NONE));
+  }
 }
 
 void ResourceBundle::UnloadLocaleResources() {
   locale_resources_data_.reset();
 }
 
 void ResourceBundle::OverrideLocalePakForTest(const FilePath& pak_path) {
   overridden_pak_path_ = pak_path;
 }
 
@@ skipping 64 matching lines @@
 
   images_[resource_id] = image;
   return images_[resource_id];
 }
 
 gfx::Image& ResourceBundle::GetNativeImageNamed(int resource_id) {
   return GetNativeImageNamed(resource_id, RTL_DISABLED);
 }
 
 base::RefCountedStaticMemory* ResourceBundle::LoadDataResourceBytes(
-    int resource_id) const {
+    int resource_id,
+    ScaleFactor scale_factor) const {
   base::RefCountedStaticMemory* bytes = NULL;
   if (delegate_)
-    bytes = delegate_->LoadDataResourceBytes(resource_id);
+    bytes = delegate_->LoadDataResourceBytes(resource_id, scale_factor);
 
   if (!bytes) {
-    for (size_t i = 0; i < data_packs_.size() && !bytes; ++i)
-      bytes = data_packs_[i]->GetStaticMemory(resource_id);
+    base::StringPiece data = GetRawDataResource(resource_id, scale_factor);
+    if (!data.empty()) {
+      bytes = new base::RefCountedStaticMemory(
+          reinterpret_cast<const unsigned char*>(data.data()), data.length());
+    }
   }
 
   return bytes;
 }
 
-base::StringPiece ResourceBundle::GetRawDataResource(int resource_id) const {
+base::StringPiece ResourceBundle::GetRawDataResource(
+    int resource_id,
+    ScaleFactor scale_factor) const {
   base::StringPiece data;
-  if (delegate_ && delegate_->GetRawDataResource(resource_id, &data))
+  if (delegate_ &&
+      delegate_->GetRawDataResource(resource_id, scale_factor, &data))
     return data;
 
   DCHECK(locale_resources_data_.get());
   if (locale_resources_data_->GetStringPiece(resource_id, &data))
     return data;
 
-  for (size_t i = 0; i < data_packs_.size(); ++i) {
-    if (data_packs_[i]->GetStringPiece(resource_id, &data))
+  if (scale_factor != ui::SCALE_FACTOR_100P) {
+    for (size_t i = 0; i < data_packs_.size(); i++) {
+      if (data_packs_[i]->GetScaleFactor() == scale_factor &&
+          data_packs_[i]->GetStringPiece(resource_id, &data))
+        return data;
+    }
+  }
+  for (size_t i = 0; i < data_packs_.size(); i++) {
+    if (data_packs_[i]->GetScaleFactor() == ui::SCALE_FACTOR_100P &&
+        data_packs_[i]->GetStringPiece(resource_id, &data))
       return data;
   }
 
   return base::StringPiece();
 }
 
 string16 ResourceBundle::GetLocalizedString(int message_id) {
   string16 string;
   if (delegate_ && delegate_->GetLocalizedString(message_id, &string))
     return string;
 
   // Ensure that ReloadLocaleResources() doesn't drop the resources while
   // we're using them.
   base::AutoLock lock_scope(*locale_resources_data_lock_);
 
   // 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 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);
+    data = GetRawDataResource(message_id, ui::SCALE_FACTOR_NONE);
     if (data.empty()) {
       NOTREACHED() << "unable to find resource: " << message_id;
       return 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)
@@ skipping 136 matching lines @@
     SkBitmap bitmap;
     bitmap.setConfig(SkBitmap::kARGB_8888_Config, 32, 32);
     bitmap.allocPixels();
     bitmap.eraseARGB(255, 255, 0, 0);
     empty_image_ = gfx::Image(bitmap);
   }
   return empty_image_;
 }
 
 }  // namespace ui