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

webkit/plugins/ppapi/ppb_graphics_2d_impl.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 "webkit/plugins/ppapi/ppb_graphics_2d_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 358 matching lines @@
                                       &scroll_delta : NULL)) {
         // Conversion requires falling back to InvalidateRect.
         operation.type = QueuedOperation::PAINT;
       }
 
       gfx::Rect clip = PP_ToGfxRect(bound_instance_->view_data().clip_rect);
       is_plugin_visible = !clip.IsEmpty();
 
       // Set |no_update_visible| to false if the change overlaps the visible
       // area.
-      gfx::Rect visible_changed_rect = clip;
-      visible_changed_rect.Intersect(op_rect);
+      gfx::Rect visible_changed_rect = gfx::IntersectRects(clip, op_rect);
       if (!visible_changed_rect.IsEmpty())
         no_update_visible = false;
 
       // Notify the plugin of the entire change (op_rect), even if it is
       // partially or completely off-screen.
       if (operation.type == QueuedOperation::SCROLL) {
         bound_instance_->ScrollRect(scroll_delta.x(), scroll_delta.y(),
                                     op_rect);
       } else {
         bound_instance_->InvalidateRect(op_rect);
@@ skipping 163 matching lines @@
 
   // TODO(jhorwich) Figure out if this code is even active anymore, and if so
   // how to properly handle scaling.
   DCHECK_EQ(1.0f, scale_);
 
   // TODO(brettw) bug 56673: do a direct memcpy instead of going through CG
   // if the is_always_opaque_ flag is set. Must ensure bitmap is still clipped.
 
   CGContextDrawImage(canvas, bitmap_rect, image);
 #else
-  gfx::Rect invalidate_rect = plugin_rect;
-  invalidate_rect.Intersect(paint_rect);
+  gfx::Rect invalidate_rect = gfx::IntersectRects(plugin_rect, paint_rect);
   SkRect sk_invalidate_rect = gfx::RectToSkRect(invalidate_rect);
   SkAutoCanvasRestore auto_restore(canvas, true);
   canvas->clipRect(sk_invalidate_rect);
   gfx::Size pixel_image_size(image_data_->width(), image_data_->height());
   gfx::Size image_size = gfx::ToFlooredSize(pixel_image_size.Scale(scale_));
 
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(this);
   if (!plugin_instance)
     return;
   if (plugin_instance->IsFullPagePlugin()) {
@@ skipping 66 matching lines @@
 bool PPB_Graphics2D_Impl::ConvertToLogicalPixels(float scale,
                                                  gfx::Rect* op_rect,
                                                  gfx::Point* delta) {
   if (scale == 1.0f || scale <= 0.0f)
     return true;
 
   gfx::Rect original_rect = *op_rect;
   // Take the enclosing rectangle after scaling so a rectangle scaled down then
   // scaled back up by the inverse scale would fully contain the entire area
   // affected by the original rectangle.
-  gfx::RectF scaled_rect = *op_rect;
-  scaled_rect.Scale(scale);
-  *op_rect = gfx::ToEnclosingRect(scaled_rect);
+  *op_rect = gfx::ToEnclosingRect(gfx::ScaleRect(*op_rect, scale));
   if (delta) {
     gfx::Point original_delta = *delta;
     float inverse_scale = 1.0f / scale;
     *delta = gfx::ToFlooredPoint(delta->Scale(scale));
 
-    gfx::RectF inverse_scaled_rect = *op_rect;
-    inverse_scaled_rect.Scale(inverse_scale);
-    if (original_rect != gfx::ToEnclosingRect(inverse_scaled_rect) ||
-        original_delta != gfx::ToFlooredPoint(delta->Scale(inverse_scale))) {
+    gfx::Rect inverse_scaled_rect =
+        gfx::ToEnclosingRect(gfx::ScaleRect(*op_rect, inverse_scale));
+    if (original_rect != inverse_scaled_rect)
       return false;
-    }
+    gfx::Point inverse_scaled_point =
+        gfx::ToFlooredPoint(delta->Scale(inverse_scale));
+    if (original_delta != inverse_scaled_point)
+      return false;
   }
 
   return true;
 }
 
 void PPB_Graphics2D_Impl::ExecutePaintImageData(PPB_ImageData_Impl* image,
                                                 int x, int y,
                                                 const gfx::Rect& src_rect,
                                                 gfx::Rect* invalidated_rect) {
   // Ensure the source image is mapped to read from it.
@@ skipping 86 matching lines @@
 }
 
 bool PPB_Graphics2D_Impl::HasPendingFlush() const {
   return !unpainted_flush_callback_.is_null() ||
          !painted_flush_callback_.is_null() ||
          offscreen_flush_pending_;
 }
 
 }  // namespace ppapi
 }  // namespace webkit