Add ability to store hidpi theme images in data pack

chrome/browser/themes/browser_theme_pack.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 <limits>
 
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "net/base/file_stream.h"
 #include "net/base/net_errors.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/base/resource/data_pack.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
-#include "ui/gfx/skbitmap_operations.h"
+#include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/screen.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 
 namespace {
 
 // Version number of the current theme pack. We just throw out and rebuild
 // theme packs that aren't int-equal to this. Increment this number if you
 // change default theme assets.
 const int kThemePackVersion = 24;
 
 // IDs that are in the DataPack won't clash with the positive integer
 // uint16. kHeaderID should always have the maximum value because we want the
 // "header" to be written last. That way we can detect whether the pack was
 // successfully written and ignore and regenerate if it was only partially
 // written (i.e. chrome crashed on a different thread while writing the pack).
 const int kMaxID = 0x0000FFFF;  // Max unsigned 16-bit int.
 const int kHeaderID = kMaxID - 1;
 const int kTintsID = kMaxID - 2;
 const int kColorsID = kMaxID - 3;
 const int kDisplayPropertiesID = kMaxID - 4;
 const int kSourceImagesID = kMaxID - 5;
+const int kScaleFactorsID = kMaxID - 6;
 
 // Static size of the tint/color/display property arrays that are mmapped.
 const int kTintArraySize = 6;
 const int kColorArraySize = 19;
 const int kDisplayPropertySize = 3;
 
 // The sum of kFrameBorderThickness and kNonClientRestoredExtraThickness from
 // OpaqueBrowserFrameView.
 const int kRestoredTabVerticalOffset = 15;
 
@@ skipping 88 matching lines @@
   { 37, IDR_BROWSER_ACTIONS_OVERFLOW_H, NULL },
   { 38, IDR_BROWSER_ACTIONS_OVERFLOW_P, NULL },
   { 39, IDR_TOOLS, NULL },
   { 40, IDR_TOOLS_H, NULL },
   { 41, IDR_TOOLS_P, NULL },
   { 42, IDR_MENU_DROPARROW, NULL },
   { 43, IDR_THROBBER, NULL },
   { 44, IDR_THROBBER_WAITING, NULL },
   { 45, IDR_THROBBER_LIGHT, NULL },
 };
+size_t kPersistingImagesLength = arraysize(kPersistingImages);
 
 int GetPersistentIDByName(const std::string& key) {
-  for (size_t i = 0; i < arraysize(kPersistingImages); ++i) {
+  for (size_t i = 0; i < kPersistingImagesLength; ++i) {
     if (kPersistingImages[i].key != NULL &&
         base::strcasecmp(key.c_str(), kPersistingImages[i].key) == 0) {
       return kPersistingImages[i].persistent_id;
     }
   }
 
   return -1;
 }
 
 int GetPersistentIDByIDR(int idr) {
-  for (size_t i = 0; i < arraysize(kPersistingImages); ++i) {
-    if (kPersistingImages[i].idr_id == idr) {
-      return kPersistingImages[i].persistent_id;
+  static std::map<int,int>* lookup_table = new std::map<int,int>();
+  if (lookup_table->empty()) {
+    for (size_t i = 0; i < kPersistingImagesLength; ++i) {
+      int idr = kPersistingImages[i].idr_id;
+      int prs_id = kPersistingImages[i].persistent_id;
+      (*lookup_table)[idr] = prs_id;
     }
   }
+  std::map<int,int>::iterator it = lookup_table->find(idr);
+  return (it == lookup_table->end()) ? -1 : it->second;
+}
 
-  return -1;
+// Returns true if the scales in |input| match those in |expected|.
+// The order must match as the index is used in determining the raw id.
+bool InputScalesValid(const char* input,
+                      const std::vector<ui::ScaleFactor>& expected) {
+  const float* scales = reinterpret_cast<const float*>(input);
+  size_t index = 0;
+  for (const float* end = scales; *end != -1.0f; ++end) {
+    if (index >= expected.size())
+      return false;
+    if (*end != ui::GetScaleFactorScale(expected[index]))
+      return false;
+    index++;
+  }
+  return (index == expected.size());
+}
+
+// Returns |scale_factors| as a string to be written to disk.
+base::StringPiece GetScaleFactorsAsString(
+    const std::vector<ui::ScaleFactor>& scale_factors) {
+  size_t scales_size = scale_factors.size() + 1;
+  float* scales = new float[scales_size];
+  for (size_t i = 0; i < scale_factors.size(); ++i)
+    scales[i] = ui::GetScaleFactorScale(scale_factors[i]);
+  scales[scales_size - 1] = -1.0f;
+  base::StringPiece out_string = base::StringPiece(
+      reinterpret_cast<const char*>(&scales),
+      scales_size * sizeof(float));
+  delete[] scales;
+  return out_string;
 }
 
 struct StringToIntTable {
   const char* key;
   int id;
 };
 
 // Strings used by themes to identify tints in the JSON.
 StringToIntTable kTintTable[] = {
   { "buttons", ThemeService::TINT_BUTTONS },
@@ skipping 111 matching lines @@
         char* data = reinterpret_cast<char*>(&(raw_data.front()));
         if (file.ReadUntilComplete(data, size) == avail)
           return base::RefCountedBytes::TakeVector(&raw_data);
       }
     }
   }
 
   return NULL;
 }
 
-// Shifts a bitmap's HSL values. The caller is responsible for deleting
+// Shifts an image's HSL values. The caller is responsible for deleting
 // the returned image.
 gfx::Image* CreateHSLShiftedImage(const gfx::Image& image,
                                   const color_utils::HSL& hsl_shift) {
   const gfx::ImageSkia* src_image = image.ToImageSkia();
-  std::vector<gfx::ImageSkiaRep> src_image_reps = src_image->image_reps();
-  gfx::ImageSkia dst_image;
-  for (size_t i = 0; i < src_image_reps.size(); ++i) {
-    const gfx::ImageSkiaRep& image_rep = src_image_reps[i];
-    SkBitmap dst_bitmap = SkBitmapOperations::CreateHSLShiftedBitmap(
-        image_rep.sk_bitmap(), hsl_shift);
-    dst_image.AddRepresentation(gfx::ImageSkiaRep(dst_bitmap,
-        image_rep.scale_factor()));
+  return new gfx::Image(gfx::ImageSkiaOperations::CreateHSLShiftedImage(
+      *src_image, hsl_shift));
+}
+
+class TabBackgroundImageSource: public gfx::CanvasImageSource {
+ public:
+  TabBackgroundImageSource(const gfx::ImageSkia& image_to_tint,
+                           const gfx::ImageSkia& overlay,
+                           const color_utils::HSL& hsl_shift,
+                           int vertical_offset)
+      : gfx::CanvasImageSource(image_to_tint.size(), false),
+        image_to_tint_(image_to_tint),
+        overlay_(overlay),
+        hsl_shift_(hsl_shift),
+        vertical_offset_(vertical_offset) {
   }
-  return new gfx::Image(dst_image);
-}
+
+  virtual ~TabBackgroundImageSource() {
+  }
+
+  // Overridden from CanvasImageSource:
+  virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
+    gfx::ImageSkia bg_tint =
+        gfx::ImageSkiaOperations::CreateHSLShiftedImage(image_to_tint_,
+            hsl_shift_);
+    canvas->TileImageInt(bg_tint, 0, vertical_offset_, 0, 0,
+        size().width(), size().height());
+
+    // If they've provided a custom image, overlay it.
+    if (!overlay_.isNull()) {
+      canvas->TileImageInt(overlay_, 0, 0, size().width(),
+                           overlay_.height());
+    }
+  }
+
+ private:
+  const gfx::ImageSkia image_to_tint_;
+  const gfx::ImageSkia overlay_;
+  const color_utils::HSL hsl_shift_;
+  const int vertical_offset_;
+
+  DISALLOW_COPY_AND_ASSIGN(TabBackgroundImageSource);
+};
 
 }  // namespace
 
 BrowserThemePack::~BrowserThemePack() {
   if (!data_pack_.get()) {
     delete header_;
     delete [] tints_;
     delete [] colors_;
     delete [] display_properties_;
     delete [] source_images_;
   }
 
-  STLDeleteValues(&prepared_images_);
-  STLDeleteValues(&loaded_images_);
+  STLDeleteValues(&images_on_ui_thread_);
+  STLDeleteValues(&images_on_file_thread_);
 }
 
 // static
 scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromExtension(
     const Extension* extension) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(extension);
   DCHECK(extension->is_theme());
 
   scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
   pack->BuildHeader(extension);
   pack->BuildTintsFromJSON(extension->GetThemeTints());
   pack->BuildColorsFromJSON(extension->GetThemeColors());
   pack->BuildDisplayPropertiesFromJSON(extension->GetThemeDisplayProperties());
 
   // Builds the images. (Image building is dependent on tints).
   FilePathMap file_paths;
   pack->ParseImageNamesFromJSON(extension->GetThemeImages(),
                                 extension->path(),
                                 &file_paths);
   pack->BuildSourceImagesArray(file_paths);
 
-  if (!pack->LoadRawBitmapsTo(file_paths, &pack->prepared_images_))
+  if (!pack->LoadRawBitmapsTo(file_paths, &pack->images_on_ui_thread_))
     return NULL;
 
-  pack->GenerateFrameImages(&pack->prepared_images_);
+  pack->CopyImagesTo(pack->images_on_ui_thread_, &pack->images_on_file_thread_);
 
-  pack->GenerateTintedButtons(
-      pack->GetTintInternal(ThemeService::TINT_BUTTONS),
-      &pack->prepared_images_);
+  pack->CreateImages(&pack->images_on_ui_thread_);
+  pack->CreateImages(&pack->images_on_file_thread_);
 
-  pack->GenerateTabBackgroundImages(&pack->prepared_images_);
+  // For M22, as it is not possible to easily determine which scale factors are
+  // in use, assume that the 1x scale factor is in use.
+  std::vector<ui::ScaleFactor> scale_factors_in_use;
+  scale_factors_in_use.push_back(ui::SCALE_FACTOR_100P);
+  pack->GenerateImageReps(scale_factors_in_use);
 
   // The BrowserThemePack is now in a consistent state.
   return pack;
 }
 
 // static
 scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromDataPack(
     const FilePath& path, const std::string& expected_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Allow IO on UI thread due to deep-seated theme design issues.
   // (see http://crbug.com/80206)
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   scoped_refptr<BrowserThemePack> pack(new BrowserThemePack);
+  // Scale factor parameter is moot as data pack has image resources for all
+  // supported scale factors.
   pack->data_pack_.reset(
-      new ui::DataPack(ui::SCALE_FACTOR_100P));
+      new ui::DataPack(ui::SCALE_FACTOR_NONE));
 
   if (!pack->data_pack_->LoadFromPath(path)) {
     LOG(ERROR) << "Failed to load theme data pack.";
     return NULL;
   }
 
   base::StringPiece pointer;
   if (!pack->data_pack_->GetStringPiece(kHeaderID, &pointer))
     return NULL;
   pack->header_ = reinterpret_cast<BrowserThemePackHeader*>(const_cast<char*>(
@@ skipping 25 matching lines @@
   if (!pack->data_pack_->GetStringPiece(kDisplayPropertiesID, &pointer))
     return NULL;
   pack->display_properties_ = reinterpret_cast<DisplayPropertyPair*>(
       const_cast<char*>(pointer.data()));
 
   if (!pack->data_pack_->GetStringPiece(kSourceImagesID, &pointer))
     return NULL;
   pack->source_images_ = reinterpret_cast<int*>(
       const_cast<char*>(pointer.data()));
 
+  if (!pack->data_pack_->GetStringPiece(kScaleFactorsID, &pointer))
+    return NULL;
+
+  if (!InputScalesValid(const_cast<char*>(pointer.data()),
+                        pack->scale_factors_)) {
+    DLOG(ERROR) << "BuildFromDataPack failure! The pack scale factors differ "
+                << "from those supported by platform.";
+  }
+
   return pack;
 }
 
 bool BrowserThemePack::WriteToDisk(const FilePath& path) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   // Add resources for each of the property arrays.
   RawDataForWriting resources;
   resources[kHeaderID] = base::StringPiece(
       reinterpret_cast<const char*>(header_), sizeof(BrowserThemePackHeader));
   resources[kTintsID] = base::StringPiece(
       reinterpret_cast<const char*>(tints_), sizeof(TintEntry[kTintArraySize]));
   resources[kColorsID] = base::StringPiece(
       reinterpret_cast<const char*>(colors_),
       sizeof(ColorPair[kColorArraySize]));
   resources[kDisplayPropertiesID] = base::StringPiece(
       reinterpret_cast<const char*>(display_properties_),
       sizeof(DisplayPropertyPair[kDisplayPropertySize]));
 
   int source_count = 1;
   int* end = source_images_;
   for (; *end != -1 ; end++)
     source_count++;
   resources[kSourceImagesID] = base::StringPiece(
       reinterpret_cast<const char*>(source_images_),
       source_count * sizeof(*source_images_));
 
+  resources[kScaleFactorsID] = GetScaleFactorsAsString(scale_factors_);
+
   AddRawImagesTo(image_memory_, &resources);
 
   RawImages reencoded_images;
-  RepackImages(prepared_images_, &reencoded_images);
+  RepackImages(images_on_file_thread_, &reencoded_images);
   AddRawImagesTo(reencoded_images, &resources);
 
   return ui::DataPack::WritePack(path, resources, ui::DataPack::BINARY);
 }
 
 bool BrowserThemePack::GetTint(int id, color_utils::HSL* hsl) const {
   if (tints_) {
     for (int i = 0; i < kTintArraySize; ++i) {
       if (tints_[i].id == id) {
         hsl->h = tints_[i].h;
@@ skipping 42 matching lines @@
   // to avoid changing the BrowserThemePack::GetBitmapNamed API. Once we
   // switch to using gfx::Image everywhere this can be removed.
   return const_cast<SkBitmap*>(image->ToSkBitmap());
 }
 
 const gfx::Image* BrowserThemePack::GetImageNamed(int idr_id) const {
   int prs_id = GetPersistentIDByIDR(idr_id);
   if (prs_id == -1)
     return NULL;
 
-  // Check our cache of prepared images, first.
-  ImageCache::const_iterator image_iter = prepared_images_.find(prs_id);
-  if (image_iter != prepared_images_.end())
+  // Check if the image is cached.
+  ImageCache::const_iterator image_iter = images_on_ui_thread_.find(prs_id);
+  if (image_iter != images_on_ui_thread_.end())
     return image_iter->second;
 
-  // Check if we've already loaded this image.
-  image_iter = loaded_images_.find(prs_id);
-  if (image_iter != loaded_images_.end())
-    return image_iter->second;
+  // TODO(pkotwicz): Do something better than loading the bitmaps
+  // for all the scale factors associated with |idr_id|.
+  gfx::ImageSkia image_skia;
+  for (size_t i = 0; i < scale_factors_.size(); ++i) {
+    scoped_refptr<base::RefCountedMemory> memory =
+        GetRawData(idr_id, scale_factors_[i]);
 
-  scoped_refptr<base::RefCountedMemory> memory;
-  if (data_pack_.get()) {
-    memory = data_pack_->GetStaticMemory(prs_id);
-  } else {
-    RawImages::const_iterator it = image_memory_.find(prs_id);
-    if (it != image_memory_.end()) {
-      memory = it->second;
+    if (memory.get()) {
+      // Decode the PNG.
+      SkBitmap bitmap;
+      if (!gfx::PNGCodec::Decode(memory->front(), memory->size(),
+                                 &bitmap)) {
+        NOTREACHED() << "Unable to decode theme image resource " << idr_id
+                     << " from saved DataPack.";
+        return NULL;
+      }
+      image_skia.AddRepresentation(
+          gfx::ImageSkiaRep(bitmap, scale_factors_[i]));
     }
   }
 
-  if (memory.get()) {
-    // Decode the PNG.
-    SkBitmap bitmap;
-    if (!gfx::PNGCodec::Decode(memory->front(), memory->size(),
-                               &bitmap)) {
-      NOTREACHED() << "Unable to decode theme image resource " << idr_id
-                   << " from saved DataPack.";
-      return NULL;
-    }
-
-    gfx::Image* ret = new gfx::Image(bitmap);
-    loaded_images_[prs_id] = ret;
-
+  if (!image_skia.isNull()) {
+    gfx::Image* ret = new gfx::Image(image_skia);
+    images_on_ui_thread_[prs_id] = ret;
     return ret;
   }
 
   return NULL;
 }
 
-base::RefCountedMemory* BrowserThemePack::GetRawData(int idr_id) const {
+base::RefCountedMemory* BrowserThemePack::GetRawData(
+    int idr_id,
+    ui::ScaleFactor scale_factor) const {
   base::RefCountedMemory* memory = NULL;
   int prs_id = GetPersistentIDByIDR(idr_id);
+  int raw_id = GetRawIDByPersistentID(prs_id, scale_factor);
 
-  if (prs_id != -1) {
+  if (raw_id != -1) {
     if (data_pack_.get()) {
-      memory = data_pack_->GetStaticMemory(prs_id);
+      memory = data_pack_->GetStaticMemory(raw_id);
     } else {
-      RawImages::const_iterator it = image_memory_.find(prs_id);
+      RawImages::const_iterator it = image_memory_.find(raw_id);
       if (it != image_memory_.end()) {
         memory = it->second;
       }
     }
   }
 
   return memory;
 }
 
 bool BrowserThemePack::HasCustomImage(int idr_id) const {
@@ skipping 11 matching lines @@
 }
 
 // private:
 
 BrowserThemePack::BrowserThemePack()
     : header_(NULL),
       tints_(NULL),
       colors_(NULL),
       display_properties_(NULL),
       source_images_(NULL) {
+#if defined(OS_MACOSX)
+  scale_factors_ = ui::GetSupportedScaleFactors();
+#else
+  scale_factors_.push_back(ui::SCALE_FACTOR_100P);
+#endif
 }
 
 void BrowserThemePack::BuildHeader(const Extension* extension) {
   header_ = new BrowserThemePackHeader;
   header_->version = kThemePackVersion;
 
   // TODO(erg): Need to make this endian safe on other computers. Prerequisite
   // is that ui::DataPack removes this same check.
 #if defined(__BYTE_ORDER)
   // Linux check
@@ skipping 246 matching lines @@
     ids.push_back(it->first);
   }
 
   source_images_ = new int[ids.size() + 1];
   std::copy(ids.begin(), ids.end(), source_images_);
   source_images_[ids.size()] = -1;
 }
 
 bool BrowserThemePack::LoadRawBitmapsTo(
     const FilePathMap& file_paths,
-    ImageCache* raw_bitmaps) {
+    ImageCache* image_cache) {
   // Themes should be loaded on the file thread, not the UI thread.
   // http://crbug.com/61838
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   for (FilePathMap::const_iterator it = file_paths.begin();
        it != file_paths.end(); ++it) {
     scoped_refptr<base::RefCountedMemory> raw_data(ReadFileData(it->second));
     if (!raw_data.get()) {
       LOG(ERROR) << "Could not load theme image";
       return false;
     }
 
-    int id = it->first;
+    int prs_id = it->first;
 
     // Some images need to go directly into |image_memory_|. No modification is
     // necessary or desirable.
     bool is_copyable = false;
     for (size_t i = 0; i < arraysize(kPreloadIDs); ++i) {
-      if (kPreloadIDs[i] == id) {
+      if (kPreloadIDs[i] == prs_id) {
         is_copyable = true;
         break;
       }
     }
 
     if (is_copyable) {
-      image_memory_[id] = raw_data;
+      int raw_id = GetRawIDByPersistentID(prs_id, ui::SCALE_FACTOR_100P);
+      image_memory_[raw_id] = raw_data;
     } else if (raw_data.get() && raw_data->size()) {
       // Decode the PNG.
       SkBitmap bitmap;
       if (gfx::PNGCodec::Decode(raw_data->front(), raw_data->size(),
                                 &bitmap)) {
-        (*raw_bitmaps)[it->first] = new gfx::Image(bitmap);
+        (*image_cache)[prs_id] = new gfx::Image(bitmap);
       } else {
         NOTREACHED() << "Unable to decode theme image resource " << it->first;
       }
     }
   }
 
   return true;
 }
 
-void BrowserThemePack::GenerateFrameImages(ImageCache* bitmaps) const {
+void BrowserThemePack::CreateImages(ImageCache* images) const {
+  CreateFrameImages(images);
+  CreateTintedButtons(GetTintInternal(ThemeService::TINT_BUTTONS), images);
+  CreateTabBackgroundImages(images);
+}
+
+void BrowserThemePack::CreateFrameImages(ImageCache* images) const {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
-  // Create all the output bitmaps in a separate cache and move them back into
-  // the input bitmaps because there can be name collisions.
+  // Create all the output images in a separate cache and move them back into
+  // the input images because there can be name collisions.
   ImageCache temp_output;
 
   for (size_t i = 0; i < arraysize(kFrameTintMap); ++i) {
     int prs_id = kFrameTintMap[i].key;
     const gfx::Image* frame = NULL;
     // If there's no frame image provided for the specified id, then load
     // the default provided frame. If that's not provided, skip this whole
     // thing and just use the default images.
     int prs_base_id;
 
     if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE) {
-      prs_base_id = bitmaps->count(PRS_THEME_FRAME_INCOGNITO) ?
+      prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO) ?
                     PRS_THEME_FRAME_INCOGNITO : PRS_THEME_FRAME;
     } else if (prs_id == PRS_THEME_FRAME_OVERLAY_INACTIVE) {
       prs_base_id = PRS_THEME_FRAME_OVERLAY;
     } else if (prs_id == PRS_THEME_FRAME_INACTIVE) {
       prs_base_id = PRS_THEME_FRAME;
     } else if (prs_id == PRS_THEME_FRAME_INCOGNITO &&
-               !bitmaps->count(PRS_THEME_FRAME_INCOGNITO)) {
+               !images->count(PRS_THEME_FRAME_INCOGNITO)) {
       prs_base_id = PRS_THEME_FRAME;
     } else {
       prs_base_id = prs_id;
     }
 
-    if (bitmaps->count(prs_id)) {
-      frame = (*bitmaps)[prs_id];
-    } else if (prs_base_id != prs_id && bitmaps->count(prs_base_id)) {
-      frame = (*bitmaps)[prs_base_id];
+    if (images->count(prs_id)) {
+      frame = (*images)[prs_id];
+    } else if (prs_base_id != prs_id && images->count(prs_base_id)) {
+      frame = (*images)[prs_base_id];
     } else if (prs_base_id == PRS_THEME_FRAME_OVERLAY &&
-               bitmaps->count(PRS_THEME_FRAME)) {
+               images->count(PRS_THEME_FRAME)) {
       // If there is no theme overlay, don't tint the default frame,
       // because it will overwrite the custom frame image when we cache and
       // reload from disk.
       frame = NULL;
     } else {
       // If the theme doesn't specify an image, then apply the tint to
       // the default frame.
       frame = &rb.GetImageNamed(IDR_THEME_FRAME);
     }
 
     if (frame) {
       temp_output[prs_id] = CreateHSLShiftedImage(
           *frame, GetTintInternal(kFrameTintMap[i].value));
     }
   }
-
-  MergeImageCaches(temp_output, bitmaps);
+  MergeImageCaches(temp_output, images);
 }
 
-void BrowserThemePack::GenerateTintedButtons(
+void BrowserThemePack::CreateTintedButtons(
     const color_utils::HSL& button_tint,
-    ImageCache* processed_bitmaps) const {
+    ImageCache* processed_images) const {
   if (button_tint.h != -1 || button_tint.s != -1 || button_tint.l != -1) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     const std::set<int>& idr_ids =
         ThemeService::GetTintableToolbarButtons();
     for (std::set<int>::const_iterator it = idr_ids.begin();
          it != idr_ids.end(); ++it) {
       int prs_id = GetPersistentIDByIDR(*it);
       DCHECK(prs_id > 0);
 
       // Fetch the image by IDR...
       gfx::Image& button = rb.GetImageNamed(*it);
 
       // but save a version with the persistent ID.
-      (*processed_bitmaps)[prs_id] =
+      (*processed_images)[prs_id] =
           CreateHSLShiftedImage(button, button_tint);
     }
   }
 }
 
-void BrowserThemePack::GenerateTabBackgroundImages(ImageCache* bitmaps) const {
+void BrowserThemePack::CreateTabBackgroundImages(ImageCache* images) const {
   ImageCache temp_output;
   for (size_t i = 0; i < arraysize(kTabBackgroundMap); ++i) {
     int prs_id = kTabBackgroundMap[i].key;
     int prs_base_id = kTabBackgroundMap[i].value;
 
     // We only need to generate the background tab images if we were provided
     // with a PRS_THEME_FRAME.
-    ImageCache::const_iterator it = bitmaps->find(prs_base_id);
-    if (it != bitmaps->end()) {
+    ImageCache::const_iterator it = images->find(prs_base_id);
+    if (it != images->end()) {
       const gfx::ImageSkia* image_to_tint = (it->second)->ToImageSkia();
-      const std::vector<gfx::ImageSkiaRep> image_reps_to_tint =
-          image_to_tint->image_reps();
-      gfx::ImageSkia tinted_image;
-      for (size_t j = 0; j < image_reps_to_tint.size(); ++j) {
-        gfx::ImageSkiaRep image_rep_to_tint =  image_reps_to_tint[j];
-        SkBitmap bg_tint = SkBitmapOperations::CreateHSLShiftedBitmap(
-            image_rep_to_tint.sk_bitmap(), GetTintInternal(
-                ThemeService::TINT_BACKGROUND_TAB));
-        gfx::Size bg_tint_dip_size(image_rep_to_tint.GetWidth(),
-                                   image_rep_to_tint.GetHeight());
-        int vertical_offset = bitmaps->count(prs_id)
-                              ? kRestoredTabVerticalOffset : 0;
-        gfx::Canvas canvas(gfx::Size(bg_tint.width(), bg_tint.height()),
-                           image_rep_to_tint.scale_factor(),
-                           false);
-        canvas.TileImageInt(bg_tint, 0, vertical_offset, 0, 0,
-            bg_tint_dip_size.width(), bg_tint_dip_size.height());
+      color_utils::HSL hsl_shift = GetTintInternal(
+          ThemeService::TINT_BACKGROUND_TAB);
+      int vertical_offset = images->count(prs_id)
+                            ? kRestoredTabVerticalOffset : 0;
 
-        // If they've provided a custom image, overlay it.
-        ImageCache::const_iterator overlay_it = bitmaps->find(prs_id);
-        if (overlay_it != bitmaps->end()) {
-          const gfx::ImageSkia* overlay = overlay_it->second->ToImageSkia();
-          canvas.TileImageInt(*overlay, 0, 0, bg_tint_dip_size.width(),
-                              overlay->height());
-        }
-        tinted_image.AddRepresentation(canvas.ExtractImageRep());
-      }
+      gfx::ImageSkia overlay;
+      ImageCache::const_iterator overlay_it = images->find(prs_id);
+      if (overlay_it != images->end())
+        overlay = *overlay_it->second->ToImageSkia();
 
-      temp_output[prs_id] = new gfx::Image(tinted_image);
+      gfx::ImageSkiaSource* source = new TabBackgroundImageSource(
+          *image_to_tint, overlay, hsl_shift, vertical_offset);
+      // ImageSkia takes ownership of |source|.
+      temp_output[prs_id] = new gfx::Image(gfx::ImageSkia(source,
+          image_to_tint->size()));
     }
   }
-
-  MergeImageCaches(temp_output, bitmaps);
+  MergeImageCaches(temp_output, images);
 }
 
 void BrowserThemePack::RepackImages(const ImageCache& images,
                                     RawImages* reencoded_images) const {
+
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  typedef std::vector<ui::ScaleFactor> ScaleFactors;
   for (ImageCache::const_iterator it = images.begin();
        it != images.end(); ++it) {
-    std::vector<unsigned char> image_data;
-    if (!gfx::PNGCodec::EncodeBGRASkBitmap(*it->second->ToSkBitmap(), false,
-                                           &image_data)) {
-      NOTREACHED() << "Image file for resource " << it->first
-                   << " could not be encoded.";
-    } else {
-      (*reencoded_images)[it->first] =
-          base::RefCountedBytes::TakeVector(&image_data);
+    gfx::ImageSkia image_skia = *it->second->ToImageSkia();
+
+    // Attempt to generate image reps for all supported scale factors.
+    for (ScaleFactors::const_iterator factor_it = scale_factors_.begin();
+         factor_it != scale_factors_.end(); ++factor_it) {
+      // Ask for representation to force the representation to be generated
+      // if it wasn't already.
+      image_skia.GetRepresentation(*factor_it);
+    }
+
+    typedef std::vector<gfx::ImageSkiaRep> ImageSkiaReps;
+    ImageSkiaReps image_reps = image_skia.image_reps();
+    if (image_reps.empty()) {
+      NOTREACHED() << "No image reps for resource " << it->first << ".";
+    }
+    for (ImageSkiaReps::iterator rep_it = image_reps.begin();
+         rep_it != image_reps.end(); ++rep_it) {
+      std::vector<unsigned char> bitmap_data;
+      if (!gfx::PNGCodec::EncodeBGRASkBitmap(rep_it->sk_bitmap(), false,
+                                             &bitmap_data)) {
+        NOTREACHED() << "Image file for resource " << it->first
+                     << " could not be encoded.";
+      }
+      int raw_id = GetRawIDByPersistentID(it->first, rep_it->scale_factor());
+      (*reencoded_images)[raw_id] =
+          base::RefCountedBytes::TakeVector(&bitmap_data);
     }
   }
 }
+
+void BrowserThemePack::GenerateImageReps(
+    const std::vector<ui::ScaleFactor>& scale_factors) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  for (ImageCache::const_iterator it = images_on_ui_thread_.begin();
+       it != images_on_ui_thread_.end();
+       ++it) {
+    const gfx::ImageSkia* image1 = it->second->ToImageSkia();
+    const gfx::ImageSkia* image2 =
+        images_on_file_thread_[it->first]->ToImageSkia();
+
+    // Ensure that image reps are generated and cached in |image1| by
+    // calling GetRepresentation().
+    for (size_t i = 0; i < scale_factors.size(); ++i)
+      image1->GetRepresentation(scale_factors[i]);
+
+    // |image1| and |image2| have ImageSkiaSources which produce pixel
+    // equivalent output. Instead of regenerating again, copy the image reps
+    // which were generated for |image1| into |image2|.
+    // Don't do a deep copy of the SkBitmaps as SkBitmap is thread safe.
+    std::vector<gfx::ImageSkiaRep> image1_reps = image1->image_reps();
+    for (size_t i = 0; i < image1_reps.size(); ++i) {
+      gfx::ImageSkiaRep image1_rep = image1_reps[i];
+      const_cast<gfx::ImageSkia*>(image2)->AddRepresentation(gfx::ImageSkiaRep(
+          image1_rep.sk_bitmap(), image1_rep.scale_factor()));
+    }
+  }
+}
 
 void BrowserThemePack::MergeImageCaches(
     const ImageCache& source, ImageCache* destination) const {
   for (ImageCache::const_iterator it = source.begin(); it != source.end();
        ++it) {
-    ImageCache::const_iterator bitmap_it = destination->find(it->first);
-    if (bitmap_it != destination->end())
-      delete bitmap_it->second;
+    ImageCache::const_iterator image_it = destination->find(it->first);
+    if (image_it != destination->end())
+      delete image_it->second;
 
     (*destination)[it->first] = it->second;
   }
 }
 
+void BrowserThemePack::CopyImagesTo(const ImageCache& source,
+                                    ImageCache* destination) const {
+  for (ImageCache::const_iterator it = source.begin(); it != source.end();
+       ++it) {
+    (*destination)[it->first] = new gfx::Image(*it->second);
+  }
+}
+
 void BrowserThemePack::AddRawImagesTo(const RawImages& images,
                                       RawDataForWriting* out) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   for (RawImages::const_iterator it = images.begin(); it != images.end();
        ++it) {
     (*out)[it->first] = base::StringPiece(
         reinterpret_cast<const char*>(it->second->front()), it->second->size());
   }
 }
 
 color_utils::HSL BrowserThemePack::GetTintInternal(int id) const {
   if (tints_) {
     for (int i = 0; i < kTintArraySize; ++i) {
       if (tints_[i].id == id) {
         color_utils::HSL hsl;
         hsl.h = tints_[i].h;
         hsl.s = tints_[i].s;
         hsl.l = tints_[i].l;
         return hsl;
       }
     }
   }
 
   return ThemeService::GetDefaultTint(id);
 }
+
+int BrowserThemePack::GetRawIDByPersistentID(
+    int prs_id,
+    ui::ScaleFactor scale_factor) const {
+  if (prs_id < 0)
+    return -1;
+
+  for (size_t i = 0; i < scale_factors_.size(); ++i) {
+    if (scale_factors_[i] == scale_factor)
+      return static_cast<int>(kPersistingImagesLength * i) + prs_id;
+  }
+  return -1;
+}