Fix the misalignment on CrOS of the tab background images

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"
@@ skipping 25 matching lines @@
 #include "ui/gfx/skia_util.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 = 31;
+const int kThemePackVersion = 32;
 
 // 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;
 
-// The sum of kFrameBorderThickness and kNonClientRestoredExtraThickness from
-// OpaqueBrowserFrameView.
-const int kRestoredTabVerticalOffset = 15;
-
 // Persistent constants for the main images that we need. These have the same
 // names as their IDR_* counterparts but these values will always stay the
 // same.
 const int PRS_THEME_FRAME = 1;
 const int PRS_THEME_FRAME_INACTIVE = 2;
 const int PRS_THEME_FRAME_INCOGNITO = 3;
 const int PRS_THEME_FRAME_INCOGNITO_INACTIVE = 4;
 const int PRS_THEME_TOOLBAR = 5;
-const int PRS_THEME_TAB_BACKGROUND = 6;
-const int PRS_THEME_TAB_BACKGROUND_INCOGNITO = 7;
-const int PRS_THEME_TAB_BACKGROUND_V = 8;
+const int PRS_THEME_TAB_BACKGROUND_OVERLAY = 6;
+const int PRS_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY = 7;
+const int PRS_THEME_TAB_BACKGROUND_V_OVERLAY = 8;
 const int PRS_THEME_NTP_BACKGROUND = 9;
 const int PRS_THEME_FRAME_OVERLAY = 10;
 const int PRS_THEME_FRAME_OVERLAY_INACTIVE = 11;
 const int PRS_THEME_BUTTON_BACKGROUND = 12;
 const int PRS_THEME_NTP_ATTRIBUTION = 13;
 const int PRS_THEME_WINDOW_CONTROL_BACKGROUND = 14;
+const int PRS_THEME_TAB_BACKGROUND = 15;
+const int PRS_THEME_TAB_BACKGROUND_INCOGNITO = 16;
 
 struct PersistingImagesTable {
   // A non-changing integer ID meant to be saved in theme packs. This ID must
   // not change between versions of chrome.
   int persistent_id;
 
   // The IDR that depends on the whims of GRIT and therefore changes whenever
   // someone adds a new resource.
   int idr_id;
 
   // String to check for when parsing theme manifests or NULL if this isn't
   // supposed to be changeable by the user.
   const char* key;
 };
 
 // IDR_* resource names change whenever new resources are added; use persistent
 // IDs when storing to a cached pack.
 PersistingImagesTable kPersistingImages[] = {
   { PRS_THEME_FRAME, IDR_THEME_FRAME,
     "theme_frame" },
   { PRS_THEME_FRAME_INACTIVE, IDR_THEME_FRAME_INACTIVE,
     "theme_frame_inactive" },
   { PRS_THEME_FRAME_INCOGNITO, IDR_THEME_FRAME_INCOGNITO,
     "theme_frame_incognito" },
   { PRS_THEME_FRAME_INCOGNITO_INACTIVE, IDR_THEME_FRAME_INCOGNITO_INACTIVE,
     "theme_frame_incognito_inactive" },
   { PRS_THEME_TOOLBAR, IDR_THEME_TOOLBAR,
     "theme_toolbar" },
-  { PRS_THEME_TAB_BACKGROUND, IDR_THEME_TAB_BACKGROUND,
+  { PRS_THEME_TAB_BACKGROUND_OVERLAY, IDR_THEME_TAB_BACKGROUND_OVERLAY,
     "theme_tab_background" },
-  { PRS_THEME_TAB_BACKGROUND_INCOGNITO, IDR_THEME_TAB_BACKGROUND_INCOGNITO,
+  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY,
+    IDR_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY,
     "theme_tab_background_incognito" },
-  { PRS_THEME_TAB_BACKGROUND_V, IDR_THEME_TAB_BACKGROUND_V,
+  { PRS_THEME_TAB_BACKGROUND_V_OVERLAY, IDR_THEME_TAB_BACKGROUND_V_OVERLAY,
     "theme_tab_background_v"},
   { PRS_THEME_NTP_BACKGROUND, IDR_THEME_NTP_BACKGROUND,
     "theme_ntp_background" },
   { PRS_THEME_FRAME_OVERLAY, IDR_THEME_FRAME_OVERLAY,
     "theme_frame_overlay" },
   { PRS_THEME_FRAME_OVERLAY_INACTIVE, IDR_THEME_FRAME_OVERLAY_INACTIVE,
     "theme_frame_overlay_inactive" },
   { PRS_THEME_BUTTON_BACKGROUND, IDR_THEME_BUTTON_BACKGROUND,
     "theme_button_background" },
   { PRS_THEME_NTP_ATTRIBUTION, IDR_THEME_NTP_ATTRIBUTION,
     "theme_ntp_attribution" },
   { PRS_THEME_WINDOW_CONTROL_BACKGROUND, IDR_THEME_WINDOW_CONTROL_BACKGROUND,
     "theme_window_control_background"},
 
   // The rest of these entries have no key because they can't be overridden
   // from the json manifest.
-  { 15, IDR_BACK, NULL },
-  { 16, IDR_BACK_D, NULL },
-  { 17, IDR_BACK_H, NULL },
-  { 18, IDR_BACK_P, NULL },
-  { 19, IDR_FORWARD, NULL },
-  { 20, IDR_FORWARD_D, NULL },
-  { 21, IDR_FORWARD_H, NULL },
-  { 22, IDR_FORWARD_P, NULL },
-  { 23, IDR_HOME, NULL },
-  { 24, IDR_HOME_H, NULL },
-  { 25, IDR_HOME_P, NULL },
-  { 26, IDR_RELOAD, NULL },
-  { 27, IDR_RELOAD_H, NULL },
-  { 28, IDR_RELOAD_P, NULL },
-  { 29, IDR_STOP, NULL },
-  { 30, IDR_STOP_D, NULL },
-  { 31, IDR_STOP_H, NULL },
-  { 32, IDR_STOP_P, NULL },
-  { 33, IDR_BROWSER_ACTIONS_OVERFLOW, NULL },
-  { 34, IDR_BROWSER_ACTIONS_OVERFLOW_H, NULL },
-  { 35, IDR_BROWSER_ACTIONS_OVERFLOW_P, NULL },
-  { 36, IDR_TOOLS, NULL },
-  { 37, IDR_TOOLS_H, NULL },
-  { 38, IDR_TOOLS_P, NULL },
-  { 39, IDR_MENU_DROPARROW, NULL },
-  { 40, IDR_THROBBER, NULL },
-  { 41, IDR_THROBBER_WAITING, NULL },
-  { 42, IDR_THROBBER_LIGHT, NULL },
-  { 43, IDR_TOOLBAR_BEZEL_HOVER, NULL },
-  { 44, IDR_TOOLBAR_BEZEL_PRESSED, NULL },
-  { 45, IDR_TOOLS_BAR, NULL },
+  { PRS_THEME_TAB_BACKGROUND, IDR_THEME_TAB_BACKGROUND, NULL },
+  { PRS_THEME_TAB_BACKGROUND_INCOGNITO,
+    IDR_THEME_TAB_BACKGROUND_INCOGNITO, NULL },
+  { 17, IDR_BACK, NULL },
+  { 18, IDR_BACK_D, NULL },
+  { 19, IDR_BACK_H, NULL },
+  { 20, IDR_BACK_P, NULL },
+  { 21, IDR_FORWARD, NULL },
+  { 22, IDR_FORWARD_D, NULL },
+  { 23, IDR_FORWARD_H, NULL },
+  { 24, IDR_FORWARD_P, NULL },
+  { 25, IDR_HOME, NULL },
+  { 26, IDR_HOME_H, NULL },
+  { 27, IDR_HOME_P, NULL },
+  { 28, IDR_RELOAD, NULL },
+  { 29, IDR_RELOAD_H, NULL },
+  { 30, IDR_RELOAD_P, NULL },
+  { 31, IDR_STOP, NULL },
+  { 32, IDR_STOP_D, NULL },
+  { 33, IDR_STOP_H, NULL },
+  { 34, IDR_STOP_P, NULL },
+  { 35, IDR_BROWSER_ACTIONS_OVERFLOW, NULL },
+  { 36, IDR_BROWSER_ACTIONS_OVERFLOW_H, NULL },
+  { 37, IDR_BROWSER_ACTIONS_OVERFLOW_P, NULL },
+  { 38, IDR_TOOLS, NULL },
+  { 39, IDR_TOOLS_H, NULL },
+  { 40, IDR_TOOLS_P, NULL },
+  { 41, IDR_MENU_DROPARROW, NULL },
+  { 42, IDR_THROBBER, NULL },
+  { 43, IDR_THROBBER_WAITING, NULL },
+  { 44, IDR_THROBBER_LIGHT, NULL },
+  { 45, IDR_TOOLBAR_BEZEL_HOVER, NULL },
+  { 46, IDR_TOOLBAR_BEZEL_PRESSED, NULL },
+  { 47, IDR_TOOLS_BAR, NULL },
 };
 const size_t kPersistingImagesLength = arraysize(kPersistingImages);
 
 #if defined(OS_WIN) && defined(USE_AURA)
 // Persistent theme ids for Windows AURA.
 const int PRS_THEME_FRAME_WIN = 100;
 const int PRS_THEME_FRAME_INACTIVE_WIN = 101;
 const int PRS_THEME_FRAME_INCOGNITO_WIN = 102;
 const int PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN = 103;
 const int PRS_THEME_TOOLBAR_WIN = 104;
-const int PRS_THEME_TAB_BACKGROUND_WIN = 105;
-const int PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN = 106;
+const int PRS_THEME_TAB_BACKGROUND_OVERLAY_WIN = 105;
+const int PRS_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY_WIN = 106;
+const int PRS_THEME_TAB_BACKGROUND_WIN = 107;
+const int PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN = 108;
 
 // Persistent theme to resource id mapping for Windows AURA.
 PersistingImagesTable kPersistingImagesWinDesktopAura[] = {
   { PRS_THEME_FRAME_WIN, IDR_THEME_FRAME_WIN,
     "theme_frame" },
   { PRS_THEME_FRAME_INACTIVE_WIN, IDR_THEME_FRAME_INACTIVE_WIN,
     "theme_frame_inactive" },
   { PRS_THEME_FRAME_INCOGNITO_WIN, IDR_THEME_FRAME_INCOGNITO_WIN,
     "theme_frame_incognito" },
   { PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
     IDR_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
     "theme_frame_incognito_inactive" },
   { PRS_THEME_TOOLBAR_WIN, IDR_THEME_TOOLBAR_WIN,
     "theme_toolbar" },
-  { PRS_THEME_TAB_BACKGROUND_WIN, IDR_THEME_TAB_BACKGROUND_WIN,
+  { PRS_THEME_TAB_BACKGROUND_OVERLAY_WIN, IDR_THEME_TAB_BACKGROUND_OVERLAY_WIN,
     "theme_tab_background" },
-  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN,
-    IDR_THEME_TAB_BACKGROUND_INCOGNITO_WIN,
+  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY_WIN,
+    IDR_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY_WIN,
     "theme_tab_background_incognito" },
 };
 const size_t kPersistingImagesWinDesktopAuraLength =
     arraysize(kPersistingImagesWinDesktopAura);
 #endif
 
 int GetPersistentIDByNameHelper(const std::string& key,
                                 const PersistingImagesTable* image_table,
                                 size_t image_table_size) {
   for (size_t i = 0; i < image_table_size; ++i) {
@@ skipping 141 matching lines @@
     ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
 #if defined(OS_WIN) && defined(USE_AURA)
   { PRS_THEME_FRAME_WIN, ThemeProperties::TINT_FRAME },
   { PRS_THEME_FRAME_INACTIVE_WIN, ThemeProperties::TINT_FRAME_INACTIVE },
   { PRS_THEME_FRAME_INCOGNITO_WIN, ThemeProperties::TINT_FRAME_INCOGNITO },
   { PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
     ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
 #endif
 };
 
-// Mapping used in GenerateTabBackgroundImages() to associate what frame image
+// Mapping used in CreateTabBackgroundImages() to associate what frame image
 // goes with which tab background.
 IntToIntTable kTabBackgroundMap[] = {
   { PRS_THEME_TAB_BACKGROUND, PRS_THEME_FRAME },
   { PRS_THEME_TAB_BACKGROUND_INCOGNITO, PRS_THEME_FRAME_INCOGNITO },
 #if defined(OS_WIN) && defined(USE_AURA)
   { PRS_THEME_TAB_BACKGROUND_WIN, PRS_THEME_FRAME_WIN },
   { PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN, PRS_THEME_FRAME_INCOGNITO_WIN },
 #endif
 };
 
+// The tab background overlay images. For the sake of simplicity, these images
+// are resized to have the exact height listed in |kImagesToCrop|.
+int kTabBackgroundOverlayImages[] = {
+  PRS_THEME_TAB_BACKGROUND_OVERLAY,
+  PRS_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY,
+#if defined(OS_WIN) && defined(USE_AURA)
+  PRS_THEME_TAB_BACKGROUND_OVERLAY_WIN,
+  PRS_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY_WIN
+#endif
+};
+
 struct CropEntry {
   int prs_id;
 
   // The maximum useful height of the image at |prs_id|.
   int max_height;
 
   // Whether cropping the image at |prs_id| should be skipped on OSes which
   // have a frame border to the left and right of the web contents.
   // This should be true for images which can be used to decorate the border to
   // the left and the right of the web contents.
   bool skip_if_frame_border;
 };
 
 // The images which should be cropped before being saved to the data pack. The
 // maximum heights are meant to be conservative as to give room for the UI to
 // change without the maximum heights having to be modified.
 // |kThemePackVersion| must be incremented if any of the maximum heights below
 // are modified.
-struct CropEntry kImagesToCrop[] = {
+CropEntry kImagesToCrop[] = {
   { PRS_THEME_FRAME, 120, true },
   { PRS_THEME_FRAME_INACTIVE, 120, true },
   { PRS_THEME_FRAME_INCOGNITO, 120, true },
   { PRS_THEME_FRAME_INCOGNITO_INACTIVE, 120, true },
   { PRS_THEME_FRAME_OVERLAY, 120, true },
   { PRS_THEME_FRAME_OVERLAY_INACTIVE, 120, true },
   { PRS_THEME_TOOLBAR, 200, false },
+  { PRS_THEME_TAB_BACKGROUND_OVERLAY, 120, false },
+  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY, 120, false },
+  { PRS_THEME_TAB_BACKGROUND_V_OVERLAY, 120, false },
+  { PRS_THEME_TAB_BACKGROUND, 120, false },
+  { PRS_THEME_TAB_BACKGROUND_INCOGNITO, 120, false },
   { PRS_THEME_BUTTON_BACKGROUND, 60, false },
   { PRS_THEME_WINDOW_CONTROL_BACKGROUND, 50, false },
 #if defined(OS_WIN) && defined(USE_AURA)
-  { PRS_THEME_TOOLBAR_WIN, 200, false }
+  { PRS_THEME_TOOLBAR_WIN, 200, false },
+  { PRS_THEME_TAB_BACKGROUND_OVERLAY_WIN, 120, false },
+  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY_WIN, 120, false },
+  { PRS_THEME_TAB_BACKGROUND_WIN, 120, false },
+  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN, 120, false }
 #endif
 };
 
-
 // A list of images that don't need tinting or any other modification and can
 // be byte-copied directly into the finished DataPack. This should contain the
 // persistent IDs for all themeable image IDs that aren't in kFrameTintMap,
 // kTabBackgroundMap or kImagesToCrop.
 const int kPreloadIDs[] = {
   PRS_THEME_NTP_BACKGROUND,
   PRS_THEME_NTP_ATTRIBUTION,
 };
 
 // Returns true if this OS uses a browser frame which has a non zero width to
@@ skipping 20 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 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();
+// Returns the maximum height for |prs_id|. Returns -1 if there is no maximum
+// height.
+int GetMaxHeight(int prs_id) {
+  for (size_t i = 0; i < arraysize(kImagesToCrop); ++i) {
+    if (kImagesToCrop[i].prs_id != prs_id)
+      continue;
+
+    if (HasFrameBorder() && kImagesToCrop[i].skip_if_frame_border)
+      return -1;
+    return kImagesToCrop[i].max_height;
+  }
+  return -1;
+}
+
+// Returns an image which is cropped based on the maximum height for
+// |destination_prs_id|. This method is a no-op if no cropping is necessary.
+gfx::Image CreateCroppedImage(const gfx::Image& source_image,
+                              int destination_prs_id) {
+  int crop_height = GetMaxHeight(destination_prs_id);
+  if (crop_height < 0)
+    return source_image;
+
+  gfx::ImageSkia image_skia = source_image.AsImageSkia();
+  return gfx::Image(gfx::ImageSkiaOperations::ExtractSubset(
+      image_skia, gfx::Rect(0, 0, image_skia.width(), crop_height)));
+}
+
+// Retuns an image which is cropped based on the maximum height for
+// |destination_prs_id| and which is shifted by |hsl_shift|.
+gfx::Image CreateHSLShiftedAndCroppedImage(const gfx::Image& image,
+                                           const color_utils::HSL& hsl_shift,
+                                           int destination_prs_id) {
+  gfx::Image cropped = CreateCroppedImage(image, destination_prs_id);
   return gfx::Image(gfx::ImageSkiaOperations::CreateHSLShiftedImage(
-      *src_image, hsl_shift));
+      cropped.AsImageSkia(), hsl_shift));
 }
 
 // Computes a bitmap at one scale from a bitmap at a different scale.
 SkBitmap CreateLowQualityResizedBitmap(const SkBitmap& source_bitmap,
                                        ui::ScaleFactor source_scale_factor,
                                        ui::ScaleFactor desired_scale_factor) {
   gfx::Size scaled_size = gfx::ToCeiledSize(
       gfx::ScaleSize(gfx::Size(source_bitmap.width(),
                                source_bitmap.height()),
                      ui::GetScaleFactorScale(desired_scale_factor) /
@@ skipping 119 matching lines @@
   }
 
   PngMap png_map_;
 
   typedef std::map<ui::ScaleFactor, SkBitmap> BitmapMap;
   BitmapMap bitmap_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ThemeImagePngSource);
 };
 
-class TabBackgroundImageSource: public gfx::CanvasImageSource {
+// ImageSkiaSource which resizes |image| to |size| by padding |image| with
+// transparent pixels.
+class PadWithTransparentImageSource : 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) {
+  PadWithTransparentImageSource(const gfx::ImageSkia& image,
+                                const gfx::Size& size)
+      : gfx::CanvasImageSource(size, false),
+        image_(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());
-    }
+  virtual ~PadWithTransparentImageSource() {
   }
 
  private:
-  const gfx::ImageSkia image_to_tint_;
-  const gfx::ImageSkia overlay_;
-  const color_utils::HSL hsl_shift_;
-  const int vertical_offset_;
+  // Overridden from CanvasImageSource:
+  virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
+    canvas->DrawImageInt(image_, 0, 0);
+  }
 
-  DISALLOW_COPY_AND_ASSIGN(TabBackgroundImageSource);
+  const gfx::ImageSkia image_;
+
+  DISALLOW_COPY_AND_ASSIGN(PadWithTransparentImageSource);
 };
 
 }  // namespace
 
 BrowserThemePack::~BrowserThemePack() {
   if (!data_pack_.get()) {
     delete header_;
     delete [] tints_;
     delete [] colors_;
     delete [] display_properties_;
@@ skipping 667 matching lines @@
 }
 
 void BrowserThemePack::CreateImages(ImageCache* images) const {
   CropImages(images);
   CreateFrameImages(images);
   CreateTintedButtons(GetTintInternal(ThemeProperties::TINT_BUTTONS), images);
   CreateTabBackgroundImages(images);
 }
 
 void BrowserThemePack::CropImages(ImageCache* images) const {
-  bool has_frame_border = HasFrameBorder();
-  for (size_t i = 0; i < arraysize(kImagesToCrop); ++i) {
-    if (has_frame_border && kImagesToCrop[i].skip_if_frame_border)
-      continue;
-
-    int prs_id = kImagesToCrop[i].prs_id;
-    ImageCache::iterator it = images->find(prs_id);
-    if (it == images->end())
-      continue;
-
-    int crop_height = kImagesToCrop[i].max_height;
-    gfx::ImageSkia image_skia = it->second.AsImageSkia();
-    (*images)[prs_id] = gfx::Image(gfx::ImageSkiaOperations::ExtractSubset(
-        image_skia, gfx::Rect(0, 0, image_skia.width(), crop_height)));
+  ImageCache temp_output;
+  for (ImageCache::const_iterator it = images->begin();
+       it != images->end(); ++it) {
+    temp_output[it->first] = CreateCroppedImage(it->second, it->first);
   }
+  MergeImageCaches(temp_output, images);
 }
 
 void BrowserThemePack::CreateFrameImages(ImageCache* images) const {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
   // 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) {
@@ skipping 50 matching lines @@
       // the default frame.
       frame = rb.GetImageNamed(IDR_THEME_FRAME);
 #if defined(OS_WIN) && defined(USE_AURA)
       if (prs_id >= PRS_THEME_FRAME_WIN &&
           prs_id <= PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN) {
         frame = rb.GetImageNamed(IDR_THEME_FRAME_WIN);
       }
 #endif
     }
     if (!frame.IsEmpty()) {
-      temp_output[prs_id] = CreateHSLShiftedImage(
-          frame, GetTintInternal(kFrameTintMap[i].value));
+      temp_output[prs_id] = CreateHSLShiftedAndCroppedImage(
+          frame, GetTintInternal(kFrameTintMap[i].value), prs_id);
     }
   }
   MergeImageCaches(temp_output, images);
 }
 
 void BrowserThemePack::CreateTintedButtons(
     const color_utils::HSL& button_tint,
     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 =
         ThemeProperties::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_images)[prs_id] =
-          CreateHSLShiftedImage(button, button_tint);
+          CreateHSLShiftedAndCroppedImage(button, button_tint, prs_id);
     }
   }
 }
 
 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;
+    int prs_frame_id = kTabBackgroundMap[i].value;
+    ImageCache::const_iterator frame_it = images->find(prs_frame_id);
+    if (frame_it == images->end()) {
+      // There is no image to tint.
+      continue;
+    }
 
-    // We only need to generate the background tab images if we were provided
-    // with a PRS_THEME_FRAME.
-    ImageCache::const_iterator it = images->find(prs_base_id);
-    if (it != images->end()) {
-      gfx::ImageSkia image_to_tint = (it->second).AsImageSkia();
-      color_utils::HSL hsl_shift = GetTintInternal(
-          ThemeProperties::TINT_BACKGROUND_TAB);
-      int vertical_offset = images->count(prs_id)
-                            ? kRestoredTabVerticalOffset : 0;
+    int prs_dest_id = kTabBackgroundMap[i].key;
+    color_utils::HSL tint = GetTintInternal(
+        ThemeProperties::TINT_BACKGROUND_TAB);
+    temp_output[prs_dest_id] = CreateHSLShiftedAndCroppedImage(
+        frame_it->second, tint, prs_dest_id);
+  }
 
-      gfx::ImageSkia overlay;
-      ImageCache::const_iterator overlay_it = images->find(prs_id);
-      if (overlay_it != images->end())
-        overlay = overlay_it->second.AsImageSkia();
+  // The tab background overlay images are tiled horizontally but not
+  // vertically. We have always done it this way. Pad the overlay images
+  // with enough transparent pixels so that they do not get tiled vertically
+  // to simplify the code which deals with the tab background overlay images.
+  // TODO: Investigate if any themes rely on the vertical tiling behavior.
+  for (size_t i = 0; i < arraysize(kTabBackgroundOverlayImages); ++i) {
+    int prs_overlay_id = kTabBackgroundOverlayImages[i];
+    ImageCache::const_iterator overlay_it = images->find(prs_overlay_id);
+    if (overlay_it == images->end())
+      continue;
 
-      gfx::ImageSkiaSource* source = new TabBackgroundImageSource(
-          image_to_tint, overlay, hsl_shift, vertical_offset);
-      // ImageSkia takes ownership of |source|.
-      temp_output[prs_id] = gfx::Image(gfx::ImageSkia(source,
-          image_to_tint.size()));
-    }
+    int desired_height = GetMaxHeight(prs_overlay_id);
+    gfx::ImageSkia overlay = overlay_it->second.AsImageSkia();
+    if (overlay.height() == desired_height)
+      continue;
+
+    // The ImageSkia takes ownership of |source|.
+    PadWithTransparentImageSource* source = new PadWithTransparentImageSource(
+        overlay, gfx::Size(overlay.width(), desired_height));
+    temp_output[prs_overlay_id] = gfx::Image(gfx::ImageSkia(
+        source, source->size()));
   }
   MergeImageCaches(temp_output, images);
 }
 
 void BrowserThemePack::RepackImages(const ImageCache& images,
                                     RawImages* reencoded_images) const {
   typedef std::vector<ui::ScaleFactor> ScaleFactors;
   for (ImageCache::const_iterator it = images.begin();
        it != images.end(); ++it) {
     gfx::ImageSkia image_skia = *it->second.ToImageSkia();
@@ skipping 144 matching lines @@
                                            false,
                                            &bitmap_data)) {
       NOTREACHED() << "Unable to encode theme image for prs_id="
                    << prs_id << " for scale_factor=" << scale_factors_[i];
       break;
     }
     image_memory_[scaled_raw_id] =
         base::RefCountedBytes::TakeVector(&bitmap_data);
   }
 }