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

cc/gl_renderer.cc

Index: cc/gl_renderer.cc
diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc
index 850b8c2931628acc80be4d2ef78700f2cd55e03b..2c066e413bd599f85dd77eef7f7baa75807c0457 100644
--- a/cc/gl_renderer.cc
+++ b/cc/gl_renderer.cc
@@ -43,7 +43,7 @@ using namespace std;
 using WebKit::WebGraphicsContext3D;
 using WebKit::WebGraphicsMemoryAllocation;
 using WebKit::WebSharedGraphicsContext3D;
-using WebKit::WebTransformationMatrix;
+using gfx::Transform;
 
 namespace cc {
 
@@ -325,9 +325,9 @@ void GLRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorde
 
     // Use the full quadRect for debug quads to not move the edges based on partial swaps.
     const gfx::Rect& layerRect = quad->rect;
-    WebTransformationMatrix renderMatrix = quad->quadTransform();
-    renderMatrix.translate(0.5 * layerRect.width() + layerRect.x(), 0.5 * layerRect.height() + layerRect.y());
-    renderMatrix.scaleNonUniform(layerRect.width(), layerRect.height());
+    Transform renderMatrix = quad->quadTransform();
+    renderMatrix.PreconcatTranslate(0.5 * layerRect.width() + layerRect.x(), 0.5 * layerRect.height() + layerRect.y());
+    renderMatrix.PreconcatScale(layerRect.width(), layerRect.height());
     GLRenderer::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix);
     GLC(context(), context()->uniformMatrix4fv(program->vertexShader().matrixLocation(), 1, false, &glMatrix[0]));
 
@@ -431,8 +431,8 @@ static SkBitmap applyImageFilter(GLRenderer* renderer, SkImageFilter* filter, Sc
 scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
     DrawingFrame& frame, const RenderPassDrawQuad* quad,
     const WebKit::WebFilterOperations& filters,
-    const WebTransformationMatrix& contentsDeviceTransform,
-    const WebTransformationMatrix& contentsDeviceTransformInverse)
+    const Transform& contentsDeviceTransform,
+    const Transform& contentsDeviceTransformInverse)
 {
     // This method draws a background filter, which applies a filter to any pixels behind the quad and seen through its background.
     // The algorithm works as follows:
@@ -488,10 +488,10 @@ scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
 
     if (usingBackgroundTexture) {
         // Copy the readback pixels from device to the background texture for the surface.
-        WebTransformationMatrix deviceToFramebufferTransform;
-        deviceToFramebufferTransform.translate(quad->rect.width() / 2.0, quad->rect.height() / 2.0);
-        deviceToFramebufferTransform.scale3d(quad->rect.width(), quad->rect.height(), 1);
-        deviceToFramebufferTransform.multiply(contentsDeviceTransformInverse);
+        Transform deviceToFramebufferTransform;
+        deviceToFramebufferTransform.PreconcatTranslate(quad->rect.width() / 2.0, quad->rect.height() / 2.0);
+        deviceToFramebufferTransform.PreconcatScale3d(quad->rect.width(), quad->rect.height(), 1);
+        deviceToFramebufferTransform.PreconcatTransform(contentsDeviceTransformInverse);
         copyTextureToFramebuffer(frame, filteredDeviceBackgroundTextureId, deviceRect, deviceToFramebufferTransform);
     }
 
@@ -513,15 +513,15 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua
     if (!renderPass)
         return;
 
-    WebTransformationMatrix quadRectMatrix;
+    Transform quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->rect);
-    WebTransformationMatrix contentsDeviceTransform = (frame.windowMatrix * frame.projectionMatrix * quadRectMatrix).to2dTransform();
+    Transform contentsDeviceTransform = MathUtil::to2dTransform(frame.windowMatrix * frame.projectionMatrix * quadRectMatrix);
 
     // Can only draw surface if device matrix is invertible.
-    if (!contentsDeviceTransform.isInvertible())
+    if (!contentsDeviceTransform.IsInvertible())
         return;
 
-    WebTransformationMatrix contentsDeviceTransformInverse = contentsDeviceTransform.inverse();
+    Transform contentsDeviceTransformInverse = MathUtil::inverse(contentsDeviceTransform);
     scoped_ptr<ScopedResource> backgroundTexture = drawBackgroundFilters(
         frame, quad, renderPass->background_filters,
         contentsDeviceTransform, contentsDeviceTransformInverse);
@@ -745,8 +745,8 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
 
 
     gfx::QuadF localQuad;
-    WebTransformationMatrix deviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * quad->quadTransform()).to2dTransform();
-    if (!deviceTransform.isInvertible())
+    Transform deviceTransform = MathUtil::to2dTransform(frame.windowMatrix * frame.projectionMatrix * quad->quadTransform());
+    if (!deviceTransform.IsInvertible())
         return;
 
     bool clipped = false;
@@ -836,7 +836,7 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
         LayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge);
 
         // Map device space quad to local space. deviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
-        WebTransformationMatrix deviceTransformInverse = deviceTransform.inverse();
+        Transform deviceTransformInverse = MathUtil::inverse(deviceTransform);
         localQuad = MathUtil::mapQuad(deviceTransformInverse, deviceQuad.ToQuadF(), clipped);
 
         // We should not DCHECK(!clipped) here, because anti-aliasing inflation may cause deviceQuad to become
@@ -1041,24 +1041,24 @@ bool GLRenderer::flippedFramebuffer() const
     return true;
 }
 
-void GLRenderer::toGLMatrix(float* flattened, const WebTransformationMatrix& m)
+void GLRenderer::toGLMatrix(float* flattened, const Transform& m)
 {

[Ian Vollick, 2012/11/21 22:07:09]

use SkMatrix44::asColMajorf

-    flattened[0] = m.m11();
-    flattened[1] = m.m12();
-    flattened[2] = m.m13();
-    flattened[3] = m.m14();
-    flattened[4] = m.m21();
-    flattened[5] = m.m22();
-    flattened[6] = m.m23();
-    flattened[7] = m.m24();
-    flattened[8] = m.m31();
-    flattened[9] = m.m32();
-    flattened[10] = m.m33();
-    flattened[11] = m.m34();
-    flattened[12] = m.m41();
-    flattened[13] = m.m42();
-    flattened[14] = m.m43();
-    flattened[15] = m.m44();
+    flattened[0] = m.matrix().getDouble(0, 0);
+    flattened[1] = m.matrix().getDouble(1, 0);
+    flattened[2] = m.matrix().getDouble(2, 0);
+    flattened[3] = m.matrix().getDouble(3, 0);
+    flattened[4] = m.matrix().getDouble(0, 1);
+    flattened[5] = m.matrix().getDouble(1, 1);
+    flattened[6] = m.matrix().getDouble(2, 1);
+    flattened[7] = m.matrix().getDouble(3, 1);
+    flattened[8] = m.matrix().getDouble(0, 2);
+    flattened[9] = m.matrix().getDouble(1, 2);
+    flattened[10] = m.matrix().getDouble(2, 2);
+    flattened[11] = m.matrix().getDouble(3, 2);
+    flattened[12] = m.matrix().getDouble(0, 3);
+    flattened[13] = m.matrix().getDouble(1, 3);
+    flattened[14] = m.matrix().getDouble(2, 3);
+    flattened[15] = m.matrix().getDouble(3, 3);
 }
 
 void GLRenderer::setShaderQuadF(const gfx::QuadF& quad, int quadLocation)
@@ -1084,9 +1084,9 @@ void GLRenderer::setShaderOpacity(float opacity, int alphaLocation)
         GLC(m_context, m_context->uniform1f(alphaLocation, opacity));
 }
 
-void GLRenderer::drawQuadGeometry(const DrawingFrame& frame, const WebKit::WebTransformationMatrix& drawTransform, const gfx::RectF& quadRect, int matrixLocation)
+void GLRenderer::drawQuadGeometry(const DrawingFrame& frame, const gfx::Transform& drawTransform, const gfx::RectF& quadRect, int matrixLocation)
 {
-    WebTransformationMatrix quadRectMatrix;
+    Transform quadRectMatrix;
     quadRectTransform(&quadRectMatrix, drawTransform, quadRect);
     static float glMatrix[16];
     toGLMatrix(&glMatrix[0], frame.projectionMatrix * quadRectMatrix);
@@ -1095,7 +1095,7 @@ void GLRenderer::drawQuadGeometry(const DrawingFrame& frame, const WebKit::WebTr
     GLC(m_context, m_context->drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0));
 }
 
-void GLRenderer::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const gfx::Rect& rect, const WebTransformationMatrix& drawMatrix)
+void GLRenderer::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const gfx::Rect& rect, const Transform& drawMatrix)
 {
     const RenderPassProgram* program = renderPassProgram();