cc: Moving anti-aliasing decision to parent compositor.

cc/picture_layer_impl.cc

 // Copyright 2012 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/picture_layer_impl.h"
 
 #include "base/time.h"
 #include "cc/append_quads_data.h"
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
@@ skipping 80 matching lines @@
   SharedQuadState* sharedQuadState =
       quadSink.useSharedQuadState(createSharedQuadState());
   appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
 
   bool clipped = false;
   gfx::QuadF target_quad = MathUtil::mapQuad(
       drawTransform(),
       gfx::QuadF(rect),
       clipped);
   bool isAxisAlignedInTarget = !clipped && target_quad.IsRectilinear();
-  bool useAA = !isAxisAlignedInTarget;
 
   bool isPixelAligned = isAxisAlignedInTarget && drawTransform().IsIdentityOrIntegerTranslation();
   PictureLayerTiling::LayerDeviceAlignment layerDeviceAlignment =
     isPixelAligned ? PictureLayerTiling::LayerAlignedToDevice
                    : PictureLayerTiling::LayerNotAlignedToDevice;
 
   if (showDebugBorders()) {
     for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                               contentsScaleX(),
                                               rect,
@@ skipping 66 matching lines @@
       continue;
     }
 
     if (iter->contents_scale() != ideal_contents_scale_)
       appendQuadsData.hadIncompleteTile = true;
 
     gfx::RectF texture_rect = iter.texture_rect();
     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,
                  opaque_rect,
                  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())
       seen_tilings.push_back(iter.CurrentTiling());
   }
 
   // Aggressively remove any tilings that are not seen to save memory. Note
   // that this is at the expense of doing cause more frequent re-painting. A
   // better scheme would be to maintain a tighter visibleContentRect for the
   // finer tilings.
@@ skipping 578 matching lines @@
 scoped_ptr<base::Value> PictureLayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   LayerImpl::AsValueInto(state.get());
 
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->Set("tilings", tilings_->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc