Make gfx::Rect class operations consistently mutate the class they are called on.

content/browser/renderer_host/render_widget_host_view_aura.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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 419 matching lines @@
   gfx::Rect view_bounds = window_->GetBoundsInRootWindow();
   std::vector<webkit::npapi::WebPluginGeometry> moves = plugin_window_moves;
 
   gfx::Rect view_port(scroll_offset.x(), scroll_offset.y(), view_bounds.width(),
                       view_bounds.height());
 
   for (size_t i = 0; i < moves.size(); ++i) {
     gfx::Rect clip = moves[i].clip_rect;
     clip.Offset(moves[i].window_rect.origin());
     clip.Offset(scroll_offset);
-    clip = clip.Intersect(view_port);
+    clip.Intersect(view_port);
     clip.Offset(-moves[i].window_rect.x(), -moves[i].window_rect.y());
     clip.Offset(-scroll_offset.x(), -scroll_offset.y());
     moves[i].clip_rect = clip;
 
     moves[i].window_rect.Offset(view_bounds.origin());
   }
   MovePluginWindowsHelper(parent, moves);
 
   // Make sure each plugin window (or its wrapper if it exists) has a pointer to
   // |this|.
@@ skipping 100 matching lines @@
   if (paint_canvas_) {
     SkRect sk_clip_rect;
     if (paint_canvas_->sk_canvas()->getClipBounds(&sk_clip_rect))
       clip_rect = gfx::SkRectToRect(sk_clip_rect);
   }
 
   if (!scroll_rect.IsEmpty())
     SchedulePaintIfNotInClip(scroll_rect, clip_rect);
 
   for (size_t i = 0; i < copy_rects.size(); ++i) {
-    gfx::Rect rect = copy_rects[i].Subtract(scroll_rect);
+    gfx::Rect rect = copy_rects[i];
+    rect.Subtract(scroll_rect);
     if (rect.IsEmpty())
       continue;
 
     SchedulePaintIfNotInClip(rect, clip_rect);
 
 #if defined(OS_WIN)
     // Send the invalid rect in screen coordinates.
     gfx::Rect screen_rect = GetViewBounds();
     gfx::Rect invalid_screen_rect(rect);
     invalid_screen_rect.Offset(screen_rect.x(), screen_rect.y());
@@ skipping 292 matching lines @@
     gfx::Rect rect_to_paint = ConvertRectToDIP(this, gfx::Rect(
         params_in_pixel.x,
         surface_size_in_pixel.height() - params_in_pixel.y -
             params_in_pixel.height,
         params_in_pixel.width,
         params_in_pixel.height));
 
     // Damage may not have been DIP aligned, so inflate damage to compensate
     // for any round-off error.
     rect_to_paint.Inset(-1, -1);
-    rect_to_paint = rect_to_paint.Intersect(window_->bounds());
+    rect_to_paint.Intersect(window_->bounds());
 
     window_->SchedulePaintInRect(rect_to_paint);
 
     if (!resize_locks_.empty()) {
       // If we are waiting for the resize, fast-track the ACK.
       if (compositor->IsThreaded()) {
         // We need the compositor thread to pick up the active buffer before
         // ACKing.
         on_compositing_did_commit_callbacks_.push_back(
             base::Bind(&RenderWidgetHostViewAura::InsertSyncPointAndACK,
@@ skipping 276 matching lines @@
       aura::client::GetScreenPositionClient(root_window);
   screen_position_client->ConvertPointToScreen(window_, &origin);
   screen_position_client->ConvertPointToScreen(window_, &end);
   return gfx::Rect(origin.x(),
                    origin.y(),
                    end.x() - origin.x(),
                    end.y() - origin.y());
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetCaretBounds() {
-  const gfx::Rect rect = selection_start_rect_.Union(selection_end_rect_);
+  gfx::Rect rect = selection_start_rect_;
+  rect.Union(selection_end_rect_);
   return ConvertRectToScreen(rect);
 }
 
 bool RenderWidgetHostViewAura::GetCompositionCharacterBounds(uint32 index,
                                                              gfx::Rect* rect) {
   DCHECK(rect);
   if (index >= composition_character_bounds_.size())
     return false;
   *rect = ConvertRectToScreen(composition_character_bounds_[index]);
   return true;
@@ skipping 607 matching lines @@
   } else {
     unlocked_mouse_position_.SetPoint(event->windowX, event->windowY);
     unlocked_global_mouse_position_.SetPoint(event->globalX, event->globalY);
   }
 }
 
 void RenderWidgetHostViewAura::SchedulePaintIfNotInClip(
     const gfx::Rect& rect,
     const gfx::Rect& clip) {
   if (!clip.IsEmpty()) {
-    gfx::Rect to_paint = rect.Subtract(clip);
+    gfx::Rect to_paint = rect;
+    to_paint.Subtract(clip);
     if (!to_paint.IsEmpty())
       window_->SchedulePaintInRect(to_paint);
   } else {
     window_->SchedulePaintInRect(rect);
   }
 }
 
 bool RenderWidgetHostViewAura::ShouldMoveToCenter() {
   gfx::Rect rect = window_->bounds();
   int border_x = rect.width() * kMouseLockBorderPercentage / 100;
@@ skipping 75 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content