Pass const gfx::Rect& as the first parameter to FillRect.

chrome/browser/ui/views/frame/opaque_browser_frame_view.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 "chrome/browser/ui/views/frame/opaque_browser_frame_view.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 692 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->FillRect(theme_toolbar_color,
-                   gfx::Rect(x, bottom_y, w, bottom_edge_height));
+  canvas->FillRect(gfx::Rect(x, bottom_y, w, bottom_edge_height),
+                   tp->GetColor(ThemeService::COLOR_TOOLBAR));
 
   // 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->FillRect(ResourceBundle::toolbar_separator_color,
-                   gfx::Rect(x + kClientEdgeThickness,
+  canvas->FillRect(gfx::Rect(x + kClientEdgeThickness,
                              toolbar_bounds.bottom() - kClientEdgeThickness,
                              w - (2 * kClientEdgeThickness),
-                             kClientEdgeThickness));
+                             kClientEdgeThickness),
+                   ResourceBundle::toolbar_separator_color);
 }
 
 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->FillRect(
-        toolbar_color,
-        gfx::Rect(client_area_bounds.x() - kClientEdgeThickness,
-                  client_area_top - kClientEdgeThickness,
-                  client_area_bounds.width() + (2 * kClientEdgeThickness),
-                  kClientEdgeThickness));
+    canvas->FillRect(gfx::Rect(client_area_bounds.x() - kClientEdgeThickness,
+        client_area_top - kClientEdgeThickness,
+        client_area_bounds.width() + (2 * kClientEdgeThickness),
+        kClientEdgeThickness), toolbar_color);
   }
 
   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->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));
+  canvas->FillRect(gfx::Rect(client_area_bounds.x() - kClientEdgeThickness,
+      client_area_top, kClientEdgeThickness,
+      client_area_bottom + kClientEdgeThickness - client_area_top),
+       toolbar_color);
+  canvas->FillRect(gfx::Rect(client_area_bounds.x(), client_area_bottom,
+                             client_area_bounds.width(), kClientEdgeThickness),
+                   toolbar_color);
+  canvas->FillRect(gfx::Rect(client_area_bounds.right(), client_area_top,
+      kClientEdgeThickness,
+      client_area_bottom + kClientEdgeThickness - client_area_top),
+      toolbar_color);
 }
 
 SkColor OpaqueBrowserFrameView::GetFrameColor() const {
   bool is_incognito = browser_view()->IsOffTheRecord();
   if (browser_view()->IsBrowserTypeNormal()) {
     if (ShouldPaintAsActive()) {
       return GetThemeProvider()->GetColor(is_incognito ?
           ThemeService::COLOR_FRAME_INCOGNITO : ThemeService::COLOR_FRAME);
     }
     return GetThemeProvider()->GetColor(is_incognito ?
@@ skipping 184 matching lines @@
 
 gfx::Rect OpaqueBrowserFrameView::CalculateClientAreaBounds(int width,
                                                             int height) const {
   int top_height = NonClientTopBorderHeight(false);
   int border_thickness = NonClientBorderThickness();
   return gfx::Rect(border_thickness, top_height,
                    std::max(0, width - (2 * border_thickness)),
                    std::max(0, height - GetReservedHeight() -
                        top_height - border_thickness));
 }