gfx: Rename canvas SaveAndUnscale to UnscaleTheDeviceScaleFactor.

ui/gfx/nine_image_painter.cc

 // Copyright 2014 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/nine_image_painter.h"
 
 #include <limits>
 
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkRect.h"
@@ skipping 70 matching lines @@
   // When no alpha value is specified, use default value of 100% opacity.
   Paint(canvas, bounds, std::numeric_limits<uint8>::max());
 }
 
 void NineImagePainter::Paint(Canvas* canvas,
                              const Rect& bounds,
                              const uint8 alpha) {
   if (IsEmpty())
     return;
 
-  // Painting at physical device pixels (undo device scale factor).
-  float scale = canvas->SaveAndUnscale();
+  ScopedCanvas scoped_canvas(canvas);
+
+  // Painting and doing layout at physical device pixels to avoid cracks or
+  // overlap.
+  const float scale = canvas->UndoDeviceScaleFactor();
 
   // Since the drawing from the following Fill() calls assumes the mapped origin
   // is at (0,0), we need to translate the canvas to the mapped origin.
   const int left_in_pixels = ToRoundedInt(bounds.x() * scale);
   const int top_in_pixels = ToRoundedInt(bounds.y() * scale);
   const int right_in_pixels = ToRoundedInt(bounds.right() * scale);
   const int bottom_in_pixels = ToRoundedInt(bounds.bottom() * scale);
 
   const int width_in_pixels = right_in_pixels - left_in_pixels;
   const int height_in_pixels = bottom_in_pixels - top_in_pixels;
@@ skipping 53 matching lines @@
     Fill(canvas, image_reps[3], 0, i0h, i3w, height_in_pixels - i0h - i6h,
          paint);
     Fill(canvas, image_reps[5], width_in_pixels - i5w, i2h, i5w,
          height_in_pixels - i2h - i8h, paint);
     Fill(canvas, image_reps[6], 0, height_in_pixels - i6h, i6w, i6h, paint);
     Fill(canvas, image_reps[7], i6w, height_in_pixels - i7h,
          width_in_pixels - i6w - i8w, i7h, paint);
     Fill(canvas, image_reps[8], width_in_pixels - i8w, height_in_pixels - i8h,
          i8w, i8h, paint);
   }
-
-  canvas->Restore();
 }
 
 // static
 void NineImagePainter::GetSubsetRegions(const ImageSkia& image,
                                         const Insets& insets,
                                         std::vector<Rect>* regions) {
   DCHECK_GE(image.width(), insets.width());
   DCHECK_GE(image.height(), insets.height());
 
   std::vector<Rect> result(9);
 
   const int x[] = {
       0, insets.left(), image.width() - insets.right(), image.width()};
   const int y[] = {
       0, insets.top(), image.height() - insets.bottom(), image.height()};
 
   for (size_t j = 0; j < 3; ++j) {
     for (size_t i = 0; i < 3; ++i) {
       result[i + j * 3] = Rect(x[i], y[j], x[i + 1] - x[i], y[j + 1] - y[j]);
     }
   }
   result.swap(*regions);
 }
 
 }  // namespace gfx