chromeos: Fix pixelated icons in app list and launcher (part 1)

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"
 #include "ui/base/layout.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/image/image_skia_source.h"
+#include "ui/gfx/insets.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/gfx/skia_util.h"
 
 namespace gfx {
 namespace {
 
 bool ScalingEnabled() {
   static bool scale_images = !CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 109 matching lines @@
  private:
   const ImageSkia& source_;
   const int src_x_;
   const int src_y_;
   const int dst_w_;
   const int dst_h_;
 
   DISALLOW_COPY_AND_ASSIGN(TiledImageSource);
 };
 
+class ResizeSource : public ImageSkiaSource {
+ public:
+  ResizeSource(const ImageSkia& source,
+               const Size& target_dip_size)
+      : source_(source),
+        target_dip_size_(target_dip_size) {
+  }
+  virtual ~ResizeSource() {}
+
+ private:
+  // gfx::ImageSkiaSource overrides:
+  virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
+    const ImageSkiaRep& image_rep = source_.GetRepresentation(scale_factor);
+    if (image_rep.GetWidth() == target_dip_size_.width() &&
+        image_rep.GetHeight() == target_dip_size_.height())
+      return image_rep;
+
+    const float scale = image_rep.GetScale();
+    const Size target_pixel_size(target_dip_size_.Scale(scale));
+    const SkBitmap resized = skia::ImageOperations::Resize(
+        image_rep.sk_bitmap(),
+        skia::ImageOperations::RESIZE_BEST,
+        target_pixel_size.width(),
+        target_pixel_size.height());
+    return ImageSkiaRep(resized, image_rep.scale_factor());
+  }
+
+  const ImageSkia source_;
+  const Size target_dip_size_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResizeSource);
+};
+
+class DropShadowSource : public ImageSkiaSource {
+ public:
+  DropShadowSource(const ImageSkia& source,
+                   const ShadowValues& dip_shadows)
+      : source_(source),
+        dip_shadows_(dip_shadows) {
+  }
+  virtual ~DropShadowSource() {}
+
+ private:
+  // gfx::ImageSkiaSource overrides:
+  virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
+    const ImageSkiaRep& image_rep = source_.GetRepresentation(scale_factor);
+
+    const float scale = image_rep.GetScale();
+    ShadowValues shadow_in_pixel;
+    for (size_t i = 0; i < dip_shadows_.size(); ++i)
+      shadow_in_pixel.push_back(dip_shadows_[i].Scale(scale));
+
+    const SkBitmap shadow_image = SkBitmapOperations::CreateDropShadow(
+        image_rep.sk_bitmap(),
+        shadow_in_pixel);
+    return ImageSkiaRep(shadow_image, image_rep.scale_factor());
+  }
+
+  const ImageSkia source_;
+  const ShadowValues dip_shadows_;
+
+  DISALLOW_COPY_AND_ASSIGN(DropShadowSource);
+};
+
 }  // namespace;
 
 // static
 ImageSkia ImageSkiaOperations::CreateBlendedImage(const ImageSkia& first,
                                                   const ImageSkia& second,
                                                   double alpha) {
   return ImageSkia(new BlendingImageSource(first, second, alpha), first.size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateMaskedImage(const ImageSkia& rgb,
                                                  const ImageSkia& alpha) {
   return ImageSkia(new MaskedImageSource(rgb, alpha), rgb.size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateTiledImage(const ImageSkia& source,
                                                 int src_x, int src_y,
                                                 int dst_w, int dst_h) {
   return ImageSkia(new TiledImageSource(source, src_x, src_y, dst_w, dst_h),
                    gfx::Size(dst_w, dst_h));
 }
 
+// static
+ImageSkia ImageSkiaOperations::CreateResizedImage(const ImageSkia& source,
+                                                  const Size& target_dip_size) {
+  return ImageSkia(new ResizeSource(source, target_dip_size), target_dip_size);
+}
+
+// static
+ImageSkia ImageSkiaOperations::CreateDropShadowImage(
+    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