cc: Use ui/gfx geometry types for the CCRenderPass and CCDrawQuad classes.

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 "config.h"
 
 #include "CCDirectRenderer.h"
 
 #include "CCMathUtil.h"
+#include "ui/gfx/rect_conversions.h"
 #include <public/WebTransformationMatrix.h>
 #include <vector>
 
 using WebKit::WebTransformationMatrix;
 
 static WebTransformationMatrix 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;
@@ skipping 43 matching lines @@
 }
 
 //
 // static
 FloatRect CCDirectRenderer::quadVertexRect()
 {
     return FloatRect(-0.5, -0.5, 1, 1);
 }
 
 // static
-void CCDirectRenderer::quadRectTransform(WebKit::WebTransformationMatrix* quadRectTransform, const WebKit::WebTransformationMatrix& quadTransform, const FloatRect& quadRect)
+void CCDirectRenderer::quadRectTransform(WebKit::WebTransformationMatrix* quadRectTransform, const WebKit::WebTransformationMatrix& 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());
 }
 
 // static
-void CCDirectRenderer::initializeMatrices(DrawingFrame& frame, const IntRect& drawRect, bool flipY)
+void CCDirectRenderer::initializeMatrices(DrawingFrame& frame, const gfx::Rect& drawRect, bool flipY)
 {
     if (flipY)
-        frame.projectionMatrix = orthoProjectionMatrix(drawRect.x(), drawRect.maxX(), drawRect.maxY(), drawRect.y());
+        frame.projectionMatrix = orthoProjectionMatrix(drawRect.x(), drawRect.right(), drawRect.bottom(), drawRect.y());
     else
-        frame.projectionMatrix = orthoProjectionMatrix(drawRect.x(), drawRect.maxX(), drawRect.y(), drawRect.maxY());
+        frame.projectionMatrix = orthoProjectionMatrix(drawRect.x(), drawRect.right(), drawRect.y(), drawRect.bottom());
     frame.windowMatrix = windowMatrix(0, 0, drawRect.width(), drawRect.height());
     frame.flippedY = flipY;
 }
 
 // static
-IntRect CCDirectRenderer::moveScissorToWindowSpace(const DrawingFrame& frame, FloatRect scissorRect)
+gfx::Rect CCDirectRenderer::moveScissorToWindowSpace(const DrawingFrame& frame, gfx::RectF scissorRect)
 {
-    IntRect scissorRectInCanvasSpace = enclosingIntRect(scissorRect);
+    gfx::Rect scissorRectInCanvasSpace = gfx::ToEnclosingRect(scissorRect);
     // The scissor coordinates must be supplied in viewport space so we need to offset
     // by the relative position of the top left corner of the current render pass.
-    IntRect framebufferOutputRect = frame.currentRenderPass->outputRect();
-    scissorRectInCanvasSpace.setX(scissorRectInCanvasSpace.x() - framebufferOutputRect.x());
+    gfx::Rect framebufferOutputRect = frame.currentRenderPass->outputRect();
+    scissorRectInCanvasSpace.set_x(scissorRectInCanvasSpace.x() - framebufferOutputRect.x());
     if (frame.flippedY && !frame.currentTexture)
-        scissorRectInCanvasSpace.setY(framebufferOutputRect.height() - (scissorRectInCanvasSpace.maxY() - framebufferOutputRect.y()));
+        scissorRectInCanvasSpace.set_y(framebufferOutputRect.height() - (scissorRectInCanvasSpace.bottom() - framebufferOutputRect.y()));
     else
-        scissorRectInCanvasSpace.setY(scissorRectInCanvasSpace.y() - framebufferOutputRect.y());
+        scissorRectInCanvasSpace.set_y(scissorRectInCanvasSpace.y() - framebufferOutputRect.y());
     return scissorRectInCanvasSpace;
 }
 
 CCDirectRenderer::CCDirectRenderer(CCRendererClient* client, CCResourceProvider* resourceProvider)
     : CCRenderer(client)
     , m_resourceProvider(resourceProvider)
 {
 }
 
 CCDirectRenderer::~CCDirectRenderer()
@@ skipping 39 matching lines @@
 
 void CCDirectRenderer::drawFrame(const CCRenderPassList& renderPassesInDrawOrder, const CCRenderPassIdHashMap& renderPassesById)
 {
     const CCRenderPass* rootRenderPass = renderPassesInDrawOrder.back();
     DCHECK(rootRenderPass);
 
     DrawingFrame frame;
     frame.renderPassesById = &renderPassesById;
     frame.rootRenderPass = rootRenderPass;
     frame.rootDamageRect = capabilities().usingPartialSwap ? rootRenderPass->damageRect() : rootRenderPass->outputRect();
-    frame.rootDamageRect.intersect(IntRect(IntPoint::zero(), viewportSize()));
+    frame.rootDamageRect = frame.rootDamageRect.Intersect(gfx::Rect(gfx::Point(), viewportSize()));
 
     beginDrawingFrame(frame);
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i)
         drawRenderPass(frame, renderPassesInDrawOrder[i]);
     finishDrawingFrame(frame);
 }
 
 void CCDirectRenderer::drawRenderPass(DrawingFrame& frame, const CCRenderPass* renderPass)
 {
     if (!useRenderPass(frame, renderPass))
         return;
 
     frame.scissorRectInRenderPassSpace = frame.currentRenderPass->outputRect();
     if (frame.rootDamageRect != frame.rootRenderPass->outputRect()) {
         WebTransformationMatrix inverseTransformToRoot = frame.currentRenderPass->transformToRootTarget().inverse();
-        frame.scissorRectInRenderPassSpace.intersect(CCMathUtil::projectClippedRect(inverseTransformToRoot, frame.rootDamageRect));
+        gfx::RectF damageRectInRenderPassSpace = CCMathUtil::projectClippedRect(inverseTransformToRoot, cc::FloatRect(frame.rootDamageRect));
+        frame.scissorRectInRenderPassSpace = frame.scissorRectInRenderPassSpace.Intersect(damageRectInRenderPassSpace);
     }
 
     enableScissorTestRect(moveScissorToWindowSpace(frame, frame.scissorRectInRenderPassSpace));
     clearFramebuffer(frame);
 
     const CCQuadList& quadList = renderPass->quadList();
     for (CCQuadList::constBackToFrontIterator it = quadList.backToFrontBegin(); it != quadList.backToFrontEnd(); ++it) {
-        FloatRect quadScissorRect = frame.scissorRectInRenderPassSpace;
-        quadScissorRect.intersect((*it)->clippedRectInTarget());
-        if (!quadScissorRect.isEmpty()) {
+        gfx::RectF quadScissorRect = frame.scissorRectInRenderPassSpace.Intersect((*it)->clippedRectInTarget());
+        if (!quadScissorRect.IsEmpty()) {
             enableScissorTestRect(moveScissorToWindowSpace(frame, quadScissorRect));
             drawQuad(frame, *it);
         }
     }
 
     CachedTexture* texture = m_renderPassTextures.get(renderPass->id());
     if (texture)
         texture->setIsComplete(!renderPass->hasOcclusionFromOutsideTargetSurface());
 }
 
@@ skipping 19 matching lines @@
 
 bool CCDirectRenderer::haveCachedResourcesForRenderPassId(CCRenderPass::Id id) const
 {
     CachedTexture* texture = m_renderPassTextures.get(id);
     return texture && texture->id() && texture->isComplete();
 }
 
 // static
 IntSize CCDirectRenderer::renderPassTextureSize(const CCRenderPass* pass)
 {
-    return pass->outputRect().size();
+    return cc::IntSize(pass->outputRect().size());
 }
 
 // static
 GLenum CCDirectRenderer::renderPassTextureFormat(const CCRenderPass*)
 {
     return GL_RGBA;
 }
 
 }