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

cc/picture_layer_impl_unittest.cc

 // Copyright 2013 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 "cc/layer_tree_impl.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 156 matching lines @@
         TestablePictureLayerImpl::create(pending_tree, id_, pile);
     pending_layer->setDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
   }
 
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
     for (PictureLayerTiling::Iterator iter(tiling,
                                            tiling->contents_scale(),
-                                           tiling->ContentRect());
+                                           tiling->ContentRect(),
+                                           PictureLayerTiling::LayerDeviceAlignmentUnknown);
          iter; ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_EQ(pile, iter->picture_pile());
     }
   }
 
   void SetContentsScaleOnBothLayers(float scale, bool animating_transform) {
     float result_scale_x, result_scale_y;
     gfx::Size result_bounds;
     pending_layer_->calculateContentsScale(
@@ skipping 54 matching lines @@
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings.tiling_at(i);
     gfx::Rect content_invalidation = gfx::ToEnclosingRect(gfx::ScaleRect(
         layer_invalidation,
         tiling->contents_scale()));
     for (PictureLayerTiling::Iterator iter(tiling,
                                            tiling->contents_scale(),
-                                           tiling->ContentRect());
+                                           tiling->ContentRect(),
+                                           PictureLayerTiling::LayerDeviceAlignmentUnknown);
          iter; ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       if (iter.geometry_rect().Intersects(content_invalidation))
         EXPECT_EQ(pending_pile, iter->picture_pile());
       else
         EXPECT_EQ(active_pile, iter->picture_pile());
     }
   }
 }
@@ skipping 39 matching lines @@
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings.tiling_at(i);
     gfx::Rect active_content_bounds = gfx::ToEnclosingRect(gfx::ScaleRect(
         gfx::Rect(active_layer_bounds),
         tiling->contents_scale()));
     for (PictureLayerTiling::Iterator iter(tiling,
                                            tiling->contents_scale(),
-                                           tiling->ContentRect());
+                                           tiling->ContentRect(),
+                                           PictureLayerTiling::LayerDeviceAlignmentUnknown);
          iter; ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       if (iter.geometry_rect().right() >= active_content_bounds.width() ||
           iter.geometry_rect().bottom() >= active_content_bounds.height()) {
         EXPECT_EQ(pending_pile, iter->picture_pile());
       } else {
         EXPECT_EQ(active_pile, iter->picture_pile());
       }
     }
@@ skipping 28 matching lines @@
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings.tiling_at(i);
 
     for (PictureLayerTiling::Iterator iter(tiling,
                                            tiling->contents_scale(),
-                                           tiling->ContentRect());
+                                           tiling->ContentRect(),
+                                           PictureLayerTiling::LayerDeviceAlignmentUnknown);
          iter; ++iter) {
       EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty());
       // Ensure there is a recording for this tile.
       gfx::Rect layer_rect = gfx::ToEnclosingRect(
           gfx::ScaleRect(
               iter.full_tile_geometry_rect(), 1.f / tiling->contents_scale()));
       layer_rect.Intersect(gfx::Rect(layer_bounds));
 
       bool in_pending = pending_pile->recorded_region().Contains(layer_rect);
       bool in_active = active_pile->recorded_region().Contains(layer_rect);
@@ skipping 227 matching lines @@
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings().num_tilings());
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
   
 }
 
 }  // namespace
 }  // namespace cc