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 10 matching lines @@
 #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/image/image_skia_operations.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skia_util.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 
 namespace {
 
@@ skipping 283 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->CreateImages(&pack->images_on_ui_thread_);
-  pack->CreateImages(&pack->images_on_file_thread_);
 
   // Make sure the |images_on_file_thread_| has bitmaps for supported
   // scale factors before passing to FILE thread.
+  pack->images_on_file_thread_ = pack->images_on_ui_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;
 }