cc: Make UV coords in TileDrawQuad a full RectF

Previously, TileDrawQuad assumed that texels were 1:1 with geometry, so it only
needed an offset into the texture to calculate the UVs.  For impl-side painting
where multiple contents scales might be in play, a given texture rect isn't going
to be 1:1 with geometry rects and also will not be necessarily integer aligned.

Also, some things (like edge antialiasing) still need to know the texture size
so that it can do half-texel offsets, so this new texture rect needs to stay in
"texel space" rather than 0-1 "uv space".

R=danakj@chromium.org
BUG=155209


Review URL: https://chromiumcodereview.appspot.com/11348109

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@168723 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 57 insertions, 37 deletions

diff --git a/cc/draw_quad_unittest.cc b/cc/draw_quad_unittest.cc
index 90f35fd..94b7ad5 100644
--- a/cc/draw_quad_unittest.cc
+++ b/cc/draw_quad_unittest.cc
@@ -242,7 +242,7 @@ TEST(DrawQuadTest, copyTileDrawQuad)
 {
     gfx::Rect opaqueRect(33, 44, 22, 33);
     unsigned resourceId = 104;
-    gfx::Vector2d textureOffset(-31, 47);
+    gfx::RectF texCoordRect(31, 12, 54, 20);
     gfx::Size textureSize(85, 32);
     bool swizzleContents = true;
     bool leftEdgeAA = true;
@@ -251,10 +251,10 @@ TEST(DrawQuadTest, copyTileDrawQuad)
     bool bottomEdgeAA = true;
 
     CREATE_SHARED_STATE();
-    CREATE_QUAD_9(TileDrawQuad, opaqueRect, resourceId, textureOffset, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+    CREATE_QUAD_9(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
     EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
     EXPECT_EQ(resourceId, copyQuad->resourceId());
-    EXPECT_EQ(textureOffset, copyQuad->textureOffset());
+    EXPECT_EQ(texCoordRect, copyQuad->texCoordRect());
     EXPECT_EQ(textureSize, copyQuad->textureSize());
     EXPECT_EQ(swizzleContents, copyQuad->swizzleContents());
     EXPECT_EQ(leftEdgeAA, copyQuad->leftEdgeAA());
diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc
index fb5227b..916e9e1 100644
--- a/cc/gl_renderer.cc
+++ b/cc/gl_renderer.cc
@@ -10,6 +10,7 @@
 #include "base/string_util.h"
 #include "build/build_config.h"
 #include "cc/damage_tracker.h"
+#include "cc/geometry.h"
 #include "cc/geometry_binding.h"
 #include "cc/layer_quad.h"
 #include "cc/math_util.h"
@@ -697,7 +698,23 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
 {
     gfx::Rect tileRect = quad->visible_rect;
 
-    gfx::RectF clampRect(tileRect);
+    gfx::RectF texCoordRect = quad->texCoordRect();
+    float texToGeomScaleX = quad->rect.width() / texCoordRect.width();
+    float texToGeomScaleY = quad->rect.height() / texCoordRect.height();
+
+    // texCoordRect corresponds to quadRect, but quadVisibleRect may be
+    // smaller than quadRect due to occlusion or clipping. Adjust
+    // texCoordRect to match.
+    gfx::Vector2d topLeftDiff = tileRect.origin() - quad->rect.origin();
+    gfx::Vector2d bottomRightDiff =
+            BottomRight(tileRect) - BottomRight(quad->rect);
+    texCoordRect.Inset(topLeftDiff.x() / texToGeomScaleX,
+                       topLeftDiff.y() / texToGeomScaleY,
+                       -bottomRightDiff.x() / texToGeomScaleX,
+                       -bottomRightDiff.y() / texToGeomScaleY);
+
+    gfx::RectF clampGeomRect(tileRect);
+    gfx::RectF clampTexRect(texCoordRect);
     // 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
@@ -705,24 +722,27 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
     // 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.Inset(clampX, clampY, clampX, clampY);
-
-    gfx::Vector2dF textureOffset = quad->textureOffset() + (clampRect.origin() - quad->rect.origin());
+    float texClampX = std::min(0.5f, 0.5f * clampTexRect.width() - epsilon);
+    float texClampY = std::min(0.5f, 0.5f * clampTexRect.height() - epsilon);
+    float geomClampX = std::min(texClampX * texToGeomScaleX,
+                                0.5f * clampGeomRect.width() - epsilon);
+    float geomClampY = std::min(texClampY * texToGeomScaleY,
+                                0.5f * clampGeomRect.height() - epsilon);
+    clampGeomRect.Inset(geomClampX, geomClampY, geomClampX, geomClampY);
+    clampTexRect.Inset(texClampX, texClampY, texClampX, texClampY);
 
     // 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();
+    float vertexTexTranslateX = -clampGeomRect.x() / clampGeomRect.width();
+    float vertexTexTranslateY = -clampGeomRect.y() / clampGeomRect.height();
+    float vertexTexScaleX = tileRect.width() / clampGeomRect.width();
+    float vertexTexScaleY = tileRect.height() / clampGeomRect.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();
+    float fragmentTexTranslateX = clampTexRect.x() / textureSize.width();
+    float fragmentTexTranslateY = clampTexRect.y() / textureSize.height();
+    float fragmentTexScaleX = clampTexRect.width() / textureSize.width();
+    float fragmentTexScaleY = clampTexRect.height() / textureSize.height();
 
 
     gfx::QuadF localQuad;
diff --git a/cc/layer_tree_host_impl_unittest.cc b/cc/layer_tree_host_impl_unittest.cc
index f772155..3813350 100644
--- a/cc/layer_tree_host_impl_unittest.cc
+++ b/cc/layer_tree_host_impl_unittest.cc
@@ -1603,7 +1603,7 @@ public:
             opaqueRect = m_opaqueContentRect;
 
         SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
-        scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::Vector2d(), gfx::Size(1, 1), false, false, false, false, false);
+        scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::RectF(0, 0, 1, 1), gfx::Size(1, 1), false, false, false, false, false);
         testBlendingDrawQuad->visible_rect = m_quadVisibleRect;
         EXPECT_EQ(m_blend, testBlendingDrawQuad->ShouldDrawWithBlending());
         EXPECT_EQ(m_hasRenderSurface, !!renderSurface());
diff --git a/cc/picture_layer_impl.cc b/cc/picture_layer_impl.cc
index 7ecb4b3..658c68f 100644
--- a/cc/picture_layer_impl.cc
+++ b/cc/picture_layer_impl.cc
@@ -53,7 +53,7 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink,
     }
 
     gfx::Rect geometry_rect = iter.geometry_rect();
-    gfx::Rect texture_rect = iter.texture_rect();
+    gfx::RectF texture_rect = iter.texture_rect();
     gfx::Rect opaque_rect = iter.opaque_rect();
 
     bool outside_left_edge = geometry_rect.x() == content_rect.x();
@@ -66,8 +66,8 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink,
         geometry_rect,
         opaque_rect,
         resource,
-        texture_rect.origin().OffsetFromOrigin(),
-        texture_rect.size(),
+        texture_rect,
+        iter.texture_size(),
         iter->contents_swizzled(),
         outside_left_edge && useAA,
         outside_top_edge && useAA,
diff --git a/cc/software_renderer.cc b/cc/software_renderer.cc
index 37467aa..e22ecec 100644
--- a/cc/software_renderer.cc
+++ b/cc/software_renderer.cc
@@ -258,9 +258,7 @@ void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQua
     DCHECK(isSoftwareResource(quad->resourceId()));
     ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId());
 
-    SkRect uvRect = SkRect::MakeXYWH(
-        quad->textureOffset().x(), quad->textureOffset().y(),
-        quad->rect.width(), quad->rect.height());
+    SkRect uvRect = gfx::RectFToSkRect(quad->texCoordRect());
     m_skCurrentPaint.setFilterBitmap(true);
     m_skCurrentCanvas->drawBitmapRectToRect(*lock.skBitmap(), &uvRect,
                                             gfx::RectFToSkRect(quadVertexRect()),
diff --git a/cc/software_renderer_unittest.cc b/cc/software_renderer_unittest.cc
index bd89388..0051336 100644
--- a/cc/software_renderer_unittest.cc
+++ b/cc/software_renderer_unittest.cc
@@ -126,8 +126,8 @@ TEST_F(SoftwareRendererTest, tileQuad)
     scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
     scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, gfx::Rect(gfx::Point(), deviceViewportSize()), WebTransformationMatrix());
-    scoped_ptr<DrawQuad> outerQuad = TileDrawQuad::create(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::Vector2d(), outerSize, false, false, false, false, false).PassAs<DrawQuad>();
-    scoped_ptr<DrawQuad> innerQuad = TileDrawQuad::create(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::Vector2d(), innerSize, false, false, false, false, false).PassAs<DrawQuad>();
+    scoped_ptr<DrawQuad> outerQuad = TileDrawQuad::create(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false).PassAs<DrawQuad>();
+    scoped_ptr<DrawQuad> innerQuad = TileDrawQuad::create(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false).PassAs<DrawQuad>();
     rootRenderPass->appendQuad(innerQuad.Pass());
     rootRenderPass->appendQuad(outerQuad.Pass());
 
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index 5d6b729..f8f2e22 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -40,7 +40,7 @@ void TestRenderPass::appendOneOfEveryQuadType(cc::ResourceProvider* resourceProv
     appendQuad(cc::StreamVideoDrawQuad::create(sharedState.get(), rect, opaqueRect, 1, WebKit::WebTransformationMatrix()).PassAs<DrawQuad>());
     appendQuad(cc::TextureDrawQuad::create(sharedState.get(), rect, opaqueRect, textureResource, false, rect, false).PassAs<DrawQuad>());
 
-    appendQuad(cc::TileDrawQuad::create(sharedState.get(), rect, opaqueRect, textureResource, gfx::Vector2d(), gfx::Size(100, 100), false, false, false, false, false).PassAs<DrawQuad>());
+    appendQuad(cc::TileDrawQuad::create(sharedState.get(), rect, opaqueRect, textureResource, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false, false, false).PassAs<DrawQuad>());
 
     cc::VideoLayerImpl::FramePlane planes[3];
     for (int i = 0; i < 3; ++i) {
diff --git a/cc/tile_draw_quad.cc b/cc/tile_draw_quad.cc
index fa8b9e1..1f2e9f5 100644
--- a/cc/tile_draw_quad.cc
+++ b/cc/tile_draw_quad.cc
@@ -9,14 +9,14 @@
 
 namespace cc {
 
-scoped_ptr<TileDrawQuad> TileDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::Vector2d& textureOffset, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
+scoped_ptr<TileDrawQuad> TileDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
 {
-    return make_scoped_ptr(new TileDrawQuad(sharedQuadState, quadRect, opaqueRect, resourceId, textureOffset, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
+    return make_scoped_ptr(new TileDrawQuad(sharedQuadState, quadRect, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
 }
 
-TileDrawQuad::TileDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::Vector2d& textureOffset, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
+TileDrawQuad::TileDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
     : m_resourceId(resourceId)
-    , m_textureOffset(textureOffset)
+    , m_texCoordRect(texCoordRect)
     , m_textureSize(textureSize)
     , m_swizzleContents(swizzleContents)
     , m_leftEdgeAA(leftEdgeAA)
diff --git a/cc/tile_draw_quad.h b/cc/tile_draw_quad.h
index dd5776e..dccf8bc 100644
--- a/cc/tile_draw_quad.h
+++ b/cc/tile_draw_quad.h
@@ -16,10 +16,10 @@ namespace cc {
 
 class CC_EXPORT TileDrawQuad : public DrawQuad {
 public:
-    static scoped_ptr<TileDrawQuad> create(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::Vector2d& textureOffset, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
+    static scoped_ptr<TileDrawQuad> create(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
 
     unsigned resourceId() const { return m_resourceId; }
-    gfx::Vector2d textureOffset() const { return m_textureOffset; }
+    gfx::RectF texCoordRect() const { return m_texCoordRect; }
     gfx::Size textureSize() const { return m_textureSize; }
     bool swizzleContents() const { return m_swizzleContents; }
 
@@ -34,10 +34,10 @@ public:
 
     static const TileDrawQuad* materialCast(const DrawQuad*);
 private:
-    TileDrawQuad(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::Vector2d& textureOffset, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
+    TileDrawQuad(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
 
     unsigned m_resourceId;
-    gfx::Vector2d m_textureOffset;
+    gfx::RectF m_texCoordRect;
     gfx::Size m_textureSize;
     bool m_swizzleContents;
     bool m_leftEdgeAA;
diff --git a/cc/tiled_layer_impl.cc b/cc/tiled_layer_impl.cc
index 09b4b9f..3773542 100644
--- a/cc/tiled_layer_impl.cc
+++ b/cc/tiled_layer_impl.cc
@@ -172,6 +172,8 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
             // offset the same amount.
             gfx::Vector2d displayOffset = tileRect.origin() - displayRect.origin();
             gfx::Vector2d textureOffset = m_tiler->textureOffset(i, j) + displayOffset;
+            gfx::RectF texCoordRect = gfx::RectF(tileRect.size()) + textureOffset;
+
             float tileWidth = static_cast<float>(m_tiler->tileSize().width());
             float tileHeight = static_cast<float>(m_tiler->tileSize().height());
             gfx::Size textureSize(tileWidth, tileHeight);
@@ -186,7 +188,7 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
             bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
             bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
 
-            quadSink.append(TileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), textureOffset, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA).PassAs<DrawQuad>(), appendQuadsData);
+            quadSink.append(TileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA).PassAs<DrawQuad>(), appendQuadsData);
         }
     }
 }
diff --git a/cc/tiled_layer_impl_unittest.cc b/cc/tiled_layer_impl_unittest.cc
index 6b6e8c9..c501dff 100644
--- a/cc/tiled_layer_impl_unittest.cc
+++ b/cc/tiled_layer_impl_unittest.cc
@@ -202,7 +202,7 @@ TEST(TiledLayerImplTest, textureInfoForLayerNoBorders)
         const TileDrawQuad* quad = TileDrawQuad::materialCast(quads[i]);
 
         EXPECT_NE(quad->resourceId(), 0u) << quadString << i;
-        EXPECT_EQ(quad->textureOffset(), gfx::Vector2d()) << quadString << i;
+        EXPECT_EQ(quad->texCoordRect(), gfx::RectF(gfx::PointF(), tileSize)) << quadString << i;
         EXPECT_EQ(quad->textureSize(), tileSize) << quadString << i;
         EXPECT_EQ(gfx::Rect(0, 0, 1, 1), quad->opaque_rect) << quadString << i;
     }