Revert of Changes NineImagePainter to snap to (enclosed) pixel boundaries

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"
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #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"
 
 #if defined(OS_WIN)
 #include "ui/gfx/canvas_skia_paint.h"
 #endif
 
 namespace gfx {
 
@@ skipping 312 matching lines @@
 void Canvas::DrawImageInt(const ImageSkia& image,
                           int x,
                           int y,
                           const SkPaint& paint) {
   const ImageSkiaRep& image_rep = image.GetRepresentation(image_scale_);
   if (image_rep.is_null())
     return;
   const SkBitmap& bitmap = image_rep.sk_bitmap();
   float bitmap_scale = image_rep.scale();
 
-  ScopedCanvas scoper(this);
+  canvas_->save();
   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,
                           int src_x,
                           int src_y,
                           int src_w,
                           int src_h,
                           int dest_x,
                           int dest_y,
                           int dest_w,
@@ skipping 41 matching lines @@
   //    for fractional scale factors like 1.25/1.5, etc.
   // 4. Save the current state of the canvas.
   // 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.
   // 7. Restore the state of the canvas and the SkCanvas matrix stack.
   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);
+  matrix.getScaleX() > 0 ? matrix.setScaleX(1.0f) : matrix.setScaleX(-1.0f);
+  matrix.getScaleY() > 0 ? matrix.setScaleY(1.0f) : matrix.setScaleY(-1.0f);
 
-  // Floor so that we get consistent rounding.
-  matrix.setTranslateX(SkScalarFloorToScalar(matrix.getTranslateX()));
-  matrix.setTranslateY(SkScalarFloorToScalar(matrix.getTranslateY()));
+  matrix.setTranslateX(SkScalarRoundToInt(matrix.getTranslateX()));
+  matrix.setTranslateY(SkScalarRoundToInt(matrix.getTranslateY()));
 
-  ScopedCanvas scoper(this);
+  Save();
 
   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);
+
+  // Restore the state of the canvas.
+  Restore();
 }
 
 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 181 matching lines @@
   SkPaint p(paint);
   p.setFilterLevel(filter ? SkPaint::kLow_FilterLevel
                           : SkPaint::kNone_FilterLevel);
   p.setShader(shader.get());
 
   // The rect will be filled by the bitmap.
   canvas_->drawRect(dest_rect, p);
 }
 
 }  // namespace gfx