cc: Moving anti-aliasing decision to parent compositor.

Changed edge antialiasing flags in TileDrawQuad to edge flags and moved to SharedQuadState.
The quad cannot tell anymore if it needs antialiasing or not. The renderer will make that decision.
Moved blending decision from GLRenderer::drawQuad to GLRenderer::draw*Quad functions.

BUG=169163


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

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

19 files changed, 108 insertions, 127 deletions

diff --git a/cc/delegated_renderer_layer_impl_unittest.cc b/cc/delegated_renderer_layer_impl_unittest.cc
index e2e74d2..417591a 100644
--- a/cc/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/delegated_renderer_layer_impl_unittest.cc
@@ -473,6 +473,7 @@ class DelegatedRendererLayerImplTestTransform
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
 
+    gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
     child_pass_transform.Scale(0.8, 0.8);
@@ -492,6 +493,7 @@ class DelegatedRendererLayerImplTestTransform
           SharedQuadState::Create());
       shared_quad_state->SetAll(
           child_pass_transform,
+          child_pass_content_bounds,
           child_pass_rect,
           child_pass_clip_rect,
           child_pass_clipped,
@@ -507,6 +509,7 @@ class DelegatedRendererLayerImplTestTransform
       quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
     }
 
+    gfx::Size root_pass_content_bounds(50, 50);
     gfx::Rect root_pass_rect(0, 0, 50, 50);
     gfx::Transform root_pass_transform;
     root_pass_transform.Scale(1.5, 1.5);
@@ -524,6 +527,7 @@ class DelegatedRendererLayerImplTestTransform
     SharedQuadState* shared_quad_state = quad_sink.useSharedQuadState(SharedQuadState::Create());
     shared_quad_state->SetAll(
         root_pass_transform,
+        root_pass_content_bounds,
         root_pass_rect,
         root_pass_clip_rect,
         root_pass_clipped,
@@ -859,12 +863,13 @@ class DelegatedRendererLayerImplTestClip
     root_layer->setBounds(gfx::Size(100, 100));
 
     delegated_renderer_layer->setPosition(gfx::Point(20, 20));
-    delegated_renderer_layer->setBounds(gfx::Size(50, 50)); 
+    delegated_renderer_layer->setBounds(gfx::Size(50, 50));
     delegated_renderer_layer->setContentBounds(gfx::Size(50, 50));
     delegated_renderer_layer->setDrawsContent(true);
 
     ScopedPtrVector<RenderPass> delegated_render_passes;
 
+    gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
@@ -882,6 +887,7 @@ class DelegatedRendererLayerImplTestClip
           quad_sink.useSharedQuadState(SharedQuadState::Create());
       shared_quad_state->SetAll(
           child_pass_transform,
+          child_pass_content_bounds,
           child_pass_rect,
           child_pass_clip_rect,
           child_pass_clipped,
@@ -897,6 +903,7 @@ class DelegatedRendererLayerImplTestClip
       quad_sink.append(color_quad.PassAs<DrawQuad>(), data);
     }
 
+    gfx::Size root_pass_content_bounds(50, 50);
     gfx::Rect root_pass_rect(0, 0, 50, 50);
     gfx::Transform root_pass_transform;
     gfx::Rect root_pass_clip_rect(5, 5, 40, 40);
@@ -911,7 +918,12 @@ class DelegatedRendererLayerImplTestClip
     AppendQuadsData data(pass->id);
     SharedQuadState* shared_quad_state =
         quad_sink.useSharedQuadState(SharedQuadState::Create());
-    shared_quad_state->SetAll(root_pass_transform, root_pass_rect, root_pass_clip_rect, root_pass_clipped, 1);
+    shared_quad_state->SetAll(root_pass_transform,
+                              root_pass_content_bounds,
+                              root_pass_rect,
+                              root_pass_clip_rect,
+                              root_pass_clipped,
+                              1.f);
 
     scoped_ptr<RenderPassDrawQuad> render_pass_quad =
         RenderPassDrawQuad::Create();
diff --git a/cc/draw_quad.h b/cc/draw_quad.h
index df62c7b..d6b9b40 100644
--- a/cc/draw_quad.h
+++ b/cc/draw_quad.h
@@ -67,6 +67,7 @@ class CC_EXPORT DrawQuad {
   const SharedQuadState* shared_quad_state;
 
   bool IsDebugQuad() const { return material == DEBUG_BORDER; }
+
   bool ShouldDrawWithBlending() const {
     return needs_blending || shared_quad_state->opacity < 1.0f ||
         !opaque_rect.Contains(visible_rect);
@@ -76,6 +77,32 @@ class CC_EXPORT DrawQuad {
       ResourceProvider::ResourceId)> ResourceIteratorCallback;
   virtual void IterateResources(const ResourceIteratorCallback& callback) = 0;
 
+  // Is the left edge of this tile aligned with the originating layer's
+  // left edge?
+  bool IsLeftEdge() const { return !rect.x(); }
+
+  // Is the top edge of this tile aligned with the originating layer's
+  // top edge?
+  bool IsTopEdge() const { return !rect.y(); }
+
+  // Is the right edge of this tile aligned with the originating layer's
+  // right edge?
+  bool IsRightEdge() const {
+    return rect.right() == shared_quad_state->content_bounds.width();
+  }
+
+  // Is the bottom edge of this tile aligned with the originating layer's
+  // bottom edge?
+  bool IsBottomEdge() const {
+    return rect.bottom() == shared_quad_state->content_bounds.height();
+  }
+
+  // Is any edge of this tile aligned with the originating layer's
+  // corresponding edge?
+  bool IsEdge() const {
+    return IsLeftEdge() || IsTopEdge() || IsRightEdge() || IsBottomEdge();
+  }
+
  protected:
   DrawQuad();
 
diff --git a/cc/draw_quad_unittest.cc b/cc/draw_quad_unittest.cc
index f83a930..7e72a2c 100644
--- a/cc/draw_quad_unittest.cc
+++ b/cc/draw_quad_unittest.cc
@@ -27,13 +27,15 @@ namespace {
 TEST(DrawQuadTest, copySharedQuadState)
 {
     gfx::Transform quadTransform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
+    gfx::Size contentBounds(26, 28);
     gfx::Rect visibleContentRect(10, 12, 14, 16);
     gfx::Rect clipRect(19, 21, 23, 25);
     bool isClipped = true;
     float opacity = 0.25;
 
     scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
-    state->SetAll(quadTransform, visibleContentRect, clipRect, isClipped, opacity);
+    state->SetAll(quadTransform, contentBounds, visibleContentRect, clipRect,
+                  isClipped, opacity);
 
     scoped_ptr<SharedQuadState> copy(state->Copy());
     EXPECT_EQ(quadTransform, copy->content_to_target_transform);
@@ -46,13 +48,15 @@ TEST(DrawQuadTest, copySharedQuadState)
 scoped_ptr<SharedQuadState> createSharedQuadState()
 {
     gfx::Transform quadTransform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
+    gfx::Size contentBounds(26, 28);
     gfx::Rect visibleContentRect(10, 12, 14, 16);
     gfx::Rect clipRect(19, 21, 23, 25);
     bool isClipped = false;
     float opacity = 1;
 
     scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
-    state->SetAll(quadTransform, visibleContentRect, clipRect, isClipped, opacity);
+    state->SetAll(quadTransform, contentBounds, visibleContentRect, clipRect,
+                  isClipped, opacity);
     return state.Pass();
 }
 
@@ -461,34 +465,22 @@ TEST(DrawQuadTest, copyTileDrawQuad)
     gfx::RectF texCoordRect(31, 12, 54, 20);
     gfx::Size textureSize(85, 32);
     bool swizzleContents = true;
-    bool leftEdgeAA = true;
-    bool topEdgeAA = true;
-    bool rightEdgeAA = false;
-    bool bottomEdgeAA = true;
     CREATE_SHARED_STATE();
 
-    CREATE_QUAD_9_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+    CREATE_QUAD_5_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents);
     EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material);
     EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
     EXPECT_EQ(resourceId, copyQuad->resource_id);
     EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect);
     EXPECT_EQ(textureSize, copyQuad->texture_size);
     EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents);
-    EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa);
-    EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa);
-    EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa);
-    EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa);
 
-    CREATE_QUAD_8_ALL(TileDrawQuad, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+    CREATE_QUAD_4_ALL(TileDrawQuad, resourceId, texCoordRect, textureSize, swizzleContents);
     EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material);
     EXPECT_EQ(resourceId, copyQuad->resource_id);
     EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect);
     EXPECT_EQ(textureSize, copyQuad->texture_size);
     EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents);
-    EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa);
-    EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa);
-    EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa);
-    EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa);
 }
 
 TEST(DrawQuadTest, copyYUVVideoDrawQuad)
@@ -648,13 +640,9 @@ TEST_F(DrawQuadIteratorTest, TileDrawQuad) {
   gfx::RectF texCoordRect(31, 12, 54, 20);
   gfx::Size textureSize(85, 32);
   bool swizzleContents = true;
-  bool leftEdgeAA = true;
-  bool topEdgeAA = true;
-  bool rightEdgeAA = false;
-  bool bottomEdgeAA = true;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_9_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+  CREATE_QUAD_5_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents);
   EXPECT_EQ(resourceId, quadNew->resource_id);
   EXPECT_EQ(1, IterateAndCount(quadNew.get()));
   EXPECT_EQ(resourceId + 1, quadNew->resource_id);
diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc
index 6b31e5a..a7ae9b1 100644
--- a/cc/gl_renderer.cc
+++ b/cc/gl_renderer.cc
@@ -282,8 +282,7 @@ void GLRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
 {
     DCHECK(quad->rect.Contains(quad->visible_rect));
     if (quad->material != DrawQuad::TEXTURE_CONTENT) {
-        flushTextureQuadCache();
-        setBlendEnabled(quad->ShouldDrawWithBlending());
+      flushTextureQuadCache();
     }
 
     switch (quad->material) {
@@ -322,6 +321,8 @@ void GLRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
 
 void GLRenderer::drawCheckerboardQuad(const DrawingFrame& frame, const CheckerboardDrawQuad* quad)
 {
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     const TileCheckerboardProgram* program = tileCheckerboardProgram();
     DCHECK(program && (program->initialized() || isContextLost()));
     setUseProgram(program->program());
@@ -347,6 +348,8 @@ void GLRenderer::drawCheckerboardQuad(const DrawingFrame& frame, const Checkerbo
 
 void GLRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorderDrawQuad* quad)
 {
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     static float glMatrix[16];
     const SolidColorProgram* program = solidColorProgram();
     DCHECK(program && (program->initialized() || isContextLost()));
@@ -550,6 +553,8 @@ scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
 
 void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     CachedResource* contentsTexture = m_renderPassTextures.get(quad->render_pass_id);
     if (!contentsTexture || !contentsTexture->id())
         return;
@@ -719,6 +724,8 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua
 
 void GLRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
 {
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     const SolidColorProgram* program = solidColorProgram();
     setUseProgram(program->program());
 
@@ -806,7 +813,6 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
     float fragmentTexScaleX = clampTexRect.width() / textureSize.width();
     float fragmentTexScaleY = clampTexRect.height() / textureSize.height();
 
-
     gfx::QuadF localQuad;
     gfx::Transform deviceTransform = frame.windowMatrix * frame.projectionMatrix * quad->quadTransform();
     deviceTransform.FlattenTo2d();
@@ -817,10 +823,14 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
     gfx::QuadF deviceLayerQuad = MathUtil::mapQuad(deviceTransform, gfx::QuadF(quad->visibleContentRect()), clipped);
     DCHECK(!clipped);
 
+    // TODO(reveman): Axis-aligned is not enough to avoid anti-aliasing.
+    // Bounding rectangle for quad also needs to be expressible as
+    // an integer rectangle. crbug.com/169374
+    bool isAxisAlignedInTarget = deviceLayerQuad.IsRectilinear();
+    bool useAA = !clipped && !isAxisAlignedInTarget && quad->IsEdge();
+
     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 (useAA) {
         if (quad->swizzle_contents)
             tileUniformLocation(tileProgramSwizzleAA(), uniforms);
         else
@@ -842,10 +852,9 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
     setUseProgram(uniforms.program);
     GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0));
     bool scaled = (texToGeomScaleX != 1 || texToGeomScaleY != 1);
-    GLenum filter = (quad->IsAntialiased() || scaled || !quad->quadTransform().IsIdentityOrIntegerTranslation()) ? GL_LINEAR : GL_NEAREST;
+    GLenum filter = (useAA || scaled || !quad->quadTransform().IsIdentityOrIntegerTranslation()) ? GL_LINEAR : GL_NEAREST;
     ResourceProvider::ScopedSamplerGL quadResourceLock(m_resourceProvider, quad->resource_id, GL_TEXTURE_2D, filter);
 
-    bool useAA = !clipped && quad->IsAntialiased();
     if (useAA) {
         LayerQuad deviceLayerBounds = LayerQuad(gfx::QuadF(deviceLayerQuad.BoundingBox()));
         deviceLayerBounds.inflateAntiAliasingDistance();
@@ -882,13 +891,13 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
         LayerQuad::Edge rightEdge(topRight, bottomRight);
 
         // Only apply anti-aliasing to edges not clipped by culling or scissoring.
-        if (quad->top_edge_aa && tileRect.y() == quad->rect.y())
+        if (quad->IsTopEdge() && tileRect.y() == quad->rect.y())
             topEdge = deviceLayerEdges.top();
-        if (quad->left_edge_aa && tileRect.x() == quad->rect.x())
+        if (quad->IsLeftEdge() && tileRect.x() == quad->rect.x())
             leftEdge = deviceLayerEdges.left();
-        if (quad->right_edge_aa && tileRect.right() == quad->rect.right())
+        if (quad->IsRightEdge() && tileRect.right() == quad->rect.right())
             rightEdge = deviceLayerEdges.right();
-        if (quad->bottom_edge_aa && tileRect.bottom() == quad->rect.bottom())
+        if (quad->IsBottomEdge() && tileRect.bottom() == quad->rect.bottom())
             bottomEdge = deviceLayerEdges.bottom();
 
         float sign = gfx::QuadF(tileRect).IsCounterClockwise() ? -1 : 1;
@@ -926,6 +935,10 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
         localQuad = gfx::RectF(tileRect);
     }
 
+    // Enable blending when the quad properties require it or if we decided
+    // to use antialiasing.
+    setBlendEnabled(quad->ShouldDrawWithBlending() || useAA);
+
     // Normalize to tileRect.
     localQuad.Scale(1.0f / tileRect.width(), 1.0f / tileRect.height());
 
@@ -943,6 +956,8 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
 
 void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQuad* quad)
 {
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     const VideoYUVProgram* program = videoYUVProgram();
     DCHECK(program && (program->initialized() || isContextLost()));
 
@@ -995,6 +1010,8 @@ void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQ
 
 void GLRenderer::drawStreamVideoQuad(const DrawingFrame& frame, const StreamVideoDrawQuad* quad)
 {
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     static float glMatrix[16];
 
     DCHECK(m_capabilities.usingEglImage);
@@ -1183,6 +1200,8 @@ void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQua
 
 void GLRenderer::drawIOSurfaceQuad(const DrawingFrame& frame, const IOSurfaceDrawQuad* quad)
 {
+    setBlendEnabled(quad->ShouldDrawWithBlending());
+
     TexTransformTextureProgramBinding binding;
     binding.set(textureIOSurfaceProgram(), context());
 
diff --git a/cc/gl_renderer_pixeltest.cc b/cc/gl_renderer_pixeltest.cc
index 46334f2..347428b 100644
--- a/cc/gl_renderer_pixeltest.cc
+++ b/cc/gl_renderer_pixeltest.cc
@@ -96,12 +96,14 @@ scoped_ptr<RenderPass> CreateTestRenderPass(RenderPass::Id id, gfx::Rect rect) {
 
 scoped_ptr<SharedQuadState> CreateTestSharedQuadState(
     gfx::Transform content_to_target_transform, gfx::Rect rect) {
+  const gfx::Size content_bounds = rect.size();
   const gfx::Rect visible_content_rect = rect;
   const gfx::Rect clip_rect = rect;
   const bool is_clipped = false;
   const float opacity = 1.0f;
   scoped_ptr<SharedQuadState> shared_state = SharedQuadState::Create();
   shared_state->SetAll(content_to_target_transform,
+                       content_bounds,
                        visible_content_rect,
                        clip_rect,
                        is_clipped,
diff --git a/cc/layer_impl.cc b/cc/layer_impl.cc
index cc1bb1f..638b016 100644
--- a/cc/layer_impl.cc
+++ b/cc/layer_impl.cc
@@ -122,6 +122,7 @@ scoped_ptr<SharedQuadState> LayerImpl::createSharedQuadState() const
 {
   scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
   state->SetAll(m_drawProperties.target_space_transform,
+                m_drawProperties.content_bounds,
                 m_drawProperties.visible_content_rect,
                 m_drawProperties.clip_rect,
                 m_drawProperties.is_clipped,
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index 38ef549..f9c464d 100644
--- a/cc/layer_tree_host_impl.cc
+++ b/cc/layer_tree_host_impl.cc
@@ -416,6 +416,7 @@ static void appendQuadsToFillScreen(RenderPass* targetRenderPass, LayerImpl* roo
     float opacity = 1;
     SharedQuadState* sharedQuadState = quadCuller.useSharedQuadState(SharedQuadState::Create());
     sharedQuadState->SetAll(rootLayer->drawTransform(),
+                            rootTargetRect.size(),
                             rootTargetRect,
                             rootTargetRect,
                             false,
diff --git a/cc/layer_tree_host_impl_unittest.cc b/cc/layer_tree_host_impl_unittest.cc
index 629841f..5ca504c 100644
--- a/cc/layer_tree_host_impl_unittest.cc
+++ b/cc/layer_tree_host_impl_unittest.cc
@@ -1750,7 +1750,7 @@ public:
 
         SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
         scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::Create();
-        testBlendingDrawQuad->SetNew(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::RectF(0, 0, 1, 1), gfx::Size(1, 1), false, false, false, false, false);
+        testBlendingDrawQuad->SetNew(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::RectF(0, 0, 1, 1), gfx::Size(1, 1), false);
         testBlendingDrawQuad->visible_rect = m_quadVisibleRect;
         EXPECT_EQ(m_blend, testBlendingDrawQuad->ShouldDrawWithBlending());
         EXPECT_EQ(m_hasRenderSurface, !!renderSurface());
@@ -3752,7 +3752,7 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
 
     // One shared state for all quads - we don't need the correct details
     testData.sharedQuadState = SharedQuadState::Create();
-    testData.sharedQuadState->SetAll(gfx::Transform(), gfx::Rect(), gfx::Rect(), false, 1.0);
+    testData.sharedQuadState->SetAll(gfx::Transform(), gfx::Size(), gfx::Rect(), gfx::Rect(), false, 1.0);
 
     const char* currentChar = testScript;
 
diff --git a/cc/picture_layer_impl.cc b/cc/picture_layer_impl.cc
index f0ce9ad..8e8a394 100644
--- a/cc/picture_layer_impl.cc
+++ b/cc/picture_layer_impl.cc
@@ -98,7 +98,6 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink,
       gfx::QuadF(rect),
       clipped);
   bool isAxisAlignedInTarget = !clipped && target_quad.IsRectilinear();
-  bool useAA = !isAxisAlignedInTarget;
 
   bool isPixelAligned = isAxisAlignedInTarget && drawTransform().IsIdentityOrIntegerTranslation();
   PictureLayerTiling::LayerDeviceAlignment layerDeviceAlignment =
@@ -185,11 +184,6 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink,
     gfx::Rect opaque_rect = iter->opaque_rect();
     opaque_rect.Intersect(content_rect);
 
-    bool outside_left_edge = geometry_rect.x() == content_rect.x();
-    bool outside_top_edge = geometry_rect.y() == content_rect.y();
-    bool outside_right_edge = geometry_rect.right() == content_rect.right();
-    bool outside_bottom_edge = geometry_rect.bottom() == content_rect.bottom();
-
     scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
     quad->SetNew(sharedQuadState,
                  geometry_rect,
@@ -197,11 +191,7 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink,
                  resource,
                  texture_rect,
                  iter.texture_size(),
-                 iter->contents_swizzled(),
-                 outside_left_edge && useAA,
-                 outside_top_edge && useAA,
-                 outside_right_edge && useAA,
-                 outside_bottom_edge && useAA);
+                 iter->contents_swizzled());
     quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 
     if (!seen_tilings.size() || seen_tilings.back() != iter.CurrentTiling())
diff --git a/cc/render_pass_unittest.cc b/cc/render_pass_unittest.cc
index fdf314c..fe9d3c6 100644
--- a/cc/render_pass_unittest.cc
+++ b/cc/render_pass_unittest.cc
@@ -49,7 +49,7 @@ TEST(RenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
 
     // Stick a quad in the pass, this should not get copied.
     scoped_ptr<SharedQuadState> sharedState = SharedQuadState::Create();
-    sharedState->SetAll(gfx::Transform(), gfx::Rect(), gfx::Rect(), false, 1);
+    sharedState->SetAll(gfx::Transform(), gfx::Size(), gfx::Rect(), gfx::Rect(), false, 1);
     pass->AppendSharedQuadState(sharedState.Pass());
 
     scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
diff --git a/cc/render_surface_impl.cc b/cc/render_surface_impl.cc
index c7a346b..b890aa0 100644
--- a/cc/render_surface_impl.cc
+++ b/cc/render_surface_impl.cc
@@ -174,7 +174,7 @@ void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQ
 
     const gfx::Transform& drawTransform = forReplica ? m_replicaDrawTransform : m_drawTransform;
     SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(SharedQuadState::Create());
-    sharedQuadState->SetAll(drawTransform, m_contentRect, m_clipRect, m_isClipped, m_drawOpacity);
+    sharedQuadState->SetAll(drawTransform, m_contentRect.size(), m_contentRect, m_clipRect, m_isClipped, m_drawOpacity);
 
     if (m_owningLayer->showDebugBorders()) {
         SkColor color = forReplica ? DebugColors::SurfaceReplicaBorderColor() : DebugColors::SurfaceBorderColor();
diff --git a/cc/shared_quad_state.cc b/cc/shared_quad_state.cc
index a1f07ad..c2d6b26 100644
--- a/cc/shared_quad_state.cc
+++ b/cc/shared_quad_state.cc
@@ -20,11 +20,13 @@ scoped_ptr<SharedQuadState> SharedQuadState::Copy() const {
 
 void SharedQuadState::SetAll(
     const gfx::Transform& content_to_target_transform,
+    const gfx::Size content_bounds,
     const gfx::Rect& visible_content_rect,
     const gfx::Rect& clip_rect,
     bool is_clipped,
     float opacity) {
   this->content_to_target_transform = content_to_target_transform;
+  this->content_bounds = content_bounds;
   this->visible_content_rect = visible_content_rect;
   this->clip_rect = clip_rect;
   this->is_clipped = is_clipped;
diff --git a/cc/shared_quad_state.h b/cc/shared_quad_state.h
index 974d5f1..420dc54 100644
--- a/cc/shared_quad_state.h
+++ b/cc/shared_quad_state.h
@@ -20,6 +20,7 @@ class CC_EXPORT SharedQuadState {
   scoped_ptr<SharedQuadState> Copy() const;
 
   void SetAll(const gfx::Transform& content_to_target_transform,
+              const gfx::Size content_bounds,
               const gfx::Rect& visible_content_rect,
               const gfx::Rect& clip_rect,
               bool is_clipped,
@@ -28,6 +29,7 @@ class CC_EXPORT SharedQuadState {
   // Transforms from quad's original content space to its target content space.
   gfx::Transform content_to_target_transform;
   // This rect lives in the content space for the quad's originating layer.
+  gfx::Size content_bounds;
   gfx::Rect visible_content_rect;
   gfx::Rect clip_rect;
   bool is_clipped;
diff --git a/cc/software_renderer_unittest.cc b/cc/software_renderer_unittest.cc
index 3d71a0e..cf4c2b4 100644
--- a/cc/software_renderer_unittest.cc
+++ b/cc/software_renderer_unittest.cc
@@ -78,7 +78,7 @@ TEST_F(SoftwareRendererTest, solidColorQuad)
     initializeRenderer();
 
     scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
-    sharedQuadState->SetAll(gfx::Transform(), outerRect, outerRect, false, 1.0);
+    sharedQuadState->SetAll(gfx::Transform(), outerSize, outerRect, outerRect, false, 1.0);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
     scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::Create();
     rootRenderPass->SetNew(rootRenderPassId, outerRect, outerRect, gfx::Transform());
@@ -137,14 +137,14 @@ TEST_F(SoftwareRendererTest, tileQuad)
     gfx::Rect rootRect = gfx::Rect(deviceViewportSize());
 
     scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
-    sharedQuadState->SetAll(gfx::Transform(), outerRect, outerRect, false, 1.0);
+    sharedQuadState->SetAll(gfx::Transform(), outerSize, outerRect, outerRect, false, 1.0);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
     scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::Create();
     rootRenderPass->SetNew(rootRenderPassId, rootRect, rootRect, gfx::Transform());
     scoped_ptr<TileDrawQuad> outerQuad = TileDrawQuad::Create();
-    outerQuad->SetNew(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(outerSize), outerSize, false, false, false, false, false);
+    outerQuad->SetNew(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(outerSize), outerSize, false);
     scoped_ptr<TileDrawQuad> innerQuad = TileDrawQuad::Create();
-    innerQuad->SetNew(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(innerSize), innerSize, false, false, false, false, false);
+    innerQuad->SetNew(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(innerSize), innerSize, false);
     rootRenderPass->AppendQuad(innerQuad.PassAs<DrawQuad>());
     rootRenderPass->AppendQuad(outerQuad.PassAs<DrawQuad>());
 
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index a5b7d33..4a2de14 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -74,6 +74,7 @@ void TestRenderPass::AppendOneOfEveryQuadType(
 
   scoped_ptr<cc::SharedQuadState> shared_state = cc::SharedQuadState::Create();
   shared_state->SetAll(gfx::Transform(),
+                       rect.size(),
                        rect,
                        rect,
                        false,
@@ -171,10 +172,6 @@ void TestRenderPass::AppendOneOfEveryQuadType(
                            resource2,
                            gfx::RectF(0, 0, 50, 50),
                            gfx::Size(50, 50),
-                           false,
-                           false,
-                           false,
-                           false,
                            false);
   AppendQuad(scaled_tile_quad.PassAs<DrawQuad>());
 
@@ -190,10 +187,6 @@ void TestRenderPass::AppendOneOfEveryQuadType(
                                 resource3,
                                 gfx::RectF(0, 0, 100, 100),
                                 gfx::Size(100, 100),
-                                false,
-                                false,
-                                false,
-                                false,
                                 false);
   AppendQuad(transformed_tile_quad.PassAs<DrawQuad>());
 
@@ -205,10 +198,6 @@ void TestRenderPass::AppendOneOfEveryQuadType(
                     resource4,
                     gfx::RectF(0, 0, 100, 100),
                     gfx::Size(100, 100),
-                    false,
-                    false,
-                    false,
-                    false,
                     false);
   AppendQuad(tile_quad.PassAs<DrawQuad>());
 
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index bda83dd..446fc4e 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -33,7 +33,7 @@ SolidColorDrawQuad* addQuad(TestRenderPass* pass,
   AppendQuadsData data(pass->id);
   SharedQuadState* sharedState =
       quadSink.useSharedQuadState(SharedQuadState::Create());
-  sharedState->SetAll(gfx::Transform(), rect, rect, false, 1);
+  sharedState->SetAll(gfx::Transform(), rect.size(), rect, rect, false, 1);
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
   quad->SetNew(sharedState, rect, color);
   SolidColorDrawQuad* quadPtr = quad.get();
@@ -48,7 +48,7 @@ SolidColorDrawQuad* addClippedQuad(TestRenderPass* pass,
   AppendQuadsData data(pass->id);
   SharedQuadState* sharedState =
       quadSink.useSharedQuadState(SharedQuadState::Create());
-  sharedState->SetAll(gfx::Transform(), rect, rect, true, 1);
+  sharedState->SetAll(gfx::Transform(), rect.size(), rect, rect, true, 1);
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
   quad->SetNew(sharedState, rect, color);
   SolidColorDrawQuad* quadPtr = quad.get();
@@ -63,7 +63,7 @@ void addRenderPassQuad(TestRenderPass* toPass,
   gfx::Rect outputRect = contributingPass->output_rect;
   SharedQuadState* sharedState =
       quadSink.useSharedQuadState(SharedQuadState::Create());
-  sharedState->SetAll(gfx::Transform(), outputRect, outputRect, false, 1);
+  sharedState->SetAll(gfx::Transform(), outputRect.size(), outputRect, outputRect, false, 1);
   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
   quad->SetNew(sharedState, outputRect, contributingPass->id, false, 0,
                outputRect, gfx::RectF(), WebKit::WebFilterOperations(),
diff --git a/cc/tile_draw_quad.cc b/cc/tile_draw_quad.cc
index f430f2b..13b1d33 100644
--- a/cc/tile_draw_quad.cc
+++ b/cc/tile_draw_quad.cc
@@ -11,11 +11,7 @@ namespace cc {
 
 TileDrawQuad::TileDrawQuad()
     : resource_id(0),
-      swizzle_contents(false),
-      left_edge_aa(false),
-      top_edge_aa(false),
-      right_edge_aa(false),
-      bottom_edge_aa(false) {
+      swizzle_contents(false) {
 }
 
 scoped_ptr<TileDrawQuad> TileDrawQuad::Create() {
@@ -28,11 +24,7 @@ void TileDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                           unsigned resource_id,
                           const gfx::RectF& tex_coord_rect,
                           gfx::Size texture_size,
-                          bool swizzle_contents,
-                          bool left_edge_aa,
-                          bool top_edge_aa,
-                          bool right_edge_aa,
-                          bool bottom_edge_aa) {
+                          bool swizzle_contents) {
   gfx::Rect visible_rect = rect;
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
@@ -41,13 +33,6 @@ void TileDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
   this->tex_coord_rect = tex_coord_rect;
   this->texture_size = texture_size;
   this->swizzle_contents = swizzle_contents;
-  this->left_edge_aa = left_edge_aa;
-  this->top_edge_aa = top_edge_aa;
-  this->right_edge_aa = right_edge_aa;
-  this->bottom_edge_aa = bottom_edge_aa;
-
-  // Override needs_blending after initializing the quad.
-  this->needs_blending = IsAntialiased();
 }
 
 void TileDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
@@ -58,21 +43,13 @@ void TileDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                           unsigned resource_id,
                           const gfx::RectF& tex_coord_rect,
                           gfx::Size texture_size,
-                          bool swizzle_contents,
-                          bool left_edge_aa,
-                          bool top_edge_aa,
-                          bool right_edge_aa,
-                          bool bottom_edge_aa) {
+                          bool swizzle_contents) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
   this->resource_id = resource_id;
   this->tex_coord_rect = tex_coord_rect;
   this->texture_size = texture_size;
   this->swizzle_contents = swizzle_contents;
-  this->left_edge_aa = left_edge_aa;
-  this->top_edge_aa = top_edge_aa;
-  this->right_edge_aa = right_edge_aa;
-  this->bottom_edge_aa = bottom_edge_aa;
 }
 
 void TileDrawQuad::IterateResources(
diff --git a/cc/tile_draw_quad.h b/cc/tile_draw_quad.h
index 2018a54..ff04b4b 100644
--- a/cc/tile_draw_quad.h
+++ b/cc/tile_draw_quad.h
@@ -24,11 +24,7 @@ class CC_EXPORT TileDrawQuad : public DrawQuad {
               unsigned resource_id,
               const gfx::RectF& tex_coord_rect,
               gfx::Size texture_size,
-              bool swizzle_contents,
-              bool left_edge_aa,
-              bool top_edge_aa,
-              bool right_edge_aa,
-              bool bottom_edge_aa);
+              bool swizzle_contents);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               gfx::Rect rect,
@@ -38,28 +34,13 @@ class CC_EXPORT TileDrawQuad : public DrawQuad {
               unsigned resource_id,
               const gfx::RectF& tex_coord_rect,
               gfx::Size texture_size,
-              bool swizzle_contents,
-              bool left_edge_aa,
-              bool top_edge_aa,
-              bool right_edge_aa,
-              bool bottom_edge_aa);
+              bool swizzle_contents);
 
   unsigned resource_id;
   gfx::RectF tex_coord_rect;
   gfx::Size texture_size;
   bool swizzle_contents;
 
-  // TODO(danakj): Stick the data used to compute these things in the quad
-  // instead so the parent compositor can decide to use AA on its own.
-  bool left_edge_aa;
-  bool top_edge_aa;
-  bool right_edge_aa;
-  bool bottom_edge_aa;
-
-  bool IsAntialiased() const {
-    return left_edge_aa || top_edge_aa || right_edge_aa || bottom_edge_aa;
-  }
-
   virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
 
diff --git a/cc/tiled_layer_impl.cc b/cc/tiled_layer_impl.cc
index b668bf0..210ea98 100644
--- a/cc/tiled_layer_impl.cc
+++ b/cc/tiled_layer_impl.cc
@@ -218,18 +218,8 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
             float tileHeight = static_cast<float>(m_tiler->tileSize().height());
             gfx::Size textureSize(tileWidth, tileHeight);
 
-            bool clipped = false;
-            gfx::QuadF visibleContentInTargetQuad = MathUtil::mapQuad(drawTransform(), gfx::QuadF(visibleContentRect()), clipped);
-            bool isAxisAlignedInTarget = !clipped && visibleContentInTargetQuad.IsRectilinear();
-            bool useAA = m_tiler->hasBorderTexels() && !isAxisAlignedInTarget;
-
-            bool leftEdgeAA = !i && useAA;
-            bool topEdgeAA = !j && useAA;
-            bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
-            bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
-
             scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
-            quad->SetNew(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+            quad->SetNew(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled());
             quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
         }
     }