Add non-member non-mutating methods for common gfx::Rect operations.

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"
 
 namespace content {
@@ skipping 59 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
-  damaged_rect.Intersect(scroll_rect);
-  return damaged_rect;
+  return gfx::IntersectRects(scroll_rect, damaged_rect);
 }
 
 gfx::Rect PaintAggregator::PendingUpdate::GetPaintBounds() const {
   gfx::Rect bounds;
   for (size_t i = 0; i < paint_rects.size(); ++i)
     bounds.Union(paint_rects[i]);
   return bounds;
 }
 
 bool PaintAggregator::HasPendingUpdate() const {
@@ skipping 24 matching lines @@
 }
 
 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;
-      combined_rect.Union(rect);
+      gfx::Rect combined_rect = gfx::UnionRects(existing_rect, 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)) {
-      gfx::Rect paint_rect = rect;
-      paint_rect.Subtract(update_.GetScrollDamage());
-      update_.paint_rects[update_.paint_rects.size() - 1] = paint_rect;
+      update_.paint_rects[update_.paint_rects.size() - 1] =
+          gfx::SubtractRects(rect, update_.GetScrollDamage());
       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 125 matching lines @@
         outer.Union(existing_rect);
       }
     }
     update_.paint_rects.clear();
     update_.paint_rects.push_back(inner);
     update_.paint_rects.push_back(outer);
   }
 }
 
 }  // namespace content