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

ui/gfx/rect_unittest.cc

 // Copyright (c) 2011 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 "base/basictypes.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 
@@ skipping 89 matching lines @@
       3, 1, 4, 2,
       3, 1, 1, 2 },
     { 3, 0, 2, 2,   // gap
       0, 0, 2, 2,
       0, 0, 0, 0 }
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     gfx::Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
     gfx::Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
     gfx::Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
-    gfx::Rect ir = r1;
-    ir.Intersect(r2);
+    gfx::Rect ir = gfx::Intersection(r1, r2);
     EXPECT_EQ(r3.x(), ir.x());
     EXPECT_EQ(r3.y(), ir.y());
     EXPECT_EQ(r3.width(), ir.width());
     EXPECT_EQ(r3.height(), ir.height());
   }
 }
 
 TEST(RectTest, Union) {
   static const struct Test {
     int x1;  // rect 1
@@ skipping 28 matching lines @@
       0, 0, 2, 2,
       0, 0, 5, 5 },
     { 0, 0, 0, 0,   // union with empty rect
       2, 2, 2, 2,
       2, 2, 2, 2 }
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     gfx::Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
     gfx::Rect r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
     gfx::Rect r3(tests[i].x3, tests[i].y3, tests[i].w3, tests[i].h3);
-    gfx::Rect u = r1;
-    u.Union(r2);
+    gfx::Rect u = gfx::Union(r1, r2);
     EXPECT_EQ(r3.x(), u.x());
     EXPECT_EQ(r3.y(), u.y());
     EXPECT_EQ(r3.width(), u.width());
     EXPECT_EQ(r3.height(), u.height());
   }
 }
 
 TEST(RectTest, Equals) {
   ASSERT_TRUE(gfx::Rect(0, 0, 0, 0) == gfx::Rect(0, 0, 0, 0));
   ASSERT_TRUE(gfx::Rect(1, 2, 3, 4) == gfx::Rect(1, 2, 3, 4));
@@ skipping 267 matching lines @@
       std::numeric_limits<float>::max() },
     { 3, 3, 3, 3,
       -1.0f,
       -3.0f, -3.0f, 0.0f, 0.0f }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     gfx::Rect r1(tests[i].x1, tests[i].y1, tests[i].w1, tests[i].h1);
     gfx::RectF r2(tests[i].x2, tests[i].y2, tests[i].w2, tests[i].h2);
 
-    gfx::RectF scaled = r1;
-    scaled.Scale(tests[i].scale);
+    gfx::RectF scaled = gfx::Scale(r1, tests[i].scale);
     EXPECT_FLOAT_AND_NAN_EQ(r2.x(), scaled.x());
     EXPECT_FLOAT_AND_NAN_EQ(r2.y(), scaled.y());
     EXPECT_FLOAT_AND_NAN_EQ(r2.width(), scaled.width());
     EXPECT_FLOAT_AND_NAN_EQ(r2.height(), scaled.height());
   }
 }
 
 TEST(RectTest, ToEnclosedRect) {
   static const struct Test {
     float x1; // source
@@ skipping 101 matching lines @@
   gfx::Rect test1(rect_1);
   gfx::Rect test2(rect_2);
 }
 #endif
 
 TEST(RectTest, ToRectF) {
   // Check that implicit conversion from integer to float compiles.
   gfx::Rect a(10, 20, 30, 40);
   gfx::RectF b(10, 20, 30, 40);
 
-  gfx::RectF intersect = b;
-  intersect.Intersect(a);
+  gfx::RectF intersect = gfx::Intersection(a, b);
   EXPECT_EQ(b.ToString(), intersect.ToString());
 
   EXPECT_EQ(a, b);
   EXPECT_EQ(b, a);
 }
 
 }  // namespace ui