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

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.Intersect(r2);
+    gfx::Rect ir = r1;
+    ir.Intersect(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.Union(r2);
+    gfx::Rect u = r1;
+    u.Union(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 31 matching lines @@
       0, 0, 3, 3,
       0, 0, 3, 3 },
     { 2, 2, 1, 1,
       0, 0, 3, 3,
       2, 2, 1, 1 }
   };
   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.AdjustToFit(r2));
+    gfx::Rect u = r1;
+    u.AdjustToFit(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, Subtract) {
+  gfx::Rect result;
+
   // Matching
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(10, 10, 20, 20)) ==
-      gfx::Rect(0, 0, 0, 0));
+  result = gfx::Rect(10, 10, 20, 20);
+  result.Subtract(gfx::Rect(10, 10, 20, 20));
+  EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(), result.ToString());
 
   // Contains
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(5, 5, 30, 30)) ==
-      gfx::Rect(0, 0, 0, 0));
+  result = gfx::Rect(10, 10, 20, 20);
+  result.Subtract(gfx::Rect(5, 5, 30, 30));
+  EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(), result.ToString());
 
   // No intersection
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(30, 30, 20, 20)) ==
-      gfx::Rect(10, 10, 20, 20));
+  result = gfx::Rect(10, 10, 20, 20);
+  result.Subtract(gfx::Rect(30, 30, 30, 30));
+  EXPECT_EQ(gfx::Rect(10, 10, 20, 20).ToString(), result.ToString());
 
   // Not a complete intersection in either direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(15, 15, 20, 20)) ==
-      gfx::Rect(10, 10, 20, 20));
+  result = gfx::Rect(10, 10, 20, 20);
+  result.Subtract(gfx::Rect(15, 15, 20, 20));
+  EXPECT_EQ(gfx::Rect(10, 10, 20, 20).ToString(), result.ToString());
 
   // Complete intersection in the x-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(10, 15, 20, 20)) ==
-      gfx::Rect(10, 10, 20, 5));
+  result = gfx::Rect(10, 10, 20, 20);
+  result.Subtract(gfx::Rect(10, 15, 20, 20));
+  EXPECT_EQ(gfx::Rect(10, 10, 20, 5).ToString(), result.ToString());
 
   // Complete intersection in the x-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(5, 15, 30, 20)) ==
-      gfx::Rect(10, 10, 20, 5));
+  result = gfx::Rect(10, 10, 20, 20);
+  result.Subtract(gfx::Rect(5, 15, 30, 20));
+  EXPECT_EQ(gfx::Rect(10, 10, 20, 5).ToString(), result.ToString());
 
   // Complete intersection in the x-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(5, 5, 30, 20)) ==
-      gfx::Rect(10, 25, 20, 5));
+  result = gfx::Rect(10, 10, 20, 20);
+  result.Subtract(gfx::Rect(5, 5, 30, 20));
+  EXPECT_EQ(gfx::Rect(10, 25, 20, 5).ToString(), result.ToString());
 
   // Complete intersection in the y-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(10, 10, 10, 30)) ==
-      gfx::Rect(20, 10, 10, 20));
+  result = gfx::Rect(10, 10, 20, 20);
+  result.Subtract(gfx::Rect(10, 10, 10, 30));
+  EXPECT_EQ(gfx::Rect(20, 10, 10, 20).ToString(), result.ToString());
 
   // Complete intersection in the y-direction
-  EXPECT_TRUE(
-      gfx::Rect(10, 10, 20, 20).Subtract(
-      gfx::Rect(5, 5, 20, 30)) ==
-      gfx::Rect(25, 10, 5, 20));
+  result = gfx::Rect(10, 10, 20, 20);
+  result.Subtract(gfx::Rect(5, 5, 20, 30));
+  EXPECT_EQ(gfx::Rect(25, 10, 5, 20).ToString(), result.ToString());
 }
 
 TEST(RectTest, IsEmpty) {
   EXPECT_TRUE(gfx::Rect(0, 0, 0, 0).IsEmpty());
   EXPECT_TRUE(gfx::Rect(0, 0, 0, 0).size().IsEmpty());
   EXPECT_TRUE(gfx::Rect(0, 0, 10, 0).IsEmpty());
   EXPECT_TRUE(gfx::Rect(0, 0, 10, 0).size().IsEmpty());
   EXPECT_TRUE(gfx::Rect(0, 0, 0, 10).IsEmpty());
   EXPECT_TRUE(gfx::Rect(0, 0, 0, 10).size().IsEmpty());
   EXPECT_FALSE(gfx::Rect(0, 0, 10, 10).IsEmpty());
@@ skipping 160 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.Scale(tests[i].scale);
+    gfx::RectF scaled = r1;
+    scaled.Scale(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(a);
+  gfx::RectF intersect = b;
+  intersect.Intersect(a);
   EXPECT_EQ(b.ToString(), intersect.ToString());
 
   EXPECT_EQ(a, b);
   EXPECT_EQ(b, a);
 }
 
 }  // namespace ui