Splitting of layers for correct intersections

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>
 #include <vector>
 
 #include "base/debug/trace_event.h"
+#include "base/debug/stack_trace.h"
 #include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "build/build_config.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/video_layer_impl.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/geometry_binding.h"
 #include "cc/output/gl_frame_data.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/render_surface_filters.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/stream_video_draw_quad.h"
+#include "cc/quads/draw_polygon.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/layer_quad.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/resources/texture_mailbox_deleter.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 437 matching lines @@
 
   // TODO(enne): Do we need to reinitialize all of this state per frame?
   ReinitializeGLState();
 }
 
 void GLRenderer::DoNoOp() {
   GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, 0));
   GLC(gl_, gl_->Flush());
 }
 
-void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
+void GLRenderer::DoDrawQuad(DrawingFrame* frame,
+                            const DrawQuad* quad,
+                            const gfx::QuadF* draw_region) {
   DCHECK(quad->rect.Contains(quad->visible_rect));
   if (quad->material != DrawQuad::TEXTURE_CONTENT) {
-    FlushTextureQuadCache();
+    FlushTextureQuadCache(false);
   }
 
   switch (quad->material) {
     case DrawQuad::INVALID:
       NOTREACHED();
       break;
     case DrawQuad::CHECKERBOARD:
-      DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
+      DrawCheckerboardQuad(
+          frame, CheckerboardDrawQuad::MaterialCast(quad), draw_region);
       break;
     case DrawQuad::DEBUG_BORDER:
       DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::IO_SURFACE_CONTENT:
-      DrawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad));
+      DrawIOSurfaceQuad(
+          frame, IOSurfaceDrawQuad::MaterialCast(quad), draw_region);
       break;
     case DrawQuad::PICTURE_CONTENT:
-      DrawPictureQuad(frame, PictureDrawQuad::MaterialCast(quad));
+      DrawPictureQuad(frame, PictureDrawQuad::MaterialCast(quad), draw_region);
       break;
     case DrawQuad::RENDER_PASS:
-      DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
+      DrawRenderPassQuad(
+          frame, RenderPassDrawQuad::MaterialCast(quad), draw_region);
       break;
     case DrawQuad::SOLID_COLOR:
-      DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
+      DrawSolidColorQuad(
+          frame, SolidColorDrawQuad::MaterialCast(quad), draw_region);
       break;
     case DrawQuad::STREAM_VIDEO_CONTENT:
-      DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad));
+      DrawStreamVideoQuad(
+          frame, StreamVideoDrawQuad::MaterialCast(quad), draw_region);
       break;
     case DrawQuad::SURFACE_CONTENT:
       // Surface content should be fully resolved to other quad types before
       // reaching a direct renderer.
       NOTREACHED();
       break;
     case DrawQuad::TEXTURE_CONTENT:
-      EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
+      EnqueueTextureQuad(
+          frame, TextureDrawQuad::MaterialCast(quad), draw_region);
       break;
     case DrawQuad::TILED_CONTENT:
-      DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
+      DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad), draw_region);
       break;
     case DrawQuad::YUV_VIDEO_CONTENT:
-      DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
+      DrawYUVVideoQuad(
+          frame, YUVVideoDrawQuad::MaterialCast(quad), draw_region);
       break;
   }
 }
 
 void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
-                                      const CheckerboardDrawQuad* quad) {
+                                      const CheckerboardDrawQuad* quad,
+                                      const gfx::QuadF* clip_region) {
+  // TODO(thildebr) For now since checkerboards shouldn't be part of a 3D
+  // context, clipping regions aren't supported so we skip drawing them
+  // if this becomes the case.
+  if (clip_region) {
+    return;
+  }
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   const TileCheckerboardProgram* program = GetTileCheckerboardProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
 
   SkColor color = quad->color;
   GLC(gl_,
       gl_->Uniform4f(program->fragment_shader().color_location(),
                      SkColorGetR(color) * (1.0f / 255.0f),
@@ skipping 21 matching lines @@
                      frequency));
 
   SetShaderOpacity(quad->opacity(),
                    program->fragment_shader().alpha_location());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    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
@@ skipping 359 matching lines @@
   }
 
   UseRenderPass(frame, target_render_pass);
 
   if (!using_background_texture)
     return scoped_ptr<ScopedResource>();
   return background_texture.Pass();
 }
 
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
-                                    const RenderPassDrawQuad* quad) {
+                                    const RenderPassDrawQuad* quad,
+                                    const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   ScopedResource* contents_texture =
       render_pass_textures_.get(quad->render_pass_id);
   if (!contents_texture || !contents_texture->id())
     return;
 
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
   gfx::Transform contents_device_transform =
@@ skipping 85 matching lines @@
     bool flip_vertically = true;
 
     CopyTextureToFramebuffer(frame,
                              lock.texture_id(),
                              quad->rect,
                              quad->quadTransform(),
                              flip_vertically);
   }
 
   bool clipped = false;
-  gfx::QuadF device_quad = MathUtil::MapQuad(
-      contents_device_transform, SharedGeometryQuad(), &clipped);
+  // The idea here is to scale the clip_region down to the 1.0x1.0 quad with
+  // a top corner of -0.5,-0.5 to match the ShaderGeometryQuad(). Unfortunately
+  // doesn't work properly yet.
+  gfx::QuadF local_clip_region = SharedGeometryQuad();
+  if (clip_region) {
+    gfx::RectF content_rect(quad->shared_quad_state->content_bounds);

[enne (OOO), 2014/09/24 17:35:30]

I'm not sure I understand why this is needed.  Also, if you're going to scale to
ShaderGeometryQuad, you should use those values indirectly rather than assuming
them.

+    // Scale this quad down to within the bounds of the SharedGeometryQuad
+    gfx::PointF p1((clip_region->p1().x() / content_rect.width()) - 0.5f,
+                   (clip_region->p1().y() / content_rect.height()) - 0.5f);
+    gfx::PointF p2((clip_region->p2().x() / content_rect.width()) - 0.5f,
+                   (clip_region->p2().y() / content_rect.height()) - 0.5f);
+    gfx::PointF p3((clip_region->p3().x() / content_rect.width()) - 0.5f,
+                   (clip_region->p3().y() / content_rect.height()) - 0.5f);
+    gfx::PointF p4((clip_region->p4().x() / content_rect.width()) - 0.5f,
+                   (clip_region->p4().y() / content_rect.height()) - 0.5f);
+    local_clip_region = gfx::QuadF(p1, p2, p3, p4);
+  }
+  gfx::QuadF device_quad =
+      MathUtil::MapQuad(contents_device_transform, local_clip_region, &clipped);
   LayerQuad device_layer_bounds(gfx::QuadF(device_quad.BoundingBox()));
   LayerQuad device_layer_edges(device_quad);
 
   // Use anti-aliasing programs only when necessary.
   bool use_aa =
       !clipped && (!device_quad.IsRectilinear() ||
                    !gfx::IsNearestRectWithinDistance(device_quad.BoundingBox(),
                                                      kAntiAliasingEpsilon));
   if (use_aa) {
     device_layer_bounds.InflateAntiAliasingDistance();
@@ skipping 285 matching lines @@
 static void SolidColorUniformLocation(T program,
                                       SolidColorProgramUniforms* uniforms) {
   uniforms->program = program->program();
   uniforms->matrix_location = program->vertex_shader().matrix_location();
   uniforms->viewport_location = program->vertex_shader().viewport_location();
   uniforms->quad_location = program->vertex_shader().quad_location();
   uniforms->edge_location = program->vertex_shader().edge_location();
   uniforms->color_location = program->fragment_shader().color_location();
 }
 
+// This function works in layer space to expand the split resulting quads needed
+// for sorting so that they "fill out" towards the edges for the AA that's
+// performed within the shaders. It makes sure to grow each sub-quad that
+// makes up the original quad by linearly interpolating points out torwards the
+// edges.
+static void ExpandDrawRegionToAAQuad(const gfx::QuadF& original_quad,
+                                     const gfx::QuadF& aa_quad,
+                                     gfx::QuadF* draw_region) {
+  gfx::PointF region_points[] = {draw_region->p1(), draw_region->p2(),
+                                 draw_region->p3(), draw_region->p4()};
+
+  // We find the bounding box of the original quad and the inflated AA quad
+  // that was developed by SetupQuadForAntiAliasing.
+  gfx::RectF original_rect = original_quad.BoundingBox();
+  gfx::RectF aa_rect = aa_quad.BoundingBox();
+
+  // For all 4 of the draw region points, we find the factor from 0.0 to 1.0
+  // of the X, Y values of the region points within the original quad. Since
+  // the region quad lives within the boundaries of the original quad instead
+  // of the AA quad, we need to inflate the values to match those of the AA
+  // quad, so we apply the same factor, instead to the AA quad, to achieve the
+  // new draw region points.
+  // The |delta| values are just the width and height of the quads, and we
+  // divide the x, y values we get by these to get them normalized from 0.0
+  // to 1.0.
+  float min_x = original_rect.x();
+  float min_y = original_rect.y();
+  float delta_x = original_rect.width();
+  float delta_y = original_rect.height();
+  float min_aa_x = aa_rect.x();
+  float min_aa_y = aa_rect.y();
+  float delta_aa_x = aa_rect.width();
+  float delta_aa_y = aa_rect.height();
+
+  // Here we loop through the 4 vertices of the draw region and apply the
+  // scaling that we get from x / delta_x, y / delta_y on the original quad
+  // and apply those factors to delta_aa_x and delta_aa_y to get our final
+  // points.
+  for (int i = 0; i < 4; i++) {
+    float x_factor = 0.0f;
+    float y_factor = 0.0f;
+    if (delta_x != 0.0f)
+      x_factor = (region_points[i].x() - min_x) / delta_x;
+    if (delta_y != 0.0f)
+      y_factor = (region_points[i].y() - min_y) / delta_y;
+    region_points[i].set_x(min_aa_x + (delta_aa_x * x_factor));
+    region_points[i].set_y(min_aa_y + (delta_aa_y * y_factor));
+  }
+
+  *draw_region = gfx::QuadF(
+      region_points[0], region_points[1], region_points[2], region_points[3]);
+}
+
 // static
 bool GLRenderer::SetupQuadForAntialiasing(
     const gfx::Transform& device_transform,
     const DrawQuad* quad,
     gfx::QuadF* local_quad,
     float edge[24]) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   bool clipped = false;
   gfx::QuadF device_layer_quad = MathUtil::MapQuad(
       device_transform, gfx::QuadF(quad->visibleContentRect()), &clipped);
 
+  // The 2d BoundingBox of the quad may still be empty even if the quad
+  // was not clipped (if the plane is edge-on for example).
+  if (device_layer_quad.BoundingBox().IsEmpty()) {
+    return false;
+  }
+
   bool is_axis_aligned_in_target = device_layer_quad.IsRectilinear();
   bool is_nearest_rect_within_epsilon =
       is_axis_aligned_in_target &&
       gfx::IsNearestRectWithinDistance(device_layer_quad.BoundingBox(),
                                        kAntiAliasingEpsilon);
   // AAing clipped quads is not supported by the code yet.
   bool use_aa = !clipped && !is_nearest_rect_within_epsilon && quad->IsEdge();
   if (!use_aa)
     return false;
 
@@ skipping 54 matching lines @@
   *local_quad = MathUtil::MapQuad(
       inverse_device_transform, device_quad.ToQuadF(), &clipped);
   // We should not DCHECK(!clipped) here, because anti-aliasing inflation may
   // cause device_quad to become clipped. To our knowledge this scenario does
   // not need to be handled differently than the unclipped case.
 
   return true;
 }
 
 void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
-                                    const SolidColorDrawQuad* quad) {
+                                    const SolidColorDrawQuad* quad,
+                                    const gfx::QuadF* clip_region) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   SkColor color = quad->color;
   float opacity = quad->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->quadTransform();
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
+  gfx::QuadF original_quad = local_quad;
   float edge[24];
   bool use_aa =
-      settings_->allow_antialiasing && !quad->force_anti_aliasing_off &&
+      settings_->allow_antialiasing &&
       SetupQuadForAntialiasing(device_transform, quad, &local_quad, edge);
 
+  gfx::QuadF local_draw_region;
+  if (!clip_region) {
+    local_draw_region = local_quad;
+  } else {
+    local_draw_region = *clip_region;
+  }
+
+  if (use_aa) {
+    ExpandDrawRegionToAAQuad(original_quad, local_quad, &local_draw_region);
+  }
+
   SolidColorProgramUniforms uniforms;
   if (use_aa)
     SolidColorUniformLocation(GetSolidColorProgramAA(), &uniforms);
   else
     SolidColorUniformLocation(GetSolidColorProgram(), &uniforms);
   SetUseProgram(uniforms.program);
 
   GLC(gl_,
       gl_->Uniform4f(uniforms.color_location,
                      (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
                      (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,
                      (SkColorGetB(color) * (1.0f / 255.0f)) * alpha,
                      alpha));
   if (use_aa) {
     float viewport[4] = {static_cast<float>(viewport_.x()),
                          static_cast<float>(viewport_.y()),
                          static_cast<float>(viewport_.width()),
                          static_cast<float>(viewport_.height()), };
     GLC(gl_, gl_->Uniform4fv(uniforms.viewport_location, 1, viewport));
     GLC(gl_, gl_->Uniform3fv(uniforms.edge_location, 8, edge));
   }
 
   // Enable blending when the quad properties require it or if we decided
   // to use antialiasing.
   SetBlendEnabled(quad->ShouldDrawWithBlending() || use_aa);
 
-  // Normalize to tile_rect.
-  local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
+  //Normalize to tile_rect.
+  local_draw_region.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
 
-  SetShaderQuadF(local_quad, uniforms.quad_location);
+  SetShaderQuadF(local_draw_region, 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->quadTransform(), centered_rect, uniforms.matrix_location);
@@ skipping 21 matching lines @@
   uniforms->vertex_tex_transform_location =
       program->vertex_shader().vertex_tex_transform_location();
 
   uniforms->sampler_location = program->fragment_shader().sampler_location();
   uniforms->alpha_location = program->fragment_shader().alpha_location();
   uniforms->fragment_tex_transform_location =
       program->fragment_shader().fragment_tex_transform_location();
 }
 
 void GLRenderer::DrawTileQuad(const DrawingFrame* frame,
-                              const TileDrawQuad* quad) {
-  DrawContentQuad(frame, quad, quad->resource_id);
+                              const TileDrawQuad* quad,
+                              const gfx::QuadF* clip_region) {
+  DrawContentQuad(frame, quad, quad->resource_id, clip_region);
 }
 
 void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
                                  const ContentDrawQuadBase* quad,
-                                 ResourceProvider::ResourceId resource_id) {
+                                 ResourceProvider::ResourceId resource_id,
+                                 const gfx::QuadF* clip_region) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
       quad->tex_coord_rect, quad->rect, tile_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();
 
   gfx::RectF clamp_geom_rect(tile_rect);
   gfx::RectF clamp_tex_rect(tex_coord_rect);
@@ skipping 26 matching lines @@
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_, quad->texture_size);
 
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
+  gfx::QuadF original_quad = local_quad;
   float edge[24];
   bool use_aa =
       settings_->allow_antialiasing &&
       SetupQuadForAntialiasing(device_transform, quad, &local_quad, edge);
 
+  gfx::QuadF local_draw_region;
+  if (!clip_region) {
+    local_draw_region = local_quad;
+  } else {
+    local_draw_region = *clip_region;
+  }
+
+  if (use_aa) {
+    ExpandDrawRegionToAAQuad(original_quad, local_quad, &local_draw_region);
+  }
+
   bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);
   GLenum filter = (use_aa || scaled ||
                    !quad->quadTransform().IsIdentityOrIntegerTranslation())
                       ? GL_LINEAR
                       : GL_NEAREST;
   ResourceProvider::ScopedSamplerGL quad_resource_lock(
       resource_provider_, resource_id, filter);
   SamplerType sampler =
       SamplerTypeFromTextureTarget(quad_resource_lock.target());
 
@@ skipping 83 matching lines @@
                        vertex_tex_translate_y,
                        vertex_tex_scale_x,
                        vertex_tex_scale_y));
   }
 
   // Enable blending when the quad properties require it or if we decided
   // to use antialiasing.
   SetBlendEnabled(quad->ShouldDrawWithBlending() || use_aa);
 
   // Normalize to tile_rect.
-  local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
-
+  local_draw_region.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
   SetShaderOpacity(quad->opacity(), uniforms.alpha_location);
-  SetShaderQuadF(local_quad, uniforms.quad_location);
+  SetShaderQuadF(local_draw_region, 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->quadTransform(), centered_rect, uniforms.matrix_location);
 }
 
 void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
-                                  const YUVVideoDrawQuad* quad) {
+                                  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());
 
   bool use_alpha_plane = quad->a_plane_resource_id != 0;
 
@@ skipping 98 matching lines @@
     case YUVVideoDrawQuad::REC_601:
       yuv_to_rgb = yuv_to_rgb_rec601;
       yuv_adjust = yuv_adjust_rec601;
       break;
     case YUVVideoDrawQuad::REC_601_JPEG:
       yuv_to_rgb = yuv_to_rgb_rec601_jpeg;
       yuv_adjust = yuv_adjust_rec601_jpeg;
       break;
   }
 
+  // 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->visible_rect;
   GLC(gl_, gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb));
   GLC(gl_, gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust));
 
   SetShaderOpacity(quad->opacity(), alpha_location);
-  DrawQuadGeometry(frame, quad->quadTransform(), quad->rect, matrix_location);
+  if (!clip_region) {
+    DrawQuadGeometry(frame, quad->quadTransform(), tile_rect, matrix_location);
+  } else {
+    gfx::QuadF region_quad = *clip_region;
+    region_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
+    DrawQuadGeometryClippedByQuadF(
+        frame, quad->quadTransform(), tile_rect, region_quad, matrix_location);
+  }
 }
 
 void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
-                                     const StreamVideoDrawQuad* quad) {
+                                     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_,
@@ skipping 10 matching lines @@
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->resource_id);
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id()));
 
   GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
   SetShaderOpacity(quad->opacity(),
                    program->fragment_shader().alpha_location());
-  DrawQuadGeometry(frame,
-                   quad->quadTransform(),
-                   quad->rect,
-                   program->vertex_shader().matrix_location());
+  if (!clip_region) {
+    DrawQuadGeometry(frame,
+                     quad->quadTransform(),
+                     quad->rect,
+                     program->vertex_shader().matrix_location());
+  } else {
+    DrawQuadGeometryClippedByQuadF(frame,
+                                   quad->quadTransform(),
+                                   quad->rect,
+                                   *clip_region,
+                                   program->vertex_shader().matrix_location());
+  }
 }
 
 void GLRenderer::DrawPictureQuad(const DrawingFrame* frame,
-                                 const PictureDrawQuad* quad) {
+                                 const PictureDrawQuad* quad,
+                                 const gfx::QuadF* clip_region) {
   if (on_demand_tile_raster_bitmap_.width() != quad->texture_size.width() ||
       on_demand_tile_raster_bitmap_.height() != quad->texture_size.height()) {
     on_demand_tile_raster_bitmap_.allocN32Pixels(quad->texture_size.width(),
                                                  quad->texture_size.height());
 
     if (on_demand_tile_raster_resource_id_)
       resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
     on_demand_tile_raster_resource_id_ = resource_provider_->CreateGLTexture(
         quad->texture_size,
@@ skipping 23 matching lines @@
     bitmap_pixels =
         reinterpret_cast<uint8_t*>(on_demand_tile_raster_bitmap_.getPixels());
   }
 
   resource_provider_->SetPixels(on_demand_tile_raster_resource_id_,
                                 bitmap_pixels,
                                 gfx::Rect(quad->texture_size),
                                 gfx::Rect(quad->texture_size),
                                 gfx::Vector2d());
 
-  DrawContentQuad(frame, quad, on_demand_tile_raster_resource_id_);
+  DrawContentQuad(frame, quad, on_demand_tile_raster_resource_id_, clip_region);
 }
 
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program) {
     DCHECK(program);
     program_id = program->program();
     sampler_location = program->fragment_shader().sampler_location();
     matrix_location = program->vertex_shader().matrix_location();
     background_color_location =
         program->fragment_shader().background_color_location();
   }
   int program_id;
   int sampler_location;
   int matrix_location;
+  int transform_location;
   int background_color_location;
 };
 
 struct TexTransformTextureProgramBinding : TextureProgramBinding {
   template <class Program>
   void Set(Program* program) {
     TextureProgramBinding::Set(program);
     tex_transform_location = program->vertex_shader().tex_transform_location();
     vertex_opacity_location =
         program->vertex_shader().vertex_opacity_location();
   }
   int tex_transform_location;
   int vertex_opacity_location;
 };
 
-void GLRenderer::FlushTextureQuadCache() {
+void GLRenderer::FlushTextureQuadCache(bool using_clip_region) {
   // Check to see if we have anything to draw.
   if (draw_cache_.program_id == 0)
     return;
+/*
+  if (!using_clip_region) {
+    shared_geometry_->PrepareForDraw();
+  } else {
+    clipped_geometry_->PrepareForDraw();
+  }
+*/
 
   // Set the correct blending mode.
   SetBlendEnabled(draw_cache_.needs_blending);
 
   // Bind the program to the GL state.
   SetUseProgram(draw_cache_.program_id);
 
   // Bind the correct texture sampler location.
   GLC(gl_, gl_->Uniform1i(draw_cache_.sampler_location, 0));
 
@@ skipping 38 matching lines @@
       gl_->DrawElements(GL_TRIANGLES,
                         6 * draw_cache_.matrix_data.size(),
                         GL_UNSIGNED_SHORT,
                         0));
 
   // Clear the cache.
   draw_cache_.program_id = 0;
   draw_cache_.uv_xform_data.resize(0);
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
+/*
+  if (using_clip_region) {
+    shared_geometry_->PrepareForDraw();
+  }*/
+}
+
+void PrintQuad(const gfx::QuadF& quad) {
+  LOG(ERROR) << "quad";
+  LOG(ERROR) << quad.p1().x() << ", " << quad.p1().y();
+  LOG(ERROR) << quad.p2().x() << ", " << quad.p2().y();
+  LOG(ERROR) << quad.p3().x() << ", " << quad.p3().y();
+  LOG(ERROR) << quad.p4().x() << ", " << quad.p4().y();
 }
 
 void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
-                                    const TextureDrawQuad* quad) {
+                                    const TextureDrawQuad* quad,
+                                    const gfx::QuadF* clip_region) {
+  //TODO(awoloszyn):: THIS IS VERY SUSPICIOUS, this is going to invole
+  // a huge amount of state swapping where it may not be necessary
+  // Here we need to flush out everything that's already in the cache because
+  // we need to enqueue a single quad, switch geometry bindings, and then
+  // flush that single quad.
+  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(false);
+  }
+
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_,
       &highp_threshold_cache_,
       highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   // Choose the correct texture program binding
   TexTransformTextureProgramBinding binding;
   if (quad->premultiplied_alpha) {
     if (quad->background_color == SK_ColorTRANSPARENT) {
@@ skipping 10 matching lines @@
     }
   }
 
   int resource_id = quad->resource_id;
 
   if (draw_cache_.program_id != binding.program_id ||
       draw_cache_.resource_id != resource_id ||
       draw_cache_.needs_blending != quad->ShouldDrawWithBlending() ||
       draw_cache_.background_color != quad->background_color ||
       draw_cache_.matrix_data.size() >= 8) {
-    FlushTextureQuadCache();
+    FlushTextureQuadCache(false);
     draw_cache_.program_id = binding.program_id;
     draw_cache_.resource_id = resource_id;
     draw_cache_.needs_blending = quad->ShouldDrawWithBlending();
     draw_cache_.background_color = quad->background_color;
 
     draw_cache_.uv_xform_location = binding.tex_transform_location;
     draw_cache_.background_color_location = binding.background_color_location;
     draw_cache_.vertex_opacity_location = binding.vertex_opacity_location;
     draw_cache_.matrix_location = binding.matrix_location;
     draw_cache_.sampler_location = binding.sampler_location;
   }
 
   // Generate the uv-transform
-  draw_cache_.uv_xform_data.push_back(UVTransform(quad));
+  if (!clip_region) {
+    draw_cache_.uv_xform_data.push_back(UVTransform(quad));
+  } else {
+    Float4 uv_transform = {{0.0f, 0.0f, 1.0f, 1.0f}};
+    draw_cache_.uv_xform_data.push_back(uv_transform);
+  }
 
   // Generate the vertex opacity
   const float opacity = quad->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->quadTransform(), 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) {
+    // Now we make the clip_region fit inside the regular SharedGeometryQuad
+    // and send that in to be rendered.
+    gfx::PointF p1(clip_region->p1().x() * (1.0f / quad->rect.width()) - 0.5f,
+                   clip_region->p1().y() * (1.0f / quad->rect.height()) - 0.5f);
+    gfx::PointF p2(clip_region->p2().x() * (1.0f / quad->rect.width()) - 0.5f,
+                   clip_region->p2().y() * (1.0f / quad->rect.height()) - 0.5f);
+    gfx::PointF p3(clip_region->p3().x() * (1.0f / quad->rect.width()) - 0.5f,
+                   clip_region->p3().y() * (1.0f / quad->rect.height()) - 0.5f);
+    gfx::PointF p4(clip_region->p4().x() * (1.0f / quad->rect.width()) - 0.5f,
+                   clip_region->p4().y() * (1.0f / quad->rect.height()) - 0.5f);
+    gfx::QuadF scaled_region(p1, p2, p3, p4);
+
+    float uv[8];
+    uv[0] = p1.x() + 0.5f;
+    uv[1] = p1.y() + 0.5f;
+    uv[2] = p2.x() + 0.5f;
+    uv[3] = p2.y() + 0.5f;
+    uv[4] = p3.x() + 0.5f;
+    uv[5] = p3.y() + 0.5f;
+    uv[6] = p4.x() + 0.5f;
+    uv[7] = p4.y() + 0.5f;
+
+    clipped_geometry_->InitializeCustomQuadWithUVs(scaled_region, uv);
+    //TODO(awoloszyn) Again, if we flush with EVERY call, we are doing something
+    //wrong
+    //FlushTextureQuadCache(true);
+  }
 }
 
 void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
-                                   const IOSurfaceDrawQuad* quad) {
+                                   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());
 
   TexTransformTextureProgramBinding binding;
   binding.Set(GetTextureIOSurfaceProgram(tex_coord_precision));
@@ skipping 18 matching lines @@
 
   const float vertex_opacity[] = {quad->opacity(), quad->opacity(),
                                   quad->opacity(), quad->opacity()};
   GLC(gl_, 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_));
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id()));
 
-  DrawQuadGeometry(
-      frame, quad->quadTransform(), quad->rect, binding.matrix_location);
+  if (!clip_region) {
+    DrawQuadGeometry(
+        frame, quad->quadTransform(), quad->rect, binding.matrix_location);
+  } else {
+    DrawQuadGeometryClippedByQuadF(frame,
+                                   quad->quadTransform(),
+                                   quad->rect,
+                                   *clip_region,
+                                   binding.matrix_location);
+  }
 
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
 void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   if (use_sync_query_) {
     DCHECK(current_sync_query_);
     current_sync_query_->End();
     pending_sync_queries_.push_back(current_sync_query_.Pass());
   }
 
   current_framebuffer_lock_.reset();
   swap_buffer_rect_.Union(gfx::ToEnclosingRect(frame->root_damage_rect));
 
   GLC(gl_, gl_->Disable(GL_BLEND));
   blend_shadow_ = false;
 
   ScheduleOverlays(frame);
 }
 
-void GLRenderer::FinishDrawingQuadList() { FlushTextureQuadCache(); }
+void GLRenderer::FinishDrawingQuadList() {
+  FlushTextureQuadCache(false);
+}
 
 bool GLRenderer::FlippedFramebuffer() const { return true; }
 
 void GLRenderer::EnsureScissorTestEnabled() {
   if (is_scissor_enabled_)
     return;
 
-  FlushTextureQuadCache();
+  FlushTextureQuadCache(false);
   GLC(gl_, gl_->Enable(GL_SCISSOR_TEST));
   is_scissor_enabled_ = true;
 }
 
 void GLRenderer::EnsureScissorTestDisabled() {
   if (!is_scissor_enabled_)
     return;
 
-  FlushTextureQuadCache();
+  FlushTextureQuadCache(false);
   GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
   is_scissor_enabled_ = false;
 }
 
 void GLRenderer::CopyCurrentRenderPassToBitmap(
     DrawingFrame* frame,
     scoped_ptr<CopyOutputRequest> request) {
   TRACE_EVENT0("cc", "GLRenderer::CopyCurrentRenderPassToBitmap");
   gfx::Rect copy_rect = frame->current_render_pass->output_rect;
   if (request->has_area())
@@ skipping 48 matching lines @@
   blend_shadow_ = enabled;
 }
 
 void GLRenderer::SetUseProgram(unsigned program) {
   if (program == program_shadow_)
     return;
   gl_->UseProgram(program);
   program_shadow_ = program;
 }
 
+void GLRenderer::DrawQuadGeometryClippedByQuadF(
+    const DrawingFrame* frame,
+    const gfx::Transform& draw_transform,
+    const gfx::RectF& quad_rect,
+    const gfx::QuadF& clipping_region_quad,
+    int matrix_location) {
+//  clipped_geometry_->PrepareForDraw();
+  clipped_geometry_->InitializeCustomQuad(clipping_region_quad);
+  static float gl_matrix[16];
+  ToGLMatrix(&gl_matrix[0], frame->projection_matrix);
+  GLC(gl_, gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]));
+
+  GLC(gl_,
+      gl_->DrawElements(GL_TRIANGLES,
+                        6,
+                        GL_UNSIGNED_SHORT,
+                        reinterpret_cast<const void*>(0)));
+}
+
 void GLRenderer::DrawQuadGeometry(const DrawingFrame* frame,
                                   const gfx::Transform& draw_transform,
                                   const gfx::RectF& quad_rect,
                                   int matrix_location) {
+//  shared_geometry_->PrepareForDraw();
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
   static float gl_matrix[16];
   ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad_rect_matrix);
   GLC(gl_, gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]));
 
   GLC(gl_, gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0));
 }
 
 void GLRenderer::CopyTextureToFramebuffer(const DrawingFrame* frame,
@@ skipping 403 matching lines @@
   return true;
 }
 
 void GLRenderer::SetScissorTestRect(const gfx::Rect& scissor_rect) {
   EnsureScissorTestEnabled();
 
   // Don't unnecessarily ask the context to change the scissor, because it
   // may cause undesired GPU pipeline flushes.
   if (scissor_rect == scissor_rect_ && !scissor_rect_needs_reset_)
     return;
-
   scissor_rect_ = scissor_rect;
-  FlushTextureQuadCache();
+  FlushTextureQuadCache(false);
   GLC(gl_,
       gl_->Scissor(scissor_rect.x(),
                    scissor_rect.y(),
                    scissor_rect.width(),
                    scissor_rect.height()));
 
   scissor_rect_needs_reset_ = false;
 }
 
 void GLRenderer::SetDrawViewport(const gfx::Rect& window_space_viewport) {
   viewport_ = window_space_viewport;
   GLC(gl_,
       gl_->Viewport(window_space_viewport.x(),
                     window_space_viewport.y(),
                     window_space_viewport.width(),
                     window_space_viewport.height()));
 }
 
 void GLRenderer::InitializeSharedObjects() {
   TRACE_EVENT0("cc", "GLRenderer::InitializeSharedObjects");
 
   // Create an FBO for doing offscreen rendering.
   GLC(gl_, gl_->GenFramebuffers(1, &offscreen_framebuffer_id_));
 
-  shared_geometry_ = make_scoped_ptr(
-      new GeometryBinding(gl_, QuadVertexRect()));
+  shared_geometry_ =
+      make_scoped_ptr(new GeometryBinding(gl_, QuadVertexRect(), 8));
+  clipped_geometry_ =
+      make_scoped_ptr(new GeometryBindingQuad(gl_, QuadVertexRect()));
 }
 
 const GLRenderer::TileCheckerboardProgram*
 GLRenderer::GetTileCheckerboardProgram() {
   if (!tile_checkerboard_program_.initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::checkerboardProgram::initalize");
     tile_checkerboard_program_.Initialize(output_surface_->context_provider(),
                                           TexCoordPrecisionNA,
                                           SamplerTypeNA);
   }
@@ skipping 472 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc