Fix images drawn with the NineImagePainter class in high DPI.

ui/gfx/canvas.h

 // 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.
 
 #ifndef UI_GFX_CANVAS_H_
 #define UI_GFX_CANVAS_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 302 matching lines @@
                     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);
 
+  // Same as the DrawImageInt functions above. Difference being this does not
+  // do any scaling, i.e. it assumes that the source/destination/image, etc are
+  // in pixels. It does translate the destination rectangle to ensure that the
+  // image is displayed at the correct pixel coordinates.
+  void DrawImageIntInPixel(const ImageSkia& image,
+                           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);
+
   // Draws an |image| with the top left corner at |x| and |y|, clipped to
   // |path|.
   // Parameters are specified relative to current canvas scale not in pixels.
   // Thus, x is 2 pixels if canvas scale = 2 & |x| = 1.
   void DrawImageInPath(const ImageSkia& image,
                        int x,
                        int y,
                        const SkPath& path,
                        const SkPaint& paint);
 
@@ skipping 95 matching lines @@
   bool IntersectsClipRect(const Rect& rect);
 
   // Returns the image rep which best matches the canvas |image_scale_|.
   // Returns a null image rep if |image| contains no image reps.
   // Builds mip map for returned image rep if necessary.
   //
   // An optional additional user defined scale can be provided.
   const ImageSkiaRep& GetImageRepToPaint(const ImageSkia& image) const;
   const ImageSkiaRep& GetImageRepToPaint(
       const ImageSkia& image,
+      float image_scale,
       float user_defined_scale_factor_x,
       float user_defined_scale_factor_y) const;
 
+  // Helper for the DrawImageInt functions declared above. The |pixel|
+  // parameter if true indicates that the bounds and the image are to
+  // be assumed to be in pixels, i.e. no scaling needs to be performed.
+  void DrawImageIntHelper(const ImageSkia& image,
+                          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);
+
   // The device scale factor at which drawing on this canvas occurs.
   // An additional scale can be applied via Canvas::Scale(). However,
   // Canvas::Scale() does not affect |image_scale_|.
   float image_scale_;
 
   skia::RefPtr<skia::PlatformCanvas> owned_canvas_;
   SkCanvas* canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(Canvas);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_CANVAS_H_