cc: Stretch textures by .5 texels to prevent out of bounds sampling

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 78 matching lines @@
   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();

[brianderson, 2013/02/13 00:10:19]

Note: the logic here reflects the logic used to determine when to use GL_NEAREST
in gl_renderer.cc.

The scale is taken into account at a per-tiling level inside the
PictureLayerTiling::Iterator constructor.

+  PictureLayerTiling::LayerDeviceAlignment layerDeviceAlignment =
+    isPixelAligned ? PictureLayerTiling::LayerAlignedToDevice
+                   : PictureLayerTiling::LayerNotAlignedToDevice;
+
   if (showDebugBorders()) {
     for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                               contentsScaleX(),
                                               rect,
-                                              ideal_contents_scale_);
+                                              ideal_contents_scale_,
+                                              layerDeviceAlignment);
          iter;
          ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->GetResourceId()) {
         if (iter->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
           width = DebugColors::HighResTileBorderWidth(layerTreeImpl());
         } else if (iter->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
@@ skipping 18 matching lines @@
     }
   }
 
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
   std::vector<PictureLayerTiling*> seen_tilings;
 
   for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                             contentsScaleX(),
                                             rect,
-                                            ideal_contents_scale_);
+                                            ideal_contents_scale_,
+                                            layerDeviceAlignment);
        iter;
        ++iter) {
     ResourceProvider::ResourceId resource = 0;
     if (*iter)
       resource = iter->GetResourceId();
 
     gfx::Rect geometry_rect = iter.geometry_rect();
 
     if (!resource) {
       if (drawCheckerboardForMissingTiles()) {
@@ skipping 266 matching lines @@
   if (tilings_)
     tilings_->RemoveAllTiles();
 }
 
 ResourceProvider::ResourceId PictureLayerImpl::contentsResourceId() const {
   gfx::Rect content_rect(gfx::Point(), contentBounds());
   float scale = contentsScaleX();
   for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                             scale,
                                             content_rect,
-                                            ideal_contents_scale_);
+                                            ideal_contents_scale_,
+                                            PictureLayerTiling::LayerDeviceAlignmentUnknown);
        iter;
        ++iter) {
     // Mask resource not ready yet.
     if (!*iter || !iter->GetResourceId())
       return 0;
     // Masks only supported if they fit on exactly one tile.
     if (iter.geometry_rect() != content_rect)
       return 0;
     return iter->GetResourceId();
   }
@@ skipping 27 matching lines @@
 
   Region missing_region = rect;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
 
     if (tiling->contents_scale() < min_acceptable_scale)
       continue;
 
     for (PictureLayerTiling::Iterator iter(tiling,
                                            contentsScaleX(),
-                                           rect);
+                                           rect,
+                                           PictureLayerTiling::LayerDeviceAlignmentUnknown);
          iter;
          ++iter) {
       // A null tile (i.e. no recording) is considered "ready".
       if (!*iter || iter->GetResourceId())
         missing_region.Subtract(iter.geometry_rect());
     }
   }
 
   return missing_region.IsEmpty();
 }
@@ skipping 225 matching lines @@
   return twin;
 }
 
 void PictureLayerImpl::getDebugBorderProperties(
     SkColor* color, float* width) const {
   *color = DebugColors::TiledContentLayerBorderColor();
   *width = DebugColors::TiledContentLayerBorderWidth(layerTreeImpl());
 }
 
 }  // namespace cc