Revert 205218 "cc: Enable AntiAliasing for sub-pixel translation..."

Breaks tiling since we need to enable AA on a per-edge basis to not AA internal
edges.

> cc: Enable AntiAliasing for sub-pixel translations in software renderer
> 
> While here, make the blue/yellow tests horizontal instead of vertical
> stripes, so that we can detect vertical flipping issues.
> 
> Tests: RendererPixelTest.EnlargedRenderPassTextureWithAntiAliasing
> 
> R=enne
> BUG=247782
> 
> Review URL: https://chromiumcodereview.appspot.com/16634015

TBR=danakj@chromium.org

Review URL: https://codereview.chromium.org/16406007

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

2 files changed, 11 insertions, 85 deletions

diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index 76de3ad..cb91ca6 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -536,7 +536,7 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
       FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false)));
 }
 
-TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) {
+TYPED_TEST(RendererPixelTest, DISABLED_RenderPassChangesSize) {
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPass::Id root_pass_id(1, 1);
@@ -557,16 +557,16 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) {
   blue->SetNew(shared_state.get(),
                gfx::Rect(0,
                          0,
-                         this->device_viewport_size_.width(),
-                         this->device_viewport_size_.height() / 2),
+                         this->device_viewport_size_.width() / 2,
+                         this->device_viewport_size_.height()),
                SK_ColorBLUE,
                false);
   scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
   yellow->SetNew(shared_state.get(),
-                 gfx::Rect(0,
-                           this->device_viewport_size_.height() / 2,
-                           this->device_viewport_size_.width(),
-                           this->device_viewport_size_.height() / 2),
+                 gfx::Rect(this->device_viewport_size_.width() / 2,
+                           0,
+                           this->device_viewport_size_.width() / 2,
+                           this->device_viewport_size_.height()),
                  SK_ColorYELLOW,
                  false);
 
@@ -592,74 +592,6 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) {
       ExactPixelComparator(true)));
 }
 
-TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) {
-  gfx::Rect viewport_rect(this->device_viewport_size_);
-
-  RenderPass::Id root_pass_id(1, 1);
-  scoped_ptr<RenderPass> root_pass =
-      CreateTestRootRenderPass(root_pass_id, viewport_rect);
-
-  RenderPass::Id child_pass_id(2, 2);
-  gfx::Rect pass_rect(this->device_viewport_size_);
-  gfx::Transform transform_to_root;
-  scoped_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
-
-  gfx::Transform content_to_target_transform;
-  scoped_ptr<SharedQuadState> shared_state =
-      CreateTestSharedQuadState(content_to_target_transform, viewport_rect);
-
-  scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
-  blue->SetNew(shared_state.get(),
-               gfx::Rect(0,
-                         0,
-                         this->device_viewport_size_.width(),
-                         this->device_viewport_size_.height() / 2),
-               SK_ColorBLUE,
-               false);
-  scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
-  yellow->SetNew(shared_state.get(),
-                 gfx::Rect(0,
-                           this->device_viewport_size_.height() / 2,
-                           this->device_viewport_size_.width(),
-                           this->device_viewport_size_.height() / 2),
-                 SK_ColorYELLOW,
-                 false);
-
-  child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
-  child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
-
-  gfx::Transform aa_transform;
-  aa_transform.Translate(0.5, 0.0);
-
-  scoped_ptr<SharedQuadState> pass_shared_state =
-      CreateTestSharedQuadState(aa_transform, pass_rect);
-  root_pass->quad_list.push_back(
-      CreateTestRenderPassDrawQuad(pass_shared_state.get(),
-                                   pass_rect,
-                                   child_pass_id));
-
-  scoped_ptr<SharedQuadState> root_shared_state =
-      CreateTestSharedQuadState(gfx::Transform(), viewport_rect);
-  scoped_ptr<SolidColorDrawQuad> background = SolidColorDrawQuad::Create();
-  background->SetNew(root_shared_state.get(),
-                     gfx::Rect(this->device_viewport_size_),
-                     SK_ColorWHITE,
-                     false);
-  root_pass->quad_list.push_back(background.PassAs<DrawQuad>());
-
-  RenderPassList pass_list;
-  pass_list.push_back(child_pass.Pass());
-  pass_list.push_back(root_pass.Pass());
-
-  this->renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75));
-
-  EXPECT_TRUE(this->RunPixelTest(
-      &pass_list,
-      base::FilePath(FILE_PATH_LITERAL("blue_yellow_anti_aliasing.png")),
-      FuzzyForSoftwareOnlyPixelComparator<TypeParam>(true)));
-}
-
 template <typename RendererType>
 class RendererPixelTestWithBackgroundFilter
     : public RendererPixelTest<RendererType> {
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 15a8b90..9884666 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -32,14 +32,8 @@ namespace cc {
 
 namespace {
 
-static inline bool IsScalarNearlyInteger(SkScalar scalar) {
-  return SkScalarNearlyZero(scalar - SkScalarRound(scalar));
-}
-
-bool IsScaleAndIntegerTranslate(const SkMatrix& matrix) {
-  return IsScalarNearlyInteger(matrix[SkMatrix::kMTransX]) &&
-         IsScalarNearlyInteger(matrix[SkMatrix::kMTransY]) &&
-         SkScalarNearlyZero(matrix[SkMatrix::kMSkewX]) &&
+bool IsScaleAndTranslate(const SkMatrix& matrix) {
+  return SkScalarNearlyZero(matrix[SkMatrix::kMSkewX]) &&
          SkScalarNearlyZero(matrix[SkMatrix::kMSkewY]) &&
          SkScalarNearlyZero(matrix[SkMatrix::kMPersp0]) &&
          SkScalarNearlyZero(matrix[SkMatrix::kMPersp1]) &&
@@ -161,7 +155,7 @@ bool SoftwareRenderer::BindFramebufferToTexture(
                      target_rect,
                      gfx::Rect(target_rect.size()),
                      target_rect.size(),
-                     FlippedFramebuffer());
+                     false);
   return true;
 }
 
@@ -228,7 +222,7 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
   current_canvas_->setMatrix(sk_device_matrix);
 
   current_paint_.reset();
-  if (!IsScaleAndIntegerTranslate(sk_device_matrix)) {
+  if (!IsScaleAndTranslate(sk_device_matrix)) {
     current_paint_.setAntiAlias(true);
     current_paint_.setFilterBitmap(true);
   }