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

cc/software_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 "CCRendererSoftware.h"
 
 #include "CCDebugBorderDrawQuad.h"
 #include "CCRenderPassDrawQuad.h"
 #include "CCTileDrawQuad.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/effects/SkLayerRasterizer.h"
+#include "ui/gfx/rect_conversions.h"
 #include <public/WebImage.h>
 #include <public/WebSize.h>
 #include <public/WebTransformationMatrix.h>
 
 using WebKit::WebCompositorSoftwareOutputDevice;
 using WebKit::WebImage;
 using WebKit::WebSize;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 namespace {
 
-SkRect toSkRect(const FloatRect& rect)
+SkRect toSkRect(const gfx::RectF& rect)
 {
     return SkRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height());
 }
 
-SkIRect toSkIRect(const IntRect& rect)
+SkIRect toSkIRect(const gfx::Rect& rect)
 {
     return SkIRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height());
 }
 
 void toSkMatrix(SkMatrix* flattened, const WebTransformationMatrix& m)
 {
     // Convert from 4x4 to 3x3 by dropping the third row and column.
     flattened->set(0, m.m11());
     flattened->set(1, m.m21());
     flattened->set(2, m.m41());
@@ skipping 72 matching lines @@
 void CCRendererSoftware::finish()
 {
 }
 
 void CCRendererSoftware::bindFramebufferToOutputSurface(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
     m_skCurrentCanvas = m_skRootCanvas.get();
 }
 
-bool CCRendererSoftware::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& framebufferRect)
+bool CCRendererSoftware::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedTexture* texture, const gfx::Rect& framebufferRect)
 {
     m_currentFramebufferLock = make_scoped_ptr(new CCResourceProvider::ScopedWriteLockSoftware(m_resourceProvider, texture->id()));
     m_skCurrentCanvas = m_currentFramebufferLock->skCanvas();
     initializeMatrices(frame, framebufferRect, false);
     setDrawViewportSize(framebufferRect.size());
 
     return true;
 }
 
-void CCRendererSoftware::enableScissorTestRect(const IntRect& scissorRect)
+void CCRendererSoftware::enableScissorTestRect(const gfx::Rect& scissorRect)
 {
     m_skCurrentCanvas->clipRect(toSkRect(scissorRect), SkRegion::kReplace_Op);
 }
 
 void CCRendererSoftware::disableScissorTest()
 {
-    IntRect canvasRect(IntPoint(), viewportSize());
+    gfx::Rect canvasRect(gfx::Point(), viewportSize());
     m_skCurrentCanvas->clipRect(toSkRect(canvasRect), SkRegion::kReplace_Op);
 }
 
 void CCRendererSoftware::clearFramebuffer(DrawingFrame& frame)
 {
     if (frame.currentRenderPass->hasTransparentBackground()) {
         m_skCurrentCanvas->clear(SkColorSetARGB(0, 0, 0, 0));
     } else {
 #ifndef NDEBUG
         // On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen.
         m_skCurrentCanvas->clear(SkColorSetARGB(255, 0, 0, 255));
 #endif
     }
 }
 
-void CCRendererSoftware::setDrawViewportSize(const IntSize& viewportSize)
+void CCRendererSoftware::setDrawViewportSize(const gfx::Size& viewportSize)
 {
 }
 
 bool CCRendererSoftware::isSoftwareResource(CCResourceProvider::ResourceId id) const
 {
     switch (m_resourceProvider->resourceType(id)) {
     case CCResourceProvider::GLTexture:
         return false;
     case CCResourceProvider::Bitmap:
         return true;
@@ skipping 73 matching lines @@
 
 void CCRendererSoftware::drawTextureQuad(const DrawingFrame& frame, const CCTextureDrawQuad* quad)
 {
     if (!isSoftwareResource(quad->resourceId())) {
         drawUnsupportedQuad(frame, quad);
         return;
     }
 
     // FIXME: Add support for non-premultiplied alpha.
     CCResourceProvider::ScopedReadLockSoftware quadResourceLock(m_resourceProvider, quad->resourceId());
-    FloatRect uvRect = quad->uvRect();
-    uvRect.scale(quad->quadRect().width(), quad->quadRect().height());
-    SkIRect skUvRect = toSkIRect(enclosingIntRect(uvRect));
+    gfx::RectF uvRect = quad->uvRect().Scale(quad->quadRect().width(), quad->quadRect().height());
+    SkIRect skUvRect = toSkIRect(gfx::ToEnclosingRect(uvRect));
     if (quad->flipped())
         m_skCurrentCanvas->scale(1, -1);
     m_skCurrentCanvas->drawBitmapRect(*quadResourceLock.skBitmap(), &skUvRect, toSkRect(quadVertexRect()), &m_skCurrentPaint);
 }
 
 void CCRendererSoftware::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad* quad)
 {
     DCHECK(isSoftwareResource(quad->resourceId()));
     CCResourceProvider::ScopedReadLockSoftware quadResourceLock(m_resourceProvider, quad->resourceId());
 
-    SkIRect uvRect = toSkIRect(IntRect(quad->textureOffset(), quad->quadRect().size()));
+    SkIRect uvRect = toSkIRect(gfx::Rect(quad->textureOffset(), quad->quadRect().size()));
     m_skCurrentCanvas->drawBitmapRect(*quadResourceLock.skBitmap(), &uvRect, toSkRect(quadVertexRect()), &m_skCurrentPaint);
 }
 
 void CCRendererSoftware::drawRenderPassQuad(const DrawingFrame& frame, const CCRenderPassDrawQuad* quad)
 {
     CachedTexture* contentsTexture = m_renderPassTextures.get(quad->renderPassId());
     if (!contentsTexture || !contentsTexture->id())
         return;
 
     DCHECK(isSoftwareResource(contentsTexture->id()));
@@ skipping 67 matching lines @@
 }
 
 void CCRendererSoftware::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 }
 
 }