Fix rounding rules for skia operations to work with non-integer scaling factors.

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 "ui/base/layout.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/canvas_image_source.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/point.h"
+#include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/gfx/skia_util.h"
 
 namespace gfx {
 namespace {
 
+gfx::Size DIPToPixelSize(gfx::Size dip_size, float scale) {
+  return ToCeiledSize(ScaleSize(dip_size, scale));
+}
+
+gfx::Rect DIPToPixelBounds(gfx::Rect dip_bounds, float scale) {
+  return gfx::Rect(ToFlooredPoint(ScalePoint(dip_bounds.origin(), scale)),
+                   DIPToPixelSize(dip_bounds.size(), scale));
+}
+
+ImageSkiaRep CropImageSkiaRep(ImageSkiaRep& source,
+                              gfx::Rect& bounds_in_pixel) {

[oshima, 2013/03/14 18:12:20]

Did you define this intentionally? Or can be in ExtractSubsetImageSource?

[oshima, 2013/03/14 19:51:17]

you probably missed this comment.

[kevers, 2013/03/14 20:18:28]

Oops..I did miss it.  It was pulled out since it was being used elsewhere.  Can
move it back now that cropping is done in only one spot.

[kevers, 2013/03/14 20:41:42]

Move back to ExtractSubsetImageSource.

+  SkBitmap result;
+  bool success = source.sk_bitmap().extractSubset(&result,
+      RectToSkIRect(bounds_in_pixel));
+  DCHECK(success);
+  return ImageSkiaRep(result, source.scale_factor());
+}
+
 // Returns an image rep for the ImageSkiaSource to return to visually indicate
 // an error.
 ImageSkiaRep GetErrorImageRep(ui::ScaleFactor scale_factor,
                               const gfx::Size& pixel_size) {
   SkBitmap bitmap;
   bitmap.setConfig(
       SkBitmap::kARGB_8888_Config, pixel_size.width(), pixel_size.height());
   bitmap.allocPixels();
   bitmap.eraseColor(SK_ColorRED);
   return gfx::ImageSkiaRep(bitmap, scale_factor);
@@ skipping 172 matching lines @@
         dst_h_(dst_h) {
   }
 
   virtual ~TiledImageSource() {
   }
 
   // gfx::ImageSkiaSource overrides:
   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
     ImageSkiaRep source_rep = source_.GetRepresentation(scale_factor);
     float scale = ui::GetScaleFactorScale(source_rep.scale_factor());
+    gfx::Rect bounds = DIPToPixelBounds(gfx::Rect(src_x_, src_y_, dst_w_,
+                                                  dst_h_), scale);
     return ImageSkiaRep(
         SkBitmapOperations::CreateTiledBitmap(
             source_rep.sk_bitmap(),
-            src_x_ * scale, src_y_ * scale, dst_w_ * scale, dst_h_ * scale),
+            bounds.x(), bounds.y(), bounds.width(), bounds.height()),
         source_rep.scale_factor());
   }
 
  private:
   const ImageSkia source_;
   const int src_x_;
   const int src_y_;
   const int dst_w_;
   const int dst_h_;
 
@@ skipping 20 matching lines @@
   }
 
  private:
   const gfx::ImageSkia image_;
   const color_utils::HSL hsl_shift_;
   DISALLOW_COPY_AND_ASSIGN(HSLImageSource);
 };
 
 // ImageSkiaSource which uses SkBitmapOperations::CreateButtonBackground
 // to generate image reps for the target image.
-class ButtonImageSource: public gfx::ImageSkiaSource {
+class ButtonImageSource: public BinaryImageSource {

[oshima, 2013/03/13 22:08:53]

I vaguely remember that doing this caused some issues on 2x DSF/Pixel.

I can't remember now (Sorry, it's my fault. I should have
documented it) but could you please test this on 2x DSF
and check if this doesn't cause any issue?

[kevers, 2013/03/14 15:49:46]

Tested on Linux Chromeos with a forced scale factor.  Do not see any visual
defects.

[oshima, 2013/03/14 18:12:20]

I now remember the reason. crbug.com/171725

In short, the image and mask can be different size. Can you handle this
separately?

[kevers, 2013/03/14 19:31:39]

Reverted ButtonImageSource change and added a comment.

  public:
   ButtonImageSource(SkColor color,
                     const ImageSkia& image,
                     const ImageSkia& mask)
-      : color_(color),
-        image_(image),
-        mask_(mask) {
+      : BinaryImageSource(image, mask, "ButtonImageSource"),
+        color_(color) {
   }
 
   virtual ~ButtonImageSource() {
   }
 
-  // gfx::ImageSkiaSource overrides:
-  virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
-    ImageSkiaRep image_rep = image_.GetRepresentation(scale_factor);
-    ImageSkiaRep mask_rep = mask_.GetRepresentation(scale_factor);
-    if (image_rep.scale_factor() != mask_rep.scale_factor()) {
-      image_rep = image_.GetRepresentation(ui::SCALE_FACTOR_100P);
-      mask_rep = mask_.GetRepresentation(ui::SCALE_FACTOR_100P);
-    }
+  // BinaryImageSource overrides:
+  virtual ImageSkiaRep CreateImageSkiaRep(
+      const ImageSkiaRep& first_rep,
+      const ImageSkiaRep& second_rep) const OVERRIDE {
     return gfx::ImageSkiaRep(
         SkBitmapOperations::CreateButtonBackground(color_,
-              image_rep.sk_bitmap(), mask_rep.sk_bitmap()),
-          image_rep.scale_factor());
+              first_rep.sk_bitmap(), second_rep.sk_bitmap()),
+          first_rep.scale_factor());
   }
 
  private:
   const SkColor color_;
-  const ImageSkia image_;
-  const ImageSkia mask_;
 
   DISALLOW_COPY_AND_ASSIGN(ButtonImageSource);
 };
 
 // ImageSkiaSource which uses SkBitmap::extractSubset to generate image reps
 // for the target image.
 class ExtractSubsetImageSource: public gfx::ImageSkiaSource {
  public:
   ExtractSubsetImageSource(const gfx::ImageSkia& image,
                            const gfx::Rect& subset_bounds)
       : image_(image),
         subset_bounds_(subset_bounds) {
   }
 
   virtual ~ExtractSubsetImageSource() {
   }
 
   // gfx::ImageSkiaSource overrides:
   virtual ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) OVERRIDE {
     ImageSkiaRep image_rep = image_.GetRepresentation(scale_factor);
     float scale_to_pixel = ui::GetScaleFactorScale(image_rep.scale_factor());
-    SkIRect subset_bounds_in_pixel = RectToSkIRect(ToFlooredRectDeprecated(
-        gfx::ScaleRect(subset_bounds_, scale_to_pixel)));
-    SkBitmap dst;
-    bool success = image_rep.sk_bitmap().extractSubset(&dst,
-                                                       subset_bounds_in_pixel);
-    DCHECK(success);
-    return gfx::ImageSkiaRep(dst, image_rep.scale_factor());
+    Rect subset_bounds_in_pixel = DIPToPixelBounds(subset_bounds_,
+                                                   scale_to_pixel);
+    return CropImageSkiaRep(image_rep, subset_bounds_in_pixel);
   }
 
  private:
   const gfx::ImageSkia image_;
   const gfx::Rect subset_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractSubsetImageSource);
 };
 
 // ResizeSource resizes relevant image reps in |source| to |target_dip_size|
@@ skipping 10 matching lines @@
   virtual ~ResizeSource() {}
 
   // 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 = ui::GetScaleFactorScale(scale_factor);
-    const Size target_pixel_size = gfx::ToFlooredSize(
-        gfx::ScaleSize(target_dip_size_, scale));
+    const Size target_pixel_size = DIPToPixelSize(target_dip_size_, 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:
   const ImageSkia source_;
@@ skipping 181 matching lines @@
     return ImageSkia();
 
   return ImageSkia(new RotatedSource(source, rotation),
       SkBitmapOperations::ROTATION_180_CW == rotation ?
           source.size() :
           gfx::Size(source.height(), source.width()));
 
 }
 
 }  // namespace gfx