Rolls cc and webkit_compositor up to 127340

cc/CCLayerTreeHostCommonTest.cpp

 // Copyright 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 "config.h"
 
 #include "CCLayerTreeHostCommon.h"
 
 #include "CCAnimationTestCommon.h"
+#include "CCGeometryTestUtils.h"
 #include "CCLayerAnimationController.h"
 #include "CCLayerImpl.h"
 #include "CCLayerSorter.h"
-#include "CCLayerTreeTestCommon.h"
 #include "CCMathUtil.h"
 #include "CCProxy.h"
 #include "CCSingleThreadProxy.h"
 #include "CCThread.h"
 #include "ContentLayerChromium.h"
 #include "ContentLayerChromiumClient.h"
 #include "LayerChromium.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <public/WebTransformationMatrix.h>
 
 using namespace WebCore;
 using namespace WebKitTests;
 using WebKit::WebTransformationMatrix;
 
-void WebKitTests::ExpectTransformationMatrixEq(WebTransformationMatrix expected,
-                                               WebTransformationMatrix actual)
-{
-    EXPECT_FLOAT_EQ((expected).m11(), (actual).m11());
-    EXPECT_FLOAT_EQ((expected).m12(), (actual).m12());
-    EXPECT_FLOAT_EQ((expected).m13(), (actual).m13());
-    EXPECT_FLOAT_EQ((expected).m14(), (actual).m14());
-    EXPECT_FLOAT_EQ((expected).m21(), (actual).m21());
-    EXPECT_FLOAT_EQ((expected).m22(), (actual).m22());
-    EXPECT_FLOAT_EQ((expected).m23(), (actual).m23());
-    EXPECT_FLOAT_EQ((expected).m24(), (actual).m24());
-    EXPECT_FLOAT_EQ((expected).m31(), (actual).m31());
-    EXPECT_FLOAT_EQ((expected).m32(), (actual).m32());
-    EXPECT_FLOAT_EQ((expected).m33(), (actual).m33());
-    EXPECT_FLOAT_EQ((expected).m34(), (actual).m34());
-    EXPECT_FLOAT_EQ((expected).m41(), (actual).m41());
-    EXPECT_FLOAT_EQ((expected).m42(), (actual).m42());
-    EXPECT_FLOAT_EQ((expected).m43(), (actual).m43());
-    EXPECT_FLOAT_EQ((expected).m44(), (actual).m44());
-}
-
 namespace {
 
 template<typename LayerType>
 void setLayerPropertiesForTesting(LayerType* layer, const WebTransformationMatrix& transform, const WebTransformationMatrix& sublayerTransform, const FloatPoint& anchor, const FloatPoint& position, const IntSize& bounds, bool preserves3D)
 {
     layer->setTransform(transform);
     layer->setSublayerTransform(sublayerTransform);
     layer->setAnchorPoint(anchor);
     layer->setPosition(position);
     layer->setBounds(bounds);
@@ skipping 1391 matching lines @@
     grandChild1->setOpacity(0.5);
     grandChild2->setOpacity(0.5);
     grandChild3->setOpacity(0.5);
     grandChild4->setOpacity(0.5);
 
     Vector<RefPtr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 
-    EXPECT_INT_RECT_EQ(IntRect(IntPoint(5, 5), IntSize(10, 10)), grandChild1->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(IntPoint(15, 15), IntSize(5, 5)), grandChild3->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(IntPoint(15, 15), IntSize(5, 5)), grandChild3->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(IntPoint(5, 5), IntSize(10, 10)), grandChild1->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(IntPoint(15, 15), IntSize(5, 5)), grandChild3->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(IntPoint(15, 15), IntSize(5, 5)), grandChild3->drawableContentRect());
     EXPECT_TRUE(grandChild4->drawableContentRect().isEmpty());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyClipRectIsPropagatedCorrectlyToSurfaces)
 {
     // Verify that renderSurfaces (and their layers) get the appropriate clipRects when their parent masksToBounds is true.
     //
     // Layers that own renderSurfaces (at least for now) do not inherit any clipping;
     // instead the surface will enforce the clip for the entire subtree. They may still
     // have a clipRect of their own layer bounds, however, if masksToBounds was true.
@@ skipping 49 matching lines @@
     int dummyMaxTextureSize = 512;
     CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 
     ASSERT_TRUE(grandChild1->renderSurface());
     ASSERT_TRUE(grandChild2->renderSurface());
     ASSERT_TRUE(grandChild3->renderSurface());
     EXPECT_FALSE(grandChild4->renderSurface()); // Because grandChild4 is entirely clipped, it is expected to not have a renderSurface.
 
     // Surfaces are clipped by their parent, but un-affected by the owning layer's masksToBounds.
-    EXPECT_INT_RECT_EQ(IntRect(IntPoint(0, 0), IntSize(20, 20)), grandChild1->renderSurface()->clipRect());
-    EXPECT_INT_RECT_EQ(IntRect(IntPoint(0, 0), IntSize(20, 20)), grandChild2->renderSurface()->clipRect());
-    EXPECT_INT_RECT_EQ(IntRect(IntPoint(0, 0), IntSize(20, 20)), grandChild3->renderSurface()->clipRect());
+    EXPECT_RECT_EQ(IntRect(IntPoint(0, 0), IntSize(20, 20)), grandChild1->renderSurface()->clipRect());
+    EXPECT_RECT_EQ(IntRect(IntPoint(0, 0), IntSize(20, 20)), grandChild2->renderSurface()->clipRect());
+    EXPECT_RECT_EQ(IntRect(IntPoint(0, 0), IntSize(20, 20)), grandChild3->renderSurface()->clipRect());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyAnimationsForRenderSurfaceHierarchy)
 {
     RefPtr<LayerChromium> parent = LayerChromium::create();
     RefPtr<LayerChromium> renderSurface1 = LayerChromium::create();
     RefPtr<LayerChromium> renderSurface2 = LayerChromium::create();
     RefPtr<LayerChromium> childOfRoot = LayerChromium::create();
     RefPtr<LayerChromium> childOfRS1 = LayerChromium::create();
     RefPtr<LayerChromium> childOfRS2 = LayerChromium::create();
@@ skipping 134 matching lines @@
 {
     // Test the calculateVisibleRect() function works correctly for identity transforms.
 
     IntRect targetSurfaceRect = IntRect(IntPoint(0, 0), IntSize(100, 100));
     WebTransformationMatrix layerToSurfaceTransform;
 
     // Case 1: Layer is contained within the surface.
     IntRect layerContentRect = IntRect(IntPoint(10, 10), IntSize(30, 30));
     IntRect expected = IntRect(IntPoint(10, 10), IntSize(30, 30));
     IntRect actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: Layer is outside the surface rect.
     layerContentRect = IntRect(IntPoint(120, 120), IntSize(30, 30));
     actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_TRUE(actual.isEmpty());
 
     // Case 3: Layer is partially overlapping the surface rect.
     layerContentRect = IntRect(IntPoint(80, 80), IntSize(30, 30));
     expected = IntRect(IntPoint(80, 80), IntSize(20, 20));
     actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyVisibleRectForTranslations)
 {
     // Test the calculateVisibleRect() function works correctly for scaling transforms.
 
     IntRect targetSurfaceRect = IntRect(IntPoint(0, 0), IntSize(100, 100));
     IntRect layerContentRect = IntRect(IntPoint(0, 0), IntSize(30, 30));
     WebTransformationMatrix layerToSurfaceTransform;
 
     // Case 1: Layer is contained within the surface.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.translate(10, 10);
     IntRect expected = IntRect(IntPoint(0, 0), IntSize(30, 30));
     IntRect actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: Layer is outside the surface rect.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.translate(120, 120);
     actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_TRUE(actual.isEmpty());
 
     // Case 3: Layer is partially overlapping the surface rect.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.translate(80, 80);
     expected = IntRect(IntPoint(0, 0), IntSize(20, 20));
     actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyVisibleRectFor2DRotations)
 {
     // Test the calculateVisibleRect() function works correctly for rotations about z-axis (i.e. 2D rotations).
     // Remember that calculateVisibleRect() should return the visible rect in the layer's space.
 
     IntRect targetSurfaceRect = IntRect(IntPoint(0, 0), IntSize(100, 100));
     IntRect layerContentRect = IntRect(IntPoint(0, 0), IntSize(30, 30));
     WebTransformationMatrix layerToSurfaceTransform;
 
     // Case 1: Layer is contained within the surface.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.translate(50, 50);
     layerToSurfaceTransform.rotate(45);
     IntRect expected = IntRect(IntPoint(0, 0), IntSize(30, 30));
     IntRect actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: Layer is outside the surface rect.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.translate(-50, 0);
     layerToSurfaceTransform.rotate(45);
     actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_TRUE(actual.isEmpty());
 
     // Case 3: The layer is rotated about its top-left corner. In surface space, the layer
     //         is oriented diagonally, with the left half outside of the renderSurface. In
     //         this case, the visible rect should still be the entire layer (remember the
     //         visible rect is computed in layer space); both the top-left and
     //         bottom-right corners of the layer are still visible.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.rotate(45);
     expected = IntRect(IntPoint(0, 0), IntSize(30, 30));
     actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 
     // Case 4: The layer is rotated about its top-left corner, and translated upwards. In
     //         surface space, the layer is oriented diagonally, with only the top corner
     //         of the surface overlapping the layer. In layer space, the render surface
     //         overlaps the right side of the layer. The visible rect should be the
     //         layer's right half.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.translate(0, -sqrt(2.0) * 15);
     layerToSurfaceTransform.rotate(45);
     expected = IntRect(IntPoint(15, 0), IntSize(15, 30)); // right half of layer bounds.
     actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyVisibleRectFor3dOrthographicTransform)
 {
     // Test that the calculateVisibleRect() function works correctly for 3d transforms.
 
     IntRect targetSurfaceRect = IntRect(IntPoint(0, 0), IntSize(100, 100));
     IntRect layerContentRect = IntRect(IntPoint(0, 0), IntSize(100, 100));
     WebTransformationMatrix layerToSurfaceTransform;
 
     // Case 1: Orthographic projection of a layer rotated about y-axis by 45 degrees, should be fully contained in the renderSurface.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.rotate3d(0, 45, 0);
     IntRect expected = IntRect(IntPoint(0, 0), IntSize(100, 100));
     IntRect actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: Orthographic projection of a layer rotated about y-axis by 45 degrees, but
     //         shifted to the side so only the right-half the layer would be visible on
     //         the surface.
     double halfWidthOfRotatedLayer = (100 / sqrt(2.0)) * 0.5; // 100 is the un-rotated layer width; divided by sqrt(2) is the rotated width.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.translate(-halfWidthOfRotatedLayer, 0);
     layerToSurfaceTransform.rotate3d(0, 45, 0); // rotates about the left edge of the layer
     expected = IntRect(IntPoint(50, 0), IntSize(50, 100)); // right half of the layer.
     actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyVisibleRectFor3dPerspectiveTransform)
 {
     // Test the calculateVisibleRect() function works correctly when the layer has a
     // perspective projection onto the target surface.
 
     IntRect targetSurfaceRect = IntRect(IntPoint(0, 0), IntSize(100, 100));
     IntRect layerContentRect = IntRect(IntPoint(-50, -50), IntSize(200, 200));
     WebTransformationMatrix layerToSurfaceTransform;
 
     // Case 1: Even though the layer is twice as large as the surface, due to perspective
     //         foreshortening, the layer will fit fully in the surface when its translated
     //         more than the perspective amount.
     layerToSurfaceTransform.makeIdentity();
 
     // The following sequence of transforms applies the perspective about the center of the surface.
     layerToSurfaceTransform.translate(50, 50);
     layerToSurfaceTransform.applyPerspective(9);
     layerToSurfaceTransform.translate(-50, -50);
 
     // This translate places the layer in front of the surface's projection plane.
     layerToSurfaceTransform.translate3d(0, 0, -27);
 
     IntRect expected = IntRect(IntPoint(-50, -50), IntSize(200, 200));
     IntRect actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: same projection as before, except that the layer is also translated to the
     //         side, so that only the right half of the layer should be visible.
     //
     // Explanation of expected result:
     // The perspective ratio is (z distance between layer and camera origin) / (z distance between projection plane and camera origin) == ((-27 - 9) / 9)
     // Then, by similar triangles, if we want to move a layer by translating -50 units in projected surface units (so that only half of it is
     // visible), then we would need to translate by (-36 / 9) * -50 == -200 in the layer's units.
     //
     layerToSurfaceTransform.translate3d(-200, 0, 0);
     expected = IntRect(IntPoint(50, -50), IntSize(100, 200)); // The right half of the layer's bounding rect.
     actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyVisibleRectFor3dOrthographicIsNotClippedBehindSurface)
 {
     // There is currently no explicit concept of an orthographic projection plane in our
     // code (nor in the CSS spec to my knowledge). Therefore, layers that are technically
     // behind the surface in an orthographic world should not be clipped when they are
     // flattened to the surface.
 
     IntRect targetSurfaceRect = IntRect(IntPoint(0, 0), IntSize(100, 100));
     IntRect layerContentRect = IntRect(IntPoint(0, 0), IntSize(100, 100));
     WebTransformationMatrix layerToSurfaceTransform;
 
     // This sequence of transforms effectively rotates the layer about the y-axis at the
     // center of the layer.
     layerToSurfaceTransform.makeIdentity();
     layerToSurfaceTransform.translate(50, 0);
     layerToSurfaceTransform.rotate3d(0, 45, 0);
     layerToSurfaceTransform.translate(-50, 0);
 
     IntRect expected = IntRect(IntPoint(0, 0), IntSize(100, 100));
     IntRect actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyVisibleRectFor3dPerspectiveWhenClippedByW)
 {
     // Test the calculateVisibleRect() function works correctly when projecting a surface
     // onto a layer, but the layer is partially behind the camera (not just behind the
     // projection plane). In this case, the cartesian coordinates may seem to be valid,
     // but actually they are not. The visibleRect needs to be properly clipped by the
     // w = 0 plane in homogeneous coordinates before converting to cartesian coordinates.
 
@@ skipping 45 matching lines @@
     bool clipped = false;
     FloatRect clippedRect = CCMathUtil::mapClippedRect(layerToSurfaceTransform, layerContentRect);
     CCMathUtil::projectQuad(layerToSurfaceTransform.inverse(), FloatQuad(clippedRect), clipped);
     ASSERT_TRUE(clipped);
 
     // Only the corner of the layer is not visible on the surface because of being
     // clipped. But, the net result of rounding visible region to an axis-aligned rect is
     // that the entire layer should still be considered visible.
     IntRect expected = IntRect(IntPoint(-10, -10), IntSize(20, 20));
     IntRect actual = CCLayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
-    EXPECT_INT_RECT_EQ(expected, actual);
+    EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyDrawableAndVisibleContentRectsForSimpleLayers)
 {
     RefPtr<LayerChromium> root = LayerChromium::create();
     RefPtr<LayerChromiumWithForcedDrawsContent> child1 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     RefPtr<LayerChromiumWithForcedDrawsContent> child2 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     RefPtr<LayerChromiumWithForcedDrawsContent> child3 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     root->addChild(child1);
     root->addChild(child2);
     root->addChild(child3);
 
     WebTransformationMatrix identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(50, 50), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(75, 75), IntSize(50, 50), false);
     setLayerPropertiesForTesting(child3.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(125, 125), IntSize(50, 50), false);
 
     executeCalculateDrawTransformsAndVisibility(root.get());
 
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
 
     // Layers that do not draw content should have empty visibleContentRects.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
 
     // layer visibleContentRects are clipped by their targetSurface
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 25, 25), child2->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 25, 25), child2->visibleContentRect());
     EXPECT_TRUE(child3->visibleContentRect().isEmpty());
 
     // layer drawableContentRects are not clipped.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child1->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(75, 75, 50, 50), child2->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(125, 125, 50, 50), child3->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child1->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(75, 75, 50, 50), child2->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(125, 125, 50, 50), child3->drawableContentRect());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyDrawableAndVisibleContentRectsForLayersClippedByLayer)
 {
     RefPtr<LayerChromium> root = LayerChromium::create();
     RefPtr<LayerChromium> child = LayerChromium::create();
     RefPtr<LayerChromiumWithForcedDrawsContent> grandChild1 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     RefPtr<LayerChromiumWithForcedDrawsContent> grandChild2 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     RefPtr<LayerChromiumWithForcedDrawsContent> grandChild3 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     root->addChild(child);
     child->addChild(grandChild1);
     child->addChild(grandChild2);
     child->addChild(grandChild3);
 
     WebTransformationMatrix identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(grandChild1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(5, 5), IntSize(50, 50), false);
     setLayerPropertiesForTesting(grandChild2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(75, 75), IntSize(50, 50), false);
     setLayerPropertiesForTesting(grandChild3.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(125, 125), IntSize(50, 50), false);
 
     child->setMasksToBounds(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_FALSE(child->renderSurface());
 
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
 
     // Layers that do not draw content should have empty visibleContentRects.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), child->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), child->visibleContentRect());
 
     // All grandchild visibleContentRects should be clipped by child.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), grandChild1->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 25, 25), grandChild2->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), grandChild1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 25, 25), grandChild2->visibleContentRect());
     EXPECT_TRUE(grandChild3->visibleContentRect().isEmpty());
 
     // All grandchild drawableContentRects should also be clipped by child.
-    EXPECT_INT_RECT_EQ(IntRect(5, 5, 50, 50), grandChild1->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(75, 75, 25, 25), grandChild2->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(5, 5, 50, 50), grandChild1->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(75, 75, 25, 25), grandChild2->drawableContentRect());
     EXPECT_TRUE(grandChild3->drawableContentRect().isEmpty());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyDrawableAndVisibleContentRectsForLayersInUnclippedRenderSurface)
 {
     RefPtr<LayerChromium> root = LayerChromium::create();
     RefPtr<LayerChromium> renderSurface1 = LayerChromium::create();
     RefPtr<LayerChromiumWithForcedDrawsContent> child1 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     RefPtr<LayerChromiumWithForcedDrawsContent> child2 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     RefPtr<LayerChromiumWithForcedDrawsContent> child3 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     root->addChild(renderSurface1);
     renderSurface1->addChild(child1);
     renderSurface1->addChild(child2);
     renderSurface1->addChild(child3);
 
     WebTransformationMatrix identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(3, 4), false);
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(5, 5), IntSize(50, 50), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(75, 75), IntSize(50, 50), false);
     setLayerPropertiesForTesting(child3.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(125, 125), IntSize(50, 50), false);
 
     renderSurface1->setForceRenderSurface(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_TRUE(renderSurface1->renderSurface());
 
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
 
     // Layers that do not draw content should have empty visibleContentRects.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface1->visibleContentRect());
 
     // An unclipped surface grows its drawableContentRect to include all drawable regions of the subtree.
-    EXPECT_INT_RECT_EQ(IntRect(5, 5, 170, 170), renderSurface1->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(5, 5, 170, 170), renderSurface1->renderSurface()->drawableContentRect());
 
     // All layers that draw content into the unclipped surface are also unclipped.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child2->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child3->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child2->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child3->visibleContentRect());
 
-    EXPECT_INT_RECT_EQ(IntRect(5, 5, 50, 50), child1->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(75, 75, 50, 50), child2->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(125, 125, 50, 50), child3->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(5, 5, 50, 50), child1->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(75, 75, 50, 50), child2->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(125, 125, 50, 50), child3->drawableContentRect());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyDrawableAndVisibleContentRectsForLayersInClippedRenderSurface)
 {
     RefPtr<LayerChromium> root = LayerChromium::create();
     RefPtr<LayerChromium> renderSurface1 = LayerChromium::create();
     RefPtr<LayerChromiumWithForcedDrawsContent> child1 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     RefPtr<LayerChromiumWithForcedDrawsContent> child2 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     RefPtr<LayerChromiumWithForcedDrawsContent> child3 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     root->addChild(renderSurface1);
     renderSurface1->addChild(child1);
     renderSurface1->addChild(child2);
     renderSurface1->addChild(child3);
 
     WebTransformationMatrix identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(3, 4), false);
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(5, 5), IntSize(50, 50), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(75, 75), IntSize(50, 50), false);
     setLayerPropertiesForTesting(child3.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(125, 125), IntSize(50, 50), false);
 
     root->setMasksToBounds(true);
     renderSurface1->setForceRenderSurface(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_TRUE(renderSurface1->renderSurface());
 
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
 
     // Layers that do not draw content should have empty visibleContentRects.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface1->visibleContentRect());
 
     // A clipped surface grows its drawableContentRect to include all drawable regions of the subtree,
     // but also gets clamped by the ancestor's clip.
-    EXPECT_INT_RECT_EQ(IntRect(5, 5, 95, 95), renderSurface1->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(5, 5, 95, 95), renderSurface1->renderSurface()->drawableContentRect());
 
     // All layers that draw content into the surface have their visibleContentRect clipped by the surface clipRect.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 25, 25), child2->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 25, 25), child2->visibleContentRect());
     EXPECT_TRUE(child3->visibleContentRect().isEmpty());
 
     // But the drawableContentRects are unclipped.
-    EXPECT_INT_RECT_EQ(IntRect(5, 5, 50, 50), child1->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(75, 75, 50, 50), child2->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(125, 125, 50, 50), child3->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(5, 5, 50, 50), child1->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(75, 75, 50, 50), child2->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(125, 125, 50, 50), child3->drawableContentRect());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyDrawableAndVisibleContentRectsForSurfaceHierarchy)
 {
     // Check that clipping does not propagate down surfaces.
     RefPtr<LayerChromium> root = LayerChromium::create();
     RefPtr<LayerChromium> renderSurface1 = LayerChromium::create();
     RefPtr<LayerChromium> renderSurface2 = LayerChromium::create();
     RefPtr<LayerChromiumWithForcedDrawsContent> child1 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     RefPtr<LayerChromiumWithForcedDrawsContent> child2 = adoptRef(new LayerChromiumWithForcedDrawsContent());
@@ skipping 13 matching lines @@
     setLayerPropertiesForTesting(child3.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(125, 125), IntSize(50, 50), false);
 
     root->setMasksToBounds(true);
     renderSurface1->setForceRenderSurface(true);
     renderSurface2->setForceRenderSurface(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_TRUE(renderSurface1->renderSurface());
     ASSERT_TRUE(renderSurface2->renderSurface());
 
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
 
     // Layers that do not draw content should have empty visibleContentRects.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface1->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface2->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface2->visibleContentRect());
 
     // A clipped surface grows its drawableContentRect to include all drawable regions of the subtree,
     // but also gets clamped by the ancestor's clip.
-    EXPECT_INT_RECT_EQ(IntRect(5, 5, 95, 95), renderSurface1->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(5, 5, 95, 95), renderSurface1->renderSurface()->drawableContentRect());
 
     // renderSurface1 lives in the "unclipped universe" of renderSurface1, and is only
     // implicitly clipped by renderSurface1's contentRect. So, renderSurface2 grows to
     // enclose all drawable content of its subtree.
-    EXPECT_INT_RECT_EQ(IntRect(5, 5, 170, 170), renderSurface2->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(5, 5, 170, 170), renderSurface2->renderSurface()->drawableContentRect());
 
     // All layers that draw content into renderSurface2 think they are unclipped.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child2->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child3->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child2->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child3->visibleContentRect());
 
     // drawableContentRects are also unclipped.
-    EXPECT_INT_RECT_EQ(IntRect(5, 5, 50, 50), child1->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(75, 75, 50, 50), child2->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(125, 125, 50, 50), child3->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(5, 5, 50, 50), child1->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(75, 75, 50, 50), child2->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(125, 125, 50, 50), child3->drawableContentRect());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyDrawableAndVisibleContentRectsWithTransformOnUnclippedSurface)
 {
     // Layers that have non-axis aligned bounds (due to transforms) have an expanded,
     // axis-aligned drawableContentRect and visibleContentRect.
 
     RefPtr<LayerChromium> root = LayerChromium::create();
     RefPtr<LayerChromium> renderSurface1 = LayerChromium::create();
     RefPtr<LayerChromiumWithForcedDrawsContent> child1 = adoptRef(new LayerChromiumWithForcedDrawsContent());
     root->addChild(renderSurface1);
     renderSurface1->addChild(child1);
 
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix childRotation;
     childRotation.rotate(45);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(3, 4), false);
     setLayerPropertiesForTesting(child1.get(), childRotation, identityMatrix, FloatPoint(0.5, 0.5), FloatPoint(25, 25), IntSize(50, 50), false);
 
     renderSurface1->setForceRenderSurface(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_TRUE(renderSurface1->renderSurface());
 
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 100, 100), root->drawableContentRect());
 
     // Layers that do not draw content should have empty visibleContentRects.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), root->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), renderSurface1->visibleContentRect());
 
     // The unclipped surface grows its drawableContentRect to include all drawable regions of the subtree.
     int diagonalRadius = ceil(sqrt(2.0) * 25);
     IntRect expectedSurfaceDrawableContent = IntRect(50 - diagonalRadius, 50 - diagonalRadius, diagonalRadius * 2, diagonalRadius * 2);
-    EXPECT_INT_RECT_EQ(expectedSurfaceDrawableContent, renderSurface1->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(expectedSurfaceDrawableContent, renderSurface1->renderSurface()->drawableContentRect());
 
     // All layers that draw content into the unclipped surface are also unclipped.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
-    EXPECT_INT_RECT_EQ(expectedSurfaceDrawableContent, child1->drawableContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 50, 50), child1->visibleContentRect());
+    EXPECT_RECT_EQ(expectedSurfaceDrawableContent, child1->drawableContentRect());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyDrawableAndVisibleContentRectsWithTransformOnClippedSurface)
 {
     // Layers that have non-axis aligned bounds (due to transforms) have an expanded,
     // axis-aligned drawableContentRect and visibleContentRect.
 
     RefPtr<LayerChromium> root = LayerChromium::create();
     RefPtr<LayerChromium> renderSurface1 = LayerChromium::create();
     RefPtr<LayerChromiumWithForcedDrawsContent> child1 = adoptRef(new LayerChromiumWithForcedDrawsContent());
@@ skipping 10 matching lines @@
     root->setMasksToBounds(true);
     renderSurface1->setForceRenderSurface(true);
     executeCalculateDrawTransformsAndVisibility(root.get());
 
     ASSERT_TRUE(renderSurface1->renderSurface());
 
     // The clipped surface clamps the drawableContentRect that encloses the rotated layer.
     int diagonalRadius = ceil(sqrt(2.0) * 25);
     IntRect unclippedSurfaceContent = IntRect(50 - diagonalRadius, 50 - diagonalRadius, diagonalRadius * 2, diagonalRadius * 2);
     IntRect expectedSurfaceDrawableContent = intersection(unclippedSurfaceContent, IntRect(0, 0, 50, 50));
-    EXPECT_INT_RECT_EQ(expectedSurfaceDrawableContent, renderSurface1->renderSurface()->drawableContentRect());
+    EXPECT_RECT_EQ(expectedSurfaceDrawableContent, renderSurface1->renderSurface()->drawableContentRect());
 
     // On the clipped surface, only a quarter  of the child1 is visible, but when rotating
     // it back to  child1's content space, the actual enclosing rect ends up covering the
     // full left half of child1.
-    EXPECT_INT_RECT_EQ(IntRect(0, 0, 26, 50), child1->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(0, 0, 26, 50), child1->visibleContentRect());
 
     // The child's drawableContentRect is unclipped.
-    EXPECT_INT_RECT_EQ(unclippedSurfaceContent, child1->drawableContentRect());
+    EXPECT_RECT_EQ(unclippedSurfaceContent, child1->drawableContentRect());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyBackFaceCullingWithoutPreserves3d)
 {
     // Verify the behavior of back-face culling when there are no preserve-3d layers. Note
     // that 3d transforms still apply in this case, but they are "flattened" to each
     // parent layer according to current W3C spec.
 
     const WebTransformationMatrix identityMatrix;
     RefPtr<LayerChromium> parent = LayerChromium::create();
@@ skipping 622 matching lines @@
     }
 
     Vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The visibleContentRect for testLayer is actually 100x100, even though its layout size is 50x50, positioned at 25x25.
     CCLayerImpl* testLayer = root->children()[0].get();
-    EXPECT_INT_RECT_EQ(IntRect(IntPoint::zero(), IntSize(100, 100)), testLayer->visibleContentRect());
+    EXPECT_RECT_EQ(IntRect(IntPoint::zero(), IntSize(100, 100)), testLayer->visibleContentRect());
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for a point outside the layer should return a null pointer (the root layer does not draw content, so it will not be hit tested either).
     IntPoint testPoint(101, 101);
     CCLayerImpl* resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 
     testPoint = IntPoint(24, 24);
     resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
@@ skipping 600 matching lines @@
     WebTransformationMatrix expectedDrawTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedDrawTransform, child->drawTransform());
 
     WebTransformationMatrix expectedScreenSpaceTransform;
     expectedScreenSpaceTransform.translate(deviceScaleFactor * child->position().x(), deviceScaleFactor * child->position().y());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedScreenSpaceTransform, child->screenSpaceTransform());
 
     WebTransformationMatrix expectedDuplicateChildDrawTransform = child->drawTransform();
     EXPECT_TRANSFORMATION_MATRIX_EQ(child->drawTransform(), duplicateChildNonOwner->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(child->screenSpaceTransform(), duplicateChildNonOwner->screenSpaceTransform());
-    EXPECT_INT_RECT_EQ(child->drawableContentRect(), duplicateChildNonOwner->drawableContentRect());
+    EXPECT_RECT_EQ(child->drawableContentRect(), duplicateChildNonOwner->drawableContentRect());
     EXPECT_EQ(child->contentBounds(), duplicateChildNonOwner->contentBounds());
 
     WebTransformationMatrix expectedRenderSurfaceDrawTransform;
     expectedRenderSurfaceDrawTransform.translate(deviceScaleFactor * child->position().x(), deviceScaleFactor * child->position().y());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedRenderSurfaceDrawTransform, child->renderSurface()->drawTransform());
 
     WebTransformationMatrix expectedSurfaceDrawTransform;
     expectedSurfaceDrawTransform.translate(deviceScaleFactor * 2, deviceScaleFactor * 2);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, child->renderSurface()->drawTransform());
 
@@ skipping 30 matching lines @@
     int nonexistentId = -1;
     EXPECT_EQ(root, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), root->id()));
     EXPECT_EQ(child, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), child->id()));
     EXPECT_EQ(grandChild, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), grandChild->id()));
     EXPECT_EQ(maskLayer, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), maskLayer->id()));
     EXPECT_EQ(replicaLayer, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), replicaLayer->id()));
     EXPECT_EQ(0, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), nonexistentId));
 }
 
 } // namespace