Select theme resources from ResourceBundle at requested scale factor.

ui/base/resource/resource_bundle_unittest.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 "base/base_paths.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/base/layout.h"
 
 using ::testing::_;
 using ::testing::Between;
 using ::testing::Property;
 using ::testing::Return;
 using ::testing::ReturnArg;
 
 namespace ui {
 
 extern const char kSamplePakContents[];
 extern const size_t kSamplePakSize;
+extern const char kSamplePakContents2x[];

[tony, 2012/05/15 20:19:56]

Nit: Maybe calls these 200p as well?

+extern const size_t kSamplePakSize2x;
+extern const char kEmptyPakContents[];
+extern const size_t kEmptyPakSize;
 
 namespace {
 
 // Mock for the ResourceBundle::Delegate class.
 class MockResourceBundleDelegate : public ui::ResourceBundle::Delegate {
  public:
   MockResourceBundleDelegate() {
   }
   virtual ~MockResourceBundleDelegate() {
   }
 
   MOCK_METHOD2(GetPathForResourcePack, FilePath(const FilePath& pack_path,
-                                                float scale_factor));
+                                                ui::ScaleFactor scale_factor));
   MOCK_METHOD2(GetPathForLocalePack, FilePath(const FilePath& pack_path,
                                               const std::string& locale));
   MOCK_METHOD1(GetImageNamed, gfx::Image(int resource_id));
   MOCK_METHOD2(GetNativeImageNamed,
       gfx::Image(int resource_id,
                  ui::ResourceBundle::ImageRTL rtl));
-  MOCK_METHOD1(LoadDataResourceBytes,
-      base::RefCountedStaticMemory*(int resource_id));
-  MOCK_METHOD1(GetRawDataResourceMock, base::StringPiece(int resource_id));
+  MOCK_METHOD2(LoadDataResourceBytes,
+      base::RefCountedStaticMemory*(int resource_id,
+                                    ui::ScaleFactor scale_factor));
+  MOCK_METHOD2(GetRawDataResourceMock, base::StringPiece(
+      int resource_id,
+      ui::ScaleFactor scale_factor));
   virtual bool GetRawDataResource(int resource_id,
+                                  ui::ScaleFactor scale_factor,
                                   base::StringPiece* value) OVERRIDE {
-    *value = GetRawDataResourceMock(resource_id);
+    *value = GetRawDataResourceMock(resource_id, scale_factor);
     return true;
   }
   MOCK_METHOD1(GetLocalizedStringMock, string16(int message_id));
   virtual bool GetLocalizedString(int message_id, string16* value) OVERRIDE {
     *value = GetLocalizedStringMock(message_id);
     return true;
   }
   MOCK_METHOD1(GetFontMock, gfx::Font*(ui::ResourceBundle::FontStyle style));
   virtual scoped_ptr<gfx::Font> GetFont(
       ui::ResourceBundle::FontStyle style) OVERRIDE {
     return scoped_ptr<gfx::Font>(GetFontMock(style));
   }
 };
 
 }  // namespace
 
 TEST(ResourceBundle, DelegateGetPathForResourcePack) {
   MockResourceBundleDelegate delegate;
   ResourceBundle resource_bundle(&delegate);
 
   FilePath pack_path(FILE_PATH_LITERAL("/path/to/test_path.pak"));
-  double pack_scale_factor = 2.0;
+  ui::ScaleFactor pack_scale_factor = ui::SCALE_FACTOR_200P;
 
   EXPECT_CALL(delegate,
       GetPathForResourcePack(
           Property(&FilePath::value, pack_path.value()),
           pack_scale_factor))
       .Times(1)
       .WillOnce(Return(pack_path));
 
   resource_bundle.AddDataPack(pack_path, pack_scale_factor);
 }
@@ skipping 60 matching lines @@
 TEST(ResourceBundle, DelegateLoadDataResourceBytes) {
   MockResourceBundleDelegate delegate;
   ResourceBundle resource_bundle(&delegate);
 
   // Create the data resource for testing purposes.
   unsigned char data[] = "My test data";
   scoped_refptr<base::RefCountedStaticMemory> static_memory(
       new base::RefCountedStaticMemory(data, sizeof(data)));
 
   int resource_id = 5;
+  ui::ScaleFactor scale_factor = ui::kScaleFactorNone;
 
-  EXPECT_CALL(delegate, LoadDataResourceBytes(resource_id))
+  EXPECT_CALL(delegate, LoadDataResourceBytes(resource_id, scale_factor))
       .Times(1)
       .WillOnce(Return(static_memory));
 
   scoped_refptr<base::RefCountedStaticMemory> result =
-      resource_bundle.LoadDataResourceBytes(resource_id);
+      resource_bundle.LoadDataResourceBytes(resource_id, scale_factor);
   EXPECT_EQ(static_memory, result);
 }
 
 TEST(ResourceBundle, DelegateGetRawDataResource) {
   MockResourceBundleDelegate delegate;
   ResourceBundle resource_bundle(&delegate);
 
   // Create the string piece for testing purposes.
   char data[] = "My test data";
   base::StringPiece string_piece(data);
 
   int resource_id = 5;
 
-  EXPECT_CALL(delegate, GetRawDataResourceMock(resource_id))
+  EXPECT_CALL(delegate, GetRawDataResourceMock(
+          resource_id, ui::kScaleFactorNone))
       .Times(1)
       .WillOnce(Return(string_piece));
 
-  base::StringPiece result = resource_bundle.GetRawDataResource(resource_id);
+  base::StringPiece result = resource_bundle.GetRawDataResource(
+      resource_id, ui::kScaleFactorNone);
   EXPECT_EQ(string_piece.data(), result.data());
 }
 
 TEST(ResourceBundle, DelegateGetLocalizedString) {
   MockResourceBundleDelegate delegate;
   ResourceBundle resource_bundle(&delegate);
 
   string16 data = ASCIIToUTF16("My test data");
   int resource_id = 5;
 
@@ skipping 35 matching lines @@
     // found.  In some cases, we fail to mmap resources.pak, but try to keep
     // going anyway.
     ResourceBundle resource_bundle(NULL);
 
     // Dump contents into the pak file.
     ASSERT_EQ(file_util::WriteFile(data_path, kSamplePakContents,
                                    kSamplePakSize),
               static_cast<int>(kSamplePakSize));
 
     // Create a resource bundle from the file.
-    resource_bundle.LoadTestResources(data_path);
+    resource_bundle.LoadTestResources(data_path, data_path);
 
     const int kUnfoundResourceId = 10000;
-    EXPECT_EQ(NULL, resource_bundle.LoadDataResourceBytes(kUnfoundResourceId));
+    EXPECT_EQ(NULL, resource_bundle.LoadDataResourceBytes(
+        kUnfoundResourceId, ui::kScaleFactorNone));
 
     // Give a .pak file that doesn't exist so we will fail to load it.
     resource_bundle.AddDataPack(
         FilePath(FILE_PATH_LITERAL("non-existant-file.pak")),
-        1.0);
-    EXPECT_EQ(NULL, resource_bundle.LoadDataResourceBytes(kUnfoundResourceId));
+        ui::kScaleFactorNone);
+    EXPECT_EQ(NULL, resource_bundle.LoadDataResourceBytes(
+        kUnfoundResourceId, ui::kScaleFactorNone));
   }
 }
 
+TEST(ResourceBundle, GetRawDataResource) {
+
+  // On Windows, the default data is compiled into the binary so this does
+  // nothing.
+  ScopedTempDir dir;
+  ASSERT_TRUE(dir.CreateUniqueTempDir());
+  FilePath locale_path = dir.path().Append(FILE_PATH_LITERAL("empty.pak"));
+  FilePath data_path = dir.path().Append(FILE_PATH_LITERAL("sample.pak"));
+  FilePath data_2x_path = dir.path().Append(FILE_PATH_LITERAL("sample_2x.pak"));
+
+  {
+    ResourceBundle resource_bundle(NULL);
+    // Dump contents into the pak files.
+    ASSERT_EQ(file_util::WriteFile(locale_path, kEmptyPakContents,
+        kEmptyPakSize), static_cast<int>(kEmptyPakSize));
+    ASSERT_EQ(file_util::WriteFile(data_path, kSamplePakContents,
+        kSamplePakSize), static_cast<int>(kSamplePakSize));
+    ASSERT_EQ(file_util::WriteFile(data_2x_path, kSamplePakContents2x,
+        kSamplePakSize2x), static_cast<int>(kSamplePakSize2x));
+
+    // Load the regular and 2x pak files.
+    resource_bundle.LoadTestResources(data_path, locale_path);
+    resource_bundle.AddDataPack(data_2x_path, SCALE_FACTOR_200P);
+
+    // Resource ID 4 exists in both 1x and 2x paks, so we expect a different
+    // result when requesting the 2x scale.
+    EXPECT_EQ("this is id 4", resource_bundle.GetRawDataResource(4,
+        SCALE_FACTOR_100P));
+    EXPECT_EQ("this is id 4 2x", resource_bundle.GetRawDataResource(4,
+        SCALE_FACTOR_200P));
+
+    // Resource ID 6 only exists in the 1x pak so we expect the same resource
+    // for both scale factor requests.
+    EXPECT_EQ("this is id 6", resource_bundle.GetRawDataResource(6,
+        SCALE_FACTOR_100P));
+    EXPECT_EQ("this is id 6", resource_bundle.GetRawDataResource(6,
+        SCALE_FACTOR_200P));
+  }
+}
+
 TEST(ResourceBundle, LocaleDataPakExists) {
   ResourceBundle resource_bundle(NULL);
 
   // Check that ResourceBundle::LocaleDataPakExists returns the correct results.
   EXPECT_TRUE(resource_bundle.LocaleDataPakExists("en-US"));
   EXPECT_FALSE(resource_bundle.LocaleDataPakExists("not_a_real_locale"));
 }
 
 }  // namespace ui