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

cc/direct_renderer.cc

 // Copyright 2012 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/direct_renderer.h"
 
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "cc/math_util.h"
 #include "ui/gfx/rect_conversions.h"
-#include <public/WebTransformationMatrix.h>
+#include "ui/gfx/transform.h"
 
-using WebKit::WebTransformationMatrix;
+using gfx::Transform;
 
-static WebTransformationMatrix orthoProjectionMatrix(float left, float right, float bottom, float top)
+static Transform orthoProjectionMatrix(float left, float right, float bottom, float top)
 {
     // Use the standard formula to map the clipping frustum to the cube from
     // [-1, -1, -1] to [1, 1, 1].
     float deltaX = right - left;
     float deltaY = top - bottom;
-    WebTransformationMatrix proj;
+    Transform proj;
     if (!deltaX || !deltaY)
         return proj;
-    proj.setM11(2.0f / deltaX);
-    proj.setM41(-(right + left) / deltaX);
-    proj.setM22(2.0f / deltaY);
-    proj.setM42(-(top + bottom) / deltaY);
+    proj.matrix().setDouble(0, 0, 2.0f / deltaX);
+    proj.matrix().setDouble(0, 3, -(right + left) / deltaX);
+    proj.matrix().setDouble(1, 1, 2.0f / deltaY);
+    proj.matrix().setDouble(1, 3, -(top + bottom) / deltaY);
 
     // Z component of vertices is always set to zero as we don't use the depth buffer
     // while drawing.
-    proj.setM33(0);
+    proj.matrix().setDouble(2, 2, 0);
 
     return proj;
 }
 
-static WebTransformationMatrix windowMatrix(int x, int y, int width, int height)
+static Transform windowMatrix(int x, int y, int width, int height)
 {
-    WebTransformationMatrix canvas;
+    Transform canvas;
 
     // Map to window position and scale up to pixel coordinates.
-    canvas.translate3d(x, y, 0);
-    canvas.scale3d(width, height, 0);
+    canvas.PreconcatTranslate3d(x, y, 0);
+    canvas.PreconcatScale3d(width, height, 0);
 
     // Map from ([-1, -1] to [1, 1]) -> ([0, 0] to [1, 1])
-    canvas.translate3d(0.5, 0.5, 0.5);
-    canvas.scale3d(0.5, 0.5, 0.5);
+    canvas.PreconcatTranslate3d(0.5, 0.5, 0.5);
+    canvas.PreconcatScale3d(0.5, 0.5, 0.5);
 
     return canvas;
 }
 
 namespace cc {
 
 DirectRenderer::DrawingFrame::DrawingFrame()
     : rootRenderPass(0)
     , currentRenderPass(0)
     , currentTexture(0)
     , flippedY(false)
 {
 }
 
 DirectRenderer::DrawingFrame::~DrawingFrame()
 {
 }
 
 //
 // static
 gfx::RectF DirectRenderer::quadVertexRect()
 {
     return gfx::RectF(-0.5, -0.5, 1, 1);
 }
 
 // static
-void DirectRenderer::quadRectTransform(WebKit::WebTransformationMatrix* quadRectTransform, const WebKit::WebTransformationMatrix& quadTransform, const gfx::RectF& quadRect)
+void DirectRenderer::quadRectTransform(gfx::Transform* quadRectTransform, const gfx::Transform& quadTransform, const gfx::RectF& quadRect)
 {
     *quadRectTransform = quadTransform;
-    quadRectTransform->translate(0.5 * quadRect.width() + quadRect.x(), 0.5 * quadRect.height() + quadRect.y());
-    quadRectTransform->scaleNonUniform(quadRect.width(), quadRect.height());
+    quadRectTransform->PreconcatTranslate(0.5 * quadRect.width() + quadRect.x(), 0.5 * quadRect.height() + quadRect.y());
+    quadRectTransform->PreconcatScale(quadRect.width(), quadRect.height());
 }
 
 // static
 void DirectRenderer::initializeMatrices(DrawingFrame& frame, const gfx::Rect& drawRect, bool flipY)
 {
     if (flipY)
         frame.projectionMatrix = orthoProjectionMatrix(drawRect.x(), drawRect.right(), drawRect.bottom(), drawRect.y());
     else
         frame.projectionMatrix = orthoProjectionMatrix(drawRect.x(), drawRect.right(), drawRect.y(), drawRect.bottom());
     frame.windowMatrix = windowMatrix(0, 0, drawRect.width(), drawRect.height());
@@ skipping 80 matching lines @@
     finishDrawingFrame(frame);
 }
 
 gfx::RectF DirectRenderer::computeScissorRectForRenderPass(const DrawingFrame& frame)
 {
     gfx::RectF renderPassScissor = frame.currentRenderPass->output_rect;
 
     if (frame.rootDamageRect == frame.rootRenderPass->output_rect)
         return renderPassScissor;
 
-    WebTransformationMatrix inverseTransform = frame.currentRenderPass->transform_to_root_target.inverse();
+    Transform inverseTransform = MathUtil::inverse(frame.currentRenderPass->transform_to_root_target);
     gfx::RectF damageRectInRenderPassSpace = MathUtil::projectClippedRect(inverseTransform, frame.rootDamageRect);
     renderPassScissor.Intersect(damageRectInRenderPassSpace);
 
     return renderPassScissor;
 }
 
 void DirectRenderer::setScissorStateForQuad(const DrawingFrame& frame, const DrawQuad& quad)
 {
     if (quad.isClipped()) {
         gfx::RectF quadScissorRect = quad.clipRect();
@@ skipping 86 matching lines @@
     return pass->output_rect.size();
 }
 
 // static
 GLenum DirectRenderer::renderPassTextureFormat(const RenderPass*)
 {
     return GL_RGBA;
 }
 
 }  // namespace cc