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

content/renderer/paint_aggregator.cc

 // Copyright (c) 2009 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/renderer/paint_aggregator.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 
 // ----------------------------------------------------------------------------
@@ skipping 57 matching lines @@
     if (dy > 0) {
       damaged_rect.set_y(scroll_rect.y());
       damaged_rect.set_height(dy);
     } else {
       damaged_rect.set_y(scroll_rect.bottom() + dy);
       damaged_rect.set_height(-dy);
     }
   }
 
   // In case the scroll offset exceeds the width/height of the scroll rect
-  return scroll_rect.Intersect(damaged_rect);
+  damaged_rect.Intersect(scroll_rect);
+  return damaged_rect;
 }
 
 gfx::Rect PaintAggregator::PendingUpdate::GetPaintBounds() const {
   gfx::Rect bounds;
   for (size_t i = 0; i < paint_rects.size(); ++i)
-    bounds = bounds.Union(paint_rects[i]);
+    bounds.Union(paint_rects[i]);
   return bounds;
 }
 
 bool PaintAggregator::HasPendingUpdate() const {
   return !update_.scroll_rect.IsEmpty() || !update_.paint_rects.empty();
 }
 
 void PaintAggregator::ClearPendingUpdate() {
   update_ = PendingUpdate();
 }
 
 void PaintAggregator::PopPendingUpdate(PendingUpdate* update) {
   // Combine paint rects if their combined area is not sufficiently less than
   // the area of the union of all paint rects.  We skip this if there is a
   // scroll rect since scrolling benefits from smaller paint rects.
   if (update_.scroll_rect.IsEmpty() && update_.paint_rects.size() > 1) {
     int paint_area = 0;
     gfx::Rect union_rect;
     for (size_t i = 0; i < update_.paint_rects.size(); ++i) {
       paint_area += update_.paint_rects[i].size().GetArea();
-      union_rect = union_rect.Union(update_.paint_rects[i]);
+      union_rect.Union(update_.paint_rects[i]);
     }
     int union_area = union_rect.size().GetArea();
     if (float(paint_area) / float(union_area) > kMaxPaintRectsAreaRatio)
       CombinePaintRects();
   }
   *update = update_;
   ClearPendingUpdate();
 }
 
 void PaintAggregator::InvalidateRect(const gfx::Rect& rect) {
   // Combine overlapping paints using smallest bounding box.
   for (size_t i = 0; i < update_.paint_rects.size(); ++i) {
     const gfx::Rect& existing_rect = update_.paint_rects[i];
     if (existing_rect.Contains(rect))  // Optimize out redundancy.
       return;
     if (rect.Intersects(existing_rect) || rect.SharesEdgeWith(existing_rect)) {
       // Re-invalidate in case the union intersects other paint rects.
-      gfx::Rect combined_rect = existing_rect.Union(rect);
+      gfx::Rect combined_rect = existing_rect;
+      combined_rect.Union(rect);
       update_.paint_rects.erase(update_.paint_rects.begin() + i);
       InvalidateRect(combined_rect);
       return;
     }
   }
 
   // Add a non-overlapping paint.
   update_.paint_rects.push_back(rect);
 
   // If the new paint overlaps with a scroll, then it forces an invalidation of
   // the scroll.  If the new paint is contained by a scroll, then trim off the
   // scroll damage to avoid redundant painting.
   if (!update_.scroll_rect.IsEmpty()) {
     if (ShouldInvalidateScrollRect(rect)) {
       InvalidateScrollRect();
     } else if (update_.scroll_rect.Contains(rect)) {
-      update_.paint_rects[update_.paint_rects.size() - 1] =
-          rect.Subtract(update_.GetScrollDamage());
+      gfx::Rect paint_rect = rect;
+      paint_rect.Subtract(update_.GetScrollDamage());
+      update_.paint_rects[update_.paint_rects.size() - 1] = paint_rect;
       if (update_.paint_rects[update_.paint_rects.size() - 1].IsEmpty())
         update_.paint_rects.erase(update_.paint_rects.end() - 1);
     }
   }
 
   if (update_.paint_rects.size() > kMaxPaintRects)
     CombinePaintRects();
 
   // Track how large the paint_rects vector grows during an invalidation
   // sequence.  Note: A subsequent invalidation may end up being combined
@@ skipping 54 matching lines @@
   // an invalidation of the scroll.
   if (ShouldInvalidateScrollRect(gfx::Rect()))
     InvalidateScrollRect();
 }
 
 gfx::Rect PaintAggregator::ScrollPaintRect(const gfx::Rect& paint_rect,
                                            int dx, int dy) const {
   gfx::Rect result = paint_rect;
 
   result.Offset(dx, dy);
-  result = update_.scroll_rect.Intersect(result);
+  result.Intersect(update_.scroll_rect);
 
   // Subtract out the scroll damage rect to avoid redundant painting.
-  return result.Subtract(update_.GetScrollDamage());
+  result.Subtract(update_.GetScrollDamage());
+  return result;
 }
 
 bool PaintAggregator::ShouldInvalidateScrollRect(const gfx::Rect& rect) const {
   if (!rect.IsEmpty()) {
     if (!update_.scroll_rect.Intersects(rect))
       return false;
 
     if (!update_.scroll_rect.Contains(rect))
       return true;
   }
@@ skipping 34 matching lines @@
   //
   if (update_.scroll_rect.IsEmpty()) {
     gfx::Rect bounds = update_.GetPaintBounds();
     update_.paint_rects.clear();
     update_.paint_rects.push_back(bounds);
   } else {
     gfx::Rect inner, outer;
     for (size_t i = 0; i < update_.paint_rects.size(); ++i) {
       const gfx::Rect& existing_rect = update_.paint_rects[i];
       if (update_.scroll_rect.Contains(existing_rect)) {
-        inner = inner.Union(existing_rect);
+        inner.Union(existing_rect);
       } else {
-        outer = outer.Union(existing_rect);
+        outer.Union(existing_rect);
       }
     }
     update_.paint_rects.clear();
     update_.paint_rects.push_back(inner);
     update_.paint_rects.push_back(outer);
   }
 }