cc: Use gfx:: Geometry types for positions, bounds, and related things.

cc/layer_tree_host_common.cc

 // 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 "cc/layer_tree_host_common.h"
 
-#include "FloatQuad.h"
-#include "IntRect.h"
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_sorter.h"
 #include "cc/math_util.h"
 #include "cc/render_surface.h"
 #include "cc/render_surface_impl.h"
+#include "ui/gfx/rect_conversions.h"
 #include <algorithm>
 #include <public/WebTransformationMatrix.h>
 
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 ScrollAndScaleSet::ScrollAndScaleSet()
 {
 }
 
 ScrollAndScaleSet::~ScrollAndScaleSet()
 {
 }
 
-IntRect LayerTreeHostCommon::calculateVisibleRect(const IntRect& targetSurfaceRect, const IntRect& layerBoundRect, const WebTransformationMatrix& transform)
+gfx::Rect LayerTreeHostCommon::calculateVisibleRect(const gfx::Rect& targetSurfaceRect, const gfx::Rect& layerBoundRect, const WebTransformationMatrix& transform)
 {
     // Is this layer fully contained within the target surface?
-    IntRect layerInSurfaceSpace = MathUtil::mapClippedRect(transform, layerBoundRect);
-    if (targetSurfaceRect.contains(layerInSurfaceSpace))
+    gfx::Rect layerInSurfaceSpace = MathUtil::mapClippedRect(transform, layerBoundRect);
+    if (targetSurfaceRect.Contains(layerInSurfaceSpace))
         return layerBoundRect;
 
     // If the layer doesn't fill up the entire surface, then find the part of
     // the surface rect where the layer could be visible. This avoids trying to
     // project surface rect points that are behind the projection point.
-    IntRect minimalSurfaceRect = targetSurfaceRect;
-    minimalSurfaceRect.intersect(layerInSurfaceSpace);
+    gfx::Rect minimalSurfaceRect = targetSurfaceRect;
+    minimalSurfaceRect.Intersect(layerInSurfaceSpace);
 
     // Project the corners of the target surface rect into the layer space.
     // This bounding rectangle may be larger than it needs to be (being
     // axis-aligned), but is a reasonable filter on the space to consider.
     // Non-invertible transforms will create an empty rect here.
     const WebTransformationMatrix surfaceToLayer = transform.inverse();
-    IntRect layerRect = enclosingIntRect(MathUtil::projectClippedRect(surfaceToLayer, FloatRect(minimalSurfaceRect)));
-    layerRect.intersect(layerBoundRect);
+    gfx::Rect layerRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(surfaceToLayer, gfx::RectF(minimalSurfaceRect)));
+    layerRect.Intersect(layerBoundRect);
     return layerRect;
 }
 
 template <typename LayerType>
 static inline bool isRootLayer(LayerType* layer)
 {
     return !layer->parent();
 }
 
 template<typename LayerType>
@@ skipping 46 matching lines @@
     return false;
 }
 
 template<typename LayerType>
 static inline bool layerClipsSubtree(LayerType* layer)
 {
     return layer->masksToBounds() || layer->maskLayer();
 }
 
 template<typename LayerType>
-static IntRect calculateVisibleContentRect(LayerType* layer)
+static gfx::Rect calculateVisibleContentRect(LayerType* layer)
 {
     DCHECK(layer->renderTarget());
 
     // Nothing is visible if the layer bounds are empty.
-    if (!layer->drawsContent() || layer->contentBounds().isEmpty() || layer->drawableContentRect().isEmpty())
-        return IntRect();
+    if (!layer->drawsContent() || layer->contentBounds().IsEmpty() || layer->drawableContentRect().IsEmpty())
+        return gfx::Rect();
 
-    IntRect targetSurfaceClipRect;
+    gfx::Rect targetSurfaceClipRect;
 
     // First, compute visible bounds in target surface space.
-    if (layer->renderTarget()->renderSurface()->clipRect().isEmpty())
+    if (layer->renderTarget()->renderSurface()->clipRect().IsEmpty())
         targetSurfaceClipRect = layer->drawableContentRect();
     else {
         // In this case the target surface does clip layers that contribute to it. So, we
         // have convert the current surface's clipRect from its ancestor surface space to
         // the current surface space.
-        targetSurfaceClipRect = enclosingIntRect(MathUtil::projectClippedRect(layer->renderTarget()->renderSurface()->drawTransform().inverse(), layer->renderTarget()->renderSurface()->clipRect()));
-        targetSurfaceClipRect.intersect(layer->drawableContentRect());
+        targetSurfaceClipRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(layer->renderTarget()->renderSurface()->drawTransform().inverse(), layer->renderTarget()->renderSurface()->clipRect()));
+        targetSurfaceClipRect.Intersect(layer->drawableContentRect());
     }
 
-    if (targetSurfaceClipRect.isEmpty())
-        return IntRect();
+    if (targetSurfaceClipRect.IsEmpty())
+        return gfx::Rect();
 
-    return LayerTreeHostCommon::calculateVisibleRect(targetSurfaceClipRect, IntRect(IntPoint(), layer->contentBounds()), layer->drawTransform());
+    return LayerTreeHostCommon::calculateVisibleRect(targetSurfaceClipRect, gfx::Rect(gfx::Point(), layer->contentBounds()), layer->drawTransform());
 }
 
 static bool isScaleOrTranslation(const WebTransformationMatrix& m)
 {
     return !m.m12() && !m.m13() && !m.m14()
            && !m.m21() && !m.m23() && !m.m24()
            && !m.m31() && !m.m32() && !m.m43()
            && m.m44();
 }
 
@@ skipping 27 matching lines @@
     //   - the layer is not double-sided, but its back face is visible.
     //
     // Some additional conditions need to be computed at a later point after the recursion is finished.
     //   - the intersection of render surface content and layer clipRect is empty
     //   - the visibleContentRect is empty
     //
     // Note, if the layer should not have been drawn due to being fully transparent,
     // we would have skipped the entire subtree and never made it into this function,
     // so it is safe to omit this check here.
 
-    if (!layer->drawsContent() || layer->bounds().isEmpty())
+    if (!layer->drawsContent() || layer->bounds().IsEmpty())
         return true;
 
     LayerType* backfaceTestLayer = layer;
     if (layer->useParentBackfaceVisibility()) {
         DCHECK(layer->parent());
         DCHECK(!layer->parent()->useParentBackfaceVisibility());
         backfaceTestLayer = layer->parent();
     }
 
     // The layer should not be drawn if (1) it is not double-sided and (2) the back of the layer is known to be facing the screen.
@@ skipping 150 matching lines @@
 // There is no contentsScale on impl thread.
 static inline void updateLayerContentsScale(LayerImpl*, const WebTransformationMatrix&, float, float) { }
 
 static inline void updateLayerContentsScale(Layer* layer, const WebTransformationMatrix& combinedTransform, float deviceScaleFactor, float pageScaleFactor)
 {
     float rasterScale = layer->rasterScale();
     if (!rasterScale) {
         rasterScale = 1;
 
         if (layer->automaticallyComputeRasterScale()) {
-            FloatPoint transformScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
+            gfx::Vector2dF transformScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
             float combinedScale = std::max(transformScale.x(), transformScale.y());
             rasterScale = combinedScale / deviceScaleFactor;
             if (!layer->boundsContainPageScale())
                 rasterScale /= pageScaleFactor;
             layer->setRasterScale(rasterScale);
         }
     }
 
     float contentsScale = rasterScale * deviceScaleFactor;
     if (!layer->boundsContainPageScale())
         contentsScale *= pageScaleFactor;
     layer->setContentsScale(contentsScale);
 
     Layer* maskLayer = layer->maskLayer();
     if (maskLayer)
         maskLayer->setContentsScale(contentsScale);
 
     Layer* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
     if (replicaMaskLayer)
         replicaMaskLayer->setContentsScale(contentsScale);
 }
 
 // Recursively walks the layer tree starting at the given node and computes all the
 // necessary transformations, clipRects, render surfaces, etc.
 template<typename LayerType, typename LayerList, typename RenderSurfaceType, typename LayerSorter>
 static void calculateDrawTransformsInternal(LayerType* layer, const WebTransformationMatrix& parentMatrix,
     const WebTransformationMatrix& fullHierarchyMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix,
-    const IntRect& clipRectFromAncestor, bool ancestorClipsSubtree,
+    const gfx::Rect& clipRectFromAncestor, bool ancestorClipsSubtree,
     RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList,
-    LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, float pageScaleFactor, IntRect& drawableContentRectOfSubtree)
+    LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, float pageScaleFactor, gfx::Rect& drawableContentRectOfSubtree)
 {
     // This function computes the new matrix transformations recursively for this
     // layer and all its descendants. It also computes the appropriate render surfaces.
     // Some important points to remember:
     //
     // 0. Here, transforms are notated in Matrix x Vector order, and in words we describe what
     //    the transform does from left to right.
     //
     // 1. In our terminology, the "layer origin" refers to the top-left corner of a layer, and the
     //    positive Y-axis points downwards. This interpretation is valid because the orthographic
     //    projection applied at draw time flips the Y axis appropriately.
     //
-    // 2. The anchor point, when given as a FloatPoint object, is specified in "unit layer space",
+    // 2. The anchor point, when given as a PointF object, is specified in "unit layer space",
     //    where the bounds of the layer map to [0, 1]. However, as a WebTransformationMatrix object,
     //    the transform to the anchor point is specified in "layer space", where the bounds
     //    of the layer map to [bounds.width(), bounds.height()].
     //
     // 3. Definition of various transforms used:
     //        M[parent] is the parent matrix, with respect to the nearest render surface, passed down recursively.
     //        M[root] is the full hierarchy, with respect to the root, passed down recursively.
     //        Tr[origin] is the translation matrix from the parent's origin to this layer's origin.
     //        Tr[origin2anchor] is the translation from the layer's origin to its anchor point
     //        Tr[origin2center] is the translation from the layer's origin to its center
@@ skipping 51 matching lines @@
     //        M[surface2root] =  M[owningLayer->screenspace] * S[deviceScale].inverse()
     //
     // The replica draw transform to its target surface origin is:
     //        M[replicaDraw] = S[deviceScale] * M[surfaceDraw] * Tr[replica->position() + replica->anchor()] * Tr[replica] * Tr[origin2anchor].inverse() * S[contentsScale].inverse()
     //
     // The replica draw transform to the root (screen space) origin is:
     //        M[replica2root] = M[surface2root] * Tr[replica->position()] * Tr[replica] * Tr[origin2anchor].inverse()
     //
 
     // If we early-exit anywhere in this function, the drawableContentRect of this subtree should be considered empty.
-    drawableContentRectOfSubtree = IntRect();
+    drawableContentRectOfSubtree = gfx::Rect();
 
     // The root layer cannot skip calcDrawTransforms.
     if (!isRootLayer(layer) && subtreeShouldBeSkipped(layer))
         return;
 
-    IntRect clipRectForSubtree;
+    gfx::Rect clipRectForSubtree;
     bool subtreeShouldBeClipped = false;
     
     float drawOpacity = layer->opacity();
     bool drawOpacityIsAnimating = layer->opacityIsAnimating();
     if (layer->parent() && layer->parent()->preserves3D()) {
         drawOpacity *= layer->parent()->drawOpacity();
         drawOpacityIsAnimating |= layer->parent()->drawOpacityIsAnimating();
     }
 
-    IntSize bounds = layer->bounds();
-    FloatPoint anchorPoint = layer->anchorPoint();
-    FloatPoint position = layer->position() - layer->scrollDelta();
+    gfx::Size bounds = layer->bounds();
+    gfx::PointF anchorPoint = layer->anchorPoint();
+    gfx::PointF position = layer->position() - gfx::Vector2d(layer->scrollDelta().width(), layer->scrollDelta().height());
 
     WebTransformationMatrix layerLocalTransform;
     // LT = Tr[origin] * Tr[origin2anchor]
     layerLocalTransform.translate3d(position.x() + anchorPoint.x() * bounds.width(), position.y() + anchorPoint.y() * bounds.height(), layer->anchorPointZ());
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer]
     layerLocalTransform.multiply(layer->transform());
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2origin]
     layerLocalTransform.translate3d(-anchorPoint.x() * bounds.width(), -anchorPoint.y() * bounds.height(), -layer->anchorPointZ());
 
     WebTransformationMatrix combinedTransform = parentMatrix;
@@ skipping 10 matching lines @@
     if (layer->fixedToContainerLayer()) {
         // Special case: this layer is a composited fixed-position layer; we need to
         // explicitly compensate for all ancestors' nonzero scrollDeltas to keep this layer
         // fixed correctly.
         combinedTransform = currentScrollCompensationMatrix * combinedTransform;
     }
 
     // The drawTransform that gets computed below is effectively the layer's drawTransform, unless
     // the layer itself creates a renderSurface. In that case, the renderSurface re-parents the transforms.
     WebTransformationMatrix drawTransform = combinedTransform;
-    if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
+    if (!layer->contentBounds().IsEmpty() && !layer->bounds().IsEmpty()) {
         // M[draw] = M[parent] * LT * S[layer2content]
         drawTransform.scaleNonUniform(1.0 / layer->contentsScaleX(),
                                       1.0 / layer->contentsScaleY());
     }
 
     // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local content space.
     WebTransformationMatrix layerScreenSpaceTransform = fullHierarchyMatrix;
     if (!layer->preserves3D())
         MathUtil::flattenTransformTo2d(layerScreenSpaceTransform);
     layerScreenSpaceTransform.multiply(drawTransform);
     layer->setScreenSpaceTransform(layerScreenSpaceTransform);
 
     bool animatingTransformToTarget = layer->transformIsAnimating();
     bool animatingTransformToScreen = animatingTransformToTarget;
     if (layer->parent()) {
         animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
         animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
     }
 
-    FloatRect contentRect(FloatPoint(), layer->contentBounds());
+    gfx::RectF contentRect(gfx::PointF(), layer->contentBounds());
 
     // fullHierarchyMatrix is the matrix that transforms objects between screen space (except projection matrix) and the most recent RenderSurfaceImpl's space.
     // nextHierarchyMatrix will only change if this layer uses a new RenderSurfaceImpl, otherwise remains the same.
     WebTransformationMatrix nextHierarchyMatrix = fullHierarchyMatrix;
     WebTransformationMatrix sublayerMatrix;
 
-    FloatPoint renderSurfaceSublayerScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
+    gfx::Vector2dF renderSurfaceSublayerScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
 
     if (subtreeShouldRenderToSeparateSurface(layer, isScaleOrTranslation(combinedTransform))) {
         // Check back-face visibility before continuing with this surface and its subtree
         if (!layer->doubleSided() && transformToParentIsKnown(layer) && isSurfaceBackFaceVisible(layer, combinedTransform))
             return;
 
         if (!layer->renderSurface())
             layer->createRenderSurface();
 
         RenderSurfaceType* renderSurface = layer->renderSurface();
         renderSurface->clearLayerLists();
 
         // The owning layer's draw transform has a scale from content to layer space which we need to undo and
         // replace with a scale from the surface's subtree into layer space.
-        if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
-            drawTransform.scaleNonUniform(layer->contentsScaleX(),
-                                          layer->contentsScaleY());
-        }
+        if (!layer->contentBounds().IsEmpty() && !layer->bounds().IsEmpty())
+            drawTransform.scaleNonUniform(layer->contentsScaleX(), layer->contentsScaleY());
         drawTransform.scaleNonUniform(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y());
         renderSurface->setDrawTransform(drawTransform);
 
         // The origin of the new surface is the upper left corner of the layer.
         WebTransformationMatrix layerDrawTransform;
         layerDrawTransform.scaleNonUniform(renderSurfaceSublayerScale.x(), renderSurfaceSublayerScale.y());
-        if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
-            layerDrawTransform.scaleNonUniform(1.0 / layer->contentsScaleX(),
-                                               1.0 / layer->contentsScaleY());
-        }
+        if (!layer->contentBounds().IsEmpty() && !layer->bounds().IsEmpty())
+            layerDrawTransform.scaleNonUniform(1.0 / layer->contentsScaleX(), 1.0 / layer->contentsScaleY());
         layer->setDrawTransform(layerDrawTransform);
 
         // Inside the surface's subtree, we scale everything to the owning layer's scale.
         // The sublayer matrix transforms centered layer rects into target
         // surface content space.
         sublayerMatrix.makeIdentity();
         sublayerMatrix.scaleNonUniform(renderSurfaceSublayerScale.x(), renderSurfaceSublayerScale.y());
 
         // The opacity value is moved from the layer to its surface, so that the entire subtree properly inherits opacity.
         renderSurface->setDrawOpacity(drawOpacity);
@@ skipping 12 matching lines @@
         nextHierarchyMatrix.multiply(renderSurface->drawTransform());
 
         // The new renderSurface here will correctly clip the entire subtree. So, we do
         // not need to continue propagating the clipping state further down the tree. This
         // way, we can avoid transforming clipRects from ancestor target surface space to
         // current target surface space that could cause more w < 0 headaches.
         subtreeShouldBeClipped = false;
 
         if (layer->maskLayer()) {
             layer->maskLayer()->setRenderTarget(layer);
-            layer->maskLayer()->setVisibleContentRect(IntRect(IntPoint(), layer->contentBounds()));
+            layer->maskLayer()->setVisibleContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
         }
 
         if (layer->replicaLayer() && layer->replicaLayer()->maskLayer()) {
             layer->replicaLayer()->maskLayer()->setRenderTarget(layer);
-            layer->replicaLayer()->maskLayer()->setVisibleContentRect(IntRect(IntPoint(), layer->contentBounds()));
+            layer->replicaLayer()->maskLayer()->setVisibleContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
         }
 
         // FIXME:  make this smarter for the SkImageFilter case (check for
         //         pixel-moving filters)
         if (layer->filters().hasFilterThatMovesPixels() || layer->filter())
             nearestAncestorThatMovesPixels = renderSurface;
 
         // The render surface clipRect is expressed in the space where this surface draws, i.e. the same space as clipRectFromAncestor.
         if (ancestorClipsSubtree)
             renderSurface->setClipRect(clipRectFromAncestor);
         else
-            renderSurface->setClipRect(IntRect());
+            renderSurface->setClipRect(gfx::Rect());
 
         renderSurface->setNearestAncestorThatMovesPixels(nearestAncestorThatMovesPixels);
 
         renderSurfaceLayerList.push_back(layer);
     } else {
         DCHECK(layer->parent());
 
         layer->setDrawTransform(drawTransform);
         layer->setDrawTransformIsAnimating(animatingTransformToTarget);
         layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
         sublayerMatrix = combinedTransform;
 
         layer->setDrawOpacity(drawOpacity);
         layer->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
 
         layer->clearRenderSurface();
 
         // Layers without renderSurfaces directly inherit the ancestor's clip status.
         subtreeShouldBeClipped = ancestorClipsSubtree;
         if (ancestorClipsSubtree)
             clipRectForSubtree = clipRectFromAncestor;
 
         // Layers that are not their own renderTarget will render into the target of their nearest ancestor.
         layer->setRenderTarget(layer->parent()->renderTarget());
     }
 
-    IntRect rectInTargetSpace = enclosingIntRect(MathUtil::mapClippedRect(layer->drawTransform(), contentRect));
+    gfx::Rect rectInTargetSpace = ToEnclosingRect(MathUtil::mapClippedRect(layer->drawTransform(), contentRect));
 
     if (layerClipsSubtree(layer)) {
         subtreeShouldBeClipped = true;
         if (ancestorClipsSubtree && !layer->renderSurface()) {
             clipRectForSubtree = clipRectFromAncestor;
-            clipRectForSubtree.intersect(rectInTargetSpace);
+            clipRectForSubtree.Intersect(rectInTargetSpace);
         } else
             clipRectForSubtree = rectInTargetSpace;
     }
 
     // Flatten to 2D if the layer doesn't preserve 3D.
     if (!layer->preserves3D())
         MathUtil::flattenTransformTo2d(sublayerMatrix);
 
     // Apply the sublayer transform at the center of the layer.
     sublayerMatrix.translate(0.5 * bounds.width(), 0.5 * bounds.height());
     sublayerMatrix.multiply(layer->sublayerTransform());
     sublayerMatrix.translate(-0.5 * bounds.width(), -0.5 * bounds.height());
 
     LayerList& descendants = (layer->renderSurface() ? layer->renderSurface()->layerList() : layerList);
 
     // Any layers that are appended after this point are in the layer's subtree and should be included in the sorting process.
     unsigned sortingStartIndex = descendants.size();
 
     if (!layerShouldBeSkipped(layer))
         descendants.push_back(layer);
 
     WebTransformationMatrix nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);;
 
-    IntRect accumulatedDrawableContentRectOfChildren;
+    gfx::Rect accumulatedDrawableContentRectOfChildren;
     for (size_t i = 0; i < layer->children().size(); ++i) {
         LayerType* child = LayerTreeHostCommon::getChildAsRawPtr(layer->children(), i);
-        IntRect drawableContentRectOfChildSubtree;
+        gfx::Rect drawableContentRectOfChildSubtree;
         calculateDrawTransformsInternal<LayerType, LayerList, RenderSurfaceType, LayerSorter>(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
                                                                                               clipRectForSubtree, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
                                                                                               renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, drawableContentRectOfChildSubtree);
-        if (!drawableContentRectOfChildSubtree.isEmpty()) {
-            accumulatedDrawableContentRectOfChildren.unite(drawableContentRectOfChildSubtree);
+        if (!drawableContentRectOfChildSubtree.IsEmpty()) {
+            accumulatedDrawableContentRectOfChildren.Union(drawableContentRectOfChildSubtree);
             if (child->renderSurface())
                 descendants.push_back(child);
         }
     }
 
     // Compute the total drawableContentRect for this subtree (the rect is in targetSurface space)
-    IntRect localDrawableContentRectOfSubtree = accumulatedDrawableContentRectOfChildren;
+    gfx::Rect localDrawableContentRectOfSubtree = accumulatedDrawableContentRectOfChildren;
     if (layer->drawsContent())
-        localDrawableContentRectOfSubtree.unite(rectInTargetSpace);
+        localDrawableContentRectOfSubtree.Union(rectInTargetSpace);
     if (subtreeShouldBeClipped)
-        localDrawableContentRectOfSubtree.intersect(clipRectForSubtree);
+        localDrawableContentRectOfSubtree.Intersect(clipRectForSubtree);
 
     // Compute the layer's drawable content rect (the rect is in targetSurface space)
-    IntRect drawableContentRectOfLayer = rectInTargetSpace;
+    gfx::Rect drawableContentRectOfLayer = rectInTargetSpace;
     if (subtreeShouldBeClipped)
-        drawableContentRectOfLayer.intersect(clipRectForSubtree);
+        drawableContentRectOfLayer.Intersect(clipRectForSubtree);
     layer->setDrawableContentRect(drawableContentRectOfLayer);
 
     // Compute the layer's visible content rect (the rect is in content space)
-    IntRect visibleContentRectOfLayer = calculateVisibleContentRect(layer);
+    gfx::Rect visibleContentRectOfLayer = calculateVisibleContentRect(layer);
     layer->setVisibleContentRect(visibleContentRectOfLayer);
 
     // Compute the remaining properties for the render surface, if the layer has one.
     if (isRootLayer(layer)) {
         // The root layer's surface's contentRect is always the entire viewport.
         DCHECK(layer->renderSurface());
         layer->renderSurface()->setContentRect(clipRectFromAncestor);
     } else if (layer->renderSurface() && !isRootLayer(layer)) {
         RenderSurfaceType* renderSurface = layer->renderSurface();
-        IntRect clippedContentRect = localDrawableContentRectOfSubtree;
+        gfx::Rect clippedContentRect = localDrawableContentRectOfSubtree;
 
         // Don't clip if the layer is reflected as the reflection shouldn't be
         // clipped. If the layer is animating, then the surface's transform to
         // its target is not known on the main thread, and we should not use it
         // to clip.
         if (!layer->replicaLayer() && transformToParentIsKnown(layer)) {
             // Note, it is correct to use ancestorClipsSubtree here, because we are looking at this layer's renderSurface, not the layer itself.
-            if (ancestorClipsSubtree && !clippedContentRect.isEmpty()) {
-                IntRect surfaceClipRect = LayerTreeHostCommon::calculateVisibleRect(renderSurface->clipRect(), clippedContentRect, renderSurface->drawTransform());
-                clippedContentRect.intersect(surfaceClipRect);
+            if (ancestorClipsSubtree && !clippedContentRect.IsEmpty()) {
+                gfx::Rect surfaceClipRect = LayerTreeHostCommon::calculateVisibleRect(renderSurface->clipRect(), clippedContentRect, renderSurface->drawTransform());
+                clippedContentRect.Intersect(surfaceClipRect);
             }
         }
 
         // The RenderSurfaceImpl backing texture cannot exceed the maximum supported
         // texture size.
-        clippedContentRect.setWidth(std::min(clippedContentRect.width(), maxTextureSize));
-        clippedContentRect.setHeight(std::min(clippedContentRect.height(), maxTextureSize));
+        clippedContentRect.set_width(std::min(clippedContentRect.width(), maxTextureSize));
+        clippedContentRect.set_height(std::min(clippedContentRect.height(), maxTextureSize));
 
-        if (clippedContentRect.isEmpty())
+        if (clippedContentRect.IsEmpty())
             renderSurface->clearLayerLists();
 
         renderSurface->setContentRect(clippedContentRect);
 
         // The owning layer's screenSpaceTransform has a scale from content to layer space which we need to undo and
         // replace with a scale from the surface's subtree into layer space.
         WebTransformationMatrix screenSpaceTransform = layer->screenSpaceTransform();
-        if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
-            screenSpaceTransform.scaleNonUniform(layer->contentsScaleX(),
-                                                 layer->contentsScaleY());
-        }
+        if (!layer->contentBounds().IsEmpty() && !layer->bounds().IsEmpty())
+            screenSpaceTransform.scaleNonUniform(layer->contentsScaleX(), layer->contentsScaleY());
         screenSpaceTransform.scaleNonUniform(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y());
         renderSurface->setScreenSpaceTransform(screenSpaceTransform);
 
         if (layer->replicaLayer()) {
             WebTransformationMatrix surfaceOriginToReplicaOriginTransform;
             surfaceOriginToReplicaOriginTransform.scaleNonUniform(renderSurfaceSublayerScale.x(), renderSurfaceSublayerScale.y());
             surfaceOriginToReplicaOriginTransform.translate(layer->replicaLayer()->position().x() + layer->replicaLayer()->anchorPoint().x() * bounds.width(),
                                                             layer->replicaLayer()->position().y() + layer->replicaLayer()->anchorPoint().y() * bounds.height());
             surfaceOriginToReplicaOriginTransform.multiply(layer->replicaLayer()->transform());
             surfaceOriginToReplicaOriginTransform.translate(-layer->replicaLayer()->anchorPoint().x() * bounds.width(), -layer->replicaLayer()->anchorPoint().y() * bounds.height());
@@ skipping 30 matching lines @@
     if (sortingStartIndex == descendants.size())
         return;
 
     // If preserves-3d then sort all the descendants in 3D so that they can be
     // drawn from back to front. If the preserves-3d property is also set on the parent then
     // skip the sorting as the parent will sort all the descendants anyway.
     if (descendants.size() && layer->preserves3D() && (!layer->parent() || !layer->parent()->preserves3D()))
         sortLayers(descendants.begin() + sortingStartIndex, descendants.end(), layerSorter);
 
     if (layer->renderSurface())
-        drawableContentRectOfSubtree = enclosingIntRect(layer->renderSurface()->drawableContentRect());
+        drawableContentRectOfSubtree = gfx::ToEnclosingRect(layer->renderSurface()->drawableContentRect());
     else
         drawableContentRectOfSubtree = localDrawableContentRectOfSubtree;
 
     if (layer->hasContributingDelegatedRenderPasses())
         layer->renderTarget()->renderSurface()->addContributingDelegatedRenderPassLayer(layer);
 }
 
-void LayerTreeHostCommon::calculateDrawTransforms(Layer* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, std::vector<scoped_refptr<Layer> >& renderSurfaceLayerList)
+void LayerTreeHostCommon::calculateDrawTransforms(Layer* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, std::vector<scoped_refptr<Layer> >& renderSurfaceLayerList)
 {
-    IntRect totalDrawableContentRect;
+    gfx::Rect totalDrawableContentRect;
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
     std::vector<scoped_refptr<Layer> > dummyLayerList;
 
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
-    IntRect deviceViewportRect(IntPoint::zero(), deviceViewportSize);
+    gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
     cc::calculateDrawTransformsInternal<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface, void>(
         rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
         deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
         dummyLayerList, 0, maxTextureSize,
         deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
 
     // The dummy layer list should not have been used.
     DCHECK(dummyLayerList.size() == 0);
     // A root layer renderSurface should always exist after calculateDrawTransforms.
     DCHECK(rootLayer->renderSurface());
 }
 
-void LayerTreeHostCommon::calculateDrawTransforms(LayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, LayerSorter* layerSorter, int maxTextureSize, std::vector<LayerImpl*>& renderSurfaceLayerList)
+void LayerTreeHostCommon::calculateDrawTransforms(LayerImpl* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, LayerSorter* layerSorter, int maxTextureSize, std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
-    IntRect totalDrawableContentRect;
+    gfx::Rect totalDrawableContentRect;
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
     std::vector<LayerImpl*> dummyLayerList;
 
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
-    IntRect deviceViewportRect(IntPoint::zero(), deviceViewportSize);
+    gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
     cc::calculateDrawTransformsInternal<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerSorter>(
         rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
         deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
         dummyLayerList, layerSorter, maxTextureSize,
         deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
 
     // The dummy layer list should not have been used.
     DCHECK(dummyLayerList.size() == 0);
     // A root layer renderSurface should always exist after calculateDrawTransforms.
     DCHECK(rootLayer->renderSurface());
 }
 
-static bool pointHitsRect(const IntPoint& screenSpacePoint, const WebTransformationMatrix& localSpaceToScreenSpaceTransform, FloatRect localSpaceRect)
+static bool pointHitsRect(const gfx::Point& screenSpacePoint, const WebTransformationMatrix& localSpaceToScreenSpaceTransform, gfx::RectF localSpaceRect)
 {
     // If the transform is not invertible, then assume that this point doesn't hit this rect.
     if (!localSpaceToScreenSpaceTransform.isInvertible())
         return false;
 
     // Transform the hit test point from screen space to the local space of the given rect.
     bool clipped = false;
-    FloatPoint hitTestPointInLocalSpace = MathUtil::projectPoint(localSpaceToScreenSpaceTransform.inverse(), FloatPoint(screenSpacePoint), clipped);
+    gfx::PointF hitTestPointInLocalSpace = MathUtil::projectPoint(localSpaceToScreenSpaceTransform.inverse(), gfx::PointF(screenSpacePoint), clipped);
 
     // If projectPoint could not project to a valid value, then we assume that this point doesn't hit this rect.
     if (clipped)
         return false;
 
-    return localSpaceRect.contains(hitTestPointInLocalSpace);
+    return localSpaceRect.Contains(hitTestPointInLocalSpace);
 }
 
-static bool pointIsClippedBySurfaceOrClipRect(const IntPoint& screenSpacePoint, LayerImpl* layer)
+static bool pointIsClippedBySurfaceOrClipRect(const gfx::Point& screenSpacePoint, LayerImpl* layer)
 {
     LayerImpl* currentLayer = layer;
 
     // Walk up the layer tree and hit-test any renderSurfaces and any layer clipRects that are active.
     while (currentLayer) {
         if (currentLayer->renderSurface() && !pointHitsRect(screenSpacePoint, currentLayer->renderSurface()->screenSpaceTransform(), currentLayer->renderSurface()->contentRect()))
             return true;
 
         // Note that drawableContentRects are actually in targetSurface space, so the transform we
         // have to provide is the target surface's screenSpaceTransform.
         LayerImpl* renderTarget = currentLayer->renderTarget();
         if (layerClipsSubtree(currentLayer) && !pointHitsRect(screenSpacePoint, renderTarget->renderSurface()->screenSpaceTransform(), currentLayer->drawableContentRect()))
             return true;
 
         currentLayer = currentLayer->parent();
     }
 
     // If we have finished walking all ancestors without having already exited, then the point is not clipped by any ancestors.
     return false;
 }
 
-LayerImpl* LayerTreeHostCommon::findLayerThatIsHitByPoint(const IntPoint& screenSpacePoint, std::vector<LayerImpl*>& renderSurfaceLayerList)
+LayerImpl* LayerTreeHostCommon::findLayerThatIsHitByPoint(const gfx::Point& screenSpacePoint, std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
     LayerImpl* foundLayer = 0;
 
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
     LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
 
     for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
         // We don't want to consider renderSurfaces for hit testing.
         if (!it.representsItself())
             continue;
 
         LayerImpl* currentLayer = (*it);
 
-        FloatRect contentRect(FloatPoint::zero(), currentLayer->contentBounds());
+        gfx::RectF contentRect(gfx::PointF(), currentLayer->contentBounds());
         if (!pointHitsRect(screenSpacePoint, currentLayer->screenSpaceTransform(), contentRect))
             continue;
 
         // At this point, we think the point does hit the layer, but we need to walk up
         // the parents to ensure that the layer was not clipped in such a way that the
         // hit point actually should not hit the layer.
         if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, currentLayer))
             continue;
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the screenSpacePoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 } // namespace cc