ui: Fix NinePatchPainter to work in physical pixels.

ui/gfx/canvas.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/canvas.h"
 
 #include <cmath>
 #include <limits>
 
 #include "base/i18n/rtl.h"
@@ skipping 36 matching lines @@
           skia::CreatePlatformCanvas(image_rep.pixel_width(),
                                      image_rep.pixel_height(),
                                      is_opaque))),
       canvas_(owned_canvas_.get()) {
   SkScalar scale_scalar = SkFloatToScalar(image_scale_);
   canvas_->scale(scale_scalar, scale_scalar);
   DrawImageInt(ImageSkia(image_rep), 0, 0);
 }
 
 Canvas::Canvas()
-    : image_scale_(1.0),
+    : image_scale_(1.f),
       owned_canvas_(skia::AdoptRef(skia::CreatePlatformCanvas(0, 0, false))),
-      canvas_(owned_canvas_.get()) {
-}
+      canvas_(owned_canvas_.get()) {}
 
 Canvas::Canvas(SkCanvas* canvas, float image_scale)
     : image_scale_(image_scale), owned_canvas_(), canvas_(canvas) {
   DCHECK(canvas);
 }
 
 Canvas::~Canvas() {
 }
 
 void Canvas::RecreateBackingCanvas(const Size& size,
@@ skipping 307 matching lines @@
                           int src_x,
                           int src_y,
                           int src_w,
                           int src_h,
                           int dest_x,
                           int dest_y,
                           int dest_w,
                           int dest_h,
                           bool filter,
                           const SkPaint& paint) {
-  DrawImageIntHelper(image, src_x, src_y, src_w, src_h, dest_x, dest_y, dest_w,
-                     dest_h, filter, paint, image_scale_, false);
+  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
+  if (image_rep.is_null())
+    return;
+  DrawImageIntHelper(image_rep, src_x, src_y, src_w, src_h, dest_x, dest_y,
+                     dest_w, dest_h, filter, paint, false);
 }
 
-void Canvas::DrawImageIntInPixel(const ImageSkia& image,
-                                 int src_x,
-                                 int src_y,
-                                 int src_w,
-                                 int src_h,
+void Canvas::DrawImageIntInPixel(const ImageSkiaRep& image_rep,
                                  int dest_x,
                                  int dest_y,
                                  int dest_w,
                                  int dest_h,
                                  bool filter,
                                  const SkPaint& paint) {
-  // All values passed into this function are in pixels, i.e. no scaling needs
-  // be done.
-  // Logic as below:-
-  // 1. Get the matrix transform from the canvas.
-  // 2. Set the scale in the matrix to 1.0 while honoring the direction of the
-  //    the scale (x/y). Example RTL layouts.
-  // 3. Round off the X and Y translation components in the matrix. This is to
-  //    reduce floating point errors during rect transformation. This is needed
-  //    for fractional scale factors like 1.25/1.5, etc.
-  // 4. Save the current state of the canvas and restore the state when going
-  //    out of scope with ScopedCanvas.
-  // 5. Set the modified matrix in the canvas. This ensures that no scaling
-  //    will be done for draw operations on the canvas.
-  // 6. Draw the image.
-  SkMatrix matrix = canvas_->getTotalMatrix();
-
-  // Ensure that the direction of the x and y scales is preserved. This is
-  // important for RTL layouts.
-  matrix.setScaleX(matrix.getScaleX() > 0 ? 1.0f : -1.0f);
-  matrix.setScaleY(matrix.getScaleY() > 0 ? 1.0f : -1.0f);
-
-  // Floor so that we get consistent rounding.
-  matrix.setTranslateX(SkScalarFloorToScalar(matrix.getTranslateX()));
-  matrix.setTranslateY(SkScalarFloorToScalar(matrix.getTranslateY()));
-
-  ScopedCanvas scoper(this);
-
-  canvas_->setMatrix(matrix);
-
-  DrawImageIntHelper(image,
-                     src_x,
-                     src_y,
-                     src_w,
-                     src_h,
-                     dest_x,
-                     dest_y,
-                     dest_w,
-                     dest_h,
-                     filter,
-                     paint,
-                     image_scale_,
-                     true);
+  int src_x = 0;
+  int src_y = 0;
+  int src_w = image_rep.pixel_width();
+  int src_h = image_rep.pixel_height();
+  DrawImageIntHelper(image_rep, src_x, src_y, src_w, src_h, dest_x, dest_y,
+                     dest_w, dest_h, filter, paint, true);
 }
 
 void Canvas::DrawImageInPath(const ImageSkia& image,
                              int x,
                              int y,
                              const SkPath& path,
                              const SkPaint& paint) {
   const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
   if (image_rep.is_null())
     return;
@@ skipping 92 matching lines @@
   return canvas_->getClipBounds(&clip) &&
       clip.intersect(SkIntToScalar(x), SkIntToScalar(y), SkIntToScalar(x + w),
                      SkIntToScalar(y + h));
 }
 
 bool Canvas::IntersectsClipRect(const Rect& rect) {
   return IntersectsClipRectInt(rect.x(), rect.y(),
                                rect.width(), rect.height());
 }
 
-void Canvas::DrawImageIntHelper(const ImageSkia& image,
+void Canvas::DrawImageIntHelper(const ImageSkiaRep& image_rep,
                                 int src_x,
                                 int src_y,
                                 int src_w,
                                 int src_h,
                                 int dest_x,
                                 int dest_y,
                                 int dest_w,
                                 int dest_h,
                                 bool filter,
                                 const SkPaint& paint,
-                                float image_scale,
                                 bool pixel) {
   DLOG_ASSERT(src_x + src_w < std::numeric_limits<int16_t>::max() &&
               src_y + src_h < std::numeric_limits<int16_t>::max());
   if (src_w <= 0 || src_h <= 0) {
     NOTREACHED() << "Attempting to draw bitmap from an empty rect!";
     return;
   }
 
   if (!IntersectsClipRectInt(dest_x, dest_y, dest_w, dest_h))
     return;
 
   float user_scale_x = static_cast<float>(dest_w) / src_w;
   float user_scale_y = static_cast<float>(dest_h) / src_h;
 
-  const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale);
-  if (image_rep.is_null())
-    return;
-
   SkRect dest_rect = { SkIntToScalar(dest_x),
                        SkIntToScalar(dest_y),
                        SkIntToScalar(dest_x + dest_w),
                        SkIntToScalar(dest_y + dest_h) };
 
   if (src_w == dest_w && src_h == dest_h &&
       user_scale_x == 1.0f && user_scale_y == 1.0f &&
       image_rep.scale() == 1.0f && !pixel) {
     // Workaround for apparent bug in Skia that causes image to occasionally
     // shift.
@@ skipping 23 matching lines @@
   // by the paint).
   SkPaint p(paint);
   p.setFilterQuality(filter ? kLow_SkFilterQuality : kNone_SkFilterQuality);
   p.setShader(shader.get());
 
   // The rect will be filled by the bitmap.
   canvas_->drawRect(dest_rect, p);
 }
 
 }  // namespace gfx