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

ui/views/window/frame_background.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/window/frame_background.h"
 
 #include "grit/ui_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/theme_provider.h"
@@ skipping 51 matching lines @@
   maximized_top_right_ = top_right;
   maximized_top_offset_ = top_offset;
 }
 
 void FrameBackground::PaintRestored(gfx::Canvas* canvas, View* view) const {
   // Fill with the frame color first so we have a constant background for
   // areas not covered by the theme image.
   PaintFrameColor(canvas, view);
 
   // Draw the theme frame.
-  canvas->TileImageInt(*theme_bitmap_,
-                       0, 0, view->width(), theme_bitmap_->height());
+  canvas->TileImage(*theme_bitmap_,
+                    gfx::Rect(0, 0, view->width(), theme_bitmap_->height()));
 
   // Draw the theme frame overlay, if available.
   if (theme_overlay_bitmap_)
     canvas->DrawBitmapInt(*theme_overlay_bitmap_, 0, 0);
 
   // Draw the top corners and edge, scaling the corner images down if they
   // are too big and relative to the vertical space available.
   int top_left_height =
       std::min(top_left_corner_->height(),
                view->height() - bottom_left_corner_->height());
   canvas->DrawBitmapInt(*top_left_corner_,
                         0, 0, top_left_corner_->width(), top_left_height,
                         0, 0, top_left_corner_->width(), top_left_height,
                         false);
-  canvas->TileImageInt(*top_edge_,
-      top_left_corner_->width(),
+  canvas->TileImage(*top_edge_, gfx::Rect(top_left_corner_->width(),
       0,
       view->width() - top_left_corner_->width() - top_right_corner_->width(),

[tfarina, 2012/02/08 19:45:15]

Peter, this calculation is resulting in -2.

10 - 6 - 6

Thus, WidgetTest.ChangeActivation is failing.

[Peter Kasting, 2012/02/08 20:54:57]

Why is the view allowed to reach as small as 10 px in width?  It seems like
GetMinimumSize() somewhere should be preventing that.

If not, and we need to handle this here, we should be deciding how to scale or
clip the images in question.  For example:

  int top_left_width = top_left_corner_->width();
  int top_right_width = top_right_corner_->width();
  int center_width = view->width() - top_left_width - top_right_width;
  if (center_width > 0) {
    canvas->TileImage(*top_edge_, gfx::Rect(top_left_width, 0, center_width,
                                            top_edge_->height()));
  } else if (center_width < 0) {
    // Not enough space for the two corners.  Remove an equal number of pixels
    // from the inside edges of each (unless this would shrink a corner beyond 0
    // width).
    int top_right_clip = std::min(-center_width / 2, top_right_width);
    top_left_width += center_width + top_right_clip;
    DCHECK_GE(top_left_width, 0);
    top_right_width -= top_right_clip;
  }
  if (top_left_width) {
    canvas->DrawBitmapInt(*top_left_corner_, 0, 0, top_left_width,
        top_left_height, 0, 0, top_left_width, top_left_height, false);
  }
  if (top_right_width) {
    canvas->DrawBitmapInt(*top_right_corner_,
        top_right_corner_->width() - top_right_width, 0, top_right_width,
        top_right_height, view->width() - top_right_width, 0, top_right_width,
        top_right_height, false);
  }

However, I don't think we should need to do this if we're setting the minimum
size appropriately.

-      top_edge_->height());
+      top_edge_->height()));
   int top_right_height =
       std::min(top_right_corner_->height(),
                view->height() - bottom_right_corner_->height());
   canvas->DrawBitmapInt(*top_right_corner_,
                         0, 0,
                         top_right_corner_->width(), top_right_height,
                         view->width() - top_right_corner_->width(), 0,
                         top_right_corner_->width(), top_right_height,
                         false);
 
   // Right edge.
   int right_edge_height =
       view->height() - top_right_height - bottom_right_corner_->height();
-  canvas->TileImageInt(*right_edge_,
-                       view->width() - right_edge_->width(),
-                       top_right_height,
-                       right_edge_->width(),
-                       right_edge_height);
+  canvas->TileImage(*right_edge_,
+                    gfx::Rect(view->width() - right_edge_->width(),
+                              top_right_height,
+                              right_edge_->width(),
+                              right_edge_height));
 
   // Bottom corners and edge.
   canvas->DrawBitmapInt(*bottom_right_corner_,
                         view->width() - bottom_right_corner_->width(),
                         view->height() - bottom_right_corner_->height());
-  canvas->TileImageInt(
-      *bottom_edge_,
-      bottom_left_corner_->width(),
-      view->height() - bottom_edge_->height(),
-      view->width() - bottom_left_corner_->width()
-          - bottom_right_corner_->width(),
-      bottom_edge_->height());
+  canvas->TileImage(*bottom_edge_,
+                    gfx::Rect(bottom_left_corner_->width(),
+                              view->height() - bottom_edge_->height(),
+                              view->width() - bottom_left_corner_->width() -
+                                  bottom_right_corner_->width(),
+                              bottom_edge_->height()));
   canvas->DrawBitmapInt(*bottom_left_corner_, 0,
                         view->height() - bottom_left_corner_->height());
 
   // Left edge.
   int left_edge_height =
       view->height() - top_left_height - bottom_left_corner_->height();
-  canvas->TileImageInt(*left_edge_,
-                       0, top_left_height,
-                       left_edge_->width(), left_edge_height);
+  canvas->TileImage(*left_edge_, gfx::Rect(0, top_left_height,
+      left_edge_->width(), left_edge_height));
 }
 
 void FrameBackground::PaintMaximized(gfx::Canvas* canvas, View* view) const {
   // We will be painting from top_offset to top_offset + theme_frame_height. If
   // this is less than top_area_height_, we need to paint the frame color
   // to fill in the area beneath the image.
   // TODO(jamescook): I'm not sure this is correct, as it doesn't seem to fully
   // account for the top_offset, but this is how it worked before.
   int theme_frame_bottom = maximized_top_offset_ + theme_bitmap_->height();
   if (top_area_height_ > theme_frame_bottom) {
@@ skipping 10 matching lines @@
     // If we have either a left or right we should have both.
     DCHECK(maximized_top_left_ && maximized_top_right_);
     left_offset = maximized_top_left_->width();
     right_offset = maximized_top_right_->width();
     canvas->DrawBitmapInt(*maximized_top_left_, 0, 0);
     canvas->DrawBitmapInt(*maximized_top_right_,
                           view->width() - right_offset, 0);
   }
 
   // Draw the theme frame.
-  canvas->TileImageInt(*theme_bitmap_,
-                       left_offset,
-                       maximized_top_offset_,
-                       view->width() - (left_offset + right_offset),
-                       theme_bitmap_->height());
+  canvas->TileImage(*theme_bitmap_,
+                    gfx::Rect(left_offset,
+                              maximized_top_offset_,
+                              view->width() - (left_offset + right_offset),
+                              theme_bitmap_->height()));
   // Draw the theme frame overlay, if available.
   if (theme_overlay_bitmap_)
     canvas->DrawBitmapInt(*theme_overlay_bitmap_, 0, theme_background_y_);
 }
 
 void FrameBackground::PaintFrameColor(gfx::Canvas* canvas, View* view) const {
   // Fill the top area.
   canvas->FillRect(gfx::Rect(0, 0, view->width(), top_area_height_),
                    frame_color_);
 
@@ skipping 16 matching lines @@
     return;
 
   // Fill the bottom area.
   canvas->FillRect(gfx::Rect(left_edge_->width(),
                              view->height() - bottom_edge_->height(),
                              center_width, bottom_edge_->height()),
                              frame_color_);
 }
 
 }  // namespace views