cc: Remove all remaining use of WebCore Rect/Point/Size types from the compositor.

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 "cc/layer.h"
 #include "cc/layer_impl.h"
@@ skipping 271 matching lines @@
     //
     // These steps create a matrix that both start and end in targetSurfaceSpace. So this matrix can
     // pre-multiply any fixed-position layer's drawTransform to undo the scrollDeltas -- as long as
     // that fixed position layer is fixed onto the same renderTarget as this scrollingLayer.
     //
 
     WebTransformationMatrix partialLayerOriginTransform = parentMatrix;
     partialLayerOriginTransform.multiply(scrollingLayer->implTransform());
 
     WebTransformationMatrix scrollCompensationForThisLayer = partialLayerOriginTransform; // Step 3
-    scrollCompensationForThisLayer.translate(scrollingLayer->scrollDelta().width(), scrollingLayer->scrollDelta().height()); // Step 2
+    scrollCompensationForThisLayer.translate(scrollingLayer->scrollDelta().x(), scrollingLayer->scrollDelta().y()); // Step 2
     scrollCompensationForThisLayer.multiply(partialLayerOriginTransform.inverse()); // Step 1
     return scrollCompensationForThisLayer;
 }
 
 WebTransformationMatrix computeScrollCompensationMatrixForChildren(Layer* currentLayer, const WebTransformationMatrix& currentParentMatrix, const WebTransformationMatrix& currentScrollCompensation)
 {
     // The main thread (i.e. Layer) does not need to worry about scroll compensation.
     // So we can just return an identity matrix here.
     return WebTransformationMatrix();
 }
@@ skipping 10 matching lines @@
     //    without a renderSurface, the renderSurface is irrelevant in that case.
     //  - A layer that does not have an explicit container is simply fixed to the viewport.
     //    (i.e. the root renderSurface.)
     //  - If the fixed-position layer has its own renderSurface, then the renderSurface is
     //    the one who gets fixed.
     //
     // This function needs to be called AFTER layers create their own renderSurfaces.
     //
 
     // Avoid the overheads (including stack allocation and matrix initialization/copy) if we know that the scroll compensation doesn't need to be reset or adjusted.
-    if (!layer->isContainerForFixedPositionLayers() && layer->scrollDelta().isZero() && !layer->renderSurface())
+    if (!layer->isContainerForFixedPositionLayers() && layer->scrollDelta().IsZero() && !layer->renderSurface())
         return currentScrollCompensationMatrix;
 
     // Start as identity matrix.
     WebTransformationMatrix nextScrollCompensationMatrix;
 
     // If this layer is not a container, then it inherits the existing scroll compensations.
     if (!layer->isContainerForFixedPositionLayers())
         nextScrollCompensationMatrix = currentScrollCompensationMatrix;
 
     // If the current layer has a non-zero scrollDelta, then we should compute its local scrollCompensation
     // and accumulate it to the nextScrollCompensationMatrix.
-    if (!layer->scrollDelta().isZero()) {
+    if (!layer->scrollDelta().IsZero()) {
         WebTransformationMatrix scrollCompensationForThisLayer = computeScrollCompensationForThisLayer(layer, parentMatrix);
         nextScrollCompensationMatrix.multiply(scrollCompensationForThisLayer);
     }
 
     // If the layer created its own renderSurface, we have to adjust nextScrollCompensationMatrix.
     // The adjustment allows us to continue using the scrollCompensation on the next surface.
     //  Step 1 (right-most in the math): transform from the new surface to the original ancestor surface
     //  Step 2: apply the scroll compensation
     //  Step 3: transform back to the new surface.
     if (layer->renderSurface() && !nextScrollCompensationMatrix.isIdentity())
@@ skipping 138 matching lines @@
     
     float drawOpacity = layer->opacity();
     bool drawOpacityIsAnimating = layer->opacityIsAnimating();
     if (layer->parent() && layer->parent()->preserves3D()) {
         drawOpacity *= layer->parent()->drawOpacity();
         drawOpacityIsAnimating |= layer->parent()->drawOpacityIsAnimating();
     }
 
     gfx::Size bounds = layer->bounds();
     gfx::PointF anchorPoint = layer->anchorPoint();
-    gfx::PointF position = layer->position() - gfx::Vector2d(layer->scrollDelta().width(), layer->scrollDelta().height());
+    gfx::PointF position = layer->position() - layer->scrollDelta();
 
     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 419 matching lines @@
 
         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