cc: Remove WebCore dependecies from 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 361 matching lines @@
     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()));
 
     int top, right, bottom, left;
     filters.getOutsets(top, right, bottom, left);
     deviceRect.move(-left, -top);
     deviceRect.expand(left + right, top + bottom);
 
-    deviceRect.intersect(frame.currentRenderPass->outputRect());
+    deviceRect.intersect(static_cast<IntRect>(frame.currentRenderPass->outputRect()));
+
+    IntRect quadRect = quad->quadRect();
 
     OwnPtr<CCScopedTexture> deviceBackgroundTexture = CCScopedTexture::create(m_resourceProvider);
     if (!getFramebufferTexture(deviceBackgroundTexture.get(), 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, quadRect.size(), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageFramebuffer))
         return nullptr;
 
     const CCRenderPass* targetRenderPass = frame.currentRenderPass;
-    bool usingBackgroundTexture = useScopedTexture(frame, backgroundTexture.get(), quad->quadRect());
+    bool usingBackgroundTexture = useScopedTexture(frame, backgroundTexture.get(), 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);
+        deviceToFramebufferTransform.translate(quadRect.width() / 2.0, quadRect.height() / 2.0);
+        deviceToFramebufferTransform.scale3d(quadRect.width(), quadRect.height(), 1);
         deviceToFramebufferTransform.multiply(contentsDeviceTransform.inverse());
         copyTextureToFramebuffer(frame, filteredDeviceBackgroundTextureId, deviceRect, deviceToFramebufferTransform);
     }
 
     useRenderPass(frame, targetRenderPass);
 
     if (!usingBackgroundTexture)
         return nullptr;
     return backgroundTexture.release();
 }
 
 void CCRendererGL::drawRenderPassQuad(DrawingFrame& frame, const CCRenderPassDrawQuad* quad)
 {
     CachedTexture* contentsTexture = m_renderPassTextures.get(quad->renderPassId());
     if (!contentsTexture || !contentsTexture->id())
         return;
 
     const CCRenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
     ASSERT(renderPass);
     if (!renderPass)
         return;
 
+    IntRect quadRect = quad->quadRect();
+
     WebTransformationMatrix renderMatrix = quad->quadTransform();
-    renderMatrix.translate(0.5 * quad->quadRect().width() + quad->quadRect().x(), 0.5 * quad->quadRect().height() + quad->quadRect().y());
+    renderMatrix.translate(0.5 * quadRect.width() + quadRect.x(), 0.5 * quadRect.height() + quadRect.y());
     WebTransformationMatrix deviceMatrix = renderMatrix;
-    deviceMatrix.scaleNonUniform(quad->quadRect().width(), quad->quadRect().height());
+    deviceMatrix.scaleNonUniform(quadRect.width(), quadRect.height());
     WebTransformationMatrix contentsDeviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * deviceMatrix).to2dTransform();
 
     // Can only draw surface if device matrix is invertible.
     if (!contentsDeviceTransform.isInvertible())
         return;
 
     OwnPtr<CCScopedTexture> backgroundTexture = drawBackgroundFilters(frame, quad, renderPass->backgroundFilters(), contentsDeviceTransform);
 
     // FIXME: Cache this value so that we don't have to do it for both the surface and its replica.
     // Apply filters to the contents texture.
     SkBitmap filterBitmap = applyFilters(this, renderPass->filters(), contentsTexture);
     OwnPtr<CCResourceProvider::ScopedReadLockGL> contentsResourceLock;
     unsigned contentsTextureId = 0;
     if (filterBitmap.getTexture()) {
         GrTexture* texture = reinterpret_cast<GrTexture*>(filterBitmap.getTexture());
         contentsTextureId = texture->getTextureHandle();
     } else {
         contentsResourceLock = adoptPtr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));
         contentsTextureId = contentsResourceLock->textureId();
     }
 
     // Draw the background texture if there is one.
     if (backgroundTexture) {
-        ASSERT(backgroundTexture->size() == quad->quadRect().size());
+        ASSERT(backgroundTexture->size() == quadRect.size());
         CCResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
-        copyTextureToFramebuffer(frame, lock.textureId(), quad->quadRect(), quad->quadTransform());
+        copyTextureToFramebuffer(frame, lock.textureId(), quadRect, quad->quadTransform());
     }
 
     bool clipped = false;
     FloatQuad deviceQuad = CCMathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped);
     ASSERT(!clipped);
     CCLayerQuad deviceLayerBounds = CCLayerQuad(FloatQuad(deviceQuad.boundingBox()));
     CCLayerQuad deviceLayerEdges = CCLayerQuad(deviceQuad);
 
     // Use anti-aliasing programs only when necessary.
     bool useAA = (!deviceQuad.isRectilinear() || !deviceQuad.boundingBox().isExpressibleAsIntRect());
@@ skipping 78 matching lines @@
         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 = CCMathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.floatQuad(), clipped);
     ASSERT(!clipped);
 
     setShaderOpacity(quad->opacity(), shaderAlphaLocation);
     setShaderFloatQuad(surfaceQuad, shaderQuadLocation);
-    drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), shaderMatrixLocation);
+    drawQuadGeometry(frame, quad->quadTransform(), quadRect, shaderMatrixLocation);
 }
 
 void CCRendererGL::drawSolidColorQuad(const DrawingFrame& frame, const CCSolidColorDrawQuad* quad)
 {
     const SolidColorProgram* program = solidColorProgram();
     GLC(context(), context()->useProgram(program->program()));
 
     SkColor color = quad->color();
     float opacity = quad->opacity();
     float alpha = (SkColorGetA(color) / 255.0) * opacity;
@@ skipping 23 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 quadRect = quad->quadRect();
     IntRect tileRect = quad->quadVisibleRect();
 
     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();
 
-    FloatPoint textureOffset = quad->textureOffset() + clampOffset +
-                               IntPoint(tileRect.location() - quad->quadRect().location());
+    FloatPoint textureOffset = static_cast<IntPoint>(quad->textureOffset()) + clampOffset +
+                               IntPoint(tileRect.location() - 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();
+    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(static_cast<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 49 matching lines @@
         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())
+        if (quad->topEdgeAA() && tileRect.y() == quadRect.y())
             topEdge = deviceLayerEdges.top();
-        if (quad->leftEdgeAA() && tileRect.x() == quad->quadRect().x())
+        if (quad->leftEdgeAA() && tileRect.x() == quadRect.x())
             leftEdge = deviceLayerEdges.left();
-        if (quad->rightEdgeAA() && tileRect.maxX() == quad->quadRect().maxX())
+        if (quad->rightEdgeAA() && tileRect.maxX() == quadRect.maxX())
             rightEdge = deviceLayerEdges.right();
-        if (quad->bottomEdgeAA() && tileRect.maxY() == quad->quadRect().maxY())
+        if (quad->bottomEdgeAA() && tileRect.maxY() == quadRect.maxY())
             bottomEdge = deviceLayerEdges.bottom();
 
         float sign = FloatQuad(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);
@@ skipping 172 matching lines @@
         // initialized to that value! Therefore, premultipliedAlpha being false is the first
         // situation we can generally see an alpha channel less than 1.0 coming out of the
         // compositor. This is causing platform differences in some layout tests (see
         // https://bugs.webkit.org/show_bug.cgi?id=82412), so in this situation, use a separate
         // blend function for the alpha channel to avoid modifying it. Don't use colorMask for this
         // as it has performance implications on some platforms.
         GLC(context(), context()->blendFuncSeparate(GraphicsContext3D::SRC_ALPHA, GraphicsContext3D::ONE_MINUS_SRC_ALPHA, GraphicsContext3D::ZERO, GraphicsContext3D::ONE));
     }
 
     setShaderOpacity(quad->opacity(), binding.alphaLocation);
-    drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), binding.matrixLocation);
+    drawQuadGeometry(frame, quad->quadTransform(), static_cast<IntRect>(quad->quadRect()), binding.matrixLocation);
 
     if (!quad->premultipliedAlpha())
         GLC(m_context, m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));
 }
 
 void CCRendererGL::drawIOSurfaceQuad(const DrawingFrame& frame, const CCIOSurfaceDrawQuad* quad)
 {
     ASSERT(CCProxy::isImplThread());
     TexTransformTextureProgramBinding binding;
     binding.set(textureIOSurfaceProgram());
@@ skipping 598 matching lines @@
 }
 
 bool CCRendererGL::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR);
 }
 
 } // namespace cc
 
 #endif // USE(ACCELERATED_COMPOSITING)