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

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 719 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.Intersect(plugin_rect_);
+  gfx::Rect rect = damaged_rect;
+  rect.Intersect(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.Intersect(bitmap_rect);
+  gfx::Rect check_rect = rect;
+  check_rect.Intersect(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.Intersect(full_content_rect);
+  gfx::Rect content_rect = rect;
+  content_rect.Intersect(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.
-  const gfx::Rect clipped_rect(rect.Intersect(gfx::Rect(plugin_rect_.size())));
+  gfx::Rect clipped_rect = rect;
+  clipped_rect.Intersect(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 100 matching lines @@
   // want to use buffer flipping at all since it would add extra locking.
   // (Alternatively we could probably safely use async updates for buffer
   // flipping all the time since the size is not changing.)
   if (UseSynchronousGeometryUpdates()) {
     allow_buffer_flipping = false;
   }
 #endif
 
   // Plugin has just painted "rect" into the back-buffer, so the front-buffer
   // no longer holds the latest content for that rectangle.
-  front_buffer_diff_ = front_buffer_diff_.Subtract(rect);
+  front_buffer_diff_.Subtract(rect);
   if (allow_buffer_flipping && front_buffer_diff_.IsEmpty()) {
     // Back-buffer contains the latest content for all areas; simply flip
     // the buffers.
     front_buffer_index_ = back_buffer_index();
     SendUpdateGeometry(false);
     // The front-buffer now holds newer content for this region than the
     // back-buffer.
     front_buffer_diff_ = rect;
   } else {
     // Back-buffer contains the latest content for "rect" but the front-buffer
     // contains the latest content for some other areas (or buffer flipping not
     // allowed); fall back to copying the data.
     CopyFromBackBufferToFrontBuffer(rect);
   }
-  transport_store_painted_ = transport_store_painted_.Union(rect);
+  transport_store_painted_.Union(rect);
 }
 
 void WebPluginDelegateProxy::OnHandleURLRequest(
     const PluginHostMsg_URLRequest_Params& params) {
   const char* data = NULL;
   if (params.buffer.size())
     data = &params.buffer[0];
 
   const char* target = NULL;
   if (params.target.length())
@@ skipping 189 matching lines @@
 }
 #endif
 
 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
                                                    int resource_id) {
   if (!plugin_)
     return;
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }