Include mask texture size in RenderPassDrawQuad

In order to support GL_TEXTURE_RECTANGLE_ARB, cc::GLRenderer needs to
know the size of the mask texture to unnormalize the texture
coordinates.  This has already been done for TileDrawQuad.

As an optimization, rather than adding two more members onto the already
bloated RenderPassDrawQuad, turn mask_uv_rect into mask_uv_scale.  The
position of the mask is now assumed to always be at the origin of the
quad's transform, which it always is in cc.  This is equivalent to
saying that the mask is always attached to the owning layer of a render
surface (since that's what defines the transform origin of the render
surface).

By making this assumption, the old mask_uv_rect can be calculated in
a helper function from just quad->rect and quad->mask_uv_scale.

With this patch, mask_texture_size is currently unused, but its values
are unit tested.

Depends on https://codereview.chromium.org/652393002/

R=danakj@chromium.org,jamesr@chromium.org
BUG=423533

Review URL: https://codereview.chromium.org/659683002

Cr-Commit-Position: refs/heads/master@{#299932}

27 files changed, 278 insertions, 144 deletions

diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 26e0aec..e66cc766 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -589,7 +589,8 @@ class DelegatedRendererLayerImplTestTransform
                              gfx::Rect(5, 5, 7, 7),  // visible_rect
                              RenderPassId(10, 7),    // render_pass_id
                              0,                      // mask_resource_id
-                             gfx::RectF(),           // mask_uv_rect
+                             gfx::Vector2dF(),       // mask_uv_scale
+                             gfx::Size(),            // mask_texture_size
                              FilterOperations(),     // filters
                              gfx::Vector2dF(),       // filters_scale
                              FilterOperations());    // background_filters
@@ -1021,7 +1022,8 @@ class DelegatedRendererLayerImplTestClip
                              gfx::Rect(5, 5, 7, 7),  // visible_quad_rect
                              RenderPassId(10, 7),    // render_pass_id
                              0,                      // mask_resource_id
-                             gfx::RectF(),           // mask_uv_rect
+                             gfx::Vector2dF(),       // mask_uv_scale
+                             gfx::Size(),            // mask_texture_size,
                              FilterOperations(),     // filters
                              gfx::Vector2dF(),       // filters_scale
                              FilterOperations());    // background_filters
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index a361772..bad15fc 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -349,9 +349,10 @@ RenderPassId LayerImpl::NextContributingRenderPassId(RenderPassId id) const {
   return RenderPassId(0, 0);
 }
 
-ResourceProvider::ResourceId LayerImpl::ContentsResourceId() const {
+void LayerImpl::GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+                                      gfx::Size* resource_size) const {
   NOTREACHED();
-  return 0;
+  *resource_id = 0;
 }
 
 void LayerImpl::SetSentScrollDelta(const gfx::Vector2dF& sent_scroll_delta) {
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 7e51eed..65b68f0 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -200,7 +200,8 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
                            AppendQuadsData* append_quads_data) {}
   virtual void DidDraw(ResourceProvider* resource_provider);
 
-  virtual ResourceProvider::ResourceId ContentsResourceId() const;
+  virtual void GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+                                     gfx::Size* resource_size) const;
 
   virtual bool HasDelegatedContent() const;
   virtual bool HasContributingDelegatedRenderPasses() const;
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 0d1e189..fd8a507 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -806,14 +806,18 @@ void PictureLayerImpl::SyncTiling(
   }
 }
 
-ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const {
-  gfx::Rect content_rect(content_bounds());
+void PictureLayerImpl::GetContentsResourceId(
+    ResourceProvider::ResourceId* resource_id,
+    gfx::Size* resource_size) const {
+  gfx::Rect content_rect(bounds());
   PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), 1.f, content_rect, ideal_contents_scale_);
 
   // Mask resource not ready yet.
-  if (!iter || !*iter)
-    return 0;
+  if (!iter || !*iter) {
+    *resource_id = 0;
+    return;
+  }
 
   // Masks only supported if they fit on exactly one tile.
   DCHECK(iter.geometry_rect() == content_rect)
@@ -822,10 +826,13 @@ ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const {
 
   const ManagedTileState::DrawInfo& draw_info = iter->draw_info();
   if (!draw_info.IsReadyToDraw() ||
-      draw_info.mode() != ManagedTileState::DrawInfo::RESOURCE_MODE)
-    return 0;
+      draw_info.mode() != ManagedTileState::DrawInfo::RESOURCE_MODE) {
+    *resource_id = 0;
+    return;
+  }
 
-  return draw_info.get_resource_id();
+  *resource_id = draw_info.get_resource_id();
+  *resource_size = iter.texture_size();
 }
 
 void PictureLayerImpl::DoPostCommitInitialization() {
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index 2fb877e..967b930 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -139,7 +139,8 @@ class CC_EXPORT PictureLayerImpl
   void SyncTiling(const PictureLayerTiling* tiling);
 
   // Mask-related functions.
-  virtual ResourceProvider::ResourceId ContentsResourceId() const override;
+  virtual void GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+                                     gfx::Size* resource_size) const override;
 
   virtual size_t GPUMemoryUsageInBytes() const override;
 
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 135695b..9b767ce 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -1202,7 +1202,11 @@ TEST_F(PictureLayerImplTest, HugeMasksDontGetTiles) {
   // Mask layers have a tiling with a single tile in it.
   EXPECT_EQ(1u, active_layer_->HighResTiling()->AllTilesForTesting().size());
   // The mask resource exists.
-  EXPECT_NE(0u, active_layer_->ContentsResourceId());
+  ResourceProvider::ResourceId mask_resource_id;
+  gfx::Size mask_texture_size;
+  active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
+  EXPECT_NE(0u, mask_resource_id);
+  EXPECT_EQ(mask_texture_size, active_layer_->bounds());
 
   // Resize larger than the max texture size.
   int max_texture_size = host_impl_.GetRendererCapabilities().max_texture_size;
@@ -1225,7 +1229,41 @@ TEST_F(PictureLayerImplTest, HugeMasksDontGetTiles) {
   // Mask layers have a tiling, but there should be no tiles in it.
   EXPECT_EQ(0u, active_layer_->HighResTiling()->AllTilesForTesting().size());
   // The mask resource is empty.
-  EXPECT_EQ(0u, active_layer_->ContentsResourceId());
+  active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
+  EXPECT_EQ(0u, mask_resource_id);
+}
+
+TEST_F(PictureLayerImplTest, ScaledMaskLayer) {
+  gfx::Size tile_size(100, 100);
+
+  scoped_refptr<FakePicturePileImpl> valid_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
+  valid_pile->set_is_mask(true);
+  SetupPendingTree(valid_pile);
+
+  float ideal_contents_scale = 1.3f;
+  SetupDrawPropertiesAndUpdateTiles(
+      pending_layer_, ideal_contents_scale, 1.f, 1.f, 1.f, false);
+  EXPECT_EQ(ideal_contents_scale,
+            pending_layer_->HighResTiling()->contents_scale());
+  EXPECT_EQ(1u, pending_layer_->num_tilings());
+
+  pending_layer_->HighResTiling()->CreateAllTilesForTesting();
+  host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
+      pending_layer_->HighResTiling()->AllTilesForTesting());
+
+  ActivateTree();
+
+  // Mask layers have a tiling with a single tile in it.
+  EXPECT_EQ(1u, active_layer_->HighResTiling()->AllTilesForTesting().size());
+  // The mask resource exists.
+  ResourceProvider::ResourceId mask_resource_id;
+  gfx::Size mask_texture_size;
+  active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
+  EXPECT_NE(0u, mask_resource_id);
+  gfx::Size expected_mask_texture_size = gfx::ToCeiledSize(
+      gfx::ScaleSize(active_layer_->bounds(), ideal_contents_scale));
+  EXPECT_EQ(mask_texture_size, expected_mask_texture_size);
 }
 
 TEST_F(PictureLayerImplTest, ReleaseResources) {
diff --git a/cc/layers/render_surface_impl.cc b/cc/layers/render_surface_impl.cc
index 18d50c5..ecb97a3 100644
--- a/cc/layers/render_surface_impl.cc
+++ b/cc/layers/render_surface_impl.cc
@@ -193,8 +193,11 @@ void RenderSurfaceImpl::AppendQuads(
       mask_layer = nullptr;
   }
 
-  gfx::RectF mask_uv_rect(0.f, 0.f, 1.f, 1.f);
+  ResourceProvider::ResourceId mask_resource_id = 0;
+  gfx::Size mask_texture_size;
+  gfx::Vector2dF mask_uv_scale;
   if (mask_layer) {
+    mask_layer->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
     gfx::Vector2dF owning_layer_draw_scale =
         MathUtil::ComputeTransform2dScaleComponents(
             owning_layer_->draw_transform(), 1.f);
@@ -202,22 +205,11 @@ void RenderSurfaceImpl::AppendQuads(
         owning_layer_->content_bounds(),
         owning_layer_draw_scale.x(),
         owning_layer_draw_scale.y());
-
-    float uv_scale_x =
-        content_rect_.width() / unclipped_mask_target_size.width();
-    float uv_scale_y =
-        content_rect_.height() / unclipped_mask_target_size.height();
-
-    mask_uv_rect = gfx::RectF(
-        uv_scale_x * content_rect_.x() / content_rect_.width(),
-        uv_scale_y * content_rect_.y() / content_rect_.height(),
-        uv_scale_x,
-        uv_scale_y);
+    mask_uv_scale = gfx::Vector2dF(
+        content_rect_.width() / unclipped_mask_target_size.width(),
+        content_rect_.height() / unclipped_mask_target_size.height());
   }
 
-  ResourceProvider::ResourceId mask_resource_id =
-      mask_layer ? mask_layer->ContentsResourceId() : 0;
-
   DCHECK(owning_layer_->draw_properties().target_space_transform.IsScale2d());
   gfx::Vector2dF owning_layer_to_target_scale =
       owning_layer_->draw_properties().target_space_transform.Scale2d();
@@ -231,7 +223,8 @@ void RenderSurfaceImpl::AppendQuads(
                visible_content_rect,
                render_pass_id,
                mask_resource_id,
-               mask_uv_rect,
+               mask_uv_scale,
+               mask_texture_size,
                owning_layer_->filters(),
                owning_layer_to_target_scale,
                owning_layer_->background_filters());
diff --git a/cc/layers/tiled_layer_impl.cc b/cc/layers/tiled_layer_impl.cc
index 5a0e81d..6052591 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -53,21 +53,25 @@ TiledLayerImpl::TiledLayerImpl(LayerTreeImpl* tree_impl, int id)
 TiledLayerImpl::~TiledLayerImpl() {
 }
 
-ResourceProvider::ResourceId TiledLayerImpl::ContentsResourceId() const {
+void TiledLayerImpl::GetContentsResourceId(
+    ResourceProvider::ResourceId* resource_id,
+    gfx::Size* resource_size) const {
   // This function is only valid for single texture layers, e.g. masks.
   DCHECK(tiler_);
   // It's possible the mask layer is created but has no size or otherwise
   // can't draw.
-  if (tiler_->num_tiles_x() == 0 || tiler_->num_tiles_y() == 0)
-    return 0;
+  if (tiler_->num_tiles_x() == 0 || tiler_->num_tiles_y() == 0) {
+    *resource_id = 0;
+    return;
+  }
 
   // Any other number of tiles other than 0 or 1 is incorrect for masks.
   DCHECK_EQ(tiler_->num_tiles_x(), 1);
   DCHECK_EQ(tiler_->num_tiles_y(), 1);
 
   DrawableTile* tile = TileAt(0, 0);
-  ResourceProvider::ResourceId resource_id = tile ? tile->resource_id() : 0;
-  return resource_id;
+  *resource_id = tile ? tile->resource_id() : 0;
+  *resource_size = tiler_->tile_size();
 }
 
 bool TiledLayerImpl::HasTileAt(int i, int j) const {
diff --git a/cc/layers/tiled_layer_impl.h b/cc/layers/tiled_layer_impl.h
index 0a65a96..fb6502c 100644
--- a/cc/layers/tiled_layer_impl.h
+++ b/cc/layers/tiled_layer_impl.h
@@ -32,7 +32,8 @@ class CC_EXPORT TiledLayerImpl : public LayerImpl {
                            const Occlusion& occlusion_in_content_space,
                            AppendQuadsData* append_quads_data) override;
 
-  virtual ResourceProvider::ResourceId ContentsResourceId() const override;
+  virtual void GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+                                     gfx::Size* resource_size) const override;
 
   void set_skips_draw(bool skips_draw) { skips_draw_ = skips_draw; }
   void SetTilingData(const LayerTilingData& tiler);
diff --git a/cc/layers/tiled_layer_impl_unittest.cc b/cc/layers/tiled_layer_impl_unittest.cc
index 3d34b9f..1becc6e 100644
--- a/cc/layers/tiled_layer_impl_unittest.cc
+++ b/cc/layers/tiled_layer_impl_unittest.cc
@@ -304,7 +304,10 @@ TEST_F(TiledLayerImplTest, EmptyMask) {
   scoped_ptr<TiledLayerImpl> layer =
       CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
 
-  EXPECT_EQ(0u, layer->ContentsResourceId());
+  ResourceProvider::ResourceId mask_resource_id;
+  gfx::Size mask_texture_size;
+  layer->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
+  EXPECT_EQ(0u, mask_resource_id);
   EXPECT_EQ(0, layer->TilingForTesting()->num_tiles_x());
   EXPECT_EQ(0, layer->TilingForTesting()->num_tiles_y());
 }
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index ac449a4..f0de102 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -1170,12 +1170,14 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
     device_layer_edges.InflateAntiAliasingDistance();
   }
 
-  scoped_ptr<ResourceProvider::ScopedReadLockGL> mask_resource_lock;
+  scoped_ptr<ResourceProvider::ScopedSamplerGL> mask_resource_lock;
   unsigned mask_texture_id = 0;
+  SamplerType mask_sampler = SamplerTypeNA;
   if (quad->mask_resource_id) {
-    mask_resource_lock.reset(new ResourceProvider::ScopedReadLockGL(
-        resource_provider_, quad->mask_resource_id));
+    mask_resource_lock.reset(new ResourceProvider::ScopedSamplerGL(
+        resource_provider_, quad->mask_resource_id, GL_TEXTURE1, GL_LINEAR));
     mask_texture_id = mask_resource_lock->texture_id();
+    mask_sampler = SamplerTypeFromTextureTarget(mask_resource_lock->target());
   }
 
   // TODO(danakj): use the background_texture and blend the background in with
@@ -1370,29 +1372,22 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
   if (shader_mask_sampler_location != -1) {
     DCHECK_NE(shader_mask_tex_coord_scale_location, 1);
     DCHECK_NE(shader_mask_tex_coord_offset_location, 1);
+    DCHECK_EQ(SamplerType2D, mask_sampler);
     GLC(gl_, gl_->Uniform1i(shader_mask_sampler_location, 1));
 
-    float mask_tex_scale_x = quad->mask_uv_rect.width() / tex_scale_x;
-    float mask_tex_scale_y = quad->mask_uv_rect.height() / tex_scale_y;
+    gfx::RectF mask_uv_rect = quad->MaskUVRect();
 
     // Mask textures are oriented vertically flipped relative to the framebuffer
     // and the RenderPass contents texture, so we flip the tex coords from the
     // RenderPass texture to find the mask texture coords.
     GLC(gl_,
         gl_->Uniform2f(shader_mask_tex_coord_offset_location,
-                       quad->mask_uv_rect.x(),
-                       quad->mask_uv_rect.y() + quad->mask_uv_rect.height()));
+                       mask_uv_rect.x(),
+                       mask_uv_rect.bottom()));
     GLC(gl_,
         gl_->Uniform2f(shader_mask_tex_coord_scale_location,
-                       mask_tex_scale_x,
-                       -mask_tex_scale_y));
-    shader_mask_sampler_lock = make_scoped_ptr(
-        new ResourceProvider::ScopedSamplerGL(resource_provider_,
-                                              quad->mask_resource_id,
-                                              GL_TEXTURE1,
-                                              GL_LINEAR));
-    DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
-              shader_mask_sampler_lock->target());
+                       mask_uv_rect.width() / tex_scale_x,
+                       -mask_uv_rect.height() / tex_scale_y));
   }
 
   if (shader_edge_location != -1) {
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index 6a770e6..3fe1caf 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -103,11 +103,12 @@ void CreateTestRenderPassDrawQuad(const SharedQuadState* shared_state,
                rect,
                rect,
                pass_id,
-               0,                     // mask_resource_id
-               gfx::RectF(1.f, 1.f),  // mask_uv_rect
-               FilterOperations(),    // foreground filters
-               gfx::Vector2dF(),      // filters scale
-               FilterOperations());   // background filters
+               0,                    // mask_resource_id
+               gfx::Vector2dF(),     // mask_uv_scale
+               gfx::Size(),          // mask_texture_size
+               FilterOperations(),   // foreground filters
+               gfx::Vector2dF(),     // filters scale
+               FilterOperations());  // background filters
 }
 
 void CreateTestTextureDrawQuad(const gfx::Rect& rect,
@@ -798,7 +799,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
                            pass_rect,
                            child_pass_id,
                            0,
-                           gfx::RectF(),
+                           gfx::Vector2dF(),
+                           gfx::Size(),
                            filters,
                            gfx::Vector2dF(),
                            FilterOperations());
@@ -869,7 +871,8 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) {
                            pass_rect,
                            child_pass_id,
                            0,
-                           gfx::RectF(),
+                           gfx::Vector2dF(),
+                           gfx::Size(),
                            filters,
                            gfx::Vector2dF(),
                            FilterOperations());
@@ -939,7 +942,8 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) {
                            pass_rect,
                            child_pass_id,
                            0,
-                           gfx::RectF(),
+                           gfx::Vector2dF(),
+                           gfx::Size(),
                            filters,
                            gfx::Vector2dF(),
                            FilterOperations());
@@ -1031,7 +1035,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
                            pass_rect,
                            child_pass_id,
                            0,
-                           gfx::RectF(),
+                           gfx::Vector2dF(),
+                           gfx::Size(),
                            filters,
                            gfx::Vector2dF(),
                            FilterOperations());
@@ -1237,10 +1242,11 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) {
                     sub_rect,
                     child_pass_id,
                     mask_resource_id,
-                    gfx::RectF(0.5f, 0.5f, 2.f, 1.f),  // mask_uv_rect
-                    FilterOperations(),                // foreground filters
-                    gfx::Vector2dF(),                  // filters scale
-                    FilterOperations());               // background filters
+                    gfx::Vector2dF(2.f, 1.f),     // mask_uv_scale
+                    gfx::Size(mask_rect.size()),  // mask_texture_size
+                    FilterOperations(),           // foreground filters
+                    gfx::Vector2dF(),             // filters scale
+                    FilterOperations());          // background filters
 
   // White background behind the masked render pass.
   SolidColorDrawQuad* white =
@@ -1304,16 +1310,16 @@ class RendererPixelTestWithBackgroundFilter
                                     filter_pass.get());
       RenderPassDrawQuad* filter_pass_quad =
           root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
-      filter_pass_quad->SetNew(
-          shared_state,
-          filter_pass_content_rect_,
-          filter_pass_content_rect_,
-          filter_pass_id,
-          0,                          // mask_resource_id
-          gfx::RectF(),               // mask_uv_rect
-          FilterOperations(),         // filters
-          gfx::Vector2dF(),           // filters_scale
-          this->background_filters_);
+      filter_pass_quad->SetNew(shared_state,
+                               filter_pass_content_rect_,
+                               filter_pass_content_rect_,
+                               filter_pass_id,
+                               0,                   // mask_resource_id
+                               gfx::Vector2dF(),    // mask_uv_scale
+                               gfx::Size(),         // mask_texture_size
+                               FilterOperations(),  // filters
+                               gfx::Vector2dF(),    // filters_scale
+                               this->background_filters_);
     }
 
     const int kColumnWidth = device_viewport_rect.width() / 3;
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index ae58b63..c3cb828 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -518,11 +518,11 @@ void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,
 
     const SkBitmap* mask = mask_lock.sk_bitmap();
 
-    SkRect mask_rect = SkRect::MakeXYWH(
-        quad->mask_uv_rect.x() * mask->width(),
-        quad->mask_uv_rect.y() * mask->height(),
-        quad->mask_uv_rect.width() * mask->width(),
-        quad->mask_uv_rect.height() * mask->height());
+    // Scale normalized uv rect into absolute texel coordinates.
+    SkRect mask_rect =
+        gfx::RectFToSkRect(gfx::ScaleRect(quad->MaskUVRect(),
+                                          quad->mask_texture_size.width(),
+                                          quad->mask_texture_size.height()));
 
     SkMatrix mask_mat;
     mask_mat.setRectToRect(mask_rect, dest_rect, SkMatrix::kFill_ScaleToFit);
diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc
index e3697ec..308f084 100644
--- a/cc/quads/draw_quad_unittest.cc
+++ b/cc/quads/draw_quad_unittest.cc
@@ -328,7 +328,7 @@ void CompareDrawQuad(DrawQuad* quad,
   }                                                        \
   SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 
-#define CREATE_QUAD_ALL_RP(Type, a, b, c, d, e, f, copy_a)       \
+#define CREATE_QUAD_ALL_RP(Type, a, b, c, d, e, f, g, copy_a)    \
   Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
   {                                                              \
     QUAD_DATA quad_all->SetAll(shared_state,                     \
@@ -341,15 +341,17 @@ void CompareDrawQuad(DrawQuad* quad,
                                c,                                \
                                d,                                \
                                e,                                \
-                               f);                               \
+                               f,                                \
+                               g);                               \
   }                                                              \
   SETUP_AND_COPY_QUAD_ALL_RP(Type, quad_all, copy_a);
 
-#define CREATE_QUAD_NEW_RP(Type, a, b, c, d, e, f, g, copy_a)                 \
-  Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>();              \
-  {                                                                           \
-    QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b, c, d, e, f, g); \
-  }                                                                           \
+#define CREATE_QUAD_NEW_RP(Type, a, b, c, d, e, f, g, h, copy_a) \
+  Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
+  {                                                              \
+    QUAD_DATA quad_new->SetNew(                                  \
+        shared_state, quad_rect, a, b, c, d, e, f, g, h);        \
+  }                                                              \
   SETUP_AND_COPY_QUAD_NEW_RP(Type, quad_new, copy_a);
 
 TEST(DrawQuadTest, CopyCheckerboardDrawQuad) {
@@ -417,7 +419,8 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
   RenderPassId render_pass_id(22, 64);
   ResourceProvider::ResourceId mask_resource_id = 78;
-  gfx::RectF mask_u_v_rect(-45.f, -21.f, 33.f, 19.f);
+  gfx::Vector2dF mask_uv_scale(33.f, 19.f);
+  gfx::Size mask_texture_size(128, 134);
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(1.f));
   gfx::Vector2dF filters_scale;
@@ -432,7 +435,8 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
                      visible_rect,
                      render_pass_id,
                      mask_resource_id,
-                     mask_u_v_rect,
+                     mask_uv_scale,
+                     mask_texture_size,
                      filters,
                      filters_scale,
                      background_filters,
@@ -441,7 +445,9 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(copied_render_pass_id, copy_quad->render_pass_id);
   EXPECT_EQ(mask_resource_id, copy_quad->mask_resource_id);
-  EXPECT_EQ(mask_u_v_rect.ToString(), copy_quad->mask_uv_rect.ToString());
+  EXPECT_EQ(mask_uv_scale.ToString(), copy_quad->mask_uv_scale.ToString());
+  EXPECT_EQ(mask_texture_size.ToString(),
+            copy_quad->mask_texture_size.ToString());
   EXPECT_EQ(filters, copy_quad->filters);
   EXPECT_EQ(filters_scale, copy_quad->filters_scale);
   EXPECT_EQ(background_filters, copy_quad->background_filters);
@@ -449,7 +455,8 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
   CREATE_QUAD_ALL_RP(RenderPassDrawQuad,
                      render_pass_id,
                      mask_resource_id,
-                     mask_u_v_rect,
+                     mask_uv_scale,
+                     mask_texture_size,
                      filters,
                      filters_scale,
                      background_filters,
@@ -457,7 +464,9 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
   EXPECT_EQ(DrawQuad::RENDER_PASS, copy_quad->material);
   EXPECT_EQ(copied_render_pass_id, copy_quad->render_pass_id);
   EXPECT_EQ(mask_resource_id, copy_quad->mask_resource_id);
-  EXPECT_EQ(mask_u_v_rect.ToString(), copy_quad->mask_uv_rect.ToString());
+  EXPECT_EQ(mask_uv_scale.ToString(), copy_quad->mask_uv_scale.ToString());
+  EXPECT_EQ(mask_texture_size.ToString(),
+            copy_quad->mask_texture_size.ToString());
   EXPECT_EQ(filters, copy_quad->filters);
   EXPECT_EQ(filters_scale, copy_quad->filters_scale);
   EXPECT_EQ(background_filters, copy_quad->background_filters);
@@ -756,7 +765,8 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
   RenderPassId render_pass_id(22, 64);
   ResourceProvider::ResourceId mask_resource_id = 78;
-  gfx::RectF mask_u_v_rect(-45.f, -21.f, 33.f, 19.f);
+  gfx::Vector2dF mask_uv_scale(33.f, 19.f);
+  gfx::Size mask_texture_size(128, 134);
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(1.f));
   gfx::Vector2dF filters_scale(2.f, 3.f);
@@ -771,7 +781,8 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
                      visible_rect,
                      render_pass_id,
                      mask_resource_id,
-                     mask_u_v_rect,
+                     mask_uv_scale,
+                     mask_texture_size,
                      filters,
                      filters_scale,
                      background_filters,
diff --git a/cc/quads/render_pass_draw_quad.cc b/cc/quads/render_pass_draw_quad.cc
index 005aed5..88f608d 100644
--- a/cc/quads/render_pass_draw_quad.cc
+++ b/cc/quads/render_pass_draw_quad.cc
@@ -25,7 +25,8 @@ void RenderPassDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                 const gfx::Rect& visible_rect,
                                 RenderPassId render_pass_id,
                                 ResourceProvider::ResourceId mask_resource_id,
-                                const gfx::RectF& mask_uv_rect,
+                                const gfx::Vector2dF& mask_uv_scale,
+                                const gfx::Size& mask_texture_size,
                                 const FilterOperations& filters,
                                 const gfx::Vector2dF& filters_scale,
                                 const FilterOperations& background_filters) {
@@ -41,7 +42,8 @@ void RenderPassDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
          needs_blending,
          render_pass_id,
          mask_resource_id,
-         mask_uv_rect,
+         mask_uv_scale,
+         mask_texture_size,
          filters,
          filters_scale,
          background_filters);
@@ -54,7 +56,8 @@ void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                                 bool needs_blending,
                                 RenderPassId render_pass_id,
                                 ResourceProvider::ResourceId mask_resource_id,
-                                const gfx::RectF& mask_uv_rect,
+                                const gfx::Vector2dF& mask_uv_scale,
+                                const gfx::Size& mask_texture_size,
                                 const FilterOperations& filters,
                                 const gfx::Vector2dF& filters_scale,
                                 const FilterOperations& background_filters) {
@@ -65,7 +68,8 @@ void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                    visible_rect, needs_blending);
   this->render_pass_id = render_pass_id;
   this->mask_resource_id = mask_resource_id;
-  this->mask_uv_rect = mask_uv_rect;
+  this->mask_uv_scale = mask_uv_scale;
+  this->mask_texture_size = mask_texture_size;
   this->filters = filters;
   this->filters_scale = filters_scale;
   this->background_filters = background_filters;
@@ -77,6 +81,14 @@ void RenderPassDrawQuad::IterateResources(
     mask_resource_id = callback.Run(mask_resource_id);
 }
 
+gfx::RectF RenderPassDrawQuad::MaskUVRect() const {
+  gfx::RectF mask_uv_rect((mask_uv_scale.x() * rect.x()) / rect.width(),
+                          (mask_uv_scale.y() * rect.y()) / rect.height(),
+                          mask_uv_scale.x(),
+                          mask_uv_scale.y());
+  return mask_uv_rect;
+}
+
 const RenderPassDrawQuad* RenderPassDrawQuad::MaterialCast(
     const DrawQuad* quad) {
   DCHECK_EQ(quad->material, DrawQuad::RENDER_PASS);
@@ -87,8 +99,12 @@ void RenderPassDrawQuad::ExtendValue(base::debug::TracedValue* value) const {
   TracedValue::SetIDRef(render_pass_id.AsTracingId(), value, "render_pass_id");
   value->SetInteger("mask_resource_id", mask_resource_id);
 
-  value->BeginArray("mask_uv_rect");
-  MathUtil::AddToTracedValue(mask_uv_rect, value);
+  value->BeginArray("mask_texture_size");
+  MathUtil::AddToTracedValue(mask_texture_size, value);
+  value->EndArray();
+
+  value->BeginArray("mask_uv_scale");
+  MathUtil::AddToTracedValue(mask_uv_scale, value);
   value->EndArray();
 
   value->BeginDictionary("filters");
diff --git a/cc/quads/render_pass_draw_quad.h b/cc/quads/render_pass_draw_quad.h
index 587c7ec..25417f6 100644
--- a/cc/quads/render_pass_draw_quad.h
+++ b/cc/quads/render_pass_draw_quad.h
@@ -25,7 +25,8 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
               const gfx::Rect& visible_rect,
               RenderPassId render_pass_id,
               ResourceProvider::ResourceId mask_resource_id,
-              const gfx::RectF& mask_uv_rect,
+              const gfx::Vector2dF& mask_uv_scale,
+              const gfx::Size& mask_texture_size,
               const FilterOperations& filters,
               const gfx::Vector2dF& filters_scale,
               const FilterOperations& background_filters);
@@ -37,14 +38,16 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
               bool needs_blending,
               RenderPassId render_pass_id,
               ResourceProvider::ResourceId mask_resource_id,
-              const gfx::RectF& mask_uv_rect,
+              const gfx::Vector2dF& mask_uv_scale,
+              const gfx::Size& mask_texture_size,
               const FilterOperations& filters,
               const gfx::Vector2dF& filters_scale,
               const FilterOperations& background_filters);
 
   RenderPassId render_pass_id;
   ResourceProvider::ResourceId mask_resource_id;
-  gfx::RectF mask_uv_rect;
+  gfx::Vector2dF mask_uv_scale;
+  gfx::Size mask_texture_size;
 
   // Post-processing filters, applied to the pixels in the render pass' texture.
   FilterOperations filters;
@@ -59,6 +62,9 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
   // background of the render pass, from behind it.
   FilterOperations background_filters;
 
+  // Helper function to generate the normalized uv rect.
+  gfx::RectF MaskUVRect() const;
+
   virtual void IterateResources(const ResourceIteratorCallback& callback)
       override;
 
diff --git a/cc/quads/render_pass_unittest.cc b/cc/quads/render_pass_unittest.cc
index 81a3d31..4c3753f 100644
--- a/cc/quads/render_pass_unittest.cc
+++ b/cc/quads/render_pass_unittest.cc
@@ -219,10 +219,11 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
                     contrib_output_rect,
                     contrib_output_rect,
                     contrib_id,
-                    0,      // mask_resource_id
-                    gfx::RectF(),  // mask_uv_rect
+                    0,
+                    gfx::Vector2dF(),
+                    gfx::Size(),
                     FilterOperations(),
-                    gfx::Vector2dF(),  // filters_scale
+                    gfx::Vector2dF(),
                     FilterOperations());
 
   pass_list.push_back(pass.Pass());
diff --git a/cc/surfaces/surface_aggregator.cc b/cc/surfaces/surface_aggregator.cc
index 88f320d..f6bf6d6 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -259,7 +259,8 @@ void SurfaceAggregator::HandleSurfaceQuad(const SurfaceDrawQuad* surface_quad,
                  surface_quad->visible_rect,
                  remapped_pass_id,
                  0,
-                 gfx::RectF(),
+                 gfx::Vector2dF(),
+                 gfx::Size(),
                  FilterOperations(),
                  gfx::Vector2dF(),
                  FilterOperations());
diff --git a/cc/surfaces/surface_aggregator_test_helpers.cc b/cc/surfaces/surface_aggregator_test_helpers.cc
index c6a7aa0..a40b2c2 100644
--- a/cc/surfaces/surface_aggregator_test_helpers.cc
+++ b/cc/surfaces/surface_aggregator_test_helpers.cc
@@ -69,7 +69,8 @@ void AddTestRenderPassQuad(TestRenderPass* pass, RenderPassId render_pass_id) {
                output_rect,
                render_pass_id,
                0,
-               gfx::RectF(),
+               gfx::Vector2dF(),
+               gfx::Size(),
                FilterOperations(),
                gfx::Vector2dF(),
                FilterOperations());
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index dd5bb90..a667dce 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -58,8 +58,9 @@ void TestRenderPass::AppendOneOfEveryQuadType(
       ResourceProvider::TextureHintImmutable,
       resource_provider->best_texture_format());
   resource_provider->AllocateForTesting(resource4);
+  gfx::Size resource5_size(73, 26);
   ResourceProvider::ResourceId resource5 = resource_provider->CreateResource(
-      gfx::Size(73, 26),
+      resource5_size,
       GL_CLAMP_TO_EDGE,
       ResourceProvider::TextureHintImmutable,
       resource_provider->best_texture_format());
@@ -124,7 +125,8 @@ void TestRenderPass::AppendOneOfEveryQuadType(
                              visible_rect,
                              child_pass,
                              resource5,
-                             gfx::RectF(),
+                             gfx::Vector2dF(1.f, 1.f),
+                             resource5_size,
                              FilterOperations(),
                              gfx::Vector2dF(),
                              FilterOperations());
@@ -136,7 +138,8 @@ void TestRenderPass::AppendOneOfEveryQuadType(
                                      visible_rect,
                                      child_pass,
                                      resource5,
-                                     gfx::RectF(),
+                                     gfx::Vector2dF(1.f, 1.f),
+                                     resource5_size,
                                      FilterOperations(),
                                      gfx::Vector2dF(),
                                      FilterOperations());
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index 1f213163..519c74a 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -100,7 +100,8 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
                output_rect,
                contributing_pass->id,
                0,
-               gfx::RectF(),
+               gfx::Vector2dF(),
+               gfx::Size(),
                FilterOperations(),
                gfx::Vector2dF(),
                FilterOperations());
@@ -123,12 +124,14 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
                        0);
   RenderPassDrawQuad* quad =
       to_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
+  gfx::Size arbitrary_nonzero_size(1, 1);
   quad->SetNew(shared_state,
                output_rect,
                output_rect,
                contributing_pass->id,
                mask_resource_id,
-               gfx::RectF(),
+               gfx::Vector2dF(1.f, 1.f),
+               arbitrary_nonzero_size,
                filters,
                gfx::Vector2dF(),
                FilterOperations());
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index f5b6cef..a7f902c 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -5290,8 +5290,9 @@ class FakeMaskLayerImpl : public LayerImpl {
     return make_scoped_ptr(new FakeMaskLayerImpl(tree_impl, id));
   }
 
-  virtual ResourceProvider::ResourceId ContentsResourceId() const override {
-    return 0;
+  virtual void GetContentsResourceId(ResourceProvider::ResourceId* resource_id,
+                                     gfx::Size* resource_size) const override {
+    *resource_id = 0;
   }
 
  private:
@@ -5373,7 +5374,9 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithScaling) {
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+              render_pass_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              render_pass_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5402,7 +5405,9 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithScaling) {
     EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+              render_pass_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              render_pass_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5433,7 +5438,9 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithScaling) {
     EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+              render_pass_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              render_pass_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5494,7 +5501,9 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithDifferentBounds) {
     EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+              render_pass_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              render_pass_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5522,7 +5531,9 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithDifferentBounds) {
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+              render_pass_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              render_pass_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5553,7 +5564,9 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithDifferentBounds) {
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+              render_pass_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              render_pass_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5579,7 +5592,9 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithDifferentBounds) {
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+              render_pass_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              render_pass_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5644,7 +5659,9 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerWithDifferentBounds) {
     EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              replica_quad->mask_uv_rect.ToString());
+              replica_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              replica_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5671,7 +5688,9 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerWithDifferentBounds) {
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              replica_quad->mask_uv_rect.ToString());
+              replica_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              replica_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5701,7 +5720,9 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerWithDifferentBounds) {
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              replica_quad->mask_uv_rect.ToString());
+              replica_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              replica_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5726,7 +5747,9 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerWithDifferentBounds) {
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-              replica_quad->mask_uv_rect.ToString());
+              replica_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(1.f, 1.f).ToString(),
+              replica_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5812,7 +5835,9 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerForSurfaceWithUnclippedChild) {
     EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 2.f, 1.f).ToString(),
-              replica_quad->mask_uv_rect.ToString());
+              replica_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(2.f, 1.f).ToString(),
+              replica_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5845,7 +5870,9 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerForSurfaceWithUnclippedChild) {
     EXPECT_EQ(gfx::Rect(-50, 0, 100, 50).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(-1.f, 0.f, 2.f, 1.f).ToString(),
-              replica_quad->mask_uv_rect.ToString());
+              replica_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(2.f, 1.f).ToString(),
+              replica_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
@@ -5929,14 +5956,15 @@ TEST_F(LayerTreeHostImplTest, MaskLayerForSurfaceWithClippedLayer) {
             frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(20, 10, 10, 20).ToString(),
               render_pass_quad->rect.ToString());
-
     // The masked layer is 50x50, but the surface size is 10x20. So the texture
     // coords in the mask are scaled by 10/50 and 20/50.
     // The surface is clipped to (20,10) so the mask texture coords are offset
     // by 20/50 and 10/50
-    EXPECT_EQ(gfx::ScaleRect(gfx::RectF(20.f, 10.f, 10.f, 20.f),
-                             1.f / 50.f).ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+    EXPECT_EQ(gfx::ScaleRect(gfx::RectF(20.f, 10.f, 10.f, 20.f), 1.f / 50.f)
+                  .ToString(),
+              render_pass_quad->MaskUVRect().ToString());
+    EXPECT_EQ(gfx::Vector2dF(10.f / 50.f, 20.f / 50.f).ToString(),
+              render_pass_quad->mask_uv_scale.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
diff --git a/cc/trees/layer_tree_host_unittest_delegated.cc b/cc/trees/layer_tree_host_unittest_delegated.cc
index 095513b..018df87 100644
--- a/cc/trees/layer_tree_host_unittest_delegated.cc
+++ b/cc/trees/layer_tree_host_unittest_delegated.cc
@@ -190,8 +190,9 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest {
                  output_rect,
                  output_rect,
                  id,
-                 0,      // mask_resource_id
-                 gfx::Rect(0, 0, 1, 1),  // mask_uv_rect
+                 0,
+                 gfx::Vector2dF(),
+                 gfx::Size(),
                  filters,
                  gfx::Vector2dF(),
                  background_filters);
diff --git a/content/common/cc_messages.h b/content/common/cc_messages.h
index b29fdc6..0c14ddf 100644
--- a/content/common/cc_messages.h
+++ b/content/common/cc_messages.h
@@ -177,7 +177,8 @@ IPC_STRUCT_TRAITS_BEGIN(cc::RenderPassDrawQuad)
   IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad)
   IPC_STRUCT_TRAITS_MEMBER(render_pass_id)
   IPC_STRUCT_TRAITS_MEMBER(mask_resource_id)
-  IPC_STRUCT_TRAITS_MEMBER(mask_uv_rect)
+  IPC_STRUCT_TRAITS_MEMBER(mask_uv_scale)
+  IPC_STRUCT_TRAITS_MEMBER(mask_texture_size)
   IPC_STRUCT_TRAITS_MEMBER(filters)
   IPC_STRUCT_TRAITS_MEMBER(filters_scale)
   IPC_STRUCT_TRAITS_MEMBER(background_filters)
diff --git a/content/common/cc_messages_unittest.cc b/content/common/cc_messages_unittest.cc
index b81bb70..ea2dd09 100644
--- a/content/common/cc_messages_unittest.cc
+++ b/content/common/cc_messages_unittest.cc
@@ -145,7 +145,8 @@ class CCMessagesTest : public testing::Test {
   void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) {
     EXPECT_EQ(a->render_pass_id, b->render_pass_id);
     EXPECT_EQ(a->mask_resource_id, b->mask_resource_id);
-    EXPECT_EQ(a->mask_uv_rect.ToString(), b->mask_uv_rect.ToString());
+    EXPECT_EQ(a->mask_uv_scale.ToString(), b->mask_uv_scale.ToString());
+    EXPECT_EQ(a->mask_texture_size.ToString(), b->mask_texture_size.ToString());
     EXPECT_EQ(a->filters.size(), b->filters.size());
     for (size_t i = 0; i < a->filters.size(); ++i) {
       if (a->filters.at(i).type() != cc::FilterOperation::REFERENCE) {
@@ -242,6 +243,7 @@ TEST_F(CCMessagesTest, AllQuads) {
   gfx::PointF arbitrary_pointf1(31.4f, 15.9f);
   gfx::PointF arbitrary_pointf2(26.5f, -35.8f);
   gfx::Vector2dF arbitrary_vector2df1(16.2f, -85.1f);
+  gfx::Vector2dF arbitrary_vector2df2(-8.3f, 0.47f);
   float arbitrary_float1 = 0.7f;
   float arbitrary_float2 = 0.3f;
   float arbitrary_float3 = 0.9f;
@@ -366,9 +368,10 @@ TEST_F(CCMessagesTest, AllQuads) {
                         arbitrary_bool1,
                         arbitrary_id,
                         arbitrary_resourceid2,
-                        arbitrary_rectf1,
-                        arbitrary_filters1,
                         arbitrary_vector2df1,
+                        arbitrary_size1,
+                        arbitrary_filters1,
+                        arbitrary_vector2df2,
                         arbitrary_filters2);
   pass_cmp->CopyFromAndAppendRenderPassDrawQuad(
       renderpass_in,
diff --git a/mojo/converters/surfaces/surfaces_type_converters.cc b/mojo/converters/surfaces/surfaces_type_converters.cc
index d034b27..fadbb97 100644
--- a/mojo/converters/surfaces/surfaces_type_converters.cc
+++ b/mojo/converters/surfaces/surfaces_type_converters.cc
@@ -71,6 +71,8 @@ bool ConvertDrawQuad(const QuadPtr& input,
           render_pass->CreateAndAppendDrawQuad<cc::RenderPassDrawQuad>();
       RenderPassQuadState* render_pass_quad_state =
           input->render_pass_quad_state.get();
+      gfx::PointF mask_uv_scale_as_point =
+          render_pass_quad_state->mask_uv_scale.To<gfx::PointF>();
       gfx::PointF filter_scale_as_point =
           render_pass_quad_state->filters_scale.To<gfx::PointF>();
       render_pass_quad->SetAll(
@@ -81,9 +83,10 @@ bool ConvertDrawQuad(const QuadPtr& input,
           input->needs_blending,
           render_pass_quad_state->render_pass_id.To<cc::RenderPassId>(),
           render_pass_quad_state->mask_resource_id,
-          render_pass_quad_state->mask_uv_rect.To<gfx::RectF>(),
+          mask_uv_scale_as_point.OffsetFromOrigin(),
+          render_pass_quad_state->mask_texture_size.To<gfx::Size>(),
           cc::FilterOperations(),  // TODO(jamesr): filters
-          gfx::Vector2dF(filter_scale_as_point.x(), filter_scale_as_point.y()),
+          filter_scale_as_point.OffsetFromOrigin(),
           cc::FilterOperations());  // TODO(jamesr): background_filters
       break;
     }
@@ -248,7 +251,10 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
       pass_state->render_pass_id =
           RenderPassId::From(render_pass_quad->render_pass_id);
       pass_state->mask_resource_id = render_pass_quad->mask_resource_id;
-      pass_state->mask_uv_rect = RectF::From(render_pass_quad->mask_uv_rect);
+      pass_state->mask_uv_scale = PointF::From(
+          gfx::PointAtOffsetFromOrigin(render_pass_quad->mask_uv_scale));
+      pass_state->mask_texture_size =
+          Size::From(render_pass_quad->mask_texture_size);
       // TODO(jamesr): pass_state->filters
       pass_state->filters_scale = PointF::From(
           gfx::PointAtOffsetFromOrigin(render_pass_quad->filters_scale));
diff --git a/mojo/services/public/interfaces/surfaces/quads.mojom b/mojo/services/public/interfaces/surfaces/quads.mojom
index 6d5cccd..7625faa 100644
--- a/mojo/services/public/interfaces/surfaces/quads.mojom
+++ b/mojo/services/public/interfaces/surfaces/quads.mojom
@@ -28,7 +28,8 @@ struct RenderPassQuadState {
 
   // If nonzero, resource id of mask to use when drawing this pass.
   uint32 mask_resource_id;
-  RectF mask_uv_rect;
+  PointF mask_uv_scale;
+  Size mask_texture_size;
 
   // Post-processing filters, applied to the pixels in the render pass' texture.
   // TODO(jamesr): Support