ui/gfx: Convert Canvas::FillRectInt() to use gfx::Rect.

chrome/browser/ui/views/frame/opaque_browser_frame_view.cc

 // Copyright (c) 2011 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 "chrome/browser/ui/views/frame/opaque_browser_frame_view.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 592 matching lines @@
 
   // Fill with the frame color first so we have a constant background for
   // areas not covered by the theme image.
   SkBitmap* theme_frame = GetFrameBitmap();
   int top_area_height = theme_frame->height();
   if (browser_view_->IsTabStripVisible()) {
     top_area_height = std::max(top_area_height,
       GetBoundsForTabStrip(browser_view_->tabstrip()).bottom());
   }
   SkColor frame_color = GetFrameColor();
-  canvas->FillRectInt(frame_color, 0, 0, width(), top_area_height);
+  canvas->FillRect(frame_color, gfx::Rect(0, 0, width(), top_area_height));
 
-  // Now fill down the sides.
-  canvas->FillRectInt(frame_color, 0, top_area_height, left_edge->width(),
-                      height() - top_area_height);
-  canvas->FillRectInt(frame_color, width() - right_edge->width(),
-                      top_area_height, right_edge->width(),
-                      height() - top_area_height);
-  // Now fill the bottom area.
-  canvas->FillRectInt(frame_color, left_edge->width(),
-                      height() - bottom_edge->height(),
-                      width() - left_edge->width() - right_edge->width(),
-                      bottom_edge->height());
+  int remaining_height = height() - top_area_height;
+  if (remaining_height > 0) {
+    // Now fill down the sides.
+    canvas->FillRect(frame_color,
+                     gfx::Rect(0, top_area_height, left_edge->width(),
+                               remaining_height));
+    canvas->FillRect(frame_color,
+                     gfx::Rect(width() - right_edge->width(),
+                               top_area_height, right_edge->width(),
+                               remaining_height));
+    int center_width = width() - left_edge->width() - right_edge->width();
+    if (center_width > 0) {
+      // Now fill the bottom area.
+      canvas->FillRect(frame_color,
+                       gfx::Rect(left_edge->width(),
+                                 height() - bottom_edge->height(),
+                                 center_width, bottom_edge->height()));
+    }
+  }
 
   // Draw the theme frame.
   canvas->TileImageInt(*theme_frame, 0, 0, width(), theme_frame->height());
 
   // Draw the theme frame overlay.
   if (tp->HasCustomImage(IDR_THEME_FRAME_OVERLAY) &&
       browser_view_->IsBrowserTypeNormal() &&
       !browser_view_->IsOffTheRecord()) {
     canvas->DrawBitmapInt(*tp->GetBitmapNamed(ShouldPaintAsActive() ?
         IDR_THEME_FRAME_OVERLAY : IDR_THEME_FRAME_OVERLAY_INACTIVE), 0, 0);
@@ skipping 48 matching lines @@
 
   // We will be painting from top_offset to top_offset + theme_frame_height. If
   // this is less than GetBoundsForTabStrip.bottom, we need to paint the frame
   // color.
   SkBitmap* theme_frame = GetFrameBitmap();
   int theme_frame_bottom = top_offset + theme_frame->height();
   int top_area_height =
       GetBoundsForTabStrip(browser_view_->tabstrip()).bottom();
   if (top_area_height > theme_frame_bottom) {
     SkColor frame_color = GetFrameColor();
-    canvas->FillRectInt(frame_color, 0, 0, width(), top_area_height);
+    canvas->FillRect(frame_color, gfx::Rect(0, 0, width(), top_area_height));
   }
 
   // Draw the theme frame.  It must be aligned with the tabstrip as if we were
   // in restored mode.  Note that the top of the tabstrip is
   // kTabstripTopShadowThickness px off the top of the screen.
   int theme_background_y = -(GetHorizontalTabStripVerticalOffset(true) +
       kTabstripTopShadowThickness);
   int left_offset = 0, right_offset = 0;
 
   if (left || right) {
@@ skipping 75 matching lines @@
   SkBitmap* toolbar_left = tp->GetBitmapNamed(IDR_CONTENT_TOP_LEFT_CORNER);
   int bottom_edge_height = std::min(toolbar_left->height(), h) - split_point;
 
   // Split our canvas out so we can mask out the corners of the toolbar
   // without masking out the frame.
   canvas->SaveLayerAlpha(
       255, gfx::Rect(x - kClientEdgeThickness, y, w + kClientEdgeThickness * 3,
                      h));
   canvas->GetSkCanvas()->drawARGB(0, 255, 255, 255, SkXfermode::kClear_Mode);
 
-  SkColor theme_toolbar_color =
-      tp->GetColor(ThemeService::COLOR_TOOLBAR);
-  canvas->FillRectInt(theme_toolbar_color, x, bottom_y, w, bottom_edge_height);
+  SkColor theme_toolbar_color = tp->GetColor(ThemeService::COLOR_TOOLBAR);
+  canvas->FillRect(theme_toolbar_color,
+                   gfx::Rect(x, bottom_y, w, bottom_edge_height));
 
   // Tile the toolbar image starting at the frame edge on the left and where the
   // horizontal tabstrip is (or would be) on the top.
   SkBitmap* theme_toolbar = tp->GetBitmapNamed(IDR_THEME_TOOLBAR);
   canvas->TileImageInt(*theme_toolbar, x,
                        bottom_y - GetHorizontalTabStripVerticalOffset(false), x,
                        bottom_y, w, theme_toolbar->height());
 
   // Draw rounded corners for the tab.
   SkBitmap* toolbar_left_mask =
@@ skipping 44 matching lines @@
 
   SkBitmap* toolbar_right = tp->GetBitmapNamed(IDR_CONTENT_TOP_RIGHT_CORNER);
   canvas->DrawBitmapInt(*toolbar_right, 0, 0, toolbar_right->width(),
       split_point, right_x, y, toolbar_right->width(), split_point, false);
   canvas->DrawBitmapInt(*toolbar_right, 0,
       toolbar_right->height() - bottom_edge_height, toolbar_right->width(),
       bottom_edge_height, right_x, bottom_y, toolbar_right->width(),
       bottom_edge_height, false);
 
   // Draw the content/toolbar separator.
-  canvas->FillRectInt(ResourceBundle::toolbar_separator_color,
-      x + kClientEdgeThickness, toolbar_bounds.bottom() - kClientEdgeThickness,
-      w - (2 * kClientEdgeThickness), kClientEdgeThickness);
+  canvas->FillRect(ResourceBundle::toolbar_separator_color,
+                   gfx::Rect(x + kClientEdgeThickness,
+                             toolbar_bounds.bottom() - kClientEdgeThickness,
+                             w - (2 * kClientEdgeThickness),
+                             kClientEdgeThickness));
 }
 
 void OpaqueBrowserFrameView::PaintRestoredClientEdge(gfx::Canvas* canvas) {
   ui::ThemeProvider* tp = GetThemeProvider();
   int client_area_top = frame_->client_view()->y();
   int image_top = client_area_top;
 
   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
   SkColor toolbar_color = tp->GetColor(ThemeService::COLOR_TOOLBAR);
 
@@ skipping 18 matching lines @@
     canvas->DrawBitmapInt(*top_left, 0, 0, top_left->width(), height,
         client_area_bounds.x() - top_left->width(), top_edge_y,
         top_left->width(), height, false);
     canvas->TileImageInt(*top_center, 0, 0, client_area_bounds.x(), top_edge_y,
       client_area_bounds.width(), std::min(height, top_center->height()));
     canvas->DrawBitmapInt(*top_right, 0, 0, top_right->width(), height,
         client_area_bounds.right(), top_edge_y,
         top_right->width(), height, false);
 
     // Draw the toolbar color across the top edge.
-    canvas->FillRectInt(toolbar_color,
-        client_area_bounds.x() - kClientEdgeThickness,
-        client_area_top - kClientEdgeThickness,
-        client_area_bounds.width() + (2 * kClientEdgeThickness),
-        kClientEdgeThickness);
+    canvas->FillRect(
+        toolbar_color,
+        gfx::Rect(client_area_bounds.x() - kClientEdgeThickness,
+                  client_area_top - kClientEdgeThickness,
+                  client_area_bounds.width() + (2 * kClientEdgeThickness),
+                  kClientEdgeThickness));
   }
 
   int client_area_bottom =
       std::max(client_area_top, height() - NonClientBorderThickness());
   int image_height = client_area_bottom - image_top;
 
   // Draw the client edge images.
   // Draw the client edge images.
   SkBitmap* right = tp->GetBitmapNamed(IDR_CONTENT_RIGHT_SIDE);
   canvas->TileImageInt(*right, client_area_bounds.right(), image_top,
@@ skipping 10 matching lines @@
   canvas->DrawBitmapInt(*bottom_left,
       client_area_bounds.x() - bottom_left->width(), client_area_bottom);
   SkBitmap* left = tp->GetBitmapNamed(IDR_CONTENT_LEFT_SIDE);
   canvas->TileImageInt(*left, client_area_bounds.x() - left->width(),
                        image_top, left->width(), image_height);
 
   // Draw the toolbar color so that the client edges show the right color even
   // where not covered by the toolbar image.  NOTE: We do this after drawing the
   // images because the images are meant to alpha-blend atop the frame whereas
   // these rects are meant to be fully opaque, without anything overlaid.
-  canvas->FillRectInt(toolbar_color,
-      client_area_bounds.x() - kClientEdgeThickness, client_area_top,
-      kClientEdgeThickness,
-      client_area_bottom + kClientEdgeThickness - client_area_top);
-  canvas->FillRectInt(toolbar_color, client_area_bounds.x(), client_area_bottom,
-                      client_area_bounds.width(), kClientEdgeThickness);
-  canvas->FillRectInt(toolbar_color, client_area_bounds.right(),
-      client_area_top, kClientEdgeThickness,
-      client_area_bottom + kClientEdgeThickness - client_area_top);
+  canvas->FillRect(
+      toolbar_color,
+      gfx::Rect(client_area_bounds.x() - kClientEdgeThickness,
+                client_area_top,
+                kClientEdgeThickness,
+                client_area_bottom + kClientEdgeThickness - client_area_top));
+  canvas->FillRect(toolbar_color,
+                   gfx::Rect(client_area_bounds.x(), client_area_bottom,
+                             client_area_bounds.width(), kClientEdgeThickness));
+  canvas->FillRect(
+      toolbar_color,
+      gfx::Rect(client_area_bounds.right(),
+                client_area_top,
+                kClientEdgeThickness,
+                client_area_bottom + kClientEdgeThickness - client_area_top));
 }
 
 SkBitmap* OpaqueBrowserFrameView::GetFrameBitmap() const {
   bool is_incognito = browser_view_->IsOffTheRecord();
   int resource_id;
   if (browser_view_->IsBrowserTypeNormal()) {
     if (ShouldPaintAsActive()) {
       resource_id = is_incognito ?
           IDR_THEME_FRAME_INCOGNITO : IDR_THEME_FRAME;
     } else {
@@ skipping 189 matching lines @@
     ProfileInfoCache& cache =
         g_browser_process->profile_manager()->GetProfileInfoCache();
     Profile* profile = browser_view_->browser()->profile();
     size_t index = cache.GetIndexOfProfileWithPath(profile->GetPath());
     if (index != std::string::npos) {
       avatar_button_->SetIcon(cache.GetAvatarIconOfProfileAtIndex(index));
       avatar_button_->SetText(cache.GetNameOfProfileAtIndex(index));
     }
   }
 }