Determine mask UVs based on texture size

cc/layers/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/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 833 matching lines @@
   // Ensure that tile width and height are properly aligned.
   tile_width = MathUtil::UncheckedRoundUp(tile_width, kTileMinimalAlignment);
   tile_height = MathUtil::UncheckedRoundUp(tile_height, kTileMinimalAlignment);
 
   // Under no circumstance should we be larger than the max texture size.
   tile_width = std::min(tile_width, max_texture_size);
   tile_height = std::min(tile_height, max_texture_size);
   return gfx::Size(tile_width, tile_height);
 }
 
-void PictureLayerImpl::GetContentsResourceId(ResourceId* resource_id,
-                                             gfx::Size* resource_size) const {
+void PictureLayerImpl::GetContentsResourceId(
+    ResourceId* resource_id,
+    gfx::Size* resource_size,
+    gfx::SizeF* resource_uv_size) const {
   // The bounds and the pile size may differ if the pile wasn't updated (ie.
   // PictureLayer::Update didn't happen). In that case the pile will be empty.
   DCHECK(raster_source_->GetSize().IsEmpty() ||
          bounds() == raster_source_->GetSize())
       << " bounds " << bounds().ToString() << " pile "
       << raster_source_->GetSize().ToString();
   float dest_scale = MaximumTilingContentsScale();
   gfx::Rect content_rect =
       gfx::ScaleToEnclosingRect(gfx::Rect(bounds()), dest_scale);
   PictureLayerTilingSet::CoverageIterator iter(
@@ skipping 12 matching lines @@
 
   const TileDrawInfo& draw_info = iter->draw_info();
   if (!draw_info.IsReadyToDraw() ||
       draw_info.mode() != TileDrawInfo::RESOURCE_MODE) {
     *resource_id = 0;
     return;
   }
 
   *resource_id = draw_info.resource_id();
   *resource_size = draw_info.resource_size();
+  // |resource_uv_size| represents the range of UV coordinates that map to the
+  // content being drawn. Typically, we draw to the entire texture, so these
+  // coordinates are (1.0f, 1.0f). However, if we are rasterizing to an
+  // over-large texture, this size will be smaller, mapping to the subset of the
+  // texture being used.
+  gfx::SizeF requested_tile_size =
+      gfx::SizeF(iter->tiling()->tiling_data()->tiling_size());
+  DCHECK_LE(requested_tile_size.width(), draw_info.resource_size().width());
+  DCHECK_LE(requested_tile_size.height(), draw_info.resource_size().height());
+  *resource_uv_size = gfx::SizeF(
+      requested_tile_size.width() / draw_info.resource_size().width(),
+      requested_tile_size.height() / draw_info.resource_size().height());
 }
 
 void PictureLayerImpl::SetNearestNeighbor(bool nearest_neighbor) {
   if (nearest_neighbor_ == nearest_neighbor)
     return;
 
   nearest_neighbor_ = nearest_neighbor;
   NoteLayerPropertyChanged();
 }
 
@@ skipping 526 matching lines @@
   }
 
   invalidation_.Union(invalidation);
   tilings_->UpdateTilingsForImplSideInvalidation(invalidation);
   SetNeedsPushProperties();
   TRACE_EVENT_END1("cc", "PictureLayerImpl::InvalidateRegionForImages",
                    "Invalidation", invalidation.ToString());
 }
 
 }  // namespace cc