Changes NineImagePainter to snap to (enclosed) pixel boundaries

Otherwise the sides may be clipped out.

BUG=417493
TEST=see bug
R=ananta@chromium.org

Review URL: https://codereview.chromium.org/604463003

Cr-Commit-Position: refs/heads/master@{#296608}

ui/gfx/canvas.cc

@@ -13,7 +13,9 @@
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/rect.h"
+#include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
@@ -346,14 +348,13 @@ void Canvas::DrawImageInt(const ImageSkia& image,
   const SkBitmap& bitmap = image_rep.sk_bitmap();
   float bitmap_scale = image_rep.scale();
 
-  canvas_->save();
+  ScopedCanvas scoper(this);
   canvas_->scale(SkFloatToScalar(1.0f / bitmap_scale),
                  SkFloatToScalar(1.0f / bitmap_scale));
   canvas_->drawBitmap(bitmap,
                       SkFloatToScalar(x * bitmap_scale),
                       SkFloatToScalar(y * bitmap_scale),
                       &paint);
-  canvas_->restore();
 }
 
 void Canvas::DrawImageInt(const ImageSkia& image,
@@ -415,13 +416,14 @@ void Canvas::DrawImageIntInPixel(const ImageSkia& image,
 
   // Ensure that the direction of the x and y scales is preserved. This is
   // important for RTL layouts.
-  matrix.getScaleX() > 0 ? matrix.setScaleX(1.0f) : matrix.setScaleX(-1.0f);
-  matrix.getScaleY() > 0 ? matrix.setScaleY(1.0f) : matrix.setScaleY(-1.0f);
+  matrix.setScaleX(matrix.getScaleX() > 0 ? 1.0f : -1.0f);
+  matrix.setScaleY(matrix.getScaleY() > 0 ? 1.0f : -1.0f);
 
-  matrix.setTranslateX(SkScalarRoundToInt(matrix.getTranslateX()));
-  matrix.setTranslateY(SkScalarRoundToInt(matrix.getTranslateY()));
+  // Floor so that we get consistent rounding.
+  matrix.setTranslateX(SkScalarFloorToScalar(matrix.getTranslateX()));
+  matrix.setTranslateY(SkScalarFloorToScalar(matrix.getTranslateY()));
 
-  Save();
+  ScopedCanvas scoper(this);
 
   canvas_->setMatrix(matrix);
 
@@ -438,9 +440,6 @@ void Canvas::DrawImageIntInPixel(const ImageSkia& image,
                      paint,
                      image_scale_,
                      true);
-
-  // Restore the state of the canvas.
-  Restore();
 }
 
 void Canvas::DrawImageInPath(const ImageSkia& image,

ui/gfx/nine_image_painter.cc

@@ -98,20 +98,29 @@ void NineImagePainter::Paint(Canvas* canvas,
   ScopedCanvas scoped_canvas(canvas);
   canvas->Translate(bounds.OffsetFromOrigin());
 
-  SkPaint paint;
-  paint.setAlpha(alpha);
-
   // Get the current transform from the canvas and apply it to the logical
   // bounds passed in. This will give us the pixel bounds which can be used
   // to draw the images at the correct locations.
   // We should not scale the bounds by the canvas->image_scale() as that can be
   // different from the real scale in the canvas transform.
+  SkRect bounds_in_pixels;
+  if (!canvas->sk_canvas()->getTotalMatrix().mapRect(&bounds_in_pixels,
+                                                     RectToSkRect(bounds)))
+    return;  // Invalid transform.
+
+  // It's often the case that |bounds| corresponds to the bounds of a View, say
+  // a button. We use enclosed rect, in pixels coordinates, to ensure the
+  // complete image can be seen. Without this clipping on all sides can happen.
+  const gfx::Rect enclosed_rect_in_pixels(
+      ToEnclosedRect(SkRectToRectF(bounds_in_pixels)));
+
   SkMatrix matrix = canvas->sk_canvas()->getTotalMatrix();
-  SkRect scaled_rect;
-  matrix.mapRect(&scaled_rect, RectToSkRect(bounds));
+  matrix.setTranslateX(SkIntToScalar(enclosed_rect_in_pixels.x()));
+  matrix.setTranslateY(SkIntToScalar(enclosed_rect_in_pixels.y()));
+  canvas->sk_canvas()->setMatrix(matrix);
 
-  int scaled_width = gfx::ToCeiledInt(SkScalarToFloat(scaled_rect.width()));
-  int scaled_height = gfx::ToCeiledInt(SkScalarToFloat(scaled_rect.height()));
+  const int width_in_pixels = enclosed_rect_in_pixels.width();
+  const int height_in_pixels = enclosed_rect_in_pixels.height();
 
   // In case the corners and edges don't all have the same width/height, we draw
   // the center first, and extend it out in all directions to the edges of the
@@ -125,7 +134,7 @@ void NineImagePainter::Paint(Canvas* canvas,
   int i8w = ImageWidthInPixels(images_[8], canvas);
 
   int i4x = std::min(std::min(i0w, i3w), i6w);
-  int i4w = scaled_width - i4x - std::min(std::min(i2w, i5w), i8w);
+  int i4w = width_in_pixels - i4x - std::min(std::min(i2w, i5w), i8w);
 
   int i0h = ImageHeightInPixels(images_[0], canvas);
   int i1h = ImageHeightInPixels(images_[1], canvas);
@@ -135,23 +144,27 @@ void NineImagePainter::Paint(Canvas* canvas,
   int i8h = ImageHeightInPixels(images_[8], canvas);
 
   int i4y = std::min(std::min(i0h, i1h), i2h);
-  int i4h = scaled_height - i4y - std::min(std::min(i6h, i7h), i8h);
+  int i4h = height_in_pixels - i4y - std::min(std::min(i6h, i7h), i8h);
+
+  SkPaint paint;
+  paint.setAlpha(alpha);
+
   if (!images_[4].isNull())
     Fill(canvas, images_[4], i4x, i4y, i4w, i4h, paint);
   canvas->DrawImageIntInPixel(images_[0], 0, 0, i0w, i0h,
                               0, 0, i0w, i0h, false, paint);
-  Fill(canvas, images_[1], i0w, 0, scaled_width - i0w - i2w, i1h, paint);
-  canvas->DrawImageIntInPixel(images_[2], 0, 0, i2w, i2h, scaled_width - i2w,
+  Fill(canvas, images_[1], i0w, 0, width_in_pixels - i0w - i2w, i1h, paint);
+  canvas->DrawImageIntInPixel(images_[2], 0, 0, i2w, i2h, width_in_pixels - i2w,
                               0, i2w, i2h, false, paint);
-  Fill(canvas, images_[3], 0, i0h, i3w, scaled_height - i0h - i6h, paint);
-  Fill(canvas, images_[5], scaled_width - i5w, i2h, i5w,
-       scaled_height - i2h - i8h, paint);
+  Fill(canvas, images_[3], 0, i0h, i3w, height_in_pixels - i0h - i6h, paint);
+  Fill(canvas, images_[5], width_in_pixels - i5w, i2h, i5w,
+       height_in_pixels - i2h - i8h, paint);
   canvas->DrawImageIntInPixel(images_[6], 0, 0, i6w, i6h, 0,
-                              scaled_height - i6h, i6w, i6h, false, paint);
-  Fill(canvas, images_[7], i6w, scaled_height - i7h, scaled_width - i6w - i8w,
-       i7h, paint);
-  canvas->DrawImageIntInPixel(images_[8], 0, 0, i8w, i8h, scaled_width - i8w,
-                              scaled_height - i8h, i8w, i8h, false, paint);
+                              height_in_pixels - i6h, i6w, i6h, false, paint);
+  Fill(canvas, images_[7], i6w, height_in_pixels - i7h,
+       width_in_pixels - i6w - i8w, i7h, paint);
+  canvas->DrawImageIntInPixel(images_[8], 0, 0, i8w, i8h, width_in_pixels - i8w,
+                              height_in_pixels - i8h, i8w, i8h, false, paint);
 }
 
 }  // namespace gfx