Crop images from custom themes before storing them into the theme 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"
@@ skipping 311 matching lines @@
   }
 
   return -1;
 }
 
 struct IntToIntTable {
   int key;
   int value;
 };
 
-// Mapping used in GenerateFrameImages() to associate frame images with the
+// Mapping used in CreateFrameImages() to associate frame images with the
 // tint ID that should maybe be applied to it.
 IntToIntTable kFrameTintMap[] = {
   { PRS_THEME_FRAME, ThemeProperties::TINT_FRAME },
   { PRS_THEME_FRAME_INACTIVE, ThemeProperties::TINT_FRAME_INACTIVE },
   { PRS_THEME_FRAME_OVERLAY, ThemeProperties::TINT_FRAME },
   { PRS_THEME_FRAME_OVERLAY_INACTIVE,
     ThemeProperties::TINT_FRAME_INACTIVE },
   { PRS_THEME_FRAME_INCOGNITO, ThemeProperties::TINT_FRAME_INCOGNITO },
   { PRS_THEME_FRAME_INCOGNITO_INACTIVE,
     ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
@@ skipping 10 matching lines @@
 // 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
 };
 
+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[] = {
+  { 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_BUTTON_BACKGROUND, 60, false },
+  { PRS_THEME_WINDOW_CONTROL_BACKGROUND, 50, false }
+#if defined(OS_WIN) && defined(USE_AURA)
+  { PRS_THEME_TOOLBAR_WIN, 200, 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 or
-// kTabBackgroundMap.
+// persistent IDs for all themeable image IDs that aren't in kFrameTintMap,
+// kTabBackgroundMap or kImagesToCrop.
 const int kPreloadIDs[] = {
-  PRS_THEME_TOOLBAR,
   PRS_THEME_NTP_BACKGROUND,
-  PRS_THEME_BUTTON_BACKGROUND,
   PRS_THEME_NTP_ATTRIBUTION,
-  PRS_THEME_WINDOW_CONTROL_BACKGROUND,
-#if defined(OS_WIN) && defined(USE_AURA)
-  PRS_THEME_TOOLBAR_WIN,
+};
+
+// Returns true if this OS uses a browser frame which has a non zero width to
+// the left and the right of the web contents.
+bool HasFrameBorder() {
+#if defined(OS_CHROMEOS) || defined(OS_MACOSX)
+  return false;
+#else
+  return true;
 #endif
-};
+}
 
 // Returns a piece of memory with the contents of the file |path|.
 base::RefCountedMemory* ReadFileData(const base::FilePath& path) {
   if (!path.empty()) {
     net::FileStream file(NULL);
     int flags = base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ;
     if (file.OpenSync(path, flags) == net::OK) {
       int64 avail = file.Available();
       if (avail > 0 && avail < INT_MAX) {
         size_t size = static_cast<size_t>(avail);
         std::vector<unsigned char> raw_data;
         raw_data.resize(size);
         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) {
+gfx::Image CreateHSLShiftedImage(const gfx::Image& image,
+                                 const color_utils::HSL& hsl_shift) {
   const gfx::ImageSkia* src_image = image.ToImageSkia();
-  return new gfx::Image(gfx::ImageSkiaOperations::CreateHSLShiftedImage(
+  return gfx::Image(gfx::ImageSkiaOperations::CreateHSLShiftedImage(
       *src_image, hsl_shift));
 }
 
 // A ImageSkiaSource that scales 100P image to the target scale factor
 // if the ImageSkiaRep for the target scale factor isn't available.
 class ThemeImageSource: public gfx::ImageSkiaSource {
  public:
   explicit ThemeImageSource(const gfx::ImageSkia& source) : source_(source) {
   }
   virtual ~ThemeImageSource() {}
@@ skipping 69 matching lines @@
 }  // namespace
 
 BrowserThemePack::~BrowserThemePack() {
   if (!data_pack_.get()) {
     delete header_;
     delete [] tints_;
     delete [] colors_;
     delete [] display_properties_;
     delete [] source_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(extensions::ThemeInfo::GetThemeTints(extension));
   pack->BuildColorsFromJSON(extensions::ThemeInfo::GetThemeColors(extension));
   pack->BuildDisplayPropertiesFromJSON(
       extensions::ThemeInfo::GetThemeDisplayProperties(extension));
 
   // Builds the images. (Image building is dependent on tints).
   FilePathMap file_paths;
   pack->ParseImageNamesFromJSON(
       extensions::ThemeInfo::GetThemeImages(extension),
       extension->path(),
       &file_paths);
   pack->BuildSourceImagesArray(file_paths);
 
   if (!pack->LoadRawBitmapsTo(file_paths, &pack->images_on_ui_thread_))
     return NULL;
 
-  pack->CopyImagesTo(pack->images_on_ui_thread_, &pack->images_on_file_thread_);
+  pack->images_on_file_thread_ = pack->images_on_ui_thread_;
 
   pack->CreateImages(&pack->images_on_ui_thread_);
   pack->CreateImages(&pack->images_on_file_thread_);

[Elliot Glaysher, 2013/04/03 17:23:35]

I think that somethings gone a little screwy here. It looks like
|images_on_file_thread_| and |images_on_ui_thread_| are now identical. And
you're creating all the images twice?

[pkotwicz, 2013/04/03 20:27:22]

You are right that this is suboptimal. I will take a pass to fix this better
than I did in this patch set in another CL. In particular, I will do the fix
before we launch hidpi Windows.
We were doing lazy loading so it was not quite as bad as creating the images
twice sequentially (but still pretty bad).

 
   // Make sure the |images_on_file_thread_| has bitmaps for supported
   // scale factors before passing to FILE thread.
   for (ImageCache::iterator it = pack->images_on_file_thread_.begin();
        it != pack->images_on_file_thread_.end(); ++it) {
     gfx::ImageSkia* image_skia =
-        const_cast<gfx::ImageSkia*>(it->second->ToImageSkia());
+        const_cast<gfx::ImageSkia*>(it->second.ToImageSkia());
     image_skia->MakeThreadSafe();
   }
 
   // The BrowserThemePack is now in a consistent state.
   return pack;
 }
 
 // static
 scoped_refptr<BrowserThemePack> BrowserThemePack::BuildFromDataPack(
     const base::FilePath& path, const std::string& expected_id) {
@@ skipping 133 matching lines @@
       if (display_properties_[i].id == id) {
         *result = display_properties_[i].property;
         return true;
       }
     }
   }
 
   return false;
 }
 
-const gfx::Image* BrowserThemePack::GetImageNamed(int idr_id) const {
+gfx::Image BrowserThemePack::GetImageNamed(int idr_id) {
   int prs_id = GetPersistentIDByIDR(idr_id);
   if (prs_id == -1)
-    return NULL;
+    return gfx::Image();
 
   // 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;
 
   // TODO(pkotwicz): Do something better than loading the bitmaps
   // for all the scale factors associated with |idr_id|.
   gfx::ImageSkia source_image_skia;
   for (size_t i = 0; i < scale_factors_.size(); ++i) {
     scoped_refptr<base::RefCountedMemory> memory =
         GetRawData(idr_id, 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.";
         continue;
       }
       source_image_skia.AddRepresentation(
           gfx::ImageSkiaRep(bitmap, scale_factors_[i]));
     }
   }
 
   if (!source_image_skia.isNull()) {
     ThemeImageSource* source = new ThemeImageSource(source_image_skia);
     gfx::ImageSkia image_skia(source, source_image_skia.size());
-    gfx::Image* ret = new gfx::Image(image_skia);
+    gfx::Image ret = gfx::Image(image_skia);
     images_on_ui_thread_[prs_id] = ret;
     return ret;
   }
-  return NULL;
+  return gfx::Image();
 }
 
 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 (raw_id != -1) {
@@ skipping 349 matching lines @@
 
     if (is_copyable) {
       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)) {
         (*image_cache)[prs_id] =
-            new gfx::Image(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
+            gfx::Image(gfx::ImageSkia::CreateFrom1xBitmap(bitmap));
       } else {
         NOTREACHED() << "Unable to decode theme image resource " << it->first;
       }
     }
   }
 
   return true;
 }
 
 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)));
+  }
+}
+
 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) {
     int prs_id = kFrameTintMap[i].key;
-    const gfx::Image* frame = NULL;
+    gfx::Image frame;
     // 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 = 0;
 
 #if defined(OS_WIN) && defined(USE_AURA)
     if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN) {
       prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO_WIN) ?
                     PRS_THEME_FRAME_INCOGNITO_WIN : PRS_THEME_FRAME_WIN;
     } else if (prs_id == PRS_THEME_FRAME_INACTIVE_WIN) {
@@ skipping 24 matching lines @@
       frame = (*images)[prs_base_id];
     } else if (prs_base_id == PRS_THEME_FRAME_OVERLAY) {
 #if defined(OS_WIN) && defined(USE_AURA)
       if (images->count(PRS_THEME_FRAME_WIN)) {
 #else
       if (images->count(PRS_THEME_FRAME)) {
 #endif
         // 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;
+        frame = gfx::Image();
       }
     } else {
       // If the theme doesn't specify an image, then apply the tint to
       // the default frame.
-      frame = &rb.GetImageNamed(IDR_THEME_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);
+        frame = rb.GetImageNamed(IDR_THEME_FRAME_WIN);
       }
 #endif
     }
-    if (frame) {
+    if (!frame.IsEmpty()) {
       temp_output[prs_id] = CreateHSLShiftedImage(
-          *frame, GetTintInternal(kFrameTintMap[i].value));
+          frame, GetTintInternal(kFrameTintMap[i].value));
     }
   }
   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();
@@ skipping 17 matching lines @@
 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 = images->find(prs_base_id);
     if (it != images->end()) {
-      const gfx::ImageSkia* image_to_tint = (it->second)->ToImageSkia();
+      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;
 
       gfx::ImageSkia overlay;
       ImageCache::const_iterator overlay_it = images->find(prs_id);
       if (overlay_it != images->end())
-        overlay = *overlay_it->second->ToImageSkia();
+        overlay = overlay_it->second.AsImageSkia();
 
       gfx::ImageSkiaSource* source = new TabBackgroundImageSource(
-          *image_to_tint, overlay, hsl_shift, vertical_offset);
+          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()));
+      temp_output[prs_id] = gfx::Image(gfx::ImageSkia(source,
+          image_to_tint.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();
+    gfx::ImageSkia image_skia = *it->second.ToImageSkia();
 
     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::MergeImageCaches(
     const ImageCache& source, ImageCache* destination) const {
   for (ImageCache::const_iterator it = source.begin(); it != source.end();
        ++it) {
-    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 {
   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 {
@@ skipping 17 matching lines @@
     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;
 }