Migrate most of cc/ from WebKit::WebTransformationMatrix to gfx::Transform

cc/layer_tree_host_impl.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 "cc/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 18 matching lines @@
 #include "cc/scrollbar_animation_controller.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/shared_quad_state.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/software_renderer.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/texture_uploader.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
-using WebKit::WebTransformationMatrix;
+using gfx::Transform;
 
 namespace {
 
 void didVisibilityChange(cc::LayerTreeHostImpl* id, bool visible)
 {
     if (visible) {
         TRACE_EVENT_ASYNC_BEGIN1("webkit", "LayerTreeHostImpl::setVisible", id, "LayerTreeHostImpl", id);
         return;
     }
 
@@ skipping 78 matching lines @@
 
     if (pinchedBounds.bottom() > m_layoutViewportSize.height()) {
         overflow.set_y(pinchedBounds.bottom() - m_layoutViewportSize.height());
         pinchedBounds += gfx::Vector2dF(0, m_layoutViewportSize.height() - pinchedBounds.bottom());
     }
     m_zoomedViewportOffset = pinchedBounds.OffsetFromOrigin();
 
     return overflow;
 }
 
-WebTransformationMatrix PinchZoomViewport::implTransform(bool pageScalePinchZoomEnabled) const
+Transform PinchZoomViewport::implTransform(bool pageScalePinchZoomEnabled) const
 {
-    WebTransformationMatrix transform;
-    transform.scale(m_pageScaleDelta);
+    Transform transform;
+    transform.PreconcatScale(m_pageScaleDelta, m_pageScaleDelta);
 
     // If the pinch state is applied in the impl, then push it to the
     // impl transform, otherwise the scale is handled by WebCore.
     if (pageScalePinchZoomEnabled) {
-        transform.scale(m_pageScaleFactor);
+        transform.PreconcatScale(m_pageScaleFactor, m_pageScaleFactor);
         // The offset needs to be scaled by deviceScaleFactor as this transform
         // needs to work with physical pixels.
         gfx::Vector2dF zoomedDeviceViewportOffset = gfx::ScaleVector2d(m_zoomedViewportOffset, m_deviceScaleFactor);
-        transform.translate(-zoomedDeviceViewportOffset.x(), -zoomedDeviceViewportOffset.y());
+        transform.PreconcatTranslate(-zoomedDeviceViewportOffset.x(), -zoomedDeviceViewportOffset.y());
     }
 
     return transform;
 }
 
 class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
 public:
     static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> create(LayerTreeHostImpl* layerTreeHostImpl, scoped_refptr<DelayBasedTimeSource> timeSource)
     {
         return make_scoped_ptr(new LayerTreeHostImplTimeSourceAdapter(layerTreeHostImpl, timeSource));
@@ skipping 280 matching lines @@
                           targetRenderPass->shared_quad_state_list,
                           rootLayer,
                           occlusionTracker,
                           rootLayer->showDebugBorders(),
                           forSurface);
 
     // Manually create the quad state for the gutter quads, as the root layer
     // doesn't have any bounds and so can't generate this itself.
     // FIXME: Make the gutter quads generated by the solid color layer (make it smarter about generating quads to fill unoccluded areas).
 
-    DCHECK(rootLayer->screenSpaceTransform().isInvertible());
+    DCHECK(rootLayer->screenSpaceTransform().IsInvertible());
 
     gfx::Rect rootTargetRect = rootLayer->renderSurface()->contentRect();
     float opacity = 1;
     SharedQuadState* sharedQuadState = quadCuller.useSharedQuadState(SharedQuadState::Create());
     sharedQuadState->SetAll(rootLayer->drawTransform(),
                             rootTargetRect,
                             rootTargetRect,
                             rootTargetRect,
                             false,
                             opacity);
 
     AppendQuadsData appendQuadsData;
-    WebTransformationMatrix transformToLayerSpace = rootLayer->screenSpaceTransform().inverse();
+    Transform transformToLayerSpace = MathUtil::inverse(rootLayer->screenSpaceTransform());
     for (Region::Iterator fillRects(fillRegion); fillRects.has_rect(); fillRects.next()) {
         // The root layer transform is composed of translations and scales only,
         // no perspective, so mapping is sufficient.
         gfx::Rect layerRect = MathUtil::mapClippedRect(transformToLayerSpace, fillRects.rect());
         // Skip the quad culler and just append the quads directly to avoid
         // occlusion checks.
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(sharedQuadState, layerRect, screenBackgroundColor);
         quadCuller.append(quad.PassAs<DrawQuad>(), appendQuadsData);
     }
@@ skipping 716 matching lines @@
         m_numImplThreadScrolls++;
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
 static gfx::Vector2dF scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport, LayerImpl& layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
-    DCHECK(layerImpl.screenSpaceTransform().isInvertible());
-    WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceTransform().inverse();
+    DCHECK(layerImpl.screenSpaceTransform().IsInvertible());
+    Transform inverseScreenSpaceTransform = MathUtil::inverse(layerImpl.screenSpaceTransform());
 
     gfx::PointF screenSpacePoint = gfx::ScalePoint(viewportPoint, scaleFromViewportToScreenSpace);
 
     gfx::Vector2dF screenSpaceDelta = viewportDelta;
     screenSpaceDelta.Scale(scaleFromViewportToScreenSpace);
 
     // First project the scroll start and end points to local layer space to find the scroll delta
     // in layer coordinates.
     bool startClipped, endClipped;
     gfx::PointF screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta;
@@ skipping 242 matching lines @@
         return scrollInfo.Pass();
     }
 
     collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get());
     scrollInfo->pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
     m_pinchZoomViewport.setSentPageScaleDelta(scrollInfo->pageScaleDelta);
 
     return scrollInfo.Pass();
 }
 
-WebTransformationMatrix LayerTreeHostImpl::implTransform() const
+Transform LayerTreeHostImpl::implTransform() const
 {
     return m_pinchZoomViewport.implTransform(m_settings.pageScalePinchZoomEnabled);
 }
 
 void LayerTreeHostImpl::setFullRootLayerDamage()
 {
     if (m_rootLayerImpl) {
         RenderSurfaceImpl* renderSurface = m_rootLayerImpl->renderSurface();
         if (renderSurface)
             renderSurface->damageTracker()->forceFullDamageNextUpdate();
@@ skipping 120 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc