cc: Replace WebCore::FloatQuad with gfx::QuadF.

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 "FloatRect.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "cc/damage_tracker.h"
 #include "cc/geometry_binding.h"
 #include "cc/layer_quad.h"
 #include "cc/math_util.h"
 #include "cc/platform_color.h"
 #include "cc/priority_calculator.h"
 #include "cc/proxy.h"
 #include "cc/render_pass.h"
 #include "cc/render_surface_filters.h"
 #include "cc/scoped_texture.h"
 #include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/stream_video_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/video_layer_impl.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
 #include "third_party/skia/include/gpu/SkGpuDevice.h"
 #include "third_party/skia/include/gpu/SkGrTexturePixelRef.h"
+#include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 #include <public/WebGraphicsContext3D.h>
 #include <public/WebSharedGraphicsContext3D.h>
 #include <set>
 #include <string>
 #include <vector>
 
 using namespace std;
 using WebKit::WebGraphicsContext3D;
 using WebKit::WebGraphicsMemoryAllocation;
@@ skipping 402 matching lines @@
     if (filters.isEmpty())
         return scoped_ptr<ScopedTexture>();
 
     // 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 scoped_ptr<ScopedTexture>();
     DCHECK(!frame.currentTexture);
 
     // 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, sharedGeometryQuad().boundingBox()));
+    gfx::Rect deviceRect = gfx::ToEnclosingRect(MathUtil::mapClippedRect(contentsDeviceTransform, 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(), deviceRect))
         return scoped_ptr<ScopedTexture>();
@@ skipping 68 matching lines @@
     }
 
     // Draw the background texture if there is one.
     if (backgroundTexture) {
         DCHECK(backgroundTexture->size() == quad->quadRect().size());
         ResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
         copyTextureToFramebuffer(frame, lock.textureId(), quad->quadRect(), quad->quadTransform());
     }
 
     bool clipped = false;
-    FloatQuad deviceQuad = MathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped);
+    gfx::QuadF deviceQuad = MathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped);
     DCHECK(!clipped);
-    LayerQuad deviceLayerBounds = LayerQuad(FloatQuad(deviceQuad.boundingBox()));
+    LayerQuad deviceLayerBounds = LayerQuad(gfx::QuadF(deviceQuad.BoundingBox()));
     LayerQuad deviceLayerEdges = LayerQuad(deviceQuad);
 
     // Use anti-aliasing programs only when necessary.
-    bool useAA = (!deviceQuad.isRectilinear() || !cc::FloatRect(deviceQuad.boundingBox()).isExpressibleAsIntRect());
+    bool useAA = (!deviceQuad.IsRectilinear() || !cc::FloatRect(deviceQuad.BoundingBox()).isExpressibleAsIntRect());
     if (useAA) {
         deviceLayerBounds.inflateAntiAliasingDistance();
         deviceLayerEdges.inflateAntiAliasingDistance();
     }
 
     scoped_ptr<ResourceProvider::ScopedReadLockGL> maskResourceLock;
     unsigned maskTextureId = 0;
     if (quad->maskResourceId()) {
         maskResourceLock.reset(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId()));
         maskTextureId = maskResourceLock->textureId();
@@ skipping 63 matching lines @@
     }
 
     if (shaderEdgeLocation != -1) {
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(shaderEdgeLocation, 8, edge));
     }
 
     // Map device space quad to surface space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
-    FloatQuad surfaceQuad = MathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.floatQuad(), clipped);
+    gfx::QuadF surfaceQuad = MathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.ToQuadF(), clipped);
     DCHECK(!clipped);
 
     setShaderOpacity(quad->opacity(), shaderAlphaLocation);
-    setShaderFloatQuad(surfaceQuad, shaderQuadLocation);
+    setShaderQuadF(surfaceQuad, shaderQuadLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), shaderMatrixLocation);
 }
 
 void GLRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
 {
     const SolidColorProgram* program = solidColorProgram();
     GLC(context(), context()->useProgram(program->program()));
 
     SkColor color = quad->color();
     float opacity = quad->opacity();
@@ skipping 54 matching lines @@
     float vertexTexScaleY = tileRect.height() / clampRect.height();
 
     // Map to normalized texture coordinates.
     const gfx::Size& 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;
+    gfx::QuadF localQuad;
     WebTransformationMatrix deviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * quad->quadTransform()).to2dTransform();
     if (!deviceTransform.isInvertible())
         return;
 
     bool clipped = false;
-    FloatQuad deviceLayerQuad = MathUtil::mapQuad(deviceTransform, FloatQuad(quad->visibleContentRect()), clipped);
+    gfx::QuadF deviceLayerQuad = MathUtil::mapQuad(deviceTransform, gfx::QuadF(quad->visibleContentRect()), clipped);
     DCHECK(!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 14 matching lines @@
     GLC(context(), context()->useProgram(uniforms.program));
     GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0));
     GLC(context(), context()->activeTexture(GL_TEXTURE0));
     ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
     GLC(context(), context()->bindTexture(GL_TEXTURE_2D, quadResourceLock.textureId()));
     GLC(context(), context()->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, quad->textureFilter()));
     GLC(context(), context()->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, quad->textureFilter()));
 
     bool useAA = !clipped && quad->isAntialiased();
     if (useAA) {
-        LayerQuad deviceLayerBounds = LayerQuad(FloatQuad(deviceLayerQuad.boundingBox()));
+        LayerQuad deviceLayerBounds = LayerQuad(gfx::QuadF(deviceLayerQuad.BoundingBox()));
         deviceLayerBounds.inflateAntiAliasingDistance();
 
         LayerQuad deviceLayerEdges = LayerQuad(deviceLayerQuad);
         deviceLayerEdges.inflateAntiAliasingDistance();
 
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(uniforms.edgeLocation, 8, edge));
 
@@ skipping 23 matching lines @@
         // 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.right() == quad->quadRect().right())
             rightEdge = deviceLayerEdges.right();
         if (quad->bottomEdgeAA() && tileRect.bottom() == quad->quadRect().bottom())
             bottomEdge = deviceLayerEdges.bottom();
 
-        float sign = FloatQuad(tileRect).isCounterclockwise() ? -1 : 1;
+        float sign = gfx::QuadF(tileRect).IsCounterClockwise() ? -1 : 1;
         bottomEdge.scale(sign);
         leftEdge.scale(sign);
         topEdge.scale(sign);
         rightEdge.scale(sign);
 
         // Create device space quad.
         LayerQuad 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();
-        localQuad = MathUtil::mapQuad(inverseDeviceTransform, deviceQuad.floatQuad(), clipped);
+        localQuad = MathUtil::mapQuad(inverseDeviceTransform, deviceQuad.ToQuadF(), clipped);
 
         // We should not DCHECK(!clipped) here, because anti-aliasing inflation may cause deviceQuad to become
         // clipped. To our knowledge this scenario does not need to be handled differently than the unclipped case.
     } else {
         // Move fragment shader transform to vertex shader. We can do this while
         // still producing correct results as fragmentTexTransformLocation
         // should always be non-negative when tiles are transformed in a way
         // that could result in sampling outside the layer.
         vertexTexScaleX *= fragmentTexScaleX;
         vertexTexScaleY *= fragmentTexScaleY;
         vertexTexTranslateX *= fragmentTexScaleX;
         vertexTexTranslateY *= fragmentTexScaleY;
         vertexTexTranslateX += fragmentTexTranslateX;
         vertexTexTranslateY += fragmentTexTranslateY;
 
         GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY));
 
         localQuad = gfx::RectF(tileRect);
     }
 
     // Normalize to tileRect.
-    localQuad.scale(1.0f / tileRect.width(), 1.0f / tileRect.height());
+    localQuad.Scale(1.0f / tileRect.width(), 1.0f / tileRect.height());
 
     setShaderOpacity(quad->opacity(), uniforms.alphaLocation);
-    setShaderFloatQuad(localQuad, uniforms.pointLocation);
+    setShaderQuadF(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.
     gfx::RectF centeredRect(gfx::PointF(-0.5 * tileRect.width(), -0.5 * tileRect.height()), tileRect.size());
     drawQuadGeometry(frame, quad->quadTransform(), centeredRect, uniforms.matrixLocation);
 }
 
@@ skipping 195 matching lines @@
     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();
 }
 
-void GLRenderer::setShaderFloatQuad(const FloatQuad& quad, int quadLocation)
+void GLRenderer::setShaderQuadF(const gfx::QuadF& quad, int quadLocation)
 {
     if (quadLocation == -1)
         return;
 
     float point[8];
     point[0] = quad.p1().x();
     point[1] = quad.p1().y();
     point[2] = quad.p2().x();
     point[3] = quad.p2().y();
     point[4] = quad.p3().x();
@@ skipping 560 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 } // namespace cc