cc: Remove texture scaling and clear edge texels of a layer.

cc/picture_layer_tiling.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_tiling.h"
 
 #include <cmath>
 
 #include "base/debug/trace_event.h"
 #include "cc/math_util.h"
@@ skipping 172 matching lines @@
       bottom_(-1) {
 }
 
 PictureLayerTiling::Iterator::Iterator(const PictureLayerTiling* tiling,
                                        float dest_scale,
                                        gfx::Rect dest_rect,
                                        LayerDeviceAlignment layerDeviceAlignment)
     : tiling_(tiling),
       dest_rect_(dest_rect),
       current_tile_(NULL),
-      dest_to_content_scale_x_(0),
-      dest_to_content_scale_y_(0),
+      dest_to_content_scale_(0),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
   DCHECK(tiling_);
   if (dest_rect_.IsEmpty())
     return;
 
-  float dest_to_content_scale = tiling_->contents_scale_ / dest_scale;
+  dest_to_content_scale_ = tiling_->contents_scale_ / dest_scale;
   // This is the maximum size that the dest rect can be, given the content size.
   gfx::Size dest_content_size = gfx::ToCeiledSize(gfx::ScaleSize(
       tiling_->ContentRect().size(),
-      1 / dest_to_content_scale,
-      1 / dest_to_content_scale));
-
-  // The last row/column of texels may not have full rasterization coverage,
-  // which can happen if the ceiled content size does not equal the floored
-  // content size.  These texels will sample outside of the recording to
-  // generate their pixels.  Use the floored size here to ignore them.
-  gfx::Size content_size_floor = gfx::ToFlooredSize(tiling->ContentSizeF());
-  dest_to_content_scale_x_ = content_size_floor.width() /
-      static_cast<float>(dest_content_size.width());
-  dest_to_content_scale_y_ = content_size_floor.height() /
-      static_cast<float>(dest_content_size.height());
-
-  // It's possible that when drawing a quad with texel:pixel ratio < 1
-  // GL_LINEAR will cause us to blend in invalid texels.
-  // We stretch the content a little more to prevent sampling past the
-  // middle of the last texel.
-  if (layerDeviceAlignment == LayerAlignedToDevice){
-    if (dest_to_content_scale_x_ < 1.0)
-      dest_to_content_scale_x_ -= 0.5f / dest_content_size.width();
-    if (dest_to_content_scale_y_ < 1.0)
-      dest_to_content_scale_y_ -= 0.5f / dest_content_size.height();
-  }
-  else if (layerDeviceAlignment == LayerNotAlignedToDevice) {
-    dest_to_content_scale_x_ -= 0.5f / dest_content_size.width();
-    dest_to_content_scale_y_ -= 0.5f / dest_content_size.height();
-  }
+      1 / dest_to_content_scale_,
+      1 / dest_to_content_scale_));
 
   gfx::Rect content_rect =
       gfx::ToEnclosingRect(gfx::ScaleRect(dest_rect_,
-                                          dest_to_content_scale_x_,
-                                          dest_to_content_scale_y_));
+                                          dest_to_content_scale_,
+                                          dest_to_content_scale_));
   // IndexFromSrcCoord clamps to valid tile ranges, so it's necessary to
   // check for non-intersection first.
   content_rect.Intersect(gfx::Rect(tiling_->tiling_data_.total_size()));
   if (content_rect.IsEmpty())
     return;
 
   left_ = tiling_->tiling_data_.TileXIndexFromSrcCoord(content_rect.x());
   top_ = tiling_->tiling_data_.TileYIndexFromSrcCoord(content_rect.y());
   right_ = tiling_->tiling_data_.TileXIndexFromSrcCoord(
       content_rect.right() - 1);
@@ skipping 28 matching lines @@
   current_tile_ = tiling_->TileAt(tile_i_, tile_j_);
 
   // Calculate the current geometry rect.  Due to floating point rounding
   // and ToEnclosingRect, tiles might overlap in destination space on the
   // edges.
   gfx::Rect last_geometry_rect = current_geometry_rect_;
 
   gfx::Rect content_rect = tiling_->tiling_data_.TileBounds(tile_i_, tile_j_);
 
   current_geometry_rect_ = gfx::ToEnclosingRect(
-      gfx::ScaleRect(content_rect, 1 / dest_to_content_scale_x_,
-                                   1 / dest_to_content_scale_y_));
+      gfx::ScaleRect(content_rect, 1 / dest_to_content_scale_,
+                                   1 / dest_to_content_scale_));
 
   current_geometry_rect_.Intersect(dest_rect_);
 
   if (first_time)
     return *this;
 
   // Iteration happens left->right, top->bottom.  Running off the bottom-right
   // edge is handled by the intersection above with dest_rect_.  Here we make
   // sure that the new current geometry rect doesn't overlap with the last.
   int min_left;
@@ skipping 28 matching lines @@
   rect.set_size(tiling_->tiling_data_.max_texture_size());
   return rect;
 }
 
 gfx::RectF PictureLayerTiling::Iterator::texture_rect() const {
   gfx::PointF tex_origin =
       tiling_->tiling_data_.TileBoundsWithBorder(tile_i_, tile_j_).origin();
 
   // Convert from dest space => content space => texture space.
   gfx::RectF texture_rect(current_geometry_rect_);
-  texture_rect.Scale(dest_to_content_scale_x_,
-                     dest_to_content_scale_y_);
+  texture_rect.Scale(dest_to_content_scale_,
+                     dest_to_content_scale_);
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
   texture_rect.Intersect(tiling_->ContentRect());
 
   return texture_rect;
 }
 
 gfx::Size PictureLayerTiling::Iterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
@@ skipping 395 matching lines @@
                          (bottom_complete ? 1 : 0);
     if (num_edges_complete == 4)
       return working_rect;
   }
 
   NOTREACHED();
   return starting_rect;
 }
 
 }  // namespace cc