Only load theme images for the scale factors that use them

chrome/browser/themes/browser_theme_pack_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 "chrome/browser/themes/browser_theme_pack.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
@@ skipping 171 matching lines @@
   }
 
   base::FilePath GetHiDpiThemePath() {
     base::FilePath test_path;
     if (!PathService::Get(chrome::DIR_TEST_DATA, &test_path)) {
       NOTREACHED();
       return test_path;
     }
     test_path = test_path.AppendASCII("extensions");
     test_path = test_path.AppendASCII("theme_hidpi");
-    return base::FilePath(test_path);
+    return test_path;
   }
 
   // Verifies the data in star gazing. We do this multiple times for different
   // BrowserThemePack objects to make sure it works in generated and mmapped
   // mode correctly.
   void VerifyStarGazing(BrowserThemePack* pack) {
     // First check that values we know exist, exist.
     SkColor color;
     EXPECT_TRUE(pack->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT,
                                &color));
@@ skipping 37 matching lines @@
     EXPECT_FALSE(pack->GetTint(ThemeProperties::TINT_FRAME, &actual));
   }
 
   void VerifyHiDpiTheme(BrowserThemePack* pack) {
     // The high DPI theme defines the following images:
     EXPECT_TRUE(pack->HasCustomImage(IDR_THEME_FRAME));
     EXPECT_TRUE(pack->HasCustomImage(IDR_THEME_FRAME_INACTIVE));
     EXPECT_TRUE(pack->HasCustomImage(IDR_THEME_FRAME_INCOGNITO));
     EXPECT_TRUE(pack->HasCustomImage(IDR_THEME_FRAME_INCOGNITO_INACTIVE));
     EXPECT_TRUE(pack->HasCustomImage(IDR_THEME_TOOLBAR));
+    // TODO(sschmitz): uncomment next two lines when ntp test data available.
+    // EXPECT_TRUE(pack->HasCustomImage(IDR_THEME_NTP_BACKGROUND));
+    // EXPECT_TRUE(pack->HasCustomImage(IDR_THEME_NTP_ATTRIBUTION));
 
     // The high DPI theme does not define the following images:
     EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_TAB_BACKGROUND));
     EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_TAB_BACKGROUND));
     EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_TAB_BACKGROUND_INCOGNITO));
     EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_TAB_BACKGROUND_V));
-    EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_NTP_BACKGROUND));
     EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_FRAME_OVERLAY));
     EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_FRAME_OVERLAY_INACTIVE));
     EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_BUTTON_BACKGROUND));
-    EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_NTP_ATTRIBUTION));
     EXPECT_FALSE(pack->HasCustomImage(IDR_THEME_WINDOW_CONTROL_BACKGROUND));
 
     // Compare some known pixel colors at know locations for a theme
     // image where two different PNG files were specified for scales 100%
     // and 200% respectively.
     int idr = IDR_THEME_FRAME;
     gfx::Image image = pack->GetImageNamed(idr);
     EXPECT_FALSE(image.IsEmpty());
     const gfx::ImageSkia* image_skia = image.ToImageSkia();
     ASSERT_TRUE(image_skia);
@@ skipping 72 matching lines @@
     // We expect the same colors and at locations scaled by 2
     // since this bitmap was scaled by 2.
     for (size_t i = 0; i < normal.size(); ++i) {
       int xy = 2 * normal[i].first;
       SkColor color = normal[i].second;
       EXPECT_EQ(color, rep4.sk_bitmap().getColor(xy, xy));
     }
     rep4.sk_bitmap().unlockPixels();
   }
 
+  void VerifyHiDpiNtpTheme(BrowserThemePack* pack) {
+    // The theme extension for this test uses the same image several times
+    // in the input (manifest.json).
+    // This (raw png) image has size 120x120. It has a black square
+    // starting at (6,6).
+    // For the NTP background this image is specified for scales: 100, 140
+    // and 200 percent.
+    // For the NTP attribution this image is specified only for scale: 150
+    // percent.
+    EXPECT_TRUE(pack->HasCustomImage(IDR_THEME_NTP_BACKGROUND));
+    EXPECT_TRUE(pack->HasCustomImage(IDR_THEME_NTP_ATTRIBUTION));
+
+    // The background image has the same png input for 100%, 140%, 200%.
+    int idr = IDR_THEME_NTP_BACKGROUND;
+    gfx::Image image = pack->GetImageNamed(idr);
+    EXPECT_FALSE(image.IsEmpty());
+    EXPECT_EQ(120, image.Size().width());
+    EXPECT_EQ(120, image.Size().height());
+
+    const gfx::ImageSkia* image_skia = image.ToImageSkia();
+    ASSERT_TRUE(image_skia);
+
+    // 100% was in input.
+    const gfx::ImageSkiaRep& rep100 = image_skia->GetRepresentation(
+        ui::SCALE_FACTOR_100P);
+    ASSERT_FALSE(rep100.is_null());
+    EXPECT_EQ(120, rep100.sk_bitmap().width());
+    EXPECT_EQ(120, rep100.sk_bitmap().height());
+    rep100.sk_bitmap().lockPixels();
+    EXPECT_EQ(SK_ColorWHITE, rep100.sk_bitmap().getColor(5, 5));
+    EXPECT_EQ(SK_ColorBLACK, rep100.sk_bitmap().getColor(6, 6));
+    rep100.sk_bitmap().unlockPixels();
+
+    // 133% not in input, was scaled from 200%.
+    const gfx::ImageSkiaRep& rep133 = image_skia->GetRepresentation(
+        ui::SCALE_FACTOR_133P);
+    ASSERT_FALSE(rep133.is_null());
+    EXPECT_EQ(80, rep133.sk_bitmap().width());
+    EXPECT_EQ(80, rep133.sk_bitmap().height());
+    rep133.sk_bitmap().lockPixels();
+    EXPECT_EQ(SK_ColorWHITE, rep133.sk_bitmap().getColor(3, 3));
+    EXPECT_EQ(SK_ColorBLACK, rep133.sk_bitmap().getColor(4, 4));
+    rep133.sk_bitmap().unlockPixels();
+
+    // 140% was in input.
+    const gfx::ImageSkiaRep& rep140 = image_skia->GetRepresentation(
+        ui::SCALE_FACTOR_140P);
+    ASSERT_FALSE(rep140.is_null());
+    EXPECT_EQ(120, rep140.sk_bitmap().width());
+    EXPECT_EQ(120, rep140.sk_bitmap().height());
+    rep140.sk_bitmap().lockPixels();
+    EXPECT_EQ(SK_ColorWHITE, rep140.sk_bitmap().getColor(5, 5));
+    EXPECT_EQ(SK_ColorBLACK, rep140.sk_bitmap().getColor(6, 6));
+    rep140.sk_bitmap().unlockPixels();
+
+    // 150% not in input, was scaled from 200%.
+    const gfx::ImageSkiaRep& rep150 = image_skia->GetRepresentation(
+        ui::SCALE_FACTOR_150P);
+    ASSERT_FALSE(rep150.is_null());
+    EXPECT_EQ(90, rep150.sk_bitmap().width());
+    EXPECT_EQ(90, rep150.sk_bitmap().height());
+    rep150.sk_bitmap().lockPixels();
+    EXPECT_EQ(SK_ColorWHITE, rep150.sk_bitmap().getColor(4, 4));
+    EXPECT_EQ(SK_ColorBLACK, rep150.sk_bitmap().getColor(5, 5));
+    rep150.sk_bitmap().unlockPixels();
+
+    // 180% not in input, was scaled from 200%.
+    const gfx::ImageSkiaRep& rep180 = image_skia->GetRepresentation(
+        ui::SCALE_FACTOR_180P);
+    ASSERT_FALSE(rep180.is_null());
+    EXPECT_EQ(108, rep180.sk_bitmap().width());
+    EXPECT_EQ(108, rep180.sk_bitmap().height());
+    rep180.sk_bitmap().lockPixels();
+    EXPECT_EQ(SK_ColorWHITE, rep180.sk_bitmap().getColor(4, 4));
+    EXPECT_EQ(SK_ColorBLACK, rep180.sk_bitmap().getColor(5, 5));
+    rep180.sk_bitmap().unlockPixels();
+
+    // 200% was in input.
+    const gfx::ImageSkiaRep& rep200 = image_skia->GetRepresentation(
+        ui::SCALE_FACTOR_200P);
+    ASSERT_FALSE(rep200.is_null());
+    EXPECT_EQ(120, rep200.sk_bitmap().width());
+    EXPECT_EQ(120, rep200.sk_bitmap().height());
+    rep200.sk_bitmap().lockPixels();
+    EXPECT_EQ(SK_ColorWHITE, rep200.sk_bitmap().getColor(5, 5));
+    EXPECT_EQ(SK_ColorBLACK, rep200.sk_bitmap().getColor(6, 6));
+    rep200.sk_bitmap().unlockPixels();
+
+    // Now process the image for NTP attribution.
+    // The attribution image has only an input for 150%.
+
+    idr = IDR_THEME_NTP_ATTRIBUTION;
+    image =  pack->GetImageNamed(idr);
+    EXPECT_FALSE(image.IsEmpty());
+    EXPECT_EQ(80, image.Size().width());
+    EXPECT_EQ(80, image.Size().height());
+
+    image_skia = image.ToImageSkia();
+    ASSERT_TRUE(image_skia);
+
+    // 100% was not in input, scaled from 150
+    const gfx::ImageSkiaRep& rpr100 = image_skia->GetRepresentation(
+        ui::SCALE_FACTOR_100P);
+    ASSERT_FALSE(rpr100.is_null());
+    EXPECT_EQ(80, rpr100.sk_bitmap().width());
+    EXPECT_EQ(80, rpr100.sk_bitmap().height());
+    rpr100.sk_bitmap().lockPixels();
+    EXPECT_EQ(SK_ColorWHITE, rpr100.sk_bitmap().getColor(3, 3));
+    EXPECT_EQ(SK_ColorBLACK, rpr100.sk_bitmap().getColor(4, 4));
+    rpr100.sk_bitmap().unlockPixels();
+
+    // 150% was in input
+    const gfx::ImageSkiaRep& rpr150 = image_skia->GetRepresentation(
+        ui::SCALE_FACTOR_150P);
+    ASSERT_FALSE(rpr150.is_null());
+    EXPECT_EQ(120, rpr150.sk_bitmap().width());
+    EXPECT_EQ(120, rpr150.sk_bitmap().height());
+    rpr150.sk_bitmap().lockPixels();
+    EXPECT_EQ(SK_ColorWHITE, rpr150.sk_bitmap().getColor(5, 5));
+    EXPECT_EQ(SK_ColorBLACK, rpr150.sk_bitmap().getColor(6, 6));
+    rpr150.sk_bitmap().unlockPixels();
+
+    // 200% was not in input, scaled from 150
+    const gfx::ImageSkiaRep& rpr200 = image_skia->GetRepresentation(
+        ui::SCALE_FACTOR_200P);
+    ASSERT_FALSE(rpr200.is_null());
+    EXPECT_EQ(160, rpr200.sk_bitmap().width());
+    EXPECT_EQ(160, rpr200.sk_bitmap().height());
+    rpr200.sk_bitmap().lockPixels();
+    EXPECT_EQ(SK_ColorWHITE, rpr200.sk_bitmap().getColor(7, 7));
+    EXPECT_EQ(SK_ColorBLACK, rpr200.sk_bitmap().getColor(8, 8));
+    rpr200.sk_bitmap().unlockPixels();
+  }
+
   base::MessageLoop message_loop;
   content::TestBrowserThread fake_ui_thread;
   content::TestBrowserThread fake_file_thread;
 
   scoped_refptr<BrowserThemePack> theme_pack_;
 };
 
 
 TEST_F(BrowserThemePackTest, DeriveUnderlineLinkColor) {
   // If we specify a link color, but don't specify the underline color, the
@@ skipping 215 matching lines @@
         BrowserThemePack::BuildFromDataPack(
             file, "mblmlcbknbnfebdfjnolmcapmdofhmme");
     ASSERT_TRUE(pack.get());
     VerifyStarGazing(pack.get());
   }
 }
 
 TEST_F(BrowserThemePackTest, HiDpiThemeTest) {
   std::vector<ui::ScaleFactor> scale_factors;
   scale_factors.push_back(ui::SCALE_FACTOR_100P);
+  scale_factors.push_back(ui::SCALE_FACTOR_133P);
+  scale_factors.push_back(ui::SCALE_FACTOR_140P);
+  scale_factors.push_back(ui::SCALE_FACTOR_150P);
+  scale_factors.push_back(ui::SCALE_FACTOR_180P);
   scale_factors.push_back(ui::SCALE_FACTOR_200P);
   ui::test::ScopedSetSupportedScaleFactors test_scale_factors(scale_factors);
   base::ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   base::FilePath file = dir.path().AppendASCII("theme_data.pak");
 
   // Part 1: Build the pack from an extension.
   {
     base::FilePath hidpi_path = GetHiDpiThemePath();
     scoped_refptr<BrowserThemePack> pack;
     BuildFromUnpackedExtension(hidpi_path, pack);
     ASSERT_TRUE(pack->WriteToDisk(file));
     VerifyHiDpiTheme(pack.get());
+    // TODO(sschmitz): uncomment the next line when test data available.
+    // VerifyHiDpiNtpTheme(pack.get());
   }
 
   // Part 2: Try to read back the data pack that we just wrote to disk.
   {
     scoped_refptr<BrowserThemePack> pack =
         BrowserThemePack::BuildFromDataPack(file, "gllekhaobjnhgeag");
     ASSERT_TRUE(pack.get());
     VerifyHiDpiTheme(pack.get());
+    // TODO(sschmitz): uncomment the next line when test data available.
+    // VerifyHiDpiNtpTheme(pack.get());
   }
 }