cc: Rename visible_content_rect and content stuff on quads.

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 581 matching lines @@
       static_cast<int>(tile_rect.y() / quad->scale) % kCheckerboardWidth;
   float tex_scale_x = tile_rect.width() / quad->scale;
   float tex_scale_y = tile_rect.height() / quad->scale;
   gl_->Uniform4f(program->fragment_shader().tex_transform_location(),
                  tex_offset_x, tex_offset_y, tex_scale_x, tex_scale_y);
 
   gl_->Uniform1f(program->fragment_shader().frequency_location(), frequency);
 
   SetShaderOpacity(quad->shared_quad_state->opacity,
                    program->fragment_shader().alpha_location());
-  DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+  DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                    quad->rect, program->vertex_shader().matrix_location());
 }
 
 // This function does not handle 3D sorting right now, since the debug border
 // quads are just drawn as their original quads and not in split pieces. This
 // results in some debug border quads drawing over foreground quads.
 void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
                                      const DebugBorderDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   static float gl_matrix[16];
   const DebugBorderProgram* program = GetDebugBorderProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
 
   // Use the full quad_rect for debug quads to not move the edges based on
   // partial swaps.
   gfx::Rect layer_rect = quad->rect;
   gfx::Transform render_matrix;
   QuadRectTransform(&render_matrix,
-                    quad->shared_quad_state->content_to_target_transform,
+                    quad->shared_quad_state->quad_to_target_transform,
                     layer_rect);
   GLRenderer::ToGLMatrix(&gl_matrix[0],
                          frame->projection_matrix * render_matrix);
   gl_->UniformMatrix4fv(program->vertex_shader().matrix_location(), 1, false,
                         &gl_matrix[0]);
 
   SkColor color = quad->color;
   float alpha = SkColorGetA(color) * (1.0f / 255.0f);
 
   gl_->Uniform4f(program->fragment_shader().color_location(),
@@ skipping 286 matching lines @@
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                                     const RenderPassDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   ScopedResource* contents_texture =
       render_pass_textures_.get(quad->render_pass_id);
   DCHECK(contents_texture);
   DCHECK(contents_texture->id());
 
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
-                    quad->shared_quad_state->content_to_target_transform,
+                    quad->shared_quad_state->quad_to_target_transform,
                     quad->rect);
   gfx::Transform contents_device_transform =
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   // Can only draw surface if device matrix is invertible.
   if (!contents_device_transform.IsInvertible())
     return;
 
   gfx::QuadF surface_quad = SharedGeometryQuad();
@@ skipping 133 matching lines @@
   }
 
   if (!use_shaders_for_blending) {
     if (!use_blend_equation_advanced_coherent_ && use_blend_equation_advanced_)
       gl_->BlendBarrierKHR();
 
     ApplyBlendModeUsingBlendFunc(blend_mode);
   }
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      gl_,
-      &highp_threshold_cache_,
-      highp_threshold_min_,
-      quad->shared_quad_state->visible_content_rect.bottom_right());
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
+      quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
 
   ShaderLocations locations;
 
   DCHECK_EQ(background_texture || background_image_id,
             use_shaders_for_blending);
   BlendMode shader_blend_mode = use_shaders_for_blending
                                     ? BlendModeFromSkXfermode(blend_mode)
                                     : BLEND_MODE_NONE;
 
   if (use_aa && mask_texture_id && !use_color_matrix) {
@@ skipping 153 matching lines @@
                                                 background_texture->id(),
                                                 GL_TEXTURE0 + last_texture_unit,
                                                 GL_LINEAR));
       DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
                 shader_background_sampler_lock->target());
     }
   }
 
   SetShaderOpacity(quad->shared_quad_state->opacity, locations.alpha);
   SetShaderQuadF(surface_quad, locations.quad);
-  DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+  DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                    quad->rect, locations.matrix);
 
   // Flush the compositor context before the filter bitmap goes out of
   // scope, so the draw gets processed before the filter texture gets deleted.
   if (filter_image_id)
     gl_->Flush();
 
   if (!use_shaders_for_blending)
     RestoreBlendFuncToDefault(blend_mode);
 }
@@ skipping 31 matching lines @@
          std::abs(clip_region->p2().y()) < kAntiAliasingEpsilon;
 }
 
 bool is_bottom(const gfx::QuadF* clip_region, const DrawQuad* quad) {
   if (!quad->IsBottomEdge())
     return false;
   if (!clip_region)
     return true;
 
   return std::abs(clip_region->p3().y() -
-                  quad->shared_quad_state->content_bounds.height()) <
+                  quad->shared_quad_state->quad_layer_bounds.height()) <
              kAntiAliasingEpsilon &&
          std::abs(clip_region->p4().y() -
-                  quad->shared_quad_state->content_bounds.height()) <
+                  quad->shared_quad_state->quad_layer_bounds.height()) <
              kAntiAliasingEpsilon;
 }
 
 bool is_left(const gfx::QuadF* clip_region, const DrawQuad* quad) {
   if (!quad->IsLeftEdge())
     return false;
   if (!clip_region)
     return true;
 
   return std::abs(clip_region->p1().x()) < kAntiAliasingEpsilon &&
          std::abs(clip_region->p4().x()) < kAntiAliasingEpsilon;
 }
 
 bool is_right(const gfx::QuadF* clip_region, const DrawQuad* quad) {
   if (!quad->IsRightEdge())
     return false;
   if (!clip_region)
     return true;
 
   return std::abs(clip_region->p2().x() -
-                  quad->shared_quad_state->content_bounds.width()) <
+                  quad->shared_quad_state->quad_layer_bounds.width()) <
              kAntiAliasingEpsilon &&
          std::abs(clip_region->p3().x() -
-                  quad->shared_quad_state->content_bounds.width()) <
+                  quad->shared_quad_state->quad_layer_bounds.width()) <
              kAntiAliasingEpsilon;
 }
 }  // anonymous namespace
 
 static gfx::QuadF GetDeviceQuadWithAntialiasingOnExteriorEdges(
     const LayerQuad& device_layer_edges,
     const gfx::Transform& device_transform,
     const gfx::QuadF& tile_quad,
     const gfx::QuadF* clip_region,
     const DrawQuad* quad) {
@@ skipping 226 matching lines @@
   float opacity = quad->shared_quad_state->opacity;
   float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
 
   // Early out if alpha is small enough that quad doesn't contribute to output.
   if (alpha < std::numeric_limits<float>::epsilon() &&
       quad->ShouldDrawWithBlending())
     return;
 
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix *
-      quad->shared_quad_state->content_to_target_transform;
+      quad->shared_quad_state->quad_to_target_transform;
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
 
   gfx::QuadF device_layer_quad;
   bool use_aa = false;
   bool allow_aa = settings_->allow_antialiasing &&
                   !quad->force_anti_aliasing_off && quad->IsEdge();
 
   if (allow_aa) {
     bool clipped = false;
     bool force_aa = false;
     device_layer_quad = MathUtil::MapQuad(
         device_transform,
-        gfx::QuadF(quad->shared_quad_state->visible_content_rect), &clipped);
+        gfx::QuadF(quad->shared_quad_state->visible_quad_layer_rect), &clipped);
     use_aa = ShouldAntialiasQuad(device_layer_quad, clipped, force_aa);
   }
 
   float edge[24];
   const gfx::QuadF* aa_quad = use_aa ? &device_layer_quad : nullptr;
   SetupQuadForClippingAndAntialiasing(device_transform, quad, aa_quad,
                                       clip_region, &local_quad, edge);
 
   SolidColorProgramUniforms uniforms;
   if (use_aa) {
@@ skipping 27 matching lines @@
 
   SetShaderQuadF(local_quad, uniforms.quad_location);
 
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   gfx::RectF centered_rect(
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
       tile_rect.size());
-  DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+  DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                    centered_rect, uniforms.matrix_location);
 }
 
 struct TileProgramUniforms {
   unsigned program;
   unsigned matrix_location;
   unsigned viewport_location;
   unsigned quad_location;
   unsigned edge_location;
   unsigned vertex_tex_transform_location;
@@ skipping 23 matching lines @@
                               const gfx::QuadF* clip_region) {
   DrawContentQuad(frame, quad, quad->resource_id(), clip_region);
 }
 
 void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
                                  const ContentDrawQuadBase* quad,
                                  ResourceId resource_id,
                                  const gfx::QuadF* clip_region) {
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix *
-      quad->shared_quad_state->content_to_target_transform;
+      quad->shared_quad_state->quad_to_target_transform;
   device_transform.FlattenTo2d();
 
   gfx::QuadF device_layer_quad;
   bool use_aa = false;
   bool allow_aa = settings_->allow_antialiasing && quad->IsEdge();
   if (allow_aa) {
     bool clipped = false;
     bool force_aa = false;
     device_layer_quad = MathUtil::MapQuad(
         device_transform,
-        gfx::QuadF(quad->shared_quad_state->visible_content_rect), &clipped);
+        gfx::QuadF(quad->shared_quad_state->visible_quad_layer_rect), &clipped);
     use_aa = ShouldAntialiasQuad(device_layer_quad, clipped, force_aa);
   }
 
   // TODO(timav): simplify coordinate transformations in DrawContentQuadAA
   // similar to the way DrawContentQuadNoAA works and then consider
   // combining DrawContentQuadAA and DrawContentQuadNoAA into one method.
   if (use_aa)
     DrawContentQuadAA(frame, quad, resource_id, device_transform,
                       device_layer_quad, clip_region);
   else
@@ skipping 110 matching lines @@
   SetShaderOpacity(quad->shared_quad_state->opacity, uniforms.alpha_location);
   SetShaderQuadF(local_quad, uniforms.quad_location);
 
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   gfx::RectF centered_rect(
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
       tile_rect.size());
-  DrawQuadGeometry(frame, quad->shared_quad_state->content_to_target_transform,
+  DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                    centered_rect, uniforms.matrix_location);
 }
 
 void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
                                      const ContentDrawQuadBase* quad,
                                      ResourceId resource_id,
                                      const gfx::QuadF* clip_region) {
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
       quad->tex_coord_rect, quad->rect, quad->visible_rect);
   float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width();
   float tex_to_geom_scale_y =
       quad->rect.height() / quad->tex_coord_rect.height();
 
   bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);
   GLenum filter = (scaled ||
-                   !quad->shared_quad_state->content_to_target_transform
+                   !quad->shared_quad_state->quad_to_target_transform
                         .IsIdentityOrIntegerTranslation()) &&
                           !quad->nearest_neighbor
                       ? GL_LINEAR
                       : GL_NEAREST;
 
   ResourceProvider::ScopedSamplerGL quad_resource_lock(
       resource_provider_, resource_id, filter);
   SamplerType sampler =
       SamplerTypeFromTextureTarget(quad_resource_lock.target());
 
@@ skipping 79 matching lines @@
       tile_rect.p2().x(),
       tile_rect.p2().y(),
       tile_rect.p3().x(),
       tile_rect.p3().y(),
   };
   gl_->Uniform2fv(uniforms.quad_location, 4, gl_quad);
 
   static float gl_matrix[16];
   ToGLMatrix(&gl_matrix[0],
              frame->projection_matrix *
-                 quad->shared_quad_state->content_to_target_transform);
+                 quad->shared_quad_state->quad_to_target_transform);
   gl_->UniformMatrix4fv(uniforms.matrix_location, 1, false, &gl_matrix[0]);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
 void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
                                   const YUVVideoDrawQuad* quad,
                                   const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      gl_,
-      &highp_threshold_cache_,
-      highp_threshold_min_,
-      quad->shared_quad_state->visible_content_rect.bottom_right());
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
+      quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
 
   bool use_alpha_plane = quad->a_plane_resource_id() != 0;
 
   ResourceProvider::ScopedSamplerGL y_plane_lock(
       resource_provider_, quad->y_plane_resource_id(), GL_TEXTURE1, GL_LINEAR);
   ResourceProvider::ScopedSamplerGL u_plane_lock(
       resource_provider_, quad->u_plane_resource_id(), GL_TEXTURE2, GL_LINEAR);
   DCHECK_EQ(y_plane_lock.target(), u_plane_lock.target());
   ResourceProvider::ScopedSamplerGL v_plane_lock(
       resource_provider_, quad->v_plane_resource_id(), GL_TEXTURE3, GL_LINEAR);
@@ skipping 172 matching lines @@
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   gfx::RectF tile_rect = quad->rect;
   gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb);
   gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust);
 
   SetShaderOpacity(quad->shared_quad_state->opacity, alpha_location);
   if (!clip_region) {
-    DrawQuadGeometry(frame,
-                     quad->shared_quad_state->content_to_target_transform,
+    DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                      tile_rect, matrix_location);
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     gfx::QuadF region_quad = *clip_region;
     region_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
     DrawQuadGeometryClippedByQuadF(
-        frame, quad->shared_quad_state->content_to_target_transform, tile_rect,
+        frame, quad->shared_quad_state->quad_to_target_transform, tile_rect,
         region_quad, matrix_location, uvs);
   }
 }
 
 void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
                                      const StreamVideoDrawQuad* quad,
                                      const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   static float gl_matrix[16];
 
   DCHECK(capabilities_.using_egl_image);
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      gl_,
-      &highp_threshold_cache_,
-      highp_threshold_min_,
-      quad->shared_quad_state->visible_content_rect.bottom_right());
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
+      quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
 
   const VideoStreamTextureProgram* program =
       GetVideoStreamTextureProgram(tex_coord_precision);
   SetUseProgram(program->program());
 
   ToGLMatrix(&gl_matrix[0], quad->matrix);
   gl_->UniformMatrix4fv(program->vertex_shader().tex_matrix_location(), 1,
                         false, gl_matrix);
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->resource_id());
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id());
 
   gl_->Uniform1i(program->fragment_shader().sampler_location(), 0);
 
   SetShaderOpacity(quad->shared_quad_state->opacity,
                    program->fragment_shader().alpha_location());
   if (!clip_region) {
-    DrawQuadGeometry(frame,
-                     quad->shared_quad_state->content_to_target_transform,
+    DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                      quad->rect, program->vertex_shader().matrix_location());
   } else {
     gfx::QuadF region_quad(*clip_region);
     region_quad.Scale(1.0f / quad->rect.width(), 1.0f / quad->rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     DrawQuadGeometryClippedByQuadF(
-        frame, quad->shared_quad_state->content_to_target_transform, quad->rect,
+        frame, quad->shared_quad_state->quad_to_target_transform, quad->rect,
         region_quad, program->vertex_shader().matrix_location(), uvs);
   }
 }
 
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program) {
     DCHECK(program);
     program_id = program->program();
     sampler_location = program->fragment_shader().sampler_location();
@@ skipping 95 matching lines @@
   // If we have a clip_region then we have to render the next quad
   // with dynamic geometry, therefore we must flush all pending
   // texture quads.
   if (clip_region) {
     // We send in false here because we want to flush what's currently in the
     // queue using the shared_geometry and not clipped_geometry
     FlushTextureQuadCache(SHARED_BINDING);
   }
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      gl_,
-      &highp_threshold_cache_,
-      highp_threshold_min_,
-      quad->shared_quad_state->visible_content_rect.bottom_right());
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
+      quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->resource_id());
   const SamplerType sampler = SamplerTypeFromTextureTarget(lock.target());
   // Choose the correct texture program binding
   TexTransformTextureProgramBinding binding;
   if (quad->premultiplied_alpha) {
     if (quad->background_color == SK_ColorTRANSPARENT) {
       binding.Set(GetTextureProgram(tex_coord_precision, sampler));
     } else {
@@ skipping 42 matching lines @@
   // Generate the vertex opacity
   const float opacity = quad->shared_quad_state->opacity;
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[1] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[2] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[3] * opacity);
 
   // Generate the transform matrix
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
-                    quad->shared_quad_state->content_to_target_transform,
+                    quad->shared_quad_state->quad_to_target_transform,
                     quad->rect);
   quad_rect_matrix = frame->projection_matrix * quad_rect_matrix;
 
   Float16 m;
   quad_rect_matrix.matrix().asColMajorf(m.data);
   draw_cache_.matrix_data.push_back(m);
 
   if (clip_region) {
     gfx::QuadF scaled_region;
     if (!GetScaledRegion(quad->rect, clip_region, &scaled_region)) {
@@ skipping 15 matching lines @@
     FlushTextureQuadCache(CLIPPED_BINDING);
   }
 }
 
 void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
                                    const IOSurfaceDrawQuad* quad,
                                    const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      gl_,
-      &highp_threshold_cache_,
-      highp_threshold_min_,
-      quad->shared_quad_state->visible_content_rect.bottom_right());
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
+      quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
 
   TexTransformTextureProgramBinding binding;
   binding.Set(GetTextureIOSurfaceProgram(tex_coord_precision));
 
   SetUseProgram(binding.program_id);
   gl_->Uniform1i(binding.sampler_location, 0);
   if (quad->orientation == IOSurfaceDrawQuad::FLIPPED) {
     gl_->Uniform4f(
         binding.tex_transform_location, 0, quad->io_surface_size.height(),
         quad->io_surface_size.width(), quad->io_surface_size.height() * -1.0f);
   } else {
     gl_->Uniform4f(binding.tex_transform_location, 0, 0,
                    quad->io_surface_size.width(),
                    quad->io_surface_size.height());
   }
 
   const float vertex_opacity[] = {quad->shared_quad_state->opacity,
                                   quad->shared_quad_state->opacity,
                                   quad->shared_quad_state->opacity,
                                   quad->shared_quad_state->opacity};
   gl_->Uniform1fv(binding.vertex_opacity_location, 4, vertex_opacity);
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->io_surface_resource_id());
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id());
 
   if (!clip_region) {
-    DrawQuadGeometry(frame,
-                     quad->shared_quad_state->content_to_target_transform,
+    DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                      quad->rect, binding.matrix_location);
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     DrawQuadGeometryClippedByQuadF(
-        frame, quad->shared_quad_state->content_to_target_transform, quad->rect,
+        frame, quad->shared_quad_state->quad_to_target_transform, quad->rect,
         *clip_region, binding.matrix_location, uvs);
   }
 
   gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
 }
 
 void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   if (use_sync_query_) {
     DCHECK(current_sync_query_);
     current_sync_query_->End();
@@ skipping 1096 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         ToNearestRect(overlay.display_rect),
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc