cc: Use gfx:: Geometry types for positions, bounds, and related things.

cc/gl_renderer.cc

 // 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"
 
 #include "cc/gl_renderer.h"
 
 #include "FloatQuad.h"
 #include "NotImplemented.h"
@@ skipping 438 matching lines @@
     // FIXME: Do a single readback for both the surface and replica and cache the filtered results (once filter textures are not reused).
     gfx::Rect deviceRect = gfx::ToEnclosingRect(MathUtil::mapClippedRect(contentsDeviceTransform, cc::FloatRect(sharedGeometryQuad().boundingBox())));
 
     int top, right, bottom, left;
     filters.getOutsets(top, right, bottom, left);
     deviceRect.Inset(-left, -top, -right, -bottom);
 
     deviceRect.Intersect(frame.currentRenderPass->outputRect());
 
     scoped_ptr<ScopedTexture> deviceBackgroundTexture = ScopedTexture::create(m_resourceProvider);
-    if (!getFramebufferTexture(deviceBackgroundTexture.get(), cc::IntRect(deviceRect)))
+    if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect))
         return scoped_ptr<ScopedTexture>();
 
     SkBitmap filteredDeviceBackground = applyFilters(this, filters, deviceBackgroundTexture.get());
     if (!filteredDeviceBackground.getTexture())
         return scoped_ptr<ScopedTexture>();
 
     GrTexture* texture = reinterpret_cast<GrTexture*>(filteredDeviceBackground.getTexture());
     int filteredDeviceBackgroundTextureId = texture->getTextureHandle();
 
     scoped_ptr<ScopedTexture> backgroundTexture = ScopedTexture::create(m_resourceProvider);
@@ skipping 213 matching lines @@
     // 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.Inset(clampX, clampY, clampX, clampY);
     gfx::Vector2dF clampOffset = clampRect.origin() - tileRect.origin();
 
-    gfx::PointF textureOffset = quad->textureOffset() + clampOffset +
-                                (tileRect.origin() - quad->quadRect().origin());
+    gfx::Vector2dF textureOffset = quad->textureOffset() + clampOffset +
+                                   (tileRect.origin() - quad->quadRect().origin());
 
     // 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 gfx::Size& textureSize = quad->textureSize();
     float fragmentTexTranslateX = textureOffset.x() / textureSize.width();
@@ skipping 50 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.right(), tileRect.bottom());
-        FloatPoint bottomLeft(tileRect.x(), tileRect.bottom());
-        FloatPoint topLeft(tileRect.x(), tileRect.y());
-        FloatPoint topRight(tileRect.right(), tileRect.y());
+        gfx::PointF bottomRight(tileRect.right(), tileRect.bottom());
+        gfx::PointF bottomLeft(tileRect.x(), tileRect.bottom());
+        gfx::PointF topLeft(tileRect.x(), tileRect.y());
+        gfx::PointF topRight(tileRect.right(), tileRect.y());
 
         // Map points to device space.
         bottomRight = MathUtil::mapPoint(deviceTransform, bottomRight, clipped);
         DCHECK(!clipped);
         bottomLeft = MathUtil::mapPoint(deviceTransform, bottomLeft, clipped);
         DCHECK(!clipped);
         topLeft = MathUtil::mapPoint(deviceTransform, topLeft, clipped);
         DCHECK(!clipped);
         topRight = MathUtil::mapPoint(deviceTransform, topRight, clipped);
         DCHECK(!clipped);
@@ skipping 413 matching lines @@
     m_context->ensureFramebufferCHROMIUM();
     m_isFramebufferDiscarded = false;
 }
 
 void GLRenderer::onContextLost()
 {
     m_client->didLoseContext();
 }
 
 
-void GLRenderer::getFramebufferPixels(void *pixels, const IntRect& rect)
+void GLRenderer::getFramebufferPixels(void *pixels, const gfx::Rect& rect)
 {
-    DCHECK(rect.maxX() <= viewportWidth());
-    DCHECK(rect.maxY() <= viewportHeight());
+    DCHECK(rect.right() <= viewportWidth());
+    DCHECK(rect.bottom() <= viewportHeight());
 
     if (!pixels)
         return;
 
     makeContextCurrent();
 
     bool doWorkaround = needsIOSurfaceReadbackWorkaround();
 
     GLuint temporaryTexture = 0;
     GLuint temporaryFBO = 0;
@@ skipping 14 matching lines @@
         GLC(m_context, m_context->copyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, viewportSize().width(), viewportSize().height(), 0));
         temporaryFBO = m_context->createFramebuffer();
         // Attach this texture to an FBO, and perform the readback from that FBO.
         GLC(m_context, m_context->bindFramebuffer(GL_FRAMEBUFFER, temporaryFBO));
         GLC(m_context, m_context->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, temporaryTexture, 0));
 
         DCHECK(m_context->checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
     }
 
     scoped_array<uint8_t> srcPixels(new uint8_t[rect.width() * rect.height() * 4]);
-    GLC(m_context, m_context->readPixels(rect.x(), viewportSize().height() - rect.maxY(), rect.width(), rect.height(),
-                                     GL_RGBA, GL_UNSIGNED_BYTE, srcPixels.get()));
+    GLC(m_context, m_context->readPixels(rect.x(), viewportSize().height() - rect.bottom(), rect.width(), rect.height(),
+                                         GL_RGBA, GL_UNSIGNED_BYTE, srcPixels.get()));
 
     uint8_t* destPixels = static_cast<uint8_t*>(pixels);
     size_t rowBytes = rect.width() * 4;
     int numRows = rect.height();
     size_t totalBytes = numRows * rowBytes;
     for (size_t destY = 0; destY < totalBytes; destY += rowBytes) {
         // Flip Y axis.
         size_t srcY = totalBytes - destY - rowBytes;
         // Swizzle BGRA -> RGBA.
         for (size_t x = 0; x < rowBytes; x += 4) {
             destPixels[destY + (x+0)] = srcPixels.get()[srcY + (x+2)];
             destPixels[destY + (x+1)] = srcPixels.get()[srcY + (x+1)];
             destPixels[destY + (x+2)] = srcPixels.get()[srcY + (x+0)];
             destPixels[destY + (x+3)] = srcPixels.get()[srcY + (x+3)];
         }
     }
 
     if (doWorkaround) {
         // Clean up.
         GLC(m_context, m_context->bindFramebuffer(GL_FRAMEBUFFER, 0));
         GLC(m_context, m_context->bindTexture(GL_TEXTURE_2D, 0));
         GLC(m_context, m_context->deleteFramebuffer(temporaryFBO));
         GLC(m_context, m_context->deleteTexture(temporaryTexture));
     }
 
     enforceMemoryPolicy();
 }
 
-bool GLRenderer::getFramebufferTexture(ScopedTexture* texture, const IntRect& deviceRect)
+bool GLRenderer::getFramebufferTexture(ScopedTexture* texture, const gfx::Rect& deviceRect)
 {
     DCHECK(!texture->id() || (texture->size() == deviceRect.size() && texture->format() == GL_RGB));
 
-    if (!texture->id() && !texture->allocate(Renderer::ImplPool, cc::IntSize(deviceRect.size()), GL_RGB, ResourceProvider::TextureUsageAny))
+    if (!texture->id() && !texture->allocate(Renderer::ImplPool, deviceRect.size(), GL_RGB, ResourceProvider::TextureUsageAny))
         return false;
 
     ResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());
     GLC(m_context, m_context->bindTexture(GL_TEXTURE_2D, lock.textureId()));
     GLC(m_context, m_context->copyTexImage2D(GL_TEXTURE_2D, 0, texture->format(),
                                              deviceRect.x(), deviceRect.y(), deviceRect.width(), deviceRect.height(), 0));
     return true;
 }
 
 bool GLRenderer::useScopedTexture(DrawingFrame& frame, const ScopedTexture* texture, const gfx::Rect& viewportRect)
@@ skipping 303 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 } // namespace cc