cc: Support anti-aliasing for solid color layers.

cc/layer_tree_host_impl_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 1707 matching lines @@
         m_quadsAppended = true;
 
         gfx::Rect opaqueRect;
         if (contentsOpaque())
             opaqueRect = m_quadRect;
         else
             opaqueRect = m_opaqueContentRect;
 
         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, DrawQuad::AntiAliasing(), 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());
         quadSink.append(testBlendingDrawQuad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
     void setExpectation(bool blend, bool hasRenderSurface)
     {
         m_blend = blend;
         m_hasRenderSurface = hasRenderSurface;
@@ skipping 480 matching lines @@
 public:
     static scoped_ptr<LayerImpl> create(LayerTreeImpl* treeImpl, int id) { return scoped_ptr<LayerImpl>(new FakeLayerWithQuads(treeImpl, id)); }
 
     virtual void appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData) OVERRIDE
     {
         SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 
         SkColor gray = SkColorSetRGB(100, 100, 100);
         gfx::Rect quadRect(gfx::Point(0, 0), contentBounds());
         scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::Create();
-        myQuad->SetNew(sharedQuadState, quadRect, gray);
+        myQuad->SetNew(sharedQuadState, quadRect, DrawQuad::AntiAliasing(), gray);
         quadSink.append(myQuad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
 private:
     FakeLayerWithQuads(LayerTreeImpl* treeImpl, int id)
         : LayerImpl(treeImpl, id)
     {
     }
 };
 
@@ skipping 1500 matching lines @@
         if (!testData.renderPassCache.contains(renderPassId))
             isReplica = true;
 
         scoped_ptr<TestRenderPass> renderPass = testData.renderPassCache.take(renderPassId);
 
         // Cycle through quad data and create all quads
         while (*currentChar && *currentChar != '\n') {
             if (*currentChar == 's') {
                 // Solid color draw quad
                 scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-                quad->SetNew(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE);
+                quad->SetNew(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), DrawQuad::AntiAliasing(), SK_ColorWHITE);
 
                 renderPass->AppendQuad(quad.PassAs<DrawQuad>());
                 currentChar++;
             } else if ((*currentChar >= 'A') && (*currentChar <= 'Z')) {
                 // RenderPass draw quad
                 int layerId = *currentChar;
                 currentChar++;
                 ASSERT_TRUE(currentChar);
                 int index = *currentChar;
                 currentChar++;
@@ skipping 651 matching lines @@
     gfx::Rect noDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
     drawFrameAndTestDamage(noDamage);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc