SkRect to gfx::Rect type conversions.

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 "cc/software_renderer.h"
 
 #include "cc/debug_border_draw_quad.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/tile_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 "ui/gfx/skia_util.h"
 #include <public/WebCompositorSoftwareOutputDevice.h>
 #include <public/WebImage.h>
 #include <public/WebSize.h>
 #include <public/WebTransformationMatrix.h>
 
 using WebKit::WebCompositorSoftwareOutputDevice;
 using WebKit::WebSize;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 namespace {
 
-SkRect toSkRect(const gfx::RectF& rect)
-{
-    return SkRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height());
-}
-
-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());
     flattened->set(3, m.m12());
     flattened->set(4, m.m22());
     flattened->set(5, m.m42());
     flattened->set(6, m.m14());
@@ skipping 80 matching lines @@
     m_currentFramebufferLock = make_scoped_ptr(new ResourceProvider::ScopedWriteLockSoftware(m_resourceProvider, texture->id()));
     m_skCurrentCanvas = m_currentFramebufferLock->skCanvas();
     initializeMatrices(frame, framebufferRect, false);
     setDrawViewportSize(framebufferRect.size());
 
     return true;
 }
 
 void SoftwareRenderer::enableScissorTestRect(const gfx::Rect& scissorRect)
 {
-    m_skCurrentCanvas->clipRect(toSkRect(scissorRect), SkRegion::kReplace_Op);
+    m_skCurrentCanvas->clipRect(gfx::RectFToSkRect(scissorRect), SkRegion::kReplace_Op);
 }
 
 void SoftwareRenderer::disableScissorTest()
 {
     gfx::Rect canvasRect(gfx::Point(), viewportSize());
-    m_skCurrentCanvas->clipRect(toSkRect(canvasRect), SkRegion::kReplace_Op);
+    m_skCurrentCanvas->clipRect(gfx::RectFToSkRect(canvasRect), SkRegion::kReplace_Op);
 }
 
 void SoftwareRenderer::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));
@@ skipping 60 matching lines @@
         break;
     }
 
     m_skCurrentCanvas->resetMatrix();
 }
 
 void SoftwareRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorderDrawQuad* quad)
 {
     // We need to apply the matrix manually to have pixel-sized stroke width.
     SkPoint vertices[4];
-    toSkRect(quadVertexRect()).toQuad(vertices);
+    gfx::RectFToSkRect(quadVertexRect()).toQuad(vertices);
     SkPoint transformedVertices[4];
     m_skCurrentCanvas->getTotalMatrix().mapPoints(transformedVertices, vertices, 4);
     m_skCurrentCanvas->resetMatrix();
 
     m_skCurrentPaint.setColor(quad->color());
     m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color()));
     m_skCurrentPaint.setStyle(SkPaint::kStroke_Style);
     m_skCurrentPaint.setStrokeWidth(quad->width());
     m_skCurrentCanvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, transformedVertices, m_skCurrentPaint);
 }
 
 void SoftwareRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
 {
     m_skCurrentPaint.setColor(quad->color());
     m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color()));
-    m_skCurrentCanvas->drawRect(toSkRect(quadVertexRect()), m_skCurrentPaint);
+    m_skCurrentCanvas->drawRect(gfx::RectFToSkRect(quadVertexRect()), m_skCurrentPaint);
 }
 
 void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
 {
     if (!isSoftwareResource(quad->resourceId())) {
         drawUnsupportedQuad(frame, quad);
         return;
     }
 
     // FIXME: Add support for non-premultiplied alpha.
     ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId());
     const SkBitmap* bitmap = lock.skBitmap();
     gfx::RectF uvRect = gfx::ScaleRect(quad->uvRect(), bitmap->width(), bitmap->height());
-    SkIRect skUvRect = toSkIRect(gfx::ToEnclosingRect(uvRect));
+    SkIRect skUvRect = gfx::RectToSkIRect(gfx::ToEnclosingRect(uvRect));
     if (quad->flipped())
         m_skCurrentCanvas->scale(1, -1);
-    m_skCurrentCanvas->drawBitmapRect(*bitmap, &skUvRect, toSkRect(quadVertexRect()), &m_skCurrentPaint);
+    m_skCurrentCanvas->drawBitmapRect(*bitmap, &skUvRect, gfx::RectFToSkRect(quadVertexRect()), &m_skCurrentPaint);
 }
 
 void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad)
 {
     DCHECK(isSoftwareResource(quad->resourceId()));
     ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId());
 
-    SkIRect uvRect = toSkIRect(gfx::Rect(quad->textureOffset(), quad->quadRect().size()));
-    m_skCurrentCanvas->drawBitmapRect(*lock.skBitmap(), &uvRect, toSkRect(quadVertexRect()), &m_skCurrentPaint);
+    SkIRect uvRect = gfx::RectToSkIRect(gfx::Rect(quad->textureOffset(), quad->quadRect().size()));
+    m_skCurrentCanvas->drawBitmapRect(*lock.skBitmap(), &uvRect, gfx::RectFToSkRect(quadVertexRect()), &m_skCurrentPaint);
 }
 
 void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
     CachedTexture* contentTexture = m_renderPassTextures.get(quad->renderPassId());
     if (!contentTexture || !contentTexture->id())
         return;
 
     DCHECK(isSoftwareResource(contentTexture->id()));
     ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, contentTexture->id());
 
-    SkRect destRect = toSkRect(quadVertexRect());
+    SkRect destRect = gfx::RectFToSkRect(quadVertexRect());
 
     const SkBitmap* content = lock.skBitmap();
 
     SkRect contentRect;
     content->getBounds(&contentRect);
 
     SkMatrix contentMat;
     contentMat.setRectToRect(contentRect, destRect, SkMatrix::kFill_ScaleToFit);
 
     SkAutoTUnref<SkShader> shader(SkShader::CreateBitmapShader(*content,
@@ skipping 32 matching lines @@
     } else {
         // FIXME: Apply background filters and blend with content
         m_skCurrentCanvas->drawRect(destRect, m_skCurrentPaint);
     }
 }
 
 void SoftwareRenderer::drawUnsupportedQuad(const DrawingFrame& frame, const DrawQuad* quad)
 {
     m_skCurrentPaint.setColor(SK_ColorMAGENTA);
     m_skCurrentPaint.setAlpha(quad->opacity() * 255);
-    m_skCurrentCanvas->drawRect(toSkRect(quadVertexRect()), m_skCurrentPaint);
+    m_skCurrentCanvas->drawRect(gfx::RectFToSkRect(quadVertexRect()), m_skCurrentPaint);
 }
 
 bool SoftwareRenderer::swapBuffers()
 {
     if (Proxy::hasImplThread())
         m_client->onSwapBuffersComplete();
     return true;
 }
 
 void SoftwareRenderer::getFramebufferPixels(void *pixels, const IntRect& rect)
 {
     SkBitmap fullBitmap = m_outputDevice->lock(false)->getSkBitmap();
     SkBitmap subsetBitmap;
     SkIRect invertRect = SkIRect::MakeXYWH(rect.x(), viewportSize().height() - rect.maxY(), rect.width(), rect.height());
     fullBitmap.extractSubset(&subsetBitmap, invertRect);
     subsetBitmap.copyPixelsTo(pixels, rect.width() * rect.height() * 4, rect.width() * 4);
     m_outputDevice->unlock();
 }
 
 void SoftwareRenderer::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 }
 
 }