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

cc/CCRendererGL.cpp

 // Copyright 2010 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"
 
 #if USE(ACCELERATED_COMPOSITING)
 #include "CCRendererGL.h"
 
@@ skipping 190 matching lines @@
     if (frame.currentRenderPass->hasTransparentBackground())
 #endif
         m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
 }
 
 void CCRendererGL::beginDrawingFrame(DrawingFrame& frame)
 {
     // FIXME: Remove this once framebuffer is automatically recreated on first use
     ensureFramebuffer();
 
-    if (viewportSize().isEmpty())
+    if (viewportSize().IsEmpty())
         return;
 
     TRACE_EVENT0("cc", "CCRendererGL::drawLayers");
     if (m_isViewportChanged) {
         // Only reshape when we know we are going to draw. Otherwise, the reshape
         // can leave the window at the wrong size if we never draw and the proper
         // viewport size is never set.
         m_isViewportChanged = false;
         m_context->reshape(viewportWidth(), viewportHeight());
     }
@@ skipping 55 matching lines @@
         break;
     }
 }
 
 void CCRendererGL::drawCheckerboardQuad(const DrawingFrame& frame, const CCCheckerboardDrawQuad* quad)
 {
     const TileCheckerboardProgram* program = tileCheckerboardProgram();
     ASSERT(program && program->initialized());
     GLC(context(), context()->useProgram(program->program()));
 
-    IntRect tileRect = quad->quadRect();
+    ccmath::IntRect tileRect = quad->quadRect();
     float texOffsetX = tileRect.x();
     float texOffsetY = tileRect.y();
     float texScaleX = tileRect.width();
     float texScaleY = tileRect.height();
     GLC(context(), context()->uniform4f(program->fragmentShader().texTransformLocation(), texOffsetX, texOffsetY, texScaleX, texScaleY));
 
     const int checkerboardWidth = 16;
     float frequency = 1.0 / checkerboardWidth;
 
     GLC(context(), context()->uniform1f(program->fragmentShader().frequencyLocation(), frequency));
 
     setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation());
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation());
 }
 
 void CCRendererGL::drawDebugBorderQuad(const DrawingFrame& frame, const CCDebugBorderDrawQuad* quad)
 {
     static float glMatrix[16];
     const SolidColorProgram* program = solidColorProgram();
     ASSERT(program && program->initialized());
     GLC(context(), context()->useProgram(program->program()));
 
     // Use the full quadRect for debug quads to not move the edges based on partial swaps.
-    const IntRect& layerRect = quad->quadRect();
+    const ccmath::IntRect& layerRect = quad->quadRect();
     WebTransformationMatrix renderMatrix = quad->quadTransform();
     renderMatrix.translate(0.5 * layerRect.width() + layerRect.x(), 0.5 * layerRect.height() + layerRect.y());
     renderMatrix.scaleNonUniform(layerRect.width(), layerRect.height());
     CCRendererGL::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix);
     GLC(context(), context()->uniformMatrix4fv(program->vertexShader().matrixLocation(), 1, false, &glMatrix[0]));
 
     SkColor color = quad->color();
     float alpha = SkColorGetA(color) / 255.0;
 
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha));
@@ skipping 43 matching lines @@
     if (filters.isEmpty())
         return nullptr;
 
     // FIXME: We only allow background filters on an opaque render surface because other surfaces may contain
     // translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied.
     if (frame.currentRenderPass->hasTransparentBackground())
         return nullptr;
     ASSERT(!frame.currentTexture);
 
     // FIXME: Do a single readback for both the surface and replica and cache the filtered results (once filter textures are not reused).
-    IntRect deviceRect = enclosingIntRect(CCMathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().boundingBox()));
+    ccmath::IntRect deviceRect = ccmath::FloatRect(CCMathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().boundingBox())).EnclosingIntRect();
 
     int top, right, bottom, left;
     filters.getOutsets(top, right, bottom, left);
-    deviceRect.move(-left, -top);
-    deviceRect.expand(left + right, top + bottom);
+    deviceRect.InflateX(-left);
+    deviceRect.InflateY(-top);
+    deviceRect.InflateWidth(left + right);
+    deviceRect.InflateHeight(top + bottom);
 
-    deviceRect.intersect(frame.currentRenderPass->outputRect());
+    deviceRect.Intersect(frame.currentRenderPass->outputRect());
 
     OwnPtr<CCScopedTexture> deviceBackgroundTexture = CCScopedTexture::create(m_resourceProvider);
-    if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect))
+    if (!getFramebufferTexture(deviceBackgroundTexture.get(), cc::IntRect(deviceRect)))
         return nullptr;
 
     SkBitmap filteredDeviceBackground = applyFilters(this, filters, deviceBackgroundTexture.get());
     if (!filteredDeviceBackground.getTexture())
         return nullptr;
 
     GrTexture* texture = reinterpret_cast<GrTexture*>(filteredDeviceBackground.getTexture());
     int filteredDeviceBackgroundTextureId = texture->getTextureHandle();
 
     OwnPtr<CCScopedTexture> backgroundTexture = CCScopedTexture::create(m_resourceProvider);
-    if (!backgroundTexture->allocate(CCRenderer::ImplPool, quad->quadRect().size(), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageFramebuffer))
+    if (!backgroundTexture->allocate(CCRenderer::ImplPool, cc::IntSize(quad->quadRect().size()), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageFramebuffer))
         return nullptr;
 
     const CCRenderPass* targetRenderPass = frame.currentRenderPass;
     bool usingBackgroundTexture = useScopedTexture(frame, backgroundTexture.get(), quad->quadRect());
 
     if (usingBackgroundTexture) {
         // Copy the readback pixels from device to the background texture for the surface.
         WebTransformationMatrix deviceToFramebufferTransform;
         deviceToFramebufferTransform.translate(quad->quadRect().width() / 2.0, quad->quadRect().height() / 2.0);
         deviceToFramebufferTransform.scale3d(quad->quadRect().width(), quad->quadRect().height(), 1);
@@ skipping 184 matching lines @@
     uniforms.pointLocation = program->vertexShader().pointLocation();
 
     uniforms.samplerLocation = program->fragmentShader().samplerLocation();
     uniforms.alphaLocation = program->fragmentShader().alphaLocation();
     uniforms.fragmentTexTransformLocation = program->fragmentShader().fragmentTexTransformLocation();
     uniforms.edgeLocation = program->fragmentShader().edgeLocation();
 }
 
 void CCRendererGL::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad* quad)
 {
-    IntRect tileRect = quad->quadVisibleRect();
+    ccmath::IntRect tileRect = quad->quadVisibleRect();
 
-    FloatRect clampRect(tileRect);
+    ccmath::FloatRect clampRect(tileRect);
     // Clamp texture coordinates to avoid sampling outside the layer
     // by deflating the tile region half a texel or half a texel
     // minus epsilon for one pixel layers. The resulting clamp region
     // is mapped to the unit square by the vertex shader and mapped
     // back to normalized texture coordinates by the fragment shader
     // after being clamped to 0-1 range.
     const float epsilon = 1 / 1024.0f;
     float clampX = min(0.5, clampRect.width() / 2.0 - epsilon);
     float clampY = min(0.5, clampRect.height() / 2.0 - epsilon);
-    clampRect.inflateX(-clampX);
-    clampRect.inflateY(-clampY);
-    FloatSize clampOffset = clampRect.minXMinYCorner() - FloatRect(tileRect).minXMinYCorner();
+    clampRect.InflateX(-clampX);
+    clampRect.InflateY(-clampY);
+    ccmath::FloatVector2d clampOffset = clampRect.location() - tileRect.location();
 
-    FloatPoint textureOffset = quad->textureOffset() + clampOffset +
-                               IntPoint(tileRect.location() - quad->quadRect().location());
+    ccmath::FloatPoint textureOffset = quad->textureOffset() + clampOffset +
+                                       (tileRect.location() - quad->quadRect().location());
 
     // Map clamping rectangle to unit square.
     float vertexTexTranslateX = -clampRect.x() / clampRect.width();
     float vertexTexTranslateY = -clampRect.y() / clampRect.height();
     float vertexTexScaleX = tileRect.width() / clampRect.width();
     float vertexTexScaleY = tileRect.height() / clampRect.height();
 
     // Map to normalized texture coordinates.
-    const IntSize& textureSize = quad->textureSize();
+    const ccmath::IntSize& textureSize = quad->textureSize();
     float fragmentTexTranslateX = textureOffset.x() / textureSize.width();
     float fragmentTexTranslateY = textureOffset.y() / textureSize.height();
     float fragmentTexScaleX = clampRect.width() / textureSize.width();
     float fragmentTexScaleY = clampRect.height() / textureSize.height();
 
 
     FloatQuad localQuad;
     WebTransformationMatrix deviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * quad->quadTransform()).to2dTransform();
     if (!deviceTransform.isInvertible())
         return;
 
     bool clipped = false;
-    FloatQuad deviceLayerQuad = CCMathUtil::mapQuad(deviceTransform, FloatQuad(quad->visibleContentRect()), clipped);
+    FloatQuad deviceLayerQuad = CCMathUtil::mapQuad(deviceTransform, FloatQuad(cc::IntRect(quad->visibleContentRect())), clipped);
     ASSERT(!clipped);
 
     TileProgramUniforms uniforms;
     // For now, we simply skip anti-aliasing with the quad is clipped. This only happens
     // on perspective transformed layers that go partially behind the camera.
     if (quad->isAntialiased() && !clipped) {
         if (quad->swizzleContents())
             tileUniformLocation(tileProgramSwizzleAA(), uniforms);
         else
             tileUniformLocation(tileProgramAA(), uniforms);
@@ skipping 28 matching lines @@
         deviceLayerEdges.inflateAntiAliasingDistance();
 
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(uniforms.edgeLocation, 8, edge));
 
         GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY));
         GLC(context(), context()->uniform4f(uniforms.fragmentTexTransformLocation, fragmentTexTranslateX, fragmentTexTranslateY, fragmentTexScaleX, fragmentTexScaleY));
 
-        FloatPoint bottomRight(tileRect.maxX(), tileRect.maxY());
-        FloatPoint bottomLeft(tileRect.x(), tileRect.maxY());
+        FloatPoint bottomRight(tileRect.max_x(), tileRect.max_y());
+        FloatPoint bottomLeft(tileRect.x(), tileRect.max_y());
         FloatPoint topLeft(tileRect.x(), tileRect.y());
-        FloatPoint topRight(tileRect.maxX(), tileRect.y());
+        FloatPoint topRight(tileRect.max_x(), tileRect.y());
 
         // Map points to device space.
         bottomRight = CCMathUtil::mapPoint(deviceTransform, bottomRight, clipped);
         ASSERT(!clipped);
         bottomLeft = CCMathUtil::mapPoint(deviceTransform, bottomLeft, clipped);
         ASSERT(!clipped);
         topLeft = CCMathUtil::mapPoint(deviceTransform, topLeft, clipped);
         ASSERT(!clipped);
         topRight = CCMathUtil::mapPoint(deviceTransform, topRight, clipped);
         ASSERT(!clipped);
 
         CCLayerQuad::Edge bottomEdge(bottomRight, bottomLeft);
         CCLayerQuad::Edge leftEdge(bottomLeft, topLeft);
         CCLayerQuad::Edge topEdge(topLeft, topRight);
         CCLayerQuad::Edge rightEdge(topRight, bottomRight);
 
         // Only apply anti-aliasing to edges not clipped by culling or scissoring.
         if (quad->topEdgeAA() && tileRect.y() == quad->quadRect().y())
             topEdge = deviceLayerEdges.top();
         if (quad->leftEdgeAA() && tileRect.x() == quad->quadRect().x())
             leftEdge = deviceLayerEdges.left();
-        if (quad->rightEdgeAA() && tileRect.maxX() == quad->quadRect().maxX())
+        if (quad->rightEdgeAA() && tileRect.max_x() == quad->quadRect().max_x())
             rightEdge = deviceLayerEdges.right();
-        if (quad->bottomEdgeAA() && tileRect.maxY() == quad->quadRect().maxY())
+        if (quad->bottomEdgeAA() && tileRect.max_y() == quad->quadRect().max_y())
             bottomEdge = deviceLayerEdges.bottom();
 
-        float sign = FloatQuad(tileRect).isCounterclockwise() ? -1 : 1;
+        float sign = FloatQuad(cc::IntRect(tileRect)).isCounterclockwise() ? -1 : 1;
         bottomEdge.scale(sign);
         leftEdge.scale(sign);
         topEdge.scale(sign);
         rightEdge.scale(sign);
 
         // Create device space quad.
         CCLayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge);
 
         // Map device space quad to local space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
         WebTransformationMatrix inverseDeviceTransform = deviceTransform.inverse();
@@ skipping 22 matching lines @@
     localQuad.scale(1.0f / tileRect.width(), 1.0f / tileRect.height());
 
     setShaderOpacity(quad->opacity(), uniforms.alphaLocation);
     setShaderFloatQuad(localQuad, uniforms.pointLocation);
 
     // The tile quad shader behaves differently compared to all other shaders.
     // The transform and vertex data are used to figure out the extents that the
     // un-antialiased quad should have and which vertex this is and the float
     // quad passed in via uniform is the actual geometry that gets used to draw
     // it. This is why this centered rect is used and not the original quadRect.
-    FloatRect centeredRect(FloatPoint(-0.5 * tileRect.width(), -0.5 * tileRect.height()), tileRect.size());
+    ccmath::FloatRect centeredRect(ccmath::FloatPoint(-0.5 * tileRect.width(), -0.5 * tileRect.height()), tileRect.size());
     drawQuadGeometry(frame, quad->quadTransform(), centeredRect, uniforms.matrixLocation);
 }
 
 void CCRendererGL::drawYUVVideoQuad(const DrawingFrame& frame, const CCYUVVideoDrawQuad* quad)
 {
     const VideoYUVProgram* program = videoYUVProgram();
     ASSERT(program && program->initialized());
 
     const CCVideoLayerImpl::FramePlane& yPlane = quad->yPlane();
     const CCVideoLayerImpl::FramePlane& uPlane = quad->uPlane();
@@ skipping 99 matching lines @@
 {
     ASSERT(CCProxy::isImplThread());
 
     TexTransformTextureProgramBinding binding;
     if (quad->flipped())
         binding.set(textureProgramFlip());
     else
         binding.set(textureProgram());
     GLC(context(), context()->useProgram(binding.programId));
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
-    const FloatRect& uvRect = quad->uvRect();
+    const ccmath::FloatRect& uvRect = quad->uvRect();
     GLC(context(), context()->uniform4f(binding.texTransformLocation, uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height()));
 
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
     CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
     GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId()));
 
     // FIXME: setting the texture parameters every time is redundant. Move this code somewhere
     // where it will only happen once per texture.
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR));
@@ skipping 37 matching lines @@
 
     setShaderOpacity(quad->opacity(), binding.alphaLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), binding.matrixLocation);
 
     GLC(context(), context()->bindTexture(Extensions3D::TEXTURE_RECTANGLE_ARB, 0));
 }
 
 void CCRendererGL::finishDrawingFrame(DrawingFrame& frame)
 {
     m_currentFramebufferLock.clear();
-    m_swapBufferRect.unite(enclosingIntRect(frame.rootDamageRect));
+    m_swapBufferRect.Unite(frame.rootDamageRect.EnclosingIntRect());
 
     GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST));
     GLC(m_context, m_context->disable(GraphicsContext3D::BLEND));
 }
 
 bool CCRendererGL::flippedFramebuffer() const
 {
     return true;
 }
 
@@ skipping 33 matching lines @@
     point[7] = quad.p4().y();
     GLC(m_context, m_context->uniform2fv(quadLocation, 4, point));
 }
 
 void CCRendererGL::setShaderOpacity(float opacity, int alphaLocation)
 {
     if (alphaLocation != -1)
         GLC(m_context, m_context->uniform1f(alphaLocation, opacity));
 }
 
-void CCRendererGL::drawQuadGeometry(const DrawingFrame& frame, const WebKit::WebTransformationMatrix& drawTransform, const FloatRect& quadRect, int matrixLocation)
+void CCRendererGL::drawQuadGeometry(const DrawingFrame& frame, const WebKit::WebTransformationMatrix& drawTransform, const ccmath::FloatRect& quadRect, int matrixLocation)
 {
     WebTransformationMatrix quadRectMatrix;
     quadRectTransform(&quadRectMatrix, drawTransform, quadRect);
     static float glMatrix[16];
     toGLMatrix(&glMatrix[0], frame.projectionMatrix * quadRectMatrix);
     GLC(m_context, m_context->uniformMatrix4fv(matrixLocation, 1, false, &glMatrix[0]));
 
     GLC(m_context, m_context->drawElements(GraphicsContext3D::TRIANGLES, 6, GraphicsContext3D::UNSIGNED_SHORT, 0));
 }
 
-void CCRendererGL::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const IntRect& rect, const WebTransformationMatrix& drawMatrix)
+void CCRendererGL::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const ccmath::IntRect& rect, const WebTransformationMatrix& drawMatrix)
 {
     const RenderPassProgram* program = renderPassProgram();
 
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
     GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE));
     GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE));
 
@@ skipping 12 matching lines @@
 bool CCRendererGL::swapBuffers()
 {
     ASSERT(m_visible);
     ASSERT(!m_isFramebufferDiscarded);
 
     TRACE_EVENT0("cc", "CCRendererGL::swapBuffers");
     // We're done! Time to swapbuffers!
 
     if (m_capabilities.usingPartialSwap) {
         // If supported, we can save significant bandwidth by only swapping the damaged/scissored region (clamped to the viewport)
-        m_swapBufferRect.intersect(IntRect(IntPoint(), viewportSize()));
+        m_swapBufferRect.Intersect(ccmath::IntRect(ccmath::IntPoint(), viewportSize()));
         int flippedYPosOfRectBottom = viewportHeight() - m_swapBufferRect.y() - m_swapBufferRect.height();
         m_context->postSubBufferCHROMIUM(m_swapBufferRect.x(), flippedYPosOfRectBottom, m_swapBufferRect.width(), m_swapBufferRect.height());
     } else {
         // Note that currently this has the same effect as swapBuffers; we should
         // consider exposing a different entry point on WebGraphicsContext3D.
         m_context->prepareTexture();
     }
 
-    m_swapBufferRect = IntRect();
+    m_swapBufferRect = ccmath::IntRect();
 
     return true;
 }
 
 void CCRendererGL::onSwapBuffersComplete()
 {
     m_client->onSwapBuffersComplete();
 }
 
 void CCRendererGL::onMemoryAllocationChanged(WebGraphicsMemoryAllocation allocation)
@@ skipping 52 matching lines @@
     m_context->ensureFramebufferCHROMIUM();
     m_isFramebufferDiscarded = false;
 }
 
 void CCRendererGL::onContextLost()
 {
     m_client->didLoseContext();
 }
 
 
-void CCRendererGL::getFramebufferPixels(void *pixels, const IntRect& rect)
+void CCRendererGL::getFramebufferPixels(void *pixels, const cc::IntRect& rect)
 {
     ASSERT(rect.maxX() <= viewportWidth() && rect.maxY() <= viewportHeight());
 
     if (!pixels)
         return;
 
     makeContextCurrent();
 
     bool doWorkaround = needsIOSurfaceReadbackWorkaround();
 
@@ skipping 56 matching lines @@
         releaseRenderPassTextures();
         m_client->releaseContentsTextures();
         GLC(m_context, m_context->flush());
     }
 }
 
 bool CCRendererGL::getFramebufferTexture(CCScopedTexture* texture, const IntRect& deviceRect)
 {
     ASSERT(!texture->id() || (texture->size() == deviceRect.size() && texture->format() == GraphicsContext3D::RGB));
 
-    if (!texture->id() && !texture->allocate(CCRenderer::ImplPool, deviceRect.size(), GraphicsContext3D::RGB, CCResourceProvider::TextureUsageAny))
+    if (!texture->id() && !texture->allocate(CCRenderer::ImplPool, cc::IntSize(deviceRect.size()), GraphicsContext3D::RGB, CCResourceProvider::TextureUsageAny))
         return false;
 
     CCResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());
     GLC(m_context, m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId()));
     GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, texture->format(),
                                              deviceRect.x(), deviceRect.y(), deviceRect.width(), deviceRect.height(), 0));
     return true;
 }
 
-bool CCRendererGL::useScopedTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& viewportRect)
+bool CCRendererGL::useScopedTexture(DrawingFrame& frame, const CCScopedTexture* texture, const ccmath::IntRect& viewportRect)
 {
     ASSERT(texture->id());
     frame.currentRenderPass = 0;
     frame.currentTexture = texture;
 
     return bindFramebufferToTexture(frame, texture, viewportRect);
 }
 
 void CCRendererGL::bindFramebufferToOutputSurface(DrawingFrame& frame)
 {
     m_currentFramebufferLock.clear();
     GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0));
 }
 
-bool CCRendererGL::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& framebufferRect)
+bool CCRendererGL::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedTexture* texture, const ccmath::IntRect& framebufferRect)
 {
     ASSERT(texture->id());
 
     GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_offscreenFramebufferId));
     m_currentFramebufferLock = adoptPtr(new CCResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id()));
     unsigned textureId = m_currentFramebufferLock->textureId();
     GLC(m_context, m_context->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, textureId, 0));
 
 #if !defined ( NDEBUG )
     if (m_context->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
         ASSERT_NOT_REACHED();
         return false;
     }
 #endif
 
     initializeMatrices(frame, framebufferRect, false);
     setDrawViewportSize(framebufferRect.size());
 
     return true;
 }
 
-void CCRendererGL::enableScissorTestRect(const IntRect& scissorRect)
+void CCRendererGL::enableScissorTestRect(const ccmath::IntRect& scissorRect)
 {
     GLC(m_context, m_context->enable(GraphicsContext3D::SCISSOR_TEST));
     GLC(m_context, m_context->scissor(scissorRect.x(), scissorRect.y(), scissorRect.width(), scissorRect.height()));
 }
 
 void CCRendererGL::disableScissorTest()
 {
     GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST));
 }
 
-void CCRendererGL::setDrawViewportSize(const IntSize& viewportSize)
+void CCRendererGL::setDrawViewportSize(const ccmath::IntSize& viewportSize)
 {
     GLC(m_context, m_context->viewport(0, 0, viewportSize.width(), viewportSize.height()));
 }
 
 bool CCRendererGL::makeContextCurrent()
 {
     return m_context->makeContextCurrent();
 }
 
 bool CCRendererGL::initializeSharedObjects()
@@ skipping 252 matching lines @@
 }
 
 bool CCRendererGL::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR);
 }
 
 } // namespace cc
 
 #endif // USE(ACCELERATED_COMPOSITING)