Use LANCZOS3 resize algorithm to generate missing image reps for extension action icons.

ui/gfx/image/image_skia_operations.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 "ui/gfx/image/image_skia_operations.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
@@ skipping 326 matching lines @@
   }
 
  private:
   const ImageSkia source_;
   skia::ImageOperations::ResizeMethod resize_method_;
   const Size target_dip_size_;
 
   DISALLOW_COPY_AND_ASSIGN(ResizeSource);
 };
 
+// Image source that uses |resize_method| to generate missing image
+// representations.
+class FallbackResizeSource : public ImageSkiaSource {

[pkotwicz, 2012/10/16 22:13:27]

Can you use ResizeSource here?
Also can you fix the bug in ResizeSource where we do not check the scale factor
of the returned image?
The only suggestion I have is "ImageSkiaOperations::SetResizeMethod(const
gfx::ImageSkia& image_skia, skia::ImageOperations::ResizeMethod resize_method)"
which I am unsure if it is better.

[tbarzic, 2012/10/16 23:19:33]

Done.
hm, we could also use CreateResizedImage directly, but it feels a bit weird to
resize image to its original size...

+ public:
+  FallbackResizeSource(const ImageSkia& source,
+                       skia::ImageOperations::ResizeMethod resize_method)
+    : source_(source),
+      resize_method_(resize_method) {
+  }
+  virtual ~FallbackResizeSource() {}
+
+  // gfx::ImageSkiaSource overrides:
+  virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
+    const ImageSkiaRep& image_rep = source_.GetRepresentation(scale_factor);
+    if (image_rep.scale_factor() == scale_factor)
+      return image_rep;
+
+    const float scale = ui::GetScaleFactorScale(scale_factor);
+    const Size target_pixel_size = gfx::ToFlooredSize(
+        source_.size().Scale(scale));
+
+    const SkBitmap resized = skia::ImageOperations::Resize(
+        image_rep.sk_bitmap(),
+        resize_method_,
+        target_pixel_size.width(),
+        target_pixel_size.height());
+    return ImageSkiaRep(resized, scale_factor);
+  }
+
+ private:
+  ImageSkia source_;
+  skia::ImageOperations::ResizeMethod resize_method_;
+};
+
 // DropShadowSource generates image reps with drop shadow for image reps in
 // |source| that represent requested scale factors.
 class DropShadowSource : public ImageSkiaSource {
  public:
   DropShadowSource(const ImageSkia& source,
                    const ShadowValues& shadows_in_dip)
       : source_(source),
         shaodws_in_dip_(shadows_in_dip) {
   }
   virtual ~DropShadowSource() {}
@@ skipping 85 matching lines @@
 // static
 ImageSkia ImageSkiaOperations::CreateResizedImage(
     const ImageSkia& source,
     skia::ImageOperations::ResizeMethod method,
     const Size& target_dip_size) {
   return ImageSkia(new ResizeSource(source, method, target_dip_size),
                    target_dip_size);
 }
 
 // static
+ImageSkia ImageSkiaOperations::CreateImageWithFallbackResizeMethod(
+      const ImageSkia& source,
+      skia::ImageOperations::ResizeMethod resize_method) {
+  return ImageSkia(new FallbackResizeSource(source, resize_method),
+                   source.size());
+}
+
+// static
 ImageSkia ImageSkiaOperations::CreateImageWithDropShadow(
     const ImageSkia& source,
     const ShadowValues& shadows) {
   const gfx::Insets shadow_padding = -gfx::ShadowValue::GetMargin(shadows);
   gfx::Size shadow_image_size = source.size();
   shadow_image_size.Enlarge(shadow_padding.width(),
                             shadow_padding.height());
   return ImageSkia(new DropShadowSource(source, shadows), shadow_image_size);
 }
 
 }  // namespace gfx