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

cc/video_layer_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/video_layer_impl.h"
 
 #include "base/logging.h"
 #include "cc/io_surface_draw_quad.h"
 #include "cc/layer_tree_host_impl.h"
+#include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/resource_provider.h"
 #include "cc/stream_video_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/yuv_video_draw_quad.h"
 #include "media/filters/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 namespace cc {
 
 VideoLayerImpl::VideoLayerImpl(int id, WebKit::WebVideoFrameProvider* provider,
                                const FrameUnwrapper& unwrapper)
     : LayerImpl(id)
     , m_provider(provider)
     , m_unwrapper(unwrapper)
     , m_webFrame(0)
     , m_frame(0)
     , m_format(GL_INVALID_VALUE)
     , m_convertYUV(false)
     , m_externalTextureResource(0)
 {
     // This matrix is the default transformation for stream textures, and flips on the Y axis.
-    m_streamTextureMatrix = WebKit::WebTransformationMatrix(
+    m_streamTextureMatrix = MathUtil::createGfxTransform(
         1, 0, 0, 0,
         0, -1, 0, 0,
         0, 0, 1, 0,
         0, 1, 0, 1);
 
     // This only happens during a commit on the compositor thread while the main
     // thread is blocked. That makes this a thread-safe call to set the video
     // frame provider client that does not require a lock. The same is true of
     // the call in the destructor.
     m_provider->setVideoFrameProviderClient(this);
@@ skipping 201 matching lines @@
     }
     case GL_TEXTURE_RECTANGLE_ARB: {
         gfx::Size visibleSize(visibleRect.width(), visibleRect.height());
         scoped_ptr<IOSurfaceDrawQuad> ioSurfaceQuad = IOSurfaceDrawQuad::Create();
         ioSurfaceQuad->SetNew(sharedQuadState, quadRect, opaqueRect, visibleSize, m_frame->texture_id(), IOSurfaceDrawQuad::UNFLIPPED);
         quadSink.append(ioSurfaceQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
     case GL_TEXTURE_EXTERNAL_OES: {
         // StreamTexture hardware decoder.
-        WebKit::WebTransformationMatrix transform(m_streamTextureMatrix);
-        transform.scaleNonUniform(texWidthScale, texHeightScale);
+        gfx::Transform transform(m_streamTextureMatrix);
+        transform.PreconcatScale(texWidthScale, texHeightScale);
         scoped_ptr<StreamVideoDrawQuad> streamVideoQuad = StreamVideoDrawQuad::Create();
         streamVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, m_frame->texture_id(), transform);
         quadSink.append(streamVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
     default:
         NOTREACHED();  // Someone updated convertVFCFormatToGLenum above but update this!
         break;
     }
 }
@@ skipping 127 matching lines @@
         m_framePlanes[i].freeData(resourceProvider);
 }
 
 void VideoLayerImpl::didReceiveFrame()
 {
     setNeedsRedraw();
 }
 
 void VideoLayerImpl::didUpdateMatrix(const float matrix[16])
 {
-    m_streamTextureMatrix = WebKit::WebTransformationMatrix(
+    m_streamTextureMatrix = MathUtil::createGfxTransform(
         matrix[0], matrix[1], matrix[2], matrix[3],
         matrix[4], matrix[5], matrix[6], matrix[7],
         matrix[8], matrix[9], matrix[10], matrix[11],
         matrix[12], matrix[13], matrix[14], matrix[15]);
     setNeedsRedraw();
 }
 
 void VideoLayerImpl::didLoseContext()
 {
     freePlaneData(layerTreeHostImpl()->resourceProvider());
 }
 
 void VideoLayerImpl::setNeedsRedraw()
 {
     layerTreeHostImpl()->setNeedsRedraw();
 }
 
 const char* VideoLayerImpl::layerTypeAsString() const
 {
     return "VideoLayer";
 }
 
 }  // namespace cc