ui/gfx: Make the first version of Canvas::TileImageInt take a gfx::Rect.

ui/views/bubble/bubble_border.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/views/bubble/bubble_border.h"
 
 #include <algorithm>  // for std::max
 
 #include "base/logging.h"
 #include "grit/ui_resources.h"
@@ skipping 301 matching lines @@
     DrawEdgeWithArrow(canvas,
                       false,
                       images_->left,
                       images_->left_arrow,
                       left,
                       start_y,
                       before_arrow,
                       after_arrow,
                       images_->left->width() - images_->left_arrow->width());
   } else {
-    canvas->TileImageInt(*images_->left, left, top + tl_height, l_width,
-                         height - tl_height - bl_height);
+    canvas->TileImage(*images_->left, gfx::Rect(left, top + tl_height,
+        l_width, height - tl_height - bl_height));
   }
 
   // Top left corner.
   canvas->DrawBitmapInt(*images_->top_left, left, top);
 
   // Top edge.
   if (arrow_location_ == TOP_LEFT || arrow_location_ == TOP_RIGHT) {
     int start_x = left + tl_width;
     int before_arrow = arrow_offset - start_x - images_->top_arrow->width() / 2;
     int after_arrow = width - tl_width - tr_width -
         images_->top_arrow->width() - before_arrow;
     DrawArrowInterior(canvas,
                       true,
                       start_x + before_arrow + images_->top_arrow->width() / 2,
                       images_->top_arrow->height() - kArrowInteriorHeight,
                       1 - images_->top_arrow->width() / 2,
                       kArrowInteriorHeight);
     DrawEdgeWithArrow(canvas,
                       true,
                       images_->top,
                       images_->top_arrow,
                       start_x,
                       top,
                       before_arrow,
                       after_arrow,
                       images_->top->height() - images_->top_arrow->height());
   } else {
-    canvas->TileImageInt(*images_->top, left + tl_width, top,
-                         width - tl_width - tr_width, t_height);
+    canvas->TileImage(*images_->top, gfx::Rect(left + tl_width, top,
+        width - tl_width - tr_width, t_height));
   }
 
   // Top right corner.
   canvas->DrawBitmapInt(*images_->top_right, right - tr_width, top);
 
   // Right edge.
   if (arrow_location_ == RIGHT_TOP || arrow_location_ == RIGHT_BOTTOM) {
     int start_y = top + tr_height;
     int before_arrow =
         arrow_offset - start_y - images_->right_arrow->height() / 2;
     int after_arrow = height - tl_height - bl_height -
         images_->right_arrow->height() - before_arrow;
     int tip_y = start_y + before_arrow + images_->right_arrow->height() / 2;
     DrawArrowInterior(canvas,
                       false,
                       right - r_width + kArrowInteriorHeight,
                       tip_y,
                       -kArrowInteriorHeight,
                       images_->right_arrow->height() / 2 - 1);
     DrawEdgeWithArrow(canvas,
                       false,
                       images_->right,
                       images_->right_arrow,
                       right - r_width,
                       start_y,
                       before_arrow,
                       after_arrow,
                       0);
   } else {
-    canvas->TileImageInt(*images_->right, right - r_width, top + tr_height,
-                         r_width, height - tr_height - br_height);
+    canvas->TileImage(*images_->right, gfx::Rect(right - r_width,
+        top + tr_height, r_width, height - tr_height - br_height));
   }
 
   // Bottom right corner.
   canvas->DrawBitmapInt(*images_->bottom_right,
                         right - br_width,
                         bottom - br_height);
 
   // Bottom edge.
   if (arrow_location_ == BOTTOM_LEFT || arrow_location_ == BOTTOM_RIGHT) {
     int start_x = left + bl_width;
@@ skipping 11 matching lines @@
     DrawEdgeWithArrow(canvas,
                       true,
                       images_->bottom,
                       images_->bottom_arrow,
                       start_x,
                       bottom - b_height,
                       before_arrow,
                       after_arrow,
                       0);
   } else {
-    canvas->TileImageInt(*images_->bottom, left + bl_width, bottom - b_height,
-                         width - bl_width - br_width, b_height);
+    canvas->TileImage(*images_->bottom, gfx::Rect(left + bl_width,
+        bottom - b_height, width - bl_width - br_width, b_height));
   }
 
   // Bottom left corner.
   canvas->DrawBitmapInt(*images_->bottom_left, left, bottom - bl_height);
 }
 
 void BubbleBorder::DrawEdgeWithArrow(gfx::Canvas* canvas,
                                      bool is_horizontal,
                                      SkBitmap* edge,
                                      SkBitmap* arrow,
                                      int start_x,
                                      int start_y,
                                      int before_arrow,
                                      int after_arrow,
                                      int offset) const {
   /* Here's what the parameters mean:
    *                     start_x
    *                       .
    *                       .        ┌───┐                 ┬ offset
    * start_y..........┌────┬────────┤ ▲ ├────────┬────┐
    *                  │  / │--------│∙ ∙│--------│ \  │
    *                  │ /  ├────────┴───┴────────┤  \ │
    *                  ├───┬┘                     └┬───┤
    *                       └───┬────┘   └───┬────┘
    *             before_arrow ─┘            └─ after_arrow
    */
   if (before_arrow) {
-    canvas->TileImageInt(*edge, start_x, start_y,
+    canvas->TileImage(*edge, gfx::Rect(start_x, start_y,
         is_horizontal ? before_arrow : edge->width(),
-        is_horizontal ? edge->height() : before_arrow);
+        is_horizontal ? edge->height() : before_arrow));
   }
 
   canvas->DrawBitmapInt(*arrow,
       start_x + (is_horizontal ? before_arrow : offset),
       start_y + (is_horizontal ? offset : before_arrow));
 
   if (after_arrow) {
     start_x += (is_horizontal ? before_arrow + arrow->width() : 0);
     start_y += (is_horizontal ? 0 : before_arrow + arrow->height());
-    canvas->TileImageInt(*edge, start_x, start_y,
+    canvas->TileImage(*edge, gfx::Rect(start_x, start_y,
         is_horizontal ? after_arrow : edge->width(),
-        is_horizontal ? edge->height() : after_arrow);
+        is_horizontal ? edge->height() : after_arrow));
   }
 }
 
 void BubbleBorder::DrawArrowInterior(gfx::Canvas* canvas,
                                      bool is_horizontal,
                                      int tip_x,
                                      int tip_y,
                                      int shift_x,
                                      int shift_y) const {
   /* This function fills the interior of the arrow with background color.
@@ skipping 50 matching lines @@
   SkRect rect;
   rect.set(SkIntToScalar(bounds.x()), SkIntToScalar(bounds.y()),
            SkIntToScalar(bounds.right()), SkIntToScalar(bounds.bottom()));
   rect.inset(-border_->border_thickness(), -border_->border_thickness());
   SkScalar radius = SkIntToScalar(BubbleBorder::GetCornerRadius());
   path.addRoundRect(rect, radius, radius);
   canvas->GetSkCanvas()->drawPath(path, paint);
 }
 
 }  // namespace views