[SCM] WebKit Debian packaging branch, debian/experimental, updated. upstream/1.3.3-9427-gc2be6fc
commit-queue at webkit.org
commit-queue at webkit.org
Wed Dec 22 12:11:04 UTC 2010
The following commit has been merged in the debian/experimental branch:
commit 9102299615da7563eae8fe88ccb716b15a70944d
Author: commit-queue at webkit.org <commit-queue at webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Mon Aug 16 21:36:52 2010 +0000
2010-08-16 Vincent Scheib <scheib at chromium.org>
Reviewed by Dimitri Glazkov.
Canvas2D does not support images larger than system's GPU max texture size
https://bugs.webkit.org/show_bug.cgi?id=43864
A new class "TilingData" has been created that provides logic for
splitting a large image into a series of smaller tiles.
GLES2Texture and CLES2Canvas are modified to use the TilingData to
split images on texture upload and render one logical image as many smaller
images.
TilingData is tested via unit tests in WebKit/chromium/tests/TilingDataTest.cpp
* WebCore.gypi:
* platform/graphics/chromium/GLES2Canvas.cpp:
(WebCore::GLES2Canvas::drawTexturedRect):
(WebCore::GLES2Canvas::drawTexturedRectTile):
* platform/graphics/chromium/GLES2Canvas.h:
* platform/graphics/chromium/GLES2Texture.cpp:
(WebCore::GLES2Texture::GLES2Texture):
(WebCore::GLES2Texture::~GLES2Texture):
(WebCore::GLES2Texture::create):
(WebCore::copySubRect):
(WebCore::GLES2Texture::load):
(WebCore::GLES2Texture::bindTile):
* platform/graphics/chromium/GLES2Texture.h:
(WebCore::GLES2Texture::tiles):
* platform/graphics/chromium/TilingData.cpp: Added.
(WebCore::computeNumTiles):
(WebCore::TilingData::TilingData):
(WebCore::TilingData::tileXIndexFromSrcCoord):
(WebCore::TilingData::tileYIndexFromSrcCoord):
(WebCore::TilingData::tileBounds):
(WebCore::TilingData::tileBoundsWithBorder):
(WebCore::TilingData::tileBoundsNormalized):
(WebCore::TilingData::tilePositionX):
(WebCore::TilingData::tilePositionY):
(WebCore::TilingData::tileSizeX):
(WebCore::TilingData::tileSizeY):
(WebCore::TilingData::overlappedTileIndices):
(WebCore::TilingData::intersectDrawQuad):
* platform/graphics/chromium/TilingData.h: Added.
(WebCore::TilingData::maxTextureSize):
(WebCore::TilingData::totalSizeX):
(WebCore::TilingData::totalSizeY):
(WebCore::TilingData::numTiles):
(WebCore::TilingData::numTilesX):
(WebCore::TilingData::numTilesY):
(WebCore::TilingData::tileIndex):
(WebCore::TilingData::tileXIndex):
(WebCore::TilingData::tileYIndex):
(WebCore::TilingData::TilingData):
(WebCore::TilingData::assertTile):
* platform/graphics/skia/ImageSkia.cpp:
(WebCore::BitmapImage::draw):
* platform/graphics/skia/PlatformContextSkia.cpp:
(WebCore::PlatformContextSkia::uploadSoftwareToHardware):
2010-08-16 Vincent Scheib <scheib at chromium.org>
Reviewed by Dimitri Glazkov.
Canvas2D does not support images larger than system's GPU max texture size
https://bugs.webkit.org/show_bug.cgi?id=43864
Unit tests for TilingData class.
* WebKit.gyp:
* tests/TilingDataTest.cpp: Added.
(WebCore::TEST):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@65455 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index a5bbc74..87cdadd 100644
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,64 @@
+2010-08-16 Vincent Scheib <scheib at chromium.org>
+
+ Reviewed by Dimitri Glazkov.
+
+ Canvas2D does not support images larger than system's GPU max texture size
+ https://bugs.webkit.org/show_bug.cgi?id=43864
+
+ A new class "TilingData" has been created that provides logic for
+ splitting a large image into a series of smaller tiles.
+
+ GLES2Texture and CLES2Canvas are modified to use the TilingData to
+ split images on texture upload and render one logical image as many smaller
+ images.
+
+ TilingData is tested via unit tests in WebKit/chromium/tests/TilingDataTest.cpp
+
+ * WebCore.gypi:
+ * platform/graphics/chromium/GLES2Canvas.cpp:
+ (WebCore::GLES2Canvas::drawTexturedRect):
+ (WebCore::GLES2Canvas::drawTexturedRectTile):
+ * platform/graphics/chromium/GLES2Canvas.h:
+ * platform/graphics/chromium/GLES2Texture.cpp:
+ (WebCore::GLES2Texture::GLES2Texture):
+ (WebCore::GLES2Texture::~GLES2Texture):
+ (WebCore::GLES2Texture::create):
+ (WebCore::copySubRect):
+ (WebCore::GLES2Texture::load):
+ (WebCore::GLES2Texture::bindTile):
+ * platform/graphics/chromium/GLES2Texture.h:
+ (WebCore::GLES2Texture::tiles):
+ * platform/graphics/chromium/TilingData.cpp: Added.
+ (WebCore::computeNumTiles):
+ (WebCore::TilingData::TilingData):
+ (WebCore::TilingData::tileXIndexFromSrcCoord):
+ (WebCore::TilingData::tileYIndexFromSrcCoord):
+ (WebCore::TilingData::tileBounds):
+ (WebCore::TilingData::tileBoundsWithBorder):
+ (WebCore::TilingData::tileBoundsNormalized):
+ (WebCore::TilingData::tilePositionX):
+ (WebCore::TilingData::tilePositionY):
+ (WebCore::TilingData::tileSizeX):
+ (WebCore::TilingData::tileSizeY):
+ (WebCore::TilingData::overlappedTileIndices):
+ (WebCore::TilingData::intersectDrawQuad):
+ * platform/graphics/chromium/TilingData.h: Added.
+ (WebCore::TilingData::maxTextureSize):
+ (WebCore::TilingData::totalSizeX):
+ (WebCore::TilingData::totalSizeY):
+ (WebCore::TilingData::numTiles):
+ (WebCore::TilingData::numTilesX):
+ (WebCore::TilingData::numTilesY):
+ (WebCore::TilingData::tileIndex):
+ (WebCore::TilingData::tileXIndex):
+ (WebCore::TilingData::tileYIndex):
+ (WebCore::TilingData::TilingData):
+ (WebCore::TilingData::assertTile):
+ * platform/graphics/skia/ImageSkia.cpp:
+ (WebCore::BitmapImage::draw):
+ * platform/graphics/skia/PlatformContextSkia.cpp:
+ (WebCore::PlatformContextSkia::uploadSoftwareToHardware):
+
2010-08-16 David Hyatt <hyatt at apple.com>
Reviewed by Anders Carlsson.
diff --git a/WebCore/WebCore.gypi b/WebCore/WebCore.gypi
index bd1f1b6..270a4cd 100644
--- a/WebCore/WebCore.gypi
+++ b/WebCore/WebCore.gypi
@@ -2264,6 +2264,8 @@
'platform/graphics/chromium/PlatformIcon.h',
'platform/graphics/chromium/SimpleFontDataChromiumWin.cpp',
'platform/graphics/chromium/SimpleFontDataLinux.cpp',
+ 'platform/graphics/chromium/TilingData.h',
+ 'platform/graphics/chromium/TilingData.cpp',
'platform/graphics/chromium/TransformLayerChromium.cpp',
'platform/graphics/chromium/TransformLayerChromium.h',
'platform/graphics/chromium/TransparencyWin.cpp',
diff --git a/WebCore/platform/graphics/chromium/GLES2Canvas.cpp b/WebCore/platform/graphics/chromium/GLES2Canvas.cpp
index 8a9bde1..534de7b 100644
--- a/WebCore/platform/graphics/chromium/GLES2Canvas.cpp
+++ b/WebCore/platform/graphics/chromium/GLES2Canvas.cpp
@@ -38,14 +38,15 @@
#include "FloatRect.h"
#include "GLES2Texture.h"
#include "GraphicsContext3D.h"
+#include "IntRect.h"
#include "PlatformString.h"
#include "Uint16Array.h"
#define _USE_MATH_DEFINES
#include <math.h>
-#include <wtf/text/CString.h>
#include <wtf/OwnArrayPtr.h>
+#include <wtf/text/CString.h>
namespace WebCore {
@@ -221,7 +222,6 @@ void GLES2Canvas::drawTexturedRect(GLES2Texture* texture, const FloatRect& srcRe
checkGLError("glUseProgram");
m_context->activeTexture(GraphicsContext3D::TEXTURE0);
- texture->bind();
m_context->uniform1i(m_texSamplerLocation, 0);
checkGLError("glUniform1i");
@@ -229,28 +229,52 @@ void GLES2Canvas::drawTexturedRect(GLES2Texture* texture, const FloatRect& srcRe
m_context->uniform1f(m_texAlphaLocation, alpha);
checkGLError("glUniform1f for alpha");
+ m_context->vertexAttribPointer(m_texPositionLocation, 3, GraphicsContext3D::FLOAT, false, 0, 0);
+
+ m_context->enableVertexAttribArray(m_texPositionLocation);
+
+ const TilingData& tiles = texture->tiles();
+ IntRect tileIdxRect = tiles.overlappedTileIndices(srcRect);
+
+ for (int y = tileIdxRect.y(); y <= tileIdxRect.bottom(); y++) {
+ for (int x = tileIdxRect.x(); x <= tileIdxRect.right(); x++)
+ drawTexturedRectTile(texture, tiles.tileIndex(x, y), srcRect, dstRect, transform);
+ }
+}
+
+void GLES2Canvas::drawTexturedRectTile(GLES2Texture* texture, int tile, const FloatRect& srcRect, const FloatRect& dstRect, const AffineTransform& transform)
+{
+ if (dstRect.isEmpty())
+ return;
+
+ const TilingData& tiles = texture->tiles();
+
+ texture->bindTile(tile);
+
+ FloatRect srcRectClippedInTileSpace;
+ FloatRect dstRectIntersected;
+ tiles.intersectDrawQuad(srcRect, dstRect, tile, &srcRectClippedInTileSpace, &dstRectIntersected);
+
+ IntRect tileBoundsWithBorder = tiles.tileBoundsWithBorder(tile);
+
AffineTransform matrix(m_flipMatrix);
matrix.multLeft(transform);
- matrix.translate(dstRect.x(), dstRect.y());
- matrix.scale(dstRect.width(), dstRect.height());
+ matrix.translate(dstRectIntersected.x(), dstRectIntersected.y());
+ matrix.scale(dstRectIntersected.width(), dstRectIntersected.height());
float mat[9];
affineTo3x3(matrix, mat);
m_context->uniformMatrix3fv(m_texMatrixLocation, false /*transpose*/, mat, 1 /*count*/);
checkGLError("glUniformMatrix3fv");
AffineTransform texMatrix;
- texMatrix.scale(1.0f / texture->width(), 1.0f / texture->height());
- texMatrix.translate(srcRect.x(), srcRect.y());
- texMatrix.scale(srcRect.width(), srcRect.height());
+ texMatrix.scale(1.0f / tileBoundsWithBorder.width(), 1.0f / tileBoundsWithBorder.height());
+ texMatrix.translate(srcRectClippedInTileSpace.x(), srcRectClippedInTileSpace.y());
+ texMatrix.scale(srcRectClippedInTileSpace.width(), srcRectClippedInTileSpace.height());
float texMat[9];
affineTo3x3(texMatrix, texMat);
m_context->uniformMatrix3fv(m_texTexMatrixLocation, false /*transpose*/, texMat, 1 /*count*/);
checkGLError("glUniformMatrix3fv");
- m_context->vertexAttribPointer(m_texPositionLocation, 3, GraphicsContext3D::FLOAT, false, 0, 0);
-
- m_context->enableVertexAttribArray(m_texPositionLocation);
-
m_context->drawElements(GraphicsContext3D::TRIANGLES, 6, GraphicsContext3D::UNSIGNED_SHORT, 0);
checkGLError("glDrawElements");
}
diff --git a/WebCore/platform/graphics/chromium/GLES2Canvas.h b/WebCore/platform/graphics/chromium/GLES2Canvas.h
index cea90ae..0ad07fc 100644
--- a/WebCore/platform/graphics/chromium/GLES2Canvas.h
+++ b/WebCore/platform/graphics/chromium/GLES2Canvas.h
@@ -81,6 +81,7 @@ public:
GLES2Texture* getTexture(NativeImagePtr);
private:
+ void drawTexturedRectTile(GLES2Texture* texture, int tile, const FloatRect& srcRect, const FloatRect& dstRect, const AffineTransform&);
void applyCompositeOperator(CompositeOperator);
void checkGLError(const char* header);
unsigned getQuadVertices();
diff --git a/WebCore/platform/graphics/chromium/GLES2Texture.cpp b/WebCore/platform/graphics/chromium/GLES2Texture.cpp
index 8b72aa8..ae230db 100644
--- a/WebCore/platform/graphics/chromium/GLES2Texture.cpp
+++ b/WebCore/platform/graphics/chromium/GLES2Texture.cpp
@@ -35,23 +35,24 @@
#include "GLES2Texture.h"
#include "GraphicsContext3D.h"
-
+#include "IntRect.h"
#include <wtf/OwnArrayPtr.h>
namespace WebCore {
-GLES2Texture::GLES2Texture(GraphicsContext3D* context, unsigned textureId, Format format, int width, int height)
+
+GLES2Texture::GLES2Texture(GraphicsContext3D* context, PassOwnPtr<Vector<unsigned int> > tileTextureIds, Format format, int width, int height, int maxTextureSize)
: m_context(context)
- , m_textureId(textureId)
, m_format(format)
- , m_width(width)
- , m_height(height)
+ , m_tiles(maxTextureSize, width, height, true)
+ , m_tileTextureIds(tileTextureIds)
{
}
GLES2Texture::~GLES2Texture()
{
- m_context->deleteTexture(m_textureId);
+ for (unsigned int i = 0; i < m_tileTextureIds->size(); i++)
+ m_context->deleteTexture(m_tileTextureIds->at(i));
}
static void convertFormat(GraphicsContext3D* context, GLES2Texture::Format format, unsigned int* glFormat, unsigned int* glType, bool* swizzle)
@@ -80,51 +81,96 @@ static void convertFormat(GraphicsContext3D* context, GLES2Texture::Format forma
PassRefPtr<GLES2Texture> GLES2Texture::create(GraphicsContext3D* context, Format format, int width, int height)
{
- int max;
- context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &max);
- if (width > max || height > max) {
- ASSERT(!"texture too big");
- return 0;
- }
+ int maxTextureSize = 0;
+ context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &maxTextureSize);
- unsigned textureId = context->createTexture();
- if (!textureId)
- return 0;
+ TilingData tiling(maxTextureSize, width, height, true);
+ int numTiles = tiling.numTiles();
+
+ OwnPtr<Vector<unsigned int> > textureIds(new Vector<unsigned int>(numTiles));
+ textureIds->fill(0, numTiles);
+
+ for (int i = 0; i < numTiles; i++) {
+ int textureId = context->createTexture();
+ if (!textureId) {
+ for (int i = 0; i < numTiles; i++)
+ context->deleteTexture(textureIds->at(i));
+ return 0;
+ }
+ textureIds->at(i) = textureId;
+
+ IntRect tileBoundsWithBorder = tiling.tileBoundsWithBorder(i);
unsigned int glFormat, glType;
bool swizzle;
convertFormat(context, format, &glFormat, &glType, &swizzle);
context->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId);
- context->texImage2D(GraphicsContext3D::TEXTURE_2D, 0, glFormat, width, height, 0, glFormat, glType, 0);
+ context->texImage2D(GraphicsContext3D::TEXTURE_2D, 0, glFormat,
+ tileBoundsWithBorder.width(),
+ tileBoundsWithBorder.height(),
+ 0, glFormat, glType, 0);
+ }
+ return adoptRef(new GLES2Texture(context, textureIds.leakPtr(), format, width, height, maxTextureSize));
+}
- return adoptRef(new GLES2Texture(context, textureId, format, width, height));
+template <bool swizzle>
+static uint32_t* copySubRect(uint32_t* src, int srcX, int srcY, uint32_t* dst, int width, int height, int srcStride)
+{
+ uint32_t* srcOffset = src + srcX + srcY * srcStride;
+
+ if (!swizzle && width == srcStride)
+ return srcOffset;
+
+ uint32_t* dstPixel = dst;
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width ; x++) {
+ uint32_t pixel = srcOffset[x + y * srcStride];
+ if (swizzle)
+ *dstPixel = pixel & 0xFF00FF00 | ((pixel & 0x00FF0000) >> 16) | ((pixel & 0x000000FF) << 16);
+ else
+ *dstPixel = pixel;
+ dstPixel++;
+ }
+ }
+ return dst;
}
void GLES2Texture::load(void* pixels)
{
+ uint32_t* pixels32 = static_cast<uint32_t*>(pixels);
unsigned int glFormat, glType;
bool swizzle;
convertFormat(m_context, m_format, &glFormat, &glType, &swizzle);
- m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, m_textureId);
if (swizzle) {
ASSERT(glFormat == GraphicsContext3D::RGBA && glType == GraphicsContext3D::UNSIGNED_BYTE);
// FIXME: This could use PBO's to save doing an extra copy here.
- int size = m_width * m_height;
- unsigned* pixels32 = static_cast<unsigned*>(pixels);
- OwnArrayPtr<unsigned> buf(new unsigned[size]);
- unsigned* bufptr = buf.get();
- for (int i = 0; i < size; ++i) {
- unsigned pixel = pixels32[i];
- bufptr[i] = pixel & 0xFF00FF00 | ((pixel & 0x00FF0000) >> 16) | ((pixel & 0x000000FF) << 16);
+ }
+ OwnArrayPtr<uint32_t> tempBuff(new uint32_t[m_tiles.maxTextureSize() * m_tiles.maxTextureSize()]);
+
+ for (int i = 0; i < m_tiles.numTiles(); i++) {
+ IntRect tileBoundsWithBorder = m_tiles.tileBoundsWithBorder(i);
+
+ uint32_t* uploadBuff = 0;
+ if (swizzle) {
+ uploadBuff = copySubRect<true>(
+ pixels32, tileBoundsWithBorder.x(), tileBoundsWithBorder.y(),
+ tempBuff.get(), tileBoundsWithBorder.width(), tileBoundsWithBorder.height(), m_tiles.totalSizeX());
+ } else {
+ uploadBuff = copySubRect<false>(
+ pixels32, tileBoundsWithBorder.x(), tileBoundsWithBorder.y(),
+ tempBuff.get(), tileBoundsWithBorder.width(), tileBoundsWithBorder.height(), m_tiles.totalSizeX());
}
- m_context->texSubImage2D(GraphicsContext3D::TEXTURE_2D, 0, 0, 0, m_width, m_height, glFormat, glType, buf.get());
- } else
- m_context->texSubImage2D(GraphicsContext3D::TEXTURE_2D, 0, 0, 0, m_width, m_height, glFormat, glType, pixels);
+
+ m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, m_tileTextureIds->at(i));
+ m_context->texSubImage2D(GraphicsContext3D::TEXTURE_2D, 0, 0, 0,
+ tileBoundsWithBorder.width(),
+ tileBoundsWithBorder.height(), glFormat, glType, uploadBuff);
+ }
}
-void GLES2Texture::bind()
+void GLES2Texture::bindTile(int tile)
{
- m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, m_textureId);
+ m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, m_tileTextureIds->at(tile));
m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR);
m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR);
m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE);
diff --git a/WebCore/platform/graphics/chromium/GLES2Texture.h b/WebCore/platform/graphics/chromium/GLES2Texture.h
index 4d351cd..43a4955 100644
--- a/WebCore/platform/graphics/chromium/GLES2Texture.h
+++ b/WebCore/platform/graphics/chromium/GLES2Texture.h
@@ -35,6 +35,10 @@
#include "RefCounted.h"
#include "RefPtr.h"
+#include "TilingData.h"
+#include <wtf/OwnPtr.h>
+#include <wtf/PassOwnPtr.h>
+#include <wtf/Vector.h>
namespace WebCore {
class GraphicsContext3D;
@@ -44,18 +48,16 @@ public:
~GLES2Texture();
enum Format { RGBA8, BGRA8 };
static PassRefPtr<GLES2Texture> create(GraphicsContext3D*, Format, int width, int height);
- void bind();
+ void bindTile(int tile);
void load(void* pixels);
Format format() const { return m_format; }
- int width() const { return m_width; }
- int height() const { return m_height; }
+ const TilingData& tiles() const { return m_tiles; }
private:
- GLES2Texture(GraphicsContext3D*, unsigned textureId, Format, int width, int height);
+ GLES2Texture(GraphicsContext3D*, PassOwnPtr<Vector<unsigned int> > tileTextureIds, Format format, int width, int height, int maxTextureSize);
GraphicsContext3D* m_context;
- unsigned m_textureId;
Format m_format;
- int m_width;
- int m_height;
+ TilingData m_tiles;
+ OwnPtr<Vector<unsigned int> > m_tileTextureIds;
};
}
diff --git a/WebCore/platform/graphics/chromium/TilingData.cpp b/WebCore/platform/graphics/chromium/TilingData.cpp
new file mode 100755
index 0000000..c52288d
--- /dev/null
+++ b/WebCore/platform/graphics/chromium/TilingData.cpp
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2010, Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "TilingData.h"
+
+#include "FloatRect.h"
+#include "IntRect.h"
+#include <algorithm>
+
+using namespace std;
+
+namespace WebCore {
+
+static int computeNumTiles(int maxTextureSize, int totalSize, int borderTexels)
+{
+ return max(1, 1 + (totalSize - 1 - 2 * borderTexels) / (maxTextureSize - 2 * borderTexels));
+}
+
+TilingData::TilingData(int maxTextureSize, int totalSizeX, int totalSizeY, bool hasBorderTexels)
+ : m_maxTextureSize(maxTextureSize)
+ , m_totalSizeX(totalSizeX)
+ , m_totalSizeY(totalSizeY)
+ , m_borderTexels(hasBorderTexels ? 1 : 0)
+{
+ m_numTilesX = computeNumTiles(maxTextureSize, m_totalSizeX, m_borderTexels);
+ m_numTilesY = computeNumTiles(maxTextureSize, m_totalSizeY, m_borderTexels);
+}
+
+int TilingData::tileXIndexFromSrcCoord(int srcPos) const
+{
+ int x = (srcPos - m_borderTexels) / (m_maxTextureSize - 2 * m_borderTexels);
+ return min(max(x, 0), numTilesX() - 1);
+}
+
+int TilingData::tileYIndexFromSrcCoord(int srcPos) const
+{
+ int y = (srcPos - m_borderTexels) / (m_maxTextureSize - 2 * m_borderTexels);
+ return min(max(y, 0), numTilesY() - 1);
+}
+
+IntRect TilingData::tileBounds(int tile) const
+{
+ assertTile(tile);
+ int ix = tileXIndex(tile);
+ int iy = tileYIndex(tile);
+ int x = tilePositionX(ix);
+ int y = tilePositionY(iy);
+ int width = tileSizeX(ix);
+ int height = tileSizeY(iy);
+ ASSERT(x >= 0 && y >= 0 && width >= 0 && height >= 0);
+ ASSERT(x <= totalSizeX() && y <= totalSizeY());
+ return IntRect(x, y, width, height);
+}
+
+IntRect TilingData::tileBoundsWithBorder(int tile) const
+{
+ IntRect bounds = tileBounds(tile);
+
+ if (m_borderTexels) {
+ int x1 = bounds.x();
+ int x2 = bounds.right();
+ int y1 = bounds.y();
+ int y2 = bounds.bottom();
+
+ if (tileXIndex(tile) > 0)
+ x1--;
+ if (tileXIndex(tile) < (numTilesX() - 1))
+ x2++;
+ if (tileYIndex(tile) > 0)
+ y1--;
+ if (tileYIndex(tile) < (numTilesY() - 1))
+ y2++;
+
+ bounds = IntRect(x1, y1, x2 - x1, y2 - y1);
+ }
+
+ return bounds;
+}
+
+FloatRect TilingData::tileBoundsNormalized(int tile) const
+{
+ assertTile(tile);
+ FloatRect bounds(tileBounds(tile));
+ bounds.scale(1.0f / m_totalSizeX, 1.0f / m_totalSizeY);
+ return bounds;
+}
+
+int TilingData::tilePositionX(int xIndex) const
+{
+ ASSERT(xIndex >= 0 && xIndex < numTilesX());
+
+ if (!xIndex)
+ return 0;
+ return tilePositionX(xIndex - 1) + tileSizeX(xIndex - 1);
+}
+
+int TilingData::tilePositionY(int yIndex) const
+{
+ ASSERT(yIndex >= 0 && yIndex < numTilesY());
+
+ if (!yIndex)
+ return 0;
+ return tilePositionX(yIndex - 1) + tileSizeY(yIndex - 1);
+}
+
+int TilingData::tileSizeX(int xIndex) const
+{
+ ASSERT(xIndex >= 0 && xIndex < numTilesX());
+
+ int size = maxTextureSize();
+ size = min(size, totalSizeX());
+
+ if (!xIndex && m_numTilesX == 1)
+ return m_totalSizeX;
+ if (!xIndex && m_numTilesX > 1)
+ return m_maxTextureSize - m_borderTexels;
+ if (xIndex < numTilesX() - 1)
+ return m_maxTextureSize - 2 * m_borderTexels;
+ if (xIndex == numTilesX() - 1)
+ return m_totalSizeX - tilePositionX(xIndex);
+
+ ASSERT_NOT_REACHED();
+ return 0;
+}
+
+int TilingData::tileSizeY(int yIndex) const
+{
+ ASSERT(yIndex >= 0 && yIndex < numTilesY());
+
+ int size = maxTextureSize();
+ size = min(size, totalSizeY());
+
+ if (!yIndex && m_numTilesY == 1)
+ return m_totalSizeY;
+ if (!yIndex && m_numTilesY > 1)
+ return m_maxTextureSize - m_borderTexels;
+ if (yIndex < numTilesY() - 1)
+ return m_maxTextureSize - 2 * m_borderTexels;
+ if (yIndex == numTilesY() - 1)
+ return m_totalSizeY - tilePositionY(yIndex);
+
+ ASSERT_NOT_REACHED();
+ return 0;
+}
+
+IntRect TilingData::overlappedTileIndices(const WebCore::IntRect &srcRect) const
+{
+ int x = tileXIndexFromSrcCoord(srcRect.x());
+ int y = tileYIndexFromSrcCoord(srcRect.y());
+ int r = tileXIndexFromSrcCoord(srcRect.right());
+ int b = tileYIndexFromSrcCoord(srcRect.bottom());
+ return IntRect(x, y, r - x, b - y);
+}
+
+IntRect TilingData::overlappedTileIndices(const WebCore::FloatRect &srcRect) const
+{
+ return overlappedTileIndices(enclosingIntRect(srcRect));
+}
+
+void TilingData::intersectDrawQuad(const FloatRect& srcRect, const FloatRect& dstRect, int tile,
+ FloatRect* newSrc, FloatRect* newDst) const
+{
+ // Intersect with tile
+ FloatRect tileBounds = this->tileBounds(tile);
+ FloatRect srcRectIntersected = srcRect;
+ srcRectIntersected.intersect(tileBounds);
+
+ if (srcRectIntersected.isEmpty()) {
+ *newSrc = *newDst = FloatRect(0, 0, 0, 0);
+ return;
+ }
+
+ float srcRectIntersectedNormX = (srcRectIntersected.x() - srcRect.x()) / srcRect.width();
+ float srcRectIntersectedNormY = (srcRectIntersected.y() - srcRect.y()) / srcRect.height();
+ float srcRectIntersectedNormW = srcRectIntersected.width() / srcRect.width();
+ float srcRectIntersectedNormH = srcRectIntersected.height() / srcRect.height();
+
+ *newSrc = srcRectIntersected;
+ newSrc->move(
+ -tileBounds.x() + ((tileXIndex(tile) > 0) ? m_borderTexels : 0),
+ -tileBounds.y() + ((tileYIndex(tile) > 0) ? m_borderTexels : 0));
+
+ *newDst = FloatRect(
+ srcRectIntersectedNormX * dstRect.width() + dstRect.x(),
+ srcRectIntersectedNormY * dstRect.height() + dstRect.y(),
+ srcRectIntersectedNormW * dstRect.width(),
+ srcRectIntersectedNormH * dstRect.height());
+}
+
+}
diff --git a/WebCore/platform/graphics/chromium/TilingData.h b/WebCore/platform/graphics/chromium/TilingData.h
new file mode 100755
index 0000000..f12e66e
--- /dev/null
+++ b/WebCore/platform/graphics/chromium/TilingData.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2010, Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TilingData_h
+#define TilingData_h
+
+#include <wtf/Noncopyable.h>
+
+namespace WebCore {
+
+class FloatRect;
+class IntRect;
+
+class TilingData : public Noncopyable {
+public:
+ TilingData(int maxTextureSize, int totalSizeX, int totalSizeY, bool hasBorderTexels);
+ int maxTextureSize() const { return m_maxTextureSize; }
+ int totalSizeX() const { return m_totalSizeX; }
+ int totalSizeY() const { return m_totalSizeY; }
+
+ int numTiles() const { return numTilesX() * numTilesY(); }
+ int numTilesX() const { return m_numTilesX; }
+ int numTilesY() const { return m_numTilesY; }
+ int tileIndex(int x, int y) const { return x + y * numTilesX(); }
+ int tileXIndex(int tile) const { assertTile(tile); return tile % numTilesX(); }
+ int tileYIndex(int tile) const { assertTile(tile); return tile / numTilesX(); }
+ int tileXIndexFromSrcCoord(int) const;
+ int tileYIndexFromSrcCoord(int) const;
+
+ IntRect tileBounds(int tile) const;
+ IntRect tileBoundsWithBorder(int tile) const;
+ FloatRect tileBoundsNormalized(int tile) const;
+ int tilePositionX(int xIndex) const;
+ int tilePositionY(int yIndex) const;
+ int tileSizeX(int xIndex) const;
+ int tileSizeY(int yIndex) const;
+ IntRect overlappedTileIndices(const IntRect& srcRect) const;
+ IntRect overlappedTileIndices(const FloatRect& srcRect) const;
+
+ // Given a set of source and destination coordinates for a drawing quad
+ // in texel units, returns adjusted data to render just the one tile.
+ void intersectDrawQuad(const FloatRect& srcRect, const FloatRect& dstRect, int tile, FloatRect* newSrc, FloatRect* newDst) const;
+
+private:
+ TilingData() : m_maxTextureSize(0), m_totalSizeX(0), m_totalSizeY(0) {}
+ void assertTile(int tile) const { ASSERT(tile >= 0 && tile < numTiles()); }
+
+ int m_maxTextureSize;
+ int m_totalSizeX;
+ int m_totalSizeY;
+ int m_borderTexels; // 0 or 1
+
+ // computed values:
+ int m_numTilesX;
+ int m_numTilesY;
+};
+
+}
+
+#endif // TilingData_h
diff --git a/WebCore/platform/graphics/skia/ImageSkia.cpp b/WebCore/platform/graphics/skia/ImageSkia.cpp
index 024bf50..b514b1a 100644
--- a/WebCore/platform/graphics/skia/ImageSkia.cpp
+++ b/WebCore/platform/graphics/skia/ImageSkia.cpp
@@ -465,18 +465,18 @@ void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dstRect,
if (!bm)
return; // It's too early and we don't have an image yet.
-#if USE(GLES2_RENDERING)
- if (ctxt->platformContext()->useGPU()) {
- drawBitmapGLES2(ctxt, bm, srcRect, dstRect, colorSpace, compositeOp);
- return;
- }
-#endif
FloatRect normDstRect = normalizeRect(dstRect);
FloatRect normSrcRect = normalizeRect(srcRect);
if (normSrcRect.isEmpty() || normDstRect.isEmpty())
return; // Nothing to draw.
+#if USE(GLES2_RENDERING)
+ if (ctxt->platformContext()->useGPU()) {
+ drawBitmapGLES2(ctxt, bm, normSrcRect, normDstRect, colorSpace, compositeOp);
+ return;
+ }
+#endif
ctxt->platformContext()->prepareForSoftwareDraw();
paintSkBitmap(ctxt->platformContext(),
diff --git a/WebCore/platform/graphics/skia/PlatformContextSkia.cpp b/WebCore/platform/graphics/skia/PlatformContextSkia.cpp
index e42dd71..1161224 100644
--- a/WebCore/platform/graphics/skia/PlatformContextSkia.cpp
+++ b/WebCore/platform/graphics/skia/PlatformContextSkia.cpp
@@ -39,6 +39,7 @@
#include "NativeImageSkia.h"
#include "PlatformContextSkia.h"
#include "SkiaUtils.h"
+#include "TilingData.h"
#include "skia/ext/image_operations.h"
#include "skia/ext/platform_canvas.h"
@@ -793,7 +794,7 @@ void PlatformContextSkia::uploadSoftwareToHardware(CompositeOperator op) const
const SkBitmap& bitmap = m_canvas->getDevice()->accessBitmap(false);
SkAutoLockPixels lock(bitmap);
GraphicsContext3D* context = m_gpuCanvas->context();
- if (!m_uploadTexture || m_uploadTexture->width() < bitmap.width() || m_uploadTexture->height() < bitmap.height())
+ if (!m_uploadTexture || m_uploadTexture->tiles().totalSizeX() < bitmap.width() || m_uploadTexture->tiles().totalSizeY() < bitmap.height())
m_uploadTexture = GLES2Texture::create(context, GLES2Texture::BGRA8, bitmap.width(), bitmap.height());
m_uploadTexture->load(bitmap.getPixels());
IntRect rect(0, 0, bitmap.width(), bitmap.height());
diff --git a/WebKit/chromium/ChangeLog b/WebKit/chromium/ChangeLog
index 865eda1..4e6404b 100644
--- a/WebKit/chromium/ChangeLog
+++ b/WebKit/chromium/ChangeLog
@@ -1,3 +1,16 @@
+2010-08-16 Vincent Scheib <scheib at chromium.org>
+
+ Reviewed by Dimitri Glazkov.
+
+ Canvas2D does not support images larger than system's GPU max texture size
+ https://bugs.webkit.org/show_bug.cgi?id=43864
+
+ Unit tests for TilingData class.
+
+ * WebKit.gyp:
+ * tests/TilingDataTest.cpp: Added.
+ (WebCore::TEST):
+
2010-08-16 Alex Milowski <alex at milowski.com>
Reviewed by David Levin.
diff --git a/WebKit/chromium/WebKit.gyp b/WebKit/chromium/WebKit.gyp
index e58912e..b5d5293 100644
--- a/WebKit/chromium/WebKit.gyp
+++ b/WebKit/chromium/WebKit.gyp
@@ -711,6 +711,7 @@
'tests/KeyboardTest.cpp',
'tests/KURLTest.cpp',
'tests/RunAllTests.cpp',
+ 'tests/TilingDataTest.cpp',
],
'conditions': [
['OS=="win"', {
diff --git a/WebKit/chromium/tests/TilingDataTest.cpp b/WebKit/chromium/tests/TilingDataTest.cpp
new file mode 100755
index 0000000..463542b
--- /dev/null
+++ b/WebKit/chromium/tests/TilingDataTest.cpp
@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2010 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include "GLES2Texture.h"
+#include <gtest/gtest.h>
+
+using namespace WebCore;
+
+namespace {
+
+TEST(TilingDataTest, numTiles_NoTiling)
+{
+ EXPECT_EQ(1, TilingData(16, 16, 16, false).numTiles());
+ EXPECT_EQ(1, TilingData(16, 15, 15, true).numTiles());
+ EXPECT_EQ(1, TilingData(16, 16, 16, true).numTiles());
+ EXPECT_EQ(1, TilingData(16, 1, 16, false).numTiles());
+ EXPECT_EQ(1, TilingData(15, 15, 15, true).numTiles());
+}
+
+TEST(TilingDataTest, numTiles_TilingNoBorders)
+{
+ EXPECT_EQ(1, TilingData(4, 1, 4, false).numTiles());
+ EXPECT_EQ(1, TilingData(4, 2, 4, false).numTiles());
+ EXPECT_EQ(1, TilingData(4, 3, 4, false).numTiles());
+ EXPECT_EQ(1, TilingData(4, 4, 4, false).numTiles());
+ EXPECT_EQ(2, TilingData(4, 5, 4, false).numTiles());
+ EXPECT_EQ(2, TilingData(4, 6, 4, false).numTiles());
+ EXPECT_EQ(2, TilingData(4, 7, 4, false).numTiles());
+ EXPECT_EQ(2, TilingData(4, 8, 4, false).numTiles());
+ EXPECT_EQ(3, TilingData(4, 9, 4, false).numTiles());
+ EXPECT_EQ(3, TilingData(4, 10, 4, false).numTiles());
+ EXPECT_EQ(3, TilingData(4, 11, 4, false).numTiles());
+
+ EXPECT_EQ(1, TilingData(5, 1, 5, false).numTiles());
+ EXPECT_EQ(1, TilingData(5, 2, 5, false).numTiles());
+ EXPECT_EQ(1, TilingData(5, 3, 5, false).numTiles());
+ EXPECT_EQ(1, TilingData(5, 4, 5, false).numTiles());
+ EXPECT_EQ(1, TilingData(5, 5, 5, false).numTiles());
+ EXPECT_EQ(2, TilingData(5, 6, 5, false).numTiles());
+ EXPECT_EQ(2, TilingData(5, 7, 5, false).numTiles());
+ EXPECT_EQ(2, TilingData(5, 8, 5, false).numTiles());
+ EXPECT_EQ(2, TilingData(5, 9, 5, false).numTiles());
+ EXPECT_EQ(2, TilingData(5, 10, 5, false).numTiles());
+ EXPECT_EQ(3, TilingData(5, 11, 5, false).numTiles());
+
+ EXPECT_EQ(1, TilingData(16, 16, 16, false).numTiles());
+ EXPECT_EQ(1, TilingData(17, 16, 16, false).numTiles());
+ EXPECT_EQ(4, TilingData(15, 16, 16, false).numTiles());
+ EXPECT_EQ(4, TilingData(8, 16, 16, false).numTiles());
+ EXPECT_EQ(6, TilingData(8, 17, 16, false).numTiles());
+}
+
+TEST(TilingDataTest, numTiles_TilingWithBorders)
+{
+ EXPECT_EQ(1, TilingData(3, 1, 3, true).numTiles());
+ EXPECT_EQ(1, TilingData(3, 2, 3, true).numTiles());
+ EXPECT_EQ(1, TilingData(3, 3, 3, true).numTiles());
+ EXPECT_EQ(2, TilingData(3, 4, 3, true).numTiles());
+ EXPECT_EQ(3, TilingData(3, 5, 3, true).numTiles());
+ EXPECT_EQ(4, TilingData(3, 6, 3, true).numTiles());
+ EXPECT_EQ(5, TilingData(3, 7, 3, true).numTiles());
+
+ EXPECT_EQ(1, TilingData(4, 1, 4, true).numTiles());
+ EXPECT_EQ(1, TilingData(4, 2, 4, true).numTiles());
+ EXPECT_EQ(1, TilingData(4, 3, 4, true).numTiles());
+ EXPECT_EQ(1, TilingData(4, 4, 4, true).numTiles());
+ EXPECT_EQ(2, TilingData(4, 5, 4, true).numTiles());
+ EXPECT_EQ(2, TilingData(4, 6, 4, true).numTiles());
+ EXPECT_EQ(3, TilingData(4, 7, 4, true).numTiles());
+ EXPECT_EQ(3, TilingData(4, 8, 4, true).numTiles());
+ EXPECT_EQ(4, TilingData(4, 9, 4, true).numTiles());
+ EXPECT_EQ(4, TilingData(4, 10, 4, true).numTiles());
+ EXPECT_EQ(5, TilingData(4, 11, 4, true).numTiles());
+
+ EXPECT_EQ(1, TilingData(5, 1, 5, true).numTiles());
+ EXPECT_EQ(1, TilingData(5, 2, 5, true).numTiles());
+ EXPECT_EQ(1, TilingData(5, 3, 5, true).numTiles());
+ EXPECT_EQ(1, TilingData(5, 4, 5, true).numTiles());
+ EXPECT_EQ(1, TilingData(5, 5, 5, true).numTiles());
+ EXPECT_EQ(2, TilingData(5, 6, 5, true).numTiles());
+ EXPECT_EQ(2, TilingData(5, 7, 5, true).numTiles());
+ EXPECT_EQ(2, TilingData(5, 8, 5, true).numTiles());
+ EXPECT_EQ(3, TilingData(5, 9, 5, true).numTiles());
+ EXPECT_EQ(3, TilingData(5, 10, 5, true).numTiles());
+ EXPECT_EQ(3, TilingData(5, 11, 5, true).numTiles());
+}
+
+TEST(TilingDataTest, tileXIndexFromSrcCoord)
+{
+ EXPECT_EQ(0, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(0));
+ EXPECT_EQ(0, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(1));
+ EXPECT_EQ(0, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(2));
+ EXPECT_EQ(1, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(3));
+ EXPECT_EQ(1, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(4));
+ EXPECT_EQ(1, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(5));
+ EXPECT_EQ(2, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(6));
+ EXPECT_EQ(2, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(7));
+ EXPECT_EQ(2, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(8));
+ EXPECT_EQ(3, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(9));
+ EXPECT_EQ(3, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(10));
+ EXPECT_EQ(3, TilingData(3, 10, 10, false).tileXIndexFromSrcCoord(11));
+
+ EXPECT_EQ(0, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(0));
+ EXPECT_EQ(0, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(1));
+ EXPECT_EQ(1, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(2));
+ EXPECT_EQ(2, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(3));
+ EXPECT_EQ(3, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(4));
+ EXPECT_EQ(4, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(5));
+ EXPECT_EQ(5, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(6));
+ EXPECT_EQ(6, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(7));
+ EXPECT_EQ(7, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(8));
+ EXPECT_EQ(7, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(9));
+ EXPECT_EQ(7, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(10));
+ EXPECT_EQ(7, TilingData(3, 10, 10, true).tileXIndexFromSrcCoord(11));
+}
+TEST(TilingDataTest, tileYIndexFromSrcCoord)
+{
+ EXPECT_EQ(0, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(0));
+ EXPECT_EQ(0, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(1));
+ EXPECT_EQ(0, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(2));
+ EXPECT_EQ(1, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(3));
+ EXPECT_EQ(1, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(4));
+ EXPECT_EQ(1, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(5));
+ EXPECT_EQ(2, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(6));
+ EXPECT_EQ(2, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(7));
+ EXPECT_EQ(2, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(8));
+ EXPECT_EQ(3, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(9));
+ EXPECT_EQ(3, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(10));
+ EXPECT_EQ(3, TilingData(3, 10, 10, false).tileYIndexFromSrcCoord(11));
+
+ EXPECT_EQ(0, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(0));
+ EXPECT_EQ(0, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(1));
+ EXPECT_EQ(1, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(2));
+ EXPECT_EQ(2, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(3));
+ EXPECT_EQ(3, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(4));
+ EXPECT_EQ(4, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(5));
+ EXPECT_EQ(5, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(6));
+ EXPECT_EQ(6, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(7));
+ EXPECT_EQ(7, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(8));
+ EXPECT_EQ(7, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(9));
+ EXPECT_EQ(7, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(10));
+ EXPECT_EQ(7, TilingData(3, 10, 10, true).tileYIndexFromSrcCoord(11));
+}
+
+TEST(TilingDataTest, tileSizeX)
+{
+ EXPECT_EQ(5, TilingData(5, 5, 5, false).tileSizeX(0));
+ EXPECT_EQ(5, TilingData(5, 5, 5, true).tileSizeX(0));
+
+ EXPECT_EQ(5, TilingData(5, 6, 6, false).tileSizeX(0));
+ EXPECT_EQ(1, TilingData(5, 6, 6, false).tileSizeX(1));
+ EXPECT_EQ(4, TilingData(5, 6, 6, true).tileSizeX(0));
+ EXPECT_EQ(2, TilingData(5, 6, 6, true).tileSizeX(1));
+
+ EXPECT_EQ(5, TilingData(5, 8, 8, false).tileSizeX(0));
+ EXPECT_EQ(3, TilingData(5, 8, 8, false).tileSizeX(1));
+ EXPECT_EQ(4, TilingData(5, 8, 8, true).tileSizeX(0));
+ EXPECT_EQ(4, TilingData(5, 8, 8, true).tileSizeX(1));
+
+ EXPECT_EQ(5, TilingData(5, 10, 10, false).tileSizeX(0));
+ EXPECT_EQ(5, TilingData(5, 10, 10, false).tileSizeX(1));
+ EXPECT_EQ(4, TilingData(5, 10, 10, true).tileSizeX(0));
+ EXPECT_EQ(3, TilingData(5, 10, 10, true).tileSizeX(1));
+ EXPECT_EQ(3, TilingData(5, 10, 10, true).tileSizeX(2));
+
+ EXPECT_EQ(4, TilingData(5, 11, 11, true).tileSizeX(2));
+ EXPECT_EQ(3, TilingData(5, 12, 12, true).tileSizeX(2));
+}
+TEST(TilingDataTest, tileSizeY)
+{
+ EXPECT_EQ(5, TilingData(5, 5, 5, false).tileSizeY(0));
+ EXPECT_EQ(5, TilingData(5, 5, 5, true).tileSizeY(0));
+
+ EXPECT_EQ(5, TilingData(5, 6, 6, false).tileSizeY(0));
+ EXPECT_EQ(1, TilingData(5, 6, 6, false).tileSizeY(1));
+ EXPECT_EQ(4, TilingData(5, 6, 6, true).tileSizeY(0));
+ EXPECT_EQ(2, TilingData(5, 6, 6, true).tileSizeY(1));
+
+ EXPECT_EQ(5, TilingData(5, 8, 8, false).tileSizeY(0));
+ EXPECT_EQ(3, TilingData(5, 8, 8, false).tileSizeY(1));
+ EXPECT_EQ(4, TilingData(5, 8, 8, true).tileSizeY(0));
+ EXPECT_EQ(4, TilingData(5, 8, 8, true).tileSizeY(1));
+
+ EXPECT_EQ(5, TilingData(5, 10, 10, false).tileSizeY(0));
+ EXPECT_EQ(5, TilingData(5, 10, 10, false).tileSizeY(1));
+ EXPECT_EQ(4, TilingData(5, 10, 10, true).tileSizeY(0));
+ EXPECT_EQ(3, TilingData(5, 10, 10, true).tileSizeY(1));
+ EXPECT_EQ(3, TilingData(5, 10, 10, true).tileSizeY(2));
+
+ EXPECT_EQ(4, TilingData(5, 11, 11, true).tileSizeY(2));
+ EXPECT_EQ(3, TilingData(5, 12, 12, true).tileSizeY(2));
+}
+
+} // namespace
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list