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

content/renderer/webplugin_delegate_proxy.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/renderer/webplugin_delegate_proxy.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #elif defined(USE_X11)
 #include <cairo/cairo.h>
@@ skipping 721 matching lines @@
 // Intended for converting rects between flipped and non-flipped contexts.
 static void FlipRectVerticallyWithHeight(gfx::Rect* rect, int height) {
   rect->set_y(height - rect->bottom());
 }
 #endif
 
 void WebPluginDelegateProxy::Paint(WebKit::WebCanvas* canvas,
                                    const gfx::Rect& damaged_rect) {
   // Limit the damaged rectangle to whatever is contained inside the plugin
   // rectangle, as that's the rectangle that we'll actually draw.
-  gfx::Rect rect = damaged_rect;
-  rect.Intersect(plugin_rect_);
+  gfx::Rect rect = gfx::Intersection(damaged_rect, plugin_rect_);
 
   // If the plugin is no longer connected (channel crashed) draw a crashed
   // plugin bitmap
   if (!channel_host_ || !channel_host_->channel_valid()) {
     PaintSadPlugin(canvas, rect);
     return;
   }
 
   if (!uses_shared_bitmaps_)
     return;
@@ skipping 93 matching lines @@
   XFORM xf;
   if (!GetWorldTransform(context, &xf)) {
     NOTREACHED();
     return true;
   }
 
   // The damaged rect that we're given can be larger than the bitmap, so
   // intersect their rects first.
   gfx::Rect bitmap_rect(static_cast<int>(-xf.eDx), static_cast<int>(-xf.eDy),
                         bitmap.bmWidth, bitmap.bmHeight);
-  gfx::Rect check_rect = rect;
-  check_rect.Intersect(bitmap_rect);
+  gfx::Rect check_rect = gfx::Intersection(rect, bitmap_rect);
   int row_byte_size = check_rect.width() * (bitmap.bmBitsPixel / 8);
   for (int y = check_rect.y(); y < check_rect.bottom(); y++) {
     char* hdc_row_start = static_cast<char*>(bitmap.bmBits) +
         (y + static_cast<int>(xf.eDy)) * bitmap.bmWidthBytes +
         (check_rect.x() + static_cast<int>(xf.eDx)) * (bitmap.bmBitsPixel / 8);
 
     // getAddr32 doesn't use the translation units, so we have to subtract
     // the plugin origin from the coordinates.
     uint32_t* canvas_row_start =
         background_store_.canvas->getDevice()->accessBitmap(true).getAddr32(
@@ skipping 24 matching lines @@
   double page_x_double = 0;
   double page_y_double = 0;
   cairo_device_to_user(context, &page_x_double, &page_y_double);
   gfx::Rect full_content_rect(static_cast<int>(page_x_double),
                               static_cast<int>(page_y_double),
                               cairo_image_surface_get_width(page_surface),
                               cairo_image_surface_get_height(page_surface));
 #endif
   // According to comments in the Windows code, the damage rect that we're given
   // may project outside the image, so intersect their rects.
-  gfx::Rect content_rect = rect;
-  content_rect.Intersect(full_content_rect);
+  gfx::Rect content_rect = gfx::Intersection(rect, full_content_rect);
 
 #if defined(OS_MACOSX)
   const unsigned char* page_bytes = static_cast<const unsigned char*>(
       CGBitmapContextGetData(context));
   int page_stride = CGBitmapContextGetBytesPerRow(context);
   int page_start_x = content_rect.x() - context_offset_x;
   int page_start_y = content_rect.y() - context_offset_y;
 
   skia::ScopedPlatformPaint scoped_platform_paint(
       background_store_.canvas.get());
@@ skipping 269 matching lines @@
   if (plugin_)
     plugin_->CancelResource(id);
 }
 
 void WebPluginDelegateProxy::OnInvalidateRect(const gfx::Rect& rect) {
   if (!plugin_)
     return;
 
   // Clip the invalidation rect to the plugin bounds; the plugin may have been
   // resized since the invalidate message was sent.
-  gfx::Rect clipped_rect = rect;
-  clipped_rect.Intersect(gfx::Rect(plugin_rect_.size()));
+  gfx::Rect clipped_rect =
+      gfx::Intersection(rect, gfx::Rect(plugin_rect_.size()));
 
   invalidate_pending_ = true;
   // The plugin is blocked on the renderer because the invalidate message it has
   // sent us is synchronous, so we can use buffer flipping here if the caller
   // allows it.
   UpdateFrontBuffer(clipped_rect, true);
   plugin_->InvalidateRect(clipped_rect);
 }
 
 void WebPluginDelegateProxy::OnGetWindowScriptNPObject(
@@ skipping 327 matching lines @@
 
 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
                                                    int resource_id) {
   if (!plugin_)
     return;
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }
 
 }  // namespace content