Splitting of layers for correct intersections

Sorting 3d-sorted layers and rendering them in that order causes issues
when layers intersect. Instead place 3d-sorted layers in a bsp tree and
fragment any intersecting layers into non-rectangular quads. We can then
render the fragments in the correct sorted order regardless of
intersections.

BUG=455918,159225,132122,230833

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

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

43 files changed, 1679 insertions, 1734 deletions

diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 83e012a..9d13ccc 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -253,6 +253,8 @@ component("cc") {
     "output/delegating_renderer.h",
     "output/direct_renderer.cc",
     "output/direct_renderer.h",
+    "output/dynamic_geometry_binding.cc",
+    "output/dynamic_geometry_binding.h",
     "output/filter_operation.cc",
     "output/filter_operation.h",
     "output/filter_operations.cc",
@@ -293,6 +295,8 @@ component("cc") {
     "output/software_output_device.h",
     "output/software_renderer.cc",
     "output/software_renderer.h",
+    "output/static_geometry_binding.cc",
+    "output/static_geometry_binding.h",
     "output/viewport_selection_bound.cc",
     "output/viewport_selection_bound.h",
     "output/vsync_parameter_observer.h",
@@ -504,8 +508,6 @@ component("cc") {
     "trees/damage_tracker.h",
     "trees/draw_property_utils.cc",
     "trees/draw_property_utils.h",
-    "trees/layer_sorter.cc",
-    "trees/layer_sorter.h",
     "trees/layer_tree_host.cc",
     "trees/layer_tree_host.h",
     "trees/layer_tree_host_client.h",
@@ -829,7 +831,6 @@ test("cc_unittests") {
     "test/test_web_graphics_context_3d_unittest.cc",
     "trees/blocking_task_runner_unittest.cc",
     "trees/damage_tracker_unittest.cc",
-    "trees/layer_sorter_unittest.cc",
     "trees/layer_tree_host_common_unittest.cc",
     "trees/layer_tree_host_impl_unittest.cc",
     "trees/layer_tree_host_pixeltest_blending.cc",
diff --git a/cc/cc.gyp b/cc/cc.gyp
index beb90ea..355b69c 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -279,6 +279,8 @@
         'output/delegating_renderer.h',
         'output/direct_renderer.cc',
         'output/direct_renderer.h',
+        'output/dynamic_geometry_binding.cc',
+        'output/dynamic_geometry_binding.h',
         'output/filter_operation.cc',
         'output/filter_operation.h',
         'output/filter_operations.cc',
@@ -319,6 +321,8 @@
         'output/software_output_device.h',
         'output/software_renderer.cc',
         'output/software_renderer.h',
+        'output/static_geometry_binding.cc',
+        'output/static_geometry_binding.h',
         'output/viewport_selection_bound.cc',
         'output/viewport_selection_bound.h',
         'output/vsync_parameter_observer.h',
@@ -531,8 +535,6 @@
         'trees/damage_tracker.h',
         'trees/draw_property_utils.cc',
         'trees/draw_property_utils.h',
-        'trees/layer_sorter.cc',
-        'trees/layer_sorter.h',
         'trees/layer_tree_host.cc',
         'trees/layer_tree_host.h',
         'trees/layer_tree_host_client.h',
diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index fd5de02..bafd747 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -106,7 +106,6 @@
       'test/test_web_graphics_context_3d_unittest.cc',
       'trees/blocking_task_runner_unittest.cc',
       'trees/damage_tracker_unittest.cc',
-      'trees/layer_sorter_unittest.cc',
       'trees/layer_tree_host_common_unittest.cc',
       'trees/layer_tree_host_impl_unittest.cc',
       'trees/layer_tree_host_pixeltest_blending.cc',
diff --git a/cc/output/bsp_tree.cc b/cc/output/bsp_tree.cc
index f2318ce..4eb87cb 100644
--- a/cc/output/bsp_tree.cc
+++ b/cc/output/bsp_tree.cc
@@ -62,10 +62,9 @@ void BspTree::BuildTree(BspNode* node,
         scoped_ptr<DrawPolygon> polygon;
         scoped_ptr<DrawPolygon> new_front;
         scoped_ptr<DrawPolygon> new_back;
-        bool split_result = false;
         // Time to split this geometry, *it needs to be split by node_data.
         polygon = polygon_list->take_front();
-        split_result =
+        bool split_result =
             polygon->Split(*(node->node_data), &new_front, &new_back);
         DCHECK(split_result);
         if (!split_result) {
diff --git a/cc/output/bsp_walk_action.cc b/cc/output/bsp_walk_action.cc
index da5ada5..9ffc299 100644
--- a/cc/output/bsp_walk_action.cc
+++ b/cc/output/bsp_walk_action.cc
@@ -9,15 +9,37 @@
 #include "base/memory/scoped_ptr.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/quads/draw_polygon.h"
+#include "cc/quads/draw_quad.h"
 
 namespace cc {
 
-void BspWalkActionToVector::operator()(DrawPolygon* item) {
-  list_->push_back(item);
+BspWalkActionDrawPolygon::BspWalkActionDrawPolygon(
+    DirectRenderer* renderer,
+    DirectRenderer::DrawingFrame* frame,
+    const gfx::Rect& render_pass_scissor,
+    bool using_scissor_as_optimization)
+    : renderer_(renderer),
+      frame_(frame),
+      render_pass_scissor_(render_pass_scissor),
+      using_scissor_as_optimization_(using_scissor_as_optimization) {
+}
+
+void BspWalkActionDrawPolygon::operator()(DrawPolygon* item) {
+  gfx::Transform inverse_transform;
+  bool invertible =
+      item->original_ref()->quadTransform().GetInverse(&inverse_transform);
+  DCHECK(invertible);
+  item->TransformToLayerSpace(inverse_transform);
+  renderer_->DoDrawPolygon(*item, frame_, render_pass_scissor_,
+                           using_scissor_as_optimization_);
 }
 
 BspWalkActionToVector::BspWalkActionToVector(std::vector<DrawPolygon*>* in_list)
     : list_(in_list) {
 }
 
+void BspWalkActionToVector::operator()(DrawPolygon* item) {
+  list_->push_back(item);
+}
+
 }  // namespace cc
diff --git a/cc/output/bsp_walk_action.h b/cc/output/bsp_walk_action.h
index ac8fa41..a89d8ea 100644
--- a/cc/output/bsp_walk_action.h
+++ b/cc/output/bsp_walk_action.h
@@ -20,6 +20,22 @@ class CC_EXPORT BspWalkAction {
 
 // The BspTree class takes ownership of all the DrawPolygons returned in list_
 // so the BspTree must be preserved while elements in that vector are in use.
+class CC_EXPORT BspWalkActionDrawPolygon : public BspWalkAction {
+ public:
+  void operator()(DrawPolygon* item) override;
+
+  BspWalkActionDrawPolygon(DirectRenderer* renderer,
+                           DirectRenderer::DrawingFrame* frame,
+                           const gfx::Rect& render_pass_scissor,
+                           bool using_scissor_as_optimization);
+
+ private:
+  DirectRenderer* renderer_;
+  DirectRenderer::DrawingFrame* frame_;
+  const gfx::Rect& render_pass_scissor_;
+  bool using_scissor_as_optimization_;
+};
+
 class CC_EXPORT BspWalkActionToVector : public BspWalkAction {
  public:
   explicit BspWalkActionToVector(std::vector<DrawPolygon*>* in_list);
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 5867fce..0ae4179 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -12,6 +12,8 @@
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
+#include "cc/output/bsp_tree.h"
+#include "cc/output/bsp_walk_action.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/draw_quad.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ -299,22 +301,27 @@ void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame,
   EnsureScissorTestDisabled();
 }
 
+bool DirectRenderer::ShouldSkipQuad(const DrawQuad& quad,
+                                    const gfx::Rect& render_pass_scissor) {
+  if (render_pass_scissor.IsEmpty())
+    return true;
+
+  if (quad.isClipped()) {
+    gfx::Rect r = quad.clipRect();
+    r.Intersect(render_pass_scissor);
+    return r.IsEmpty();
+  }
+
+  return false;
+}
+
 void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
     const DrawingFrame* frame,
     const DrawQuad& quad,
-    const gfx::Rect& render_pass_scissor,
-    bool* should_skip_quad) {
+    const gfx::Rect& render_pass_scissor) {
   gfx::Rect quad_scissor_rect = render_pass_scissor;
-
   if (quad.isClipped())
     quad_scissor_rect.Intersect(quad.clipRect());
-
-  if (quad_scissor_rect.IsEmpty()) {
-    *should_skip_quad = true;
-    return;
-  }
-
-  *should_skip_quad = false;
   SetScissorTestRectInDrawSpace(frame, quad_scissor_rect);
 }
 
@@ -330,6 +337,46 @@ void DirectRenderer::SetScissorTestRectInDrawSpace(
 
 void DirectRenderer::FinishDrawingQuadList() {}
 
+void DirectRenderer::DoDrawPolygon(const DrawPolygon& poly,
+                                   DrawingFrame* frame,
+                                   const gfx::Rect& render_pass_scissor,
+                                   bool using_scissor_as_optimization) {
+  if (using_scissor_as_optimization) {
+    SetScissorStateForQuadWithRenderPassScissor(frame, *poly.original_ref(),
+                                                render_pass_scissor);
+  } else {
+    SetScissorStateForQuad(frame, *poly.original_ref());
+  }
+
+  // If the poly has not been split, then it is just a normal DrawQuad,
+  // and we should save any extra processing that would have to be done.
+  if (!poly.is_split()) {
+    DoDrawQuad(frame, poly.original_ref(), NULL);
+    return;
+  }
+
+  std::vector<gfx::QuadF> quads;
+  poly.ToQuads2D(&quads);
+  for (size_t i = 0; i < quads.size(); ++i) {
+    DoDrawQuad(frame, poly.original_ref(), &quads[i]);
+  }
+}
+
+void DirectRenderer::FlushPolygons(ScopedPtrDeque<DrawPolygon>* poly_list,
+                                   DrawingFrame* frame,
+                                   const gfx::Rect& render_pass_scissor,
+                                   bool using_scissor_as_optimization) {
+  if (poly_list->empty()) {
+    return;
+  }
+
+  BspTree bsp_tree(poly_list);
+  BspWalkActionDrawPolygon action_handler(this, frame, render_pass_scissor,
+                                          using_scissor_as_optimization);
+  bsp_tree.TraverseWithActionHandler(&action_handler);
+  DCHECK(poly_list->empty());
+}
+
 void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
                                     const RenderPass* render_pass) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
@@ -369,21 +416,49 @@ void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
   }
 
   const QuadList& quad_list = render_pass->quad_list;
+  ScopedPtrDeque<DrawPolygon> poly_list;
+
+  int next_polygon_id = 0;
+  int last_sorting_context_id = 0;
   for (auto it = quad_list.BackToFrontBegin(); it != quad_list.BackToFrontEnd();
        ++it) {
     const DrawQuad& quad = **it;
-    bool should_skip_quad = false;
+    gfx::QuadF send_quad(quad.visible_rect);
+
+    if (using_scissor_as_optimization &&
+        ShouldSkipQuad(quad, render_pass_scissor)) {
+      continue;
+    }
+
+    if (last_sorting_context_id != quad.shared_quad_state->sorting_context_id) {
+      last_sorting_context_id = quad.shared_quad_state->sorting_context_id;
+      FlushPolygons(&poly_list, frame, render_pass_scissor,
+                    using_scissor_as_optimization);
+    }
+
+    // This layer is in a 3D sorting context so we add it to the list of
+    // polygons to go into the BSP tree.
+    if (quad.shared_quad_state->sorting_context_id != 0) {
+      scoped_ptr<DrawPolygon> new_polygon(new DrawPolygon(
+          *it, quad.visible_rect, quad.quadTransform(), next_polygon_id++));
+      if (new_polygon->points().size() > 2u) {
+        poly_list.push_back(new_polygon.Pass());
+      }
+      continue;
+    }
 
+    // We are not in a 3d sorting context, so we should draw the quad normally.
     if (using_scissor_as_optimization) {
-      SetScissorStateForQuadWithRenderPassScissor(
-          frame, quad, render_pass_scissor, &should_skip_quad);
+      SetScissorStateForQuadWithRenderPassScissor(frame, quad,
+                                                  render_pass_scissor);
     } else {
       SetScissorStateForQuad(frame, quad);
     }
 
-    if (!should_skip_quad)
-      DoDrawQuad(frame, &quad);
+    DoDrawQuad(frame, &quad, nullptr);
   }
+  FlushPolygons(&poly_list, frame, render_pass_scissor,
+                using_scissor_as_optimization);
   FinishDrawingQuadList();
 }
 
diff --git a/cc/output/direct_renderer.h b/cc/output/direct_renderer.h
index e07cb93..3399491 100644
--- a/cc/output/direct_renderer.h
+++ b/cc/output/direct_renderer.h
@@ -9,13 +9,17 @@
 #include "base/callback.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "cc/base/cc_export.h"
+#include "cc/base/scoped_ptr_deque.h"
 #include "cc/output/overlay_processor.h"
 #include "cc/output/renderer.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
+#include "cc/resources/task_graph_runner.h"
+#include "ui/gfx/geometry/quad_f.h"
 
 namespace cc {
 
+class DrawPolygon;
 class ResourceProvider;
 
 // This is the base class for code shared between the GL and software
@@ -56,6 +60,10 @@ class CC_EXPORT DirectRenderer : public Renderer {
   };
 
   void SetEnlargePassTextureAmountForTesting(const gfx::Vector2d& amount);
+  void DoDrawPolygon(const DrawPolygon& poly,
+                     DrawingFrame* frame,
+                     const gfx::Rect& render_pass_scissor,
+                     bool using_scissor_as_optimization);
 
  protected:
   DirectRenderer(RendererClient* client,
@@ -78,16 +86,21 @@ class CC_EXPORT DirectRenderer : public Renderer {
   gfx::Rect DeviceClipRectInWindowSpace(const DrawingFrame* frame) const;
   static gfx::Rect ComputeScissorRectForRenderPass(const DrawingFrame* frame);
   void SetScissorStateForQuad(const DrawingFrame* frame, const DrawQuad& quad);
+  bool ShouldSkipQuad(const DrawQuad& quad,
+                      const gfx::Rect& render_pass_scissor);
   void SetScissorStateForQuadWithRenderPassScissor(
       const DrawingFrame* frame,
       const DrawQuad& quad,
-      const gfx::Rect& render_pass_scissor,
-      bool* should_skip_quad);
+      const gfx::Rect& render_pass_scissor);
   void SetScissorTestRectInDrawSpace(const DrawingFrame* frame,
                                      const gfx::Rect& draw_space_rect);
 
   static gfx::Size RenderPassTextureSize(const RenderPass* render_pass);
 
+  void FlushPolygons(ScopedPtrDeque<DrawPolygon>* poly_list,
+                     DrawingFrame* frame,
+                     const gfx::Rect& render_pass_scissor,
+                     bool using_scissor_as_optimization);
   void DrawRenderPass(DrawingFrame* frame, const RenderPass* render_pass);
   bool UseRenderPass(DrawingFrame* frame, const RenderPass* render_pass);
 
@@ -101,7 +114,12 @@ class CC_EXPORT DirectRenderer : public Renderer {
                              bool draw_rect_covers_full_surface) = 0;
   virtual void ClearFramebuffer(DrawingFrame* frame,
                                 bool has_external_stencil_test) = 0;
-  virtual void DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) = 0;
+  // clip_region is a (possibly null) pointer to a quad in the same
+  // space as the quad. When non-null only the area of the quad that overlaps
+  // with clip_region will be drawn.
+  virtual void DoDrawQuad(DrawingFrame* frame,
+                          const DrawQuad* quad,
+                          const gfx::QuadF* clip_region) = 0;
   virtual void BeginDrawingFrame(DrawingFrame* frame) = 0;
   virtual void FinishDrawingFrame(DrawingFrame* frame) = 0;
   virtual void FinishDrawingQuadList();
diff --git a/cc/output/dynamic_geometry_binding.cc b/cc/output/dynamic_geometry_binding.cc
new file mode 100644
index 0000000..9e25892
--- /dev/null
+++ b/cc/output/dynamic_geometry_binding.cc
@@ -0,0 +1,67 @@
+// Copyright 2015 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/dynamic_geometry_binding.h"
+
+#include "cc/output/gl_renderer.h"  // For the GLC() macro.
+#include "gpu/command_buffer/client/gles2_interface.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+namespace cc {
+
+DynamicGeometryBinding::DynamicGeometryBinding(gpu::gles2::GLES2Interface* gl)
+    : gl_(gl), quad_vertices_vbo_(0), quad_elements_vbo_(0) {
+  GeometryBindingQuad quads[1];
+  GeometryBindingQuadIndex quad_indices[1];
+
+  static_assert(sizeof(GeometryBindingQuad) == 24 * sizeof(float),
+                "struct Quad should be densely packed");
+  static_assert(sizeof(GeometryBindingQuadIndex) == 6 * sizeof(uint16_t),
+                "struct QuadIndex should be densely packed");
+
+  GLC(gl_, gl_->GenBuffers(1, &quad_vertices_vbo_));
+  GLC(gl_, gl_->GenBuffers(1, &quad_elements_vbo_));
+
+  GLC(gl_, gl_->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo_));
+  GLC(gl_, gl_->BufferData(GL_ARRAY_BUFFER, sizeof(GeometryBindingQuad) * 1,
+                           quads, GL_DYNAMIC_DRAW));
+
+  GLC(gl_, gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo_));
+  GLC(gl_, gl_->BufferData(GL_ELEMENT_ARRAY_BUFFER,
+                           sizeof(GeometryBindingQuadIndex) * 1, &quad_indices,
+                           GL_DYNAMIC_DRAW));
+}
+
+void DynamicGeometryBinding::InitializeCustomQuad(const gfx::QuadF& quad) {
+  float uv[] = {0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f};
+  InitializeCustomQuadWithUVs(quad, uv);
+}
+
+void DynamicGeometryBinding::InitializeCustomQuadWithUVs(const gfx::QuadF& quad,
+                                                         const float uv[8]) {
+  GeometryBindingVertex v0 = {
+      {quad.p1().x(), quad.p1().y(), 0.0f}, {uv[0], uv[1]}, 0.0f};
+  GeometryBindingVertex v1 = {
+      {quad.p2().x(), quad.p2().y(), 0.0f}, {uv[2], uv[3]}, 1.0f};
+  GeometryBindingVertex v2 = {
+      {quad.p3().x(), quad.p3().y(), 0.0f}, {uv[4], uv[5]}, 2.0f};
+  GeometryBindingVertex v3 = {
+      {quad.p4().x(), quad.p4().y(), 0.0f}, {uv[6], uv[7]}, 3.0f};
+
+  GeometryBindingQuad local_quad = {v0, v1, v2, v3};
+  GeometryBindingQuadIndex quad_index(
+      static_cast<uint16>(0), static_cast<uint16>(1), static_cast<uint16>(2),
+      static_cast<uint16>(3), static_cast<uint16>(0), static_cast<uint16>(2));
+
+  GLC(gl_, gl_->BufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GeometryBindingQuad),
+                              &local_quad));
+  GLC(gl_, gl_->BufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0,
+                              sizeof(GeometryBindingQuadIndex), &quad_index));
+}
+
+void DynamicGeometryBinding::PrepareForDraw() {
+  SetupGLContext(gl_, quad_elements_vbo_, quad_vertices_vbo_);
+}
+
+}  // namespace cc
diff --git a/cc/output/dynamic_geometry_binding.h b/cc/output/dynamic_geometry_binding.h
new file mode 100644
index 0000000..4e4ea3d
--- /dev/null
+++ b/cc/output/dynamic_geometry_binding.h
@@ -0,0 +1,30 @@
+// Copyright 2015 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.
+
+#ifndef CC_OUTPUT_DYNAMIC_GEOMETRY_BINDING_H_
+#define CC_OUTPUT_DYNAMIC_GEOMETRY_BINDING_H_
+
+#include "cc/output/geometry_binding.h"
+
+namespace cc {
+
+class DynamicGeometryBinding {
+ public:
+  explicit DynamicGeometryBinding(gpu::gles2::GLES2Interface* gl);
+  void PrepareForDraw();
+  void InitializeCustomQuad(const gfx::QuadF& quad);
+  void InitializeCustomQuadWithUVs(const gfx::QuadF& quad, const float uv[8]);
+
+ private:
+  gpu::gles2::GLES2Interface* gl_;
+
+  GLuint quad_vertices_vbo_;
+  GLuint quad_elements_vbo_;
+
+  DISALLOW_COPY_AND_ASSIGN(DynamicGeometryBinding);
+};
+
+}  // namespace cc
+
+#endif  // CC_OUTPUT_DYNAMIC_GEOMETRY_BINDING_H_
diff --git a/cc/output/geometry_binding.cc b/cc/output/geometry_binding.cc
index eda2a5c..88a37de 100644
--- a/cc/output/geometry_binding.cc
+++ b/cc/output/geometry_binding.cc
@@ -10,70 +10,12 @@
 
 namespace cc {
 
-GeometryBinding::GeometryBinding(gpu::gles2::GLES2Interface* gl,
-                                 const gfx::RectF& quad_vertex_rect)
-    : gl_(gl), quad_vertices_vbo_(0), quad_elements_vbo_(0) {
-  struct Vertex {
-    float a_position[3];
-    float a_texCoord[2];
-    // Index of the vertex, divide by 4 to have the matrix for this quad.
-    float a_index;
-  };
-  struct Quad {
-    Vertex v0, v1, v2, v3;
-  };
-  struct QuadIndex {
-    uint16 data[6];
-  };
-
-  static_assert(sizeof(Quad) == 24 * sizeof(float),
-                "struct Quad should be densely packed");
-  static_assert(sizeof(QuadIndex) == 6 * sizeof(uint16_t),
-                "struct QuadIndex should be densely packed");
-
-  Quad quad_list[8];
-  QuadIndex quad_index_list[8];
-  for (int i = 0; i < 8; i++) {
-    Vertex v0 = {{quad_vertex_rect.x(), quad_vertex_rect.bottom(), 0.0f, },
-                 {0.0f, 1.0f, }, i * 4.0f + 0.0f};
-    Vertex v1 = {{quad_vertex_rect.x(), quad_vertex_rect.y(), 0.0f, },
-                 {0.0f, 0.0f, }, i * 4.0f + 1.0f};
-    Vertex v2 = {{quad_vertex_rect.right(), quad_vertex_rect.y(), 0.0f, },
-                 {1.0f, .0f, }, i * 4.0f + 2.0f};
-    Vertex v3 = {{quad_vertex_rect.right(), quad_vertex_rect.bottom(), 0.0f, },
-                 {1.0f, 1.0f, }, i * 4.0f + 3.0f};
-    Quad x = {v0, v1, v2, v3};
-    quad_list[i] = x;
-    QuadIndex y = {
-        {static_cast<uint16>(0 + 4 * i), static_cast<uint16>(1 + 4 * i),
-         static_cast<uint16>(2 + 4 * i), static_cast<uint16>(3 + 4 * i),
-         static_cast<uint16>(0 + 4 * i), static_cast<uint16>(2 + 4 * i)}};
-    quad_index_list[i] = y;
-  }
-
-  gl_->GenBuffers(1, &quad_vertices_vbo_);
-  gl_->GenBuffers(1, &quad_elements_vbo_);
-  GLC(gl_, gl_->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo_));
-  GLC(gl_,
-      gl_->BufferData(
-          GL_ARRAY_BUFFER, sizeof(quad_list), quad_list, GL_STATIC_DRAW));
-  GLC(gl_, gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo_));
-  GLC(gl_,
-      gl_->BufferData(GL_ELEMENT_ARRAY_BUFFER,
-                      sizeof(quad_index_list),
-                      quad_index_list,
-                      GL_STATIC_DRAW));
-}
-
-GeometryBinding::~GeometryBinding() {
-  gl_->DeleteBuffers(1, &quad_vertices_vbo_);
-  gl_->DeleteBuffers(1, &quad_elements_vbo_);
-}
+void SetupGLContext(gpu::gles2::GLES2Interface* gl,
+                    GLuint quad_elements_vbo,
+                    GLuint quad_vertices_vbo) {
+  GLC(gl, gl->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo));
 
-void GeometryBinding::PrepareForDraw() {
-  GLC(gl_, gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo_));
-
-  GLC(gl_, gl_->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo_));
+  GLC(gl, gl->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo));
   // OpenGL defines the last parameter to VertexAttribPointer as type
   // "const GLvoid*" even though it is actually an offset into the buffer
   // object's data store and not a pointer to the client's address space.
@@ -83,15 +25,56 @@ void GeometryBinding::PrepareForDraw() {
       reinterpret_cast<const void*>(5 * sizeof(float)),
   };
 
-  GLC(gl_, gl_->VertexAttribPointer(PositionAttribLocation(), 3, GL_FLOAT,
-                                    false, 6 * sizeof(float), offsets[0]));
-  GLC(gl_, gl_->VertexAttribPointer(TexCoordAttribLocation(), 2, GL_FLOAT,
-                                    false, 6 * sizeof(float), offsets[1]));
-  GLC(gl_, gl_->VertexAttribPointer(TriangleIndexAttribLocation(), 1, GL_FLOAT,
-                                    false, 6 * sizeof(float), offsets[2]));
-  GLC(gl_, gl_->EnableVertexAttribArray(PositionAttribLocation()));
-  GLC(gl_, gl_->EnableVertexAttribArray(TexCoordAttribLocation()));
-  GLC(gl_, gl_->EnableVertexAttribArray(TriangleIndexAttribLocation()));
+  GLC(gl,
+      gl->VertexAttribPointer(GeometryBinding::PositionAttribLocation(), 3,
+                              GL_FLOAT, false, 6 * sizeof(float), offsets[0]));
+  GLC(gl,
+      gl->VertexAttribPointer(GeometryBinding::TexCoordAttribLocation(), 2,
+                              GL_FLOAT, false, 6 * sizeof(float), offsets[1]));
+  GLC(gl,
+      gl->VertexAttribPointer(GeometryBinding::TriangleIndexAttribLocation(), 1,
+                              GL_FLOAT, false, 6 * sizeof(float), offsets[2]));
+  GLC(gl,
+      gl->EnableVertexAttribArray(GeometryBinding::PositionAttribLocation()));
+  GLC(gl,
+      gl->EnableVertexAttribArray(GeometryBinding::TexCoordAttribLocation()));
+  GLC(gl, gl->EnableVertexAttribArray(
+              GeometryBinding::TriangleIndexAttribLocation()));
+}
+
+GeometryBindingQuad::GeometryBindingQuad() {
+  v0 = {{0, 0, 0}, {0, 0}, 0};
+  v1 = {{0, 0, 0}, {0, 0}, 0};
+  v2 = {{0, 0, 0}, {0, 0}, 0};
+  v3 = {{0, 0, 0}, {0, 0}, 0};
+}
+
+GeometryBindingQuad::GeometryBindingQuad(const GeometryBindingVertex& vert0,
+                                         const GeometryBindingVertex& vert1,
+                                         const GeometryBindingVertex& vert2,
+                                         const GeometryBindingVertex& vert3) {
+  v0 = vert0;
+  v1 = vert1;
+  v2 = vert2;
+  v3 = vert3;
+}
+
+GeometryBindingQuadIndex::GeometryBindingQuadIndex() {
+  memset(data, 0x0, sizeof(data));
+}
+
+GeometryBindingQuadIndex::GeometryBindingQuadIndex(uint16 index0,
+                                                   uint16 index1,
+                                                   uint16 index2,
+                                                   uint16 index3,
+                                                   uint16 index4,
+                                                   uint16 index5) {
+  data[0] = index0;
+  data[1] = index1;
+  data[2] = index2;
+  data[3] = index3;
+  data[4] = index4;
+  data[5] = index5;
 }
 
 }  // namespace cc
diff --git a/cc/output/geometry_binding.h b/cc/output/geometry_binding.h
index cfa21ef..ae68687 100644
--- a/cc/output/geometry_binding.h
+++ b/cc/output/geometry_binding.h
@@ -6,43 +6,65 @@
 #define CC_OUTPUT_GEOMETRY_BINDING_H_
 
 #include "base/basictypes.h"
+#include "cc/output/gl_renderer.h"  // For the GLC() macro.
+#include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/khronos/GLES2/gl2.h"
+#include "third_party/khronos/GLES2/gl2ext.h"
+#include "ui/gfx/geometry/rect_f.h"
 
 namespace gfx {
-class RectF;
-}
-namespace gpu {
-namespace gles2 {
-class GLES2Interface;
-}
+class QuadF;
+class Quad;
+class QuadIndex;
+class PointF;
 }
 
 namespace cc {
 
-class GeometryBinding {
- public:
-  GeometryBinding(gpu::gles2::GLES2Interface* gl,
-                  const gfx::RectF& quad_vertex_rect);
-  ~GeometryBinding();
+struct GeometryBindingVertex {
+  float a_position[3];
+  float a_texCoord[2];
+  // Index of the vertex, divide by 4 to have the matrix for this quad.
+  float a_index;
+};
+
+struct GeometryBindingQuad {
+  GeometryBindingQuad();
+  GeometryBindingQuad(const GeometryBindingVertex& vert0,
+                      const GeometryBindingVertex& vert1,
+                      const GeometryBindingVertex& vert2,
+                      const GeometryBindingVertex& vert3);
+  GeometryBindingVertex v0, v1, v2, v3;
+};
+
+struct GeometryBindingQuadIndex {
+  GeometryBindingQuadIndex();
+  GeometryBindingQuadIndex(uint16 index0,
+                           uint16 index1,
+                           uint16 index2,
+                           uint16 index3,
+                           uint16 index4,
+                           uint16 index5);
 
-  void PrepareForDraw();
+  uint16 data[6];
+};
+
+class DrawQuad;
+class DrawPolygon;
 
+struct GeometryBinding {
   // All layer shaders share the same attribute locations for the vertex
   // positions and texture coordinates. This allows switching shaders without
   // rebinding attribute arrays.
   static int PositionAttribLocation() { return 0; }
   static int TexCoordAttribLocation() { return 1; }
   static int TriangleIndexAttribLocation() { return 2; }
-
- private:
-  gpu::gles2::GLES2Interface* gl_;
-
-  GLuint quad_vertices_vbo_;
-  GLuint quad_elements_vbo_;
-
-  DISALLOW_COPY_AND_ASSIGN(GeometryBinding);
 };
 
+void SetupGLContext(gpu::gles2::GLES2Interface* gl,
+                    GLuint quad_elements_vbo,
+                    GLuint quad_vertices_vbo);
+
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GEOMETRY_BINDING_H_
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 2016447..613ea4b 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -11,6 +11,11 @@
 #include <vector>
 
 #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 "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/video_layer_impl.h"
@@ -18,10 +23,12 @@
 #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/dynamic_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/output/static_geometry_binding.h"
+#include "cc/quads/draw_polygon.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/stream_video_draw_quad.h"
@@ -324,7 +331,8 @@ GLRenderer::GLRenderer(RendererClient* client,
       highp_threshold_min_(highp_threshold_min),
       highp_threshold_cache_(0),
       use_sync_query_(false),
-      on_demand_tile_raster_resource_id_(0) {
+      on_demand_tile_raster_resource_id_(0),
+      bound_geometry_(NO_BINDING) {
   DCHECK(gl_);
   DCHECK(context_support_);
 
@@ -494,10 +502,12 @@ void GLRenderer::DoNoOp() {
   GLC(gl_, gl_->Flush());
 }
 
-void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
+void GLRenderer::DoDrawQuad(DrawingFrame* frame,
+                            const DrawQuad* quad,
+                            const gfx::QuadF* clip_region) {
   DCHECK(quad->rect.Contains(quad->visible_rect));
   if (quad->material != DrawQuad::TEXTURE_CONTENT) {
-    FlushTextureQuadCache();
+    FlushTextureQuadCache(SHARED_BINDING);
   }
 
   switch (quad->material) {
@@ -505,26 +515,31 @@ void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
       NOTREACHED();
       break;
     case DrawQuad::CHECKERBOARD:
-      DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
+      DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad),
+                           clip_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),
+                        clip_region);
       break;
     case DrawQuad::PICTURE_CONTENT:
       // PictureDrawQuad should only be used for resourceless software draws.
       NOTREACHED();
       break;
     case DrawQuad::RENDER_PASS:
-      DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
+      DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad),
+                         clip_region);
       break;
     case DrawQuad::SOLID_COLOR:
-      DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
+      DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad),
+                         clip_region);
       break;
     case DrawQuad::STREAM_VIDEO_CONTENT:
-      DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad));
+      DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad),
+                          clip_region);
       break;
     case DrawQuad::SURFACE_CONTENT:
       // Surface content should be fully resolved to other quad types before
@@ -532,19 +547,28 @@ void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
       NOTREACHED();
       break;
     case DrawQuad::TEXTURE_CONTENT:
-      EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
+      EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad),
+                         clip_region);
       break;
     case DrawQuad::TILED_CONTENT:
-      DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
+      DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::YUV_VIDEO_CONTENT:
-      DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
+      DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad),
+                       clip_region);
       break;
   }
 }
 
 void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
-                                      const CheckerboardDrawQuad* quad) {
+                                      const CheckerboardDrawQuad* quad,
+                                      const gfx::QuadF* clip_region) {
+  // TODO(enne) 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();
@@ -588,6 +612,9 @@ void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
                    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());
@@ -819,13 +846,56 @@ bool GLRenderer::ShouldApplyBackgroundFilters(DrawingFrame* frame,
   return true;
 }
 
+// This takes a gfx::Rect and a clip region quad in the same space,
+// and returns a quad with the same proportions in the space -0.5->0.5.
+bool GetScaledRegion(const gfx::Rect& rect,
+                     const gfx::QuadF* clip,
+                     gfx::QuadF* scaled_region) {
+  if (!clip)
+    return false;
+
+  gfx::PointF p1(((clip->p1().x() - rect.x()) / rect.width()) - 0.5f,
+                 ((clip->p1().y() - rect.y()) / rect.height()) - 0.5f);
+  gfx::PointF p2(((clip->p2().x() - rect.x()) / rect.width()) - 0.5f,
+                 ((clip->p2().y() - rect.y()) / rect.height()) - 0.5f);
+  gfx::PointF p3(((clip->p3().x() - rect.x()) / rect.width()) - 0.5f,
+                 ((clip->p3().y() - rect.y()) / rect.height()) - 0.5f);
+  gfx::PointF p4(((clip->p4().x() - rect.x()) / rect.width()) - 0.5f,
+                 ((clip->p4().y() - rect.y()) / rect.height()) - 0.5f);
+  *scaled_region = gfx::QuadF(p1, p2, p3, p4);
+  return true;
+}
+
+// This takes a gfx::Rect and a clip region quad in the same space,
+// and returns the proportional uv's in the space 0->1.
+bool GetScaledUVs(const gfx::Rect& rect, const gfx::QuadF* clip, float uvs[8]) {
+  if (!clip)
+    return false;
+
+  uvs[0] = ((clip->p1().x() - rect.x()) / rect.width());
+  uvs[1] = ((clip->p1().y() - rect.y()) / rect.height());
+  uvs[2] = ((clip->p2().x() - rect.x()) / rect.width());
+  uvs[3] = ((clip->p2().y() - rect.y()) / rect.height());
+  uvs[4] = ((clip->p3().x() - rect.x()) / rect.width());
+  uvs[5] = ((clip->p3().y() - rect.y()) / rect.height());
+  uvs[6] = ((clip->p4().x() - rect.x()) / rect.width());
+  uvs[7] = ((clip->p4().y() - rect.y()) / rect.height());
+  return true;
+}
+
 gfx::Rect GLRenderer::GetBackdropBoundingBoxForRenderPassQuad(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
+    const gfx::QuadF* clip_region,
     bool use_aa) {
+  gfx::QuadF scaled_region;
+  if (!GetScaledRegion(quad->rect, clip_region, &scaled_region)) {
+    scaled_region = SharedGeometryQuad().BoundingBox();
+  }
+
   gfx::Rect backdrop_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
-      contents_device_transform, SharedGeometryQuad().BoundingBox()));
+      contents_device_transform, scaled_region.BoundingBox()));
 
   if (ShouldApplyBackgroundFilters(frame, quad)) {
     int top, right, bottom, left;
@@ -874,7 +944,8 @@ skia::RefPtr<SkImage> GLRenderer::ApplyBackgroundFilters(
 }
 
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
-                                    const RenderPassDrawQuad* quad) {
+                                    const RenderPassDrawQuad* quad,
+                                    const gfx::QuadF* clip_region) {
   ScopedResource* contents_texture =
       render_pass_textures_.get(quad->render_pass_id);
   if (!contents_texture || !contents_texture->id())
@@ -896,10 +967,8 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                 ShouldAntialiasQuad(contents_device_transform, quad,
                                     settings_->force_antialiasing);
 
-  if (use_aa)
-    SetupQuadForAntialiasing(contents_device_transform, quad,
-                             &surface_quad, edge);
-
+  SetupQuadForClippingAndAntialiasing(contents_device_transform, quad, use_aa,
+                                      clip_region, &surface_quad, edge);
   SkXfermode::Mode blend_mode = quad->shared_quad_state->blend_mode;
   bool use_shaders_for_blending =
       !CanApplyBlendModeUsingBlendFunc(blend_mode) ||
@@ -913,7 +982,7 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
     // Compute a bounding box around the pixels that will be visible through
     // the quad.
     background_rect = GetBackdropBoundingBoxForRenderPassQuad(
-        frame, quad, contents_device_transform, use_aa);
+        frame, quad, contents_device_transform, clip_region, use_aa);
 
     if (!background_rect.IsEmpty()) {
       // The pixels from the filtered background should completely replace the
@@ -1238,15 +1307,78 @@ static void SolidColorUniformLocation(T program,
   uniforms->color_location = program->fragment_shader().color_location();
 }
 
+namespace {
+// These functions determine if a quad, clipped by a clip_region contains
+// the entire {top|bottom|left|right} edge.
+bool is_top(const gfx::QuadF* clip_region, const DrawQuad* quad) {
+  if (!quad->IsTopEdge())
+    return false;
+  if (!clip_region)
+    return true;
+
+  return std::abs(clip_region->p1().y()) < kAntiAliasingEpsilon &&
+         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()) <
+             kAntiAliasingEpsilon &&
+         std::abs(clip_region->p4().y() -
+                  quad->shared_quad_state->content_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()) <
+             kAntiAliasingEpsilon &&
+         std::abs(clip_region->p3().x() -
+                  quad->shared_quad_state->content_bounds.width()) <
+             kAntiAliasingEpsilon;
+}
+}  // anonymous namespace
+
 static gfx::QuadF GetDeviceQuadWithAntialiasingOnExteriorEdges(
     const LayerQuad& device_layer_edges,
     const gfx::Transform& device_transform,
+    const gfx::QuadF* clip_region,
     const DrawQuad* quad) {
-  gfx::Rect tile_rect = quad->visible_rect;
-  gfx::PointF bottom_right = tile_rect.bottom_right();
-  gfx::PointF bottom_left = tile_rect.bottom_left();
-  gfx::PointF top_left = tile_rect.origin();
-  gfx::PointF top_right = tile_rect.top_right();
+  gfx::RectF tile_rect = quad->visible_rect;
+  gfx::QuadF tile_quad(tile_rect);
+
+  if (clip_region) {
+    if (quad->material != DrawQuad::RENDER_PASS) {
+      tile_quad = *clip_region;
+    } else {
+      GetScaledRegion(quad->rect, clip_region, &tile_quad);
+    }
+  }
+
+  gfx::PointF bottom_right = tile_quad.p3();
+  gfx::PointF bottom_left = tile_quad.p4();
+  gfx::PointF top_left = tile_quad.p1();
+  gfx::PointF top_right = tile_quad.p2();
   bool clipped = false;
 
   // Map points to device space. We ignore |clipped|, since the result of
@@ -1263,16 +1395,26 @@ static gfx::QuadF GetDeviceQuadWithAntialiasingOnExteriorEdges(
   LayerQuad::Edge right_edge(top_right, bottom_right);
 
   // Only apply anti-aliasing to edges not clipped by culling or scissoring.
-  if (quad->IsTopEdge() && tile_rect.y() == quad->rect.y())
+  // If an edge is degenerate we do not want to replace it with a "proper" edge
+  // as that will cause the quad to possibly expand is strange ways.
+  if (!top_edge.degenerate() && is_top(clip_region, quad) &&
+      tile_rect.y() == quad->rect.y()) {
     top_edge = device_layer_edges.top();
-  if (quad->IsLeftEdge() && tile_rect.x() == quad->rect.x())
+  }
+  if (!left_edge.degenerate() && is_left(clip_region, quad) &&
+      tile_rect.x() == quad->rect.x()) {
     left_edge = device_layer_edges.left();
-  if (quad->IsRightEdge() && tile_rect.right() == quad->rect.right())
+  }
+  if (!right_edge.degenerate() && is_right(clip_region, quad) &&
+      tile_rect.right() == quad->rect.right()) {
     right_edge = device_layer_edges.right();
-  if (quad->IsBottomEdge() && tile_rect.bottom() == quad->rect.bottom())
+  }
+  if (!bottom_edge.degenerate() && is_bottom(clip_region, quad) &&
+      tile_rect.bottom() == quad->rect.bottom()) {
     bottom_edge = device_layer_edges.bottom();
+  }
 
-  float sign = gfx::QuadF(tile_rect).IsCounterClockwise() ? -1 : 1;
+  float sign = tile_quad.IsCounterClockwise() ? -1 : 1;
   bottom_edge.scale(sign);
   left_edge.scale(sign);
   top_edge.scale(sign);
@@ -1282,6 +1424,32 @@ static gfx::QuadF GetDeviceQuadWithAntialiasingOnExteriorEdges(
   return LayerQuad(left_edge, top_edge, right_edge, bottom_edge).ToQuadF();
 }
 
+float GetTotalQuadError(const gfx::QuadF* clipped_quad,
+                        const gfx::QuadF* ideal_rect) {
+  return (clipped_quad->p1() - ideal_rect->p1()).LengthSquared() +
+         (clipped_quad->p2() - ideal_rect->p2()).LengthSquared() +
+         (clipped_quad->p3() - ideal_rect->p3()).LengthSquared() +
+         (clipped_quad->p4() - ideal_rect->p4()).LengthSquared();
+}
+
+// Attempt to rotate the clipped quad until it lines up the most
+// correctly. This is necessary because we check the edges of this
+// quad against the expected left/right/top/bottom for anti-aliasing.
+void AlignQuadToBoundingBox(gfx::QuadF* clipped_quad) {
+  gfx::QuadF bounding_quad = gfx::QuadF(clipped_quad->BoundingBox());
+  gfx::QuadF best_rotation = *clipped_quad;
+  float least_error_amount = GetTotalQuadError(clipped_quad, &bounding_quad);
+  for (size_t i = 1; i < 4; ++i) {
+    clipped_quad->Realign(1);
+    float new_error = GetTotalQuadError(clipped_quad, &bounding_quad);
+    if (new_error < least_error_amount) {
+      least_error_amount = new_error;
+      best_rotation = *clipped_quad;
+    }
+  }
+  *clipped_quad = best_rotation;
+}
+
 // static
 bool GLRenderer::ShouldAntialiasQuad(const gfx::Transform& device_transform,
                                      const DrawQuad* quad,
@@ -1313,18 +1481,39 @@ bool GLRenderer::ShouldAntialiasQuad(const gfx::Transform& device_transform,
 }
 
 // static
-void GLRenderer::SetupQuadForAntialiasing(
+void GLRenderer::SetupQuadForClippingAndAntialiasing(
     const gfx::Transform& device_transform,
     const DrawQuad* quad,
+    bool use_aa,
+    const gfx::QuadF* clip_region,
     gfx::QuadF* local_quad,
     float edge[24]) {
   bool is_render_pass_quad = (quad->material == DrawQuad::RENDER_PASS);
-  gfx::RectF content_rect =
-      is_render_pass_quad ? QuadVertexRect() : quad->visibleContentRect();
-
+  gfx::QuadF rotated_clip;
+  const gfx::QuadF* local_clip_region = clip_region;
+  if (local_clip_region) {
+    rotated_clip = *clip_region;
+    AlignQuadToBoundingBox(&rotated_clip);
+    local_clip_region = &rotated_clip;
+  }
+
+  gfx::QuadF content_rect = is_render_pass_quad
+                                ? gfx::QuadF(QuadVertexRect())
+                                : gfx::QuadF(quad->visibleContentRect());
+  if (!use_aa) {
+    if (local_clip_region) {
+      if (!is_render_pass_quad) {
+        content_rect = *local_clip_region;
+      } else {
+        GetScaledRegion(quad->rect, local_clip_region, &content_rect);
+      }
+      *local_quad = content_rect;
+    }
+    return;
+  }
   bool clipped = false;
   gfx::QuadF device_layer_quad =
-      MathUtil::MapQuad(device_transform, gfx::QuadF(content_rect), &clipped);
+      MathUtil::MapQuad(device_transform, content_rect, &clipped);
 
   LayerQuad device_layer_bounds(gfx::QuadF(device_layer_quad.BoundingBox()));
   device_layer_bounds.InflateAntiAliasingDistance();
@@ -1335,16 +1524,25 @@ void GLRenderer::SetupQuadForAntialiasing(
   device_layer_edges.ToFloatArray(edge);
   device_layer_bounds.ToFloatArray(&edge[12]);
 
+  // If we have a clip region then we are split, and therefore
+  // by necessity, at least one of our edges is not an external
+  // one.
+  bool is_full_rect = quad->visible_rect == quad->rect;
+
+  bool region_contains_all_outside_edges =
+      is_full_rect &&
+      (is_top(local_clip_region, quad) && is_left(local_clip_region, quad) &&
+       is_bottom(local_clip_region, quad) && is_right(local_clip_region, quad));
+
   bool use_aa_on_all_four_edges =
-      is_render_pass_quad ||
-      (quad->IsTopEdge() && quad->IsLeftEdge() && quad->IsBottomEdge() &&
-       quad->IsRightEdge() && quad->visible_rect == quad->rect);
+      !local_clip_region &&
+      (is_render_pass_quad || region_contains_all_outside_edges);
 
   gfx::QuadF device_quad =
       use_aa_on_all_four_edges
           ? device_layer_edges.ToQuadF()
           : GetDeviceQuadWithAntialiasingOnExteriorEdges(
-                device_layer_edges, device_transform, quad);
+                device_layer_edges, device_transform, local_clip_region, quad);
 
   // Map device space quad to local space. device_transform has no 3d
   // component since it was flattened, so we don't need to project.  We should
@@ -1360,7 +1558,8 @@ void GLRenderer::SetupQuadForAntialiasing(
 }
 
 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;
@@ -1384,10 +1583,11 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
   bool use_aa = settings_->allow_antialiasing &&
                 !quad->force_anti_aliasing_off &&
                 ShouldAntialiasQuad(device_transform, quad, force_aa);
+  SetupQuadForClippingAndAntialiasing(device_transform, quad, use_aa,
+                                      clip_region, &local_quad, edge);
 
   SolidColorProgramUniforms uniforms;
   if (use_aa) {
-    SetupQuadForAntialiasing(device_transform, quad, &local_quad, edge);
     SolidColorUniformLocation(GetSolidColorProgramAA(), &uniforms);
   } else {
     SolidColorUniformLocation(GetSolidColorProgram(), &uniforms);
@@ -1458,13 +1658,15 @@ static void TileUniformLocation(T program, TileProgramUniforms* uniforms) {
 }
 
 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::Transform device_transform =
       frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
@@ -1476,15 +1678,16 @@ void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
   // 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);
+    DrawContentQuadAA(frame, quad, resource_id, device_transform, clip_region);
   else
-    DrawContentQuadNoAA(frame, quad, resource_id);
+    DrawContentQuadNoAA(frame, quad, resource_id, clip_region);
 }
 
 void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
                                    const ContentDrawQuadBase* quad,
                                    ResourceProvider::ResourceId resource_id,
-                                   const gfx::Transform& device_transform) {
+                                   const gfx::Transform& device_transform,
+                                   const gfx::QuadF* clip_region) {
   if (!device_transform.IsInvertible())
     return;
 
@@ -1529,8 +1732,8 @@ void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
-  SetupQuadForAntialiasing(device_transform, quad, &local_quad, edge);
-
+  SetupQuadForClippingAndAntialiasing(device_transform, quad, true, clip_region,
+                                      &local_quad, edge);
   ResourceProvider::ScopedSamplerGL quad_resource_lock(
       resource_provider_, resource_id,
       quad->nearest_neighbor ? GL_NEAREST : GL_LINEAR);
@@ -1608,7 +1811,8 @@ void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
 
 void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
                                      const ContentDrawQuadBase* quad,
-                                     ResourceProvider::ResourceId resource_id) {
+                                     ResourceProvider::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();
@@ -1682,17 +1886,37 @@ void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
   // does, then vertices will match the texture mapping in the vertex buffer.
   // The method SetShaderQuadF() changes the order of vertices and so it's
   // not used here.
-
-  gfx::RectF tile_rect = quad->visible_rect;
+  gfx::QuadF tile_rect(quad->visible_rect);
+  float width = quad->visible_rect.width();
+  float height = quad->visible_rect.height();
+  gfx::PointF top_left = quad->visible_rect.origin();
+  if (clip_region) {
+    tile_rect = *clip_region;
+    float gl_uv[8] = {
+        (tile_rect.p4().x() - top_left.x()) / width,
+        (tile_rect.p4().y() - top_left.y()) / height,
+        (tile_rect.p1().x() - top_left.x()) / width,
+        (tile_rect.p1().y() - top_left.y()) / height,
+        (tile_rect.p2().x() - top_left.x()) / width,
+        (tile_rect.p2().y() - top_left.y()) / height,
+        (tile_rect.p3().x() - top_left.x()) / width,
+        (tile_rect.p3().y() - top_left.y()) / height,
+    };
+    PrepareGeometry(CLIPPED_BINDING);
+    clipped_geometry_->InitializeCustomQuadWithUVs(
+        gfx::QuadF(quad->visible_rect), gl_uv);
+  } else {
+    PrepareGeometry(SHARED_BINDING);
+  }
   float gl_quad[8] = {
-    tile_rect.x(),
-    tile_rect.bottom(),
-    tile_rect.x(),
-    tile_rect.y(),
-    tile_rect.right(),
-    tile_rect.y(),
-    tile_rect.right(),
-    tile_rect.bottom(),
+      tile_rect.p4().x(),
+      tile_rect.p4().y(),
+      tile_rect.p1().x(),
+      tile_rect.p1().y(),
+      tile_rect.p2().x(),
+      tile_rect.p2().y(),
+      tile_rect.p3().x(),
+      tile_rect.p3().y(),
   };
   GLC(gl_, gl_->Uniform2fv(uniforms.quad_location, 4, gl_quad));
 
@@ -1705,7 +1929,8 @@ void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
 }
 
 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(
@@ -1845,15 +2070,31 @@ void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
       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 {
+    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->quadTransform(), tile_rect,
+                                   region_quad, matrix_location, uvs);
+  }
 }
 
 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];
@@ -1884,10 +2125,19 @@ void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
 
   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 {
+    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->quadTransform(), quad->rect, region_quad,
+        program->vertex_shader().matrix_location(), uvs);
+  }
 }
 
 struct TextureProgramBinding {
@@ -1903,6 +2153,7 @@ struct TextureProgramBinding {
   int program_id;
   int sampler_location;
   int matrix_location;
+  int transform_location;
   int background_color_location;
 };
 
@@ -1918,11 +2169,13 @@ struct TexTransformTextureProgramBinding : TextureProgramBinding {
   int vertex_opacity_location;
 };
 
-void GLRenderer::FlushTextureQuadCache() {
+void GLRenderer::FlushTextureQuadCache(BoundGeometry flush_binding) {
   // Check to see if we have anything to draw.
   if (draw_cache_.program_id == -1)
     return;
 
+  PrepareGeometry(flush_binding);
+
   // Set the correct blending mode.
   SetBlendEnabled(draw_cache_.needs_blending);
 
@@ -1983,10 +2236,26 @@ void GLRenderer::FlushTextureQuadCache() {
   draw_cache_.uv_xform_data.resize(0);
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
+
+  // If we had a clipped binding, prepare the shared binding for the
+  // next inserts.
+  if (flush_binding == CLIPPED_BINDING) {
+    PrepareGeometry(SHARED_BINDING);
+  }
 }
 
 void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
-                                    const TextureDrawQuad* quad) {
+                                    const TextureDrawQuad* quad,
+                                    const gfx::QuadF* clip_region) {
+  // 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_,
@@ -2018,7 +2287,7 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
       draw_cache_.nearest_neighbor != quad->nearest_neighbor ||
       draw_cache_.background_color != quad->background_color ||
       draw_cache_.matrix_data.size() >= 8) {
-    FlushTextureQuadCache();
+    FlushTextureQuadCache(SHARED_BINDING);
     draw_cache_.program_id = binding.program_id;
     draw_cache_.resource_id = resource_id;
     draw_cache_.needs_blending = quad->ShouldDrawWithBlending();
@@ -2033,7 +2302,12 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
   }
 
   // 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();
@@ -2050,10 +2324,32 @@ void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
   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)) {
+      scaled_region = SharedGeometryQuad().BoundingBox();
+    }
+    // Both the scaled region and the SharedGeomtryQuad are in the space
+    // -0.5->0.5. We need to move that to the space 0->1.
+    float uv[8];
+    uv[0] = scaled_region.p1().x() + 0.5f;
+    uv[1] = scaled_region.p1().y() + 0.5f;
+    uv[2] = scaled_region.p2().x() + 0.5f;
+    uv[3] = scaled_region.p2().y() + 0.5f;
+    uv[4] = scaled_region.p3().x() + 0.5f;
+    uv[5] = scaled_region.p3().y() + 0.5f;
+    uv[6] = scaled_region.p4().x() + 0.5f;
+    uv[7] = scaled_region.p4().y() + 0.5f;
+    PrepareGeometry(CLIPPED_BINDING);
+    clipped_geometry_->InitializeCustomQuadWithUVs(scaled_region, uv);
+    FlushTextureQuadCache(CLIPPED_BINDING);
+  }
 }
 
 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(
@@ -2092,8 +2388,15 @@ void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
   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 {
+    float uvs[8] = {0};
+    GetScaledUVs(quad->visible_rect, clip_region, uvs);
+    DrawQuadGeometryClippedByQuadF(frame, quad->quadTransform(), quad->rect,
+                                   *clip_region, binding.matrix_location, uvs);
+  }
 
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0));
 }
@@ -2114,7 +2417,9 @@ void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   ScheduleOverlays(frame);
 }
 
-void GLRenderer::FinishDrawingQuadList() { FlushTextureQuadCache(); }
+void GLRenderer::FinishDrawingQuadList() {
+  FlushTextureQuadCache(SHARED_BINDING);
+}
 
 bool GLRenderer::FlippedFramebuffer(const DrawingFrame* frame) const {
   if (frame->current_render_pass != frame->root_render_pass)
@@ -2131,7 +2436,7 @@ void GLRenderer::EnsureScissorTestEnabled() {
   if (is_scissor_enabled_)
     return;
 
-  FlushTextureQuadCache();
+  FlushTextureQuadCache(SHARED_BINDING);
   GLC(gl_, gl_->Enable(GL_SCISSOR_TEST));
   is_scissor_enabled_ = true;
 }
@@ -2140,7 +2445,7 @@ void GLRenderer::EnsureScissorTestDisabled() {
   if (!is_scissor_enabled_)
     return;
 
-  FlushTextureQuadCache();
+  FlushTextureQuadCache(SHARED_BINDING);
   GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
   is_scissor_enabled_ = false;
 }
@@ -2209,10 +2514,34 @@ void GLRenderer::SetUseProgram(unsigned 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,
+    const float* uvs) {
+  PrepareGeometry(CLIPPED_BINDING);
+  if (uvs) {
+    clipped_geometry_->InitializeCustomQuadWithUVs(clipping_region_quad, uvs);
+  } else {
+    clipped_geometry_->InitializeCustomQuad(clipping_region_quad);
+  }
+  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,
+                             reinterpret_cast<const void*>(0)));
+}
+
 void GLRenderer::DrawQuadGeometry(const DrawingFrame* frame,
                                   const gfx::Transform& draw_transform,
                                   const gfx::RectF& quad_rect,
                                   int matrix_location) {
+  PrepareGeometry(SHARED_BINDING);
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
   static float gl_matrix[16];
@@ -2275,6 +2604,7 @@ void GLRenderer::EnforceMemoryPolicy() {
     output_surface_->context_provider()->DeleteCachedResources();
     GLC(gl_, gl_->Flush());
   }
+  PrepareGeometry(NO_BINDING);
 }
 
 void GLRenderer::DiscardBackbuffer() {
@@ -2606,7 +2936,7 @@ void GLRenderer::SetScissorTestRect(const gfx::Rect& scissor_rect) {
     return;
 
   scissor_rect_ = scissor_rect;
-  FlushTextureQuadCache();
+  FlushTextureQuadCache(SHARED_BINDING);
   GLC(gl_,
       gl_->Scissor(scissor_rect.x(),
                    scissor_rect.y(),
@@ -2631,8 +2961,27 @@ void 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 StaticGeometryBinding(gl_, QuadVertexRect()));
+  clipped_geometry_ = make_scoped_ptr(new DynamicGeometryBinding(gl_));
+}
+
+void GLRenderer::PrepareGeometry(BoundGeometry binding) {
+  if (binding == bound_geometry_) {
+    return;
+  }
+
+  switch (binding) {
+    case SHARED_BINDING:
+      shared_geometry_->PrepareForDraw();
+      break;
+    case CLIPPED_BINDING:
+      clipped_geometry_->PrepareForDraw();
+      break;
+    case NO_BINDING:
+      break;
+  }
+  bound_geometry_ = binding;
 }
 
 const GLRenderer::TileCheckerboardProgram*
@@ -3112,8 +3461,8 @@ void GLRenderer::ReinitializeGLState() {
 
 void GLRenderer::RestoreGLState() {
   // This restores the current GLRenderer state to the GL context.
-
-  shared_geometry_->PrepareForDraw();
+  bound_geometry_ = NO_BINDING;
+  PrepareGeometry(SHARED_BINDING);
 
   GLC(gl_, gl_->Disable(GL_DEPTH_TEST));
   GLC(gl_, gl_->Disable(GL_CULL_FACE));
diff --git a/cc/output/gl_renderer.h b/cc/output/gl_renderer.h
index 01668ab..27f2c42 100644
--- a/cc/output/gl_renderer.h
+++ b/cc/output/gl_renderer.h
@@ -39,7 +39,8 @@ class ScopedResource;
 class StreamVideoDrawQuad;
 class TextureDrawQuad;
 class TextureMailboxDeleter;
-class GeometryBinding;
+class StaticGeometryBinding;
+class DynamicGeometryBinding;
 class ScopedEnsureFramebufferAllocation;
 
 // Class that handles drawing of composited render layers using GL.
@@ -85,7 +86,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
   bool IsBackbufferDiscarded() const { return is_backbuffer_discarded_; }
 
   const gfx::QuadF& SharedGeometryQuad() const { return shared_geometry_quad_; }
-  const GeometryBinding* SharedGeometry() const {
+  const StaticGeometryBinding* SharedGeometry() const {
     return shared_geometry_.get();
   }
 
@@ -96,7 +97,8 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
                              ResourceFormat texture_format,
                              const gfx::Rect& device_rect);
   void ReleaseRenderPassTextures();
-
+  enum BoundGeometry { NO_BINDING, SHARED_BINDING, CLIPPED_BINDING };
+  void PrepareGeometry(BoundGeometry geometry_to_bind);
   void SetStencilEnabled(bool enabled);
   bool stencil_enabled() const { return stencil_shadow_; }
   void SetBlendEnabled(bool enabled);
@@ -112,7 +114,9 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
                      bool draw_rect_covers_full_surface) override;
   void ClearFramebuffer(DrawingFrame* frame,
                         bool has_external_stencil_test) override;
-  void DoDrawQuad(DrawingFrame* frame, const class DrawQuad*) override;
+  void DoDrawQuad(DrawingFrame* frame,
+                  const class DrawQuad*,
+                  const gfx::QuadF* draw_region) override;
   void BeginDrawingFrame(DrawingFrame* frame) override;
   void FinishDrawingFrame(DrawingFrame* frame) override;
   bool FlippedFramebuffer(const DrawingFrame* frame) const override;
@@ -132,10 +136,13 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
   // Inflate the quad and fill edge array for fragment shader.
   // |local_quad| is set to inflated quad. |edge| array is filled with
   // inflated quad's edge data.
-  static void SetupQuadForAntialiasing(const gfx::Transform& device_transform,
-                                       const DrawQuad* quad,
-                                       gfx::QuadF* local_quad,
-                                       float edge[24]);
+  static void SetupQuadForClippingAndAntialiasing(
+      const gfx::Transform& device_transform,
+      const DrawQuad* quad,
+      bool use_aa,
+      const gfx::QuadF* clip_region,
+      gfx::QuadF* local_quad,
+      float edge[24]);
 
  private:
   friend class GLRendererShaderPixelTest;
@@ -144,7 +151,8 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
   static void ToGLMatrix(float* gl_matrix, const gfx::Transform& transform);
 
   void DrawCheckerboardQuad(const DrawingFrame* frame,
-                            const CheckerboardDrawQuad* quad);
+                            const CheckerboardDrawQuad* quad,
+                            const gfx::QuadF* clip_region);
   void DrawDebugBorderQuad(const DrawingFrame* frame,
                            const DebugBorderDrawQuad* quad);
   static bool IsDefaultBlendMode(SkXfermode::Mode blend_mode) {
@@ -158,6 +166,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
       DrawingFrame* frame,
       const RenderPassDrawQuad* quad,
       const gfx::Transform& contents_device_transform,
+      const gfx::QuadF* clip_region,
       bool use_aa);
   scoped_ptr<ScopedResource> GetBackdropTexture(const gfx::Rect& bounding_rect);
 
@@ -168,34 +177,56 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
       const RenderPassDrawQuad* quad,
       ScopedResource* background_texture);
 
-  void DrawRenderPassQuad(DrawingFrame* frame, const RenderPassDrawQuad* quad);
+  void DrawRenderPassQuad(DrawingFrame* frame,
+                          const RenderPassDrawQuad* quadi,
+                          const gfx::QuadF* clip_region);
   void DrawSolidColorQuad(const DrawingFrame* frame,
-                          const SolidColorDrawQuad* quad);
+                          const SolidColorDrawQuad* quad,
+                          const gfx::QuadF* clip_region);
   void DrawStreamVideoQuad(const DrawingFrame* frame,
-                           const StreamVideoDrawQuad* quad);
+                           const StreamVideoDrawQuad* quad,
+                           const gfx::QuadF* clip_region);
+  void DrawTextureQuad(const DrawingFrame* frame,
+                       const TextureDrawQuad* quad,
+                       const gfx::QuadF* clip_region);
   void EnqueueTextureQuad(const DrawingFrame* frame,
-                          const TextureDrawQuad* quad);
-  void FlushTextureQuadCache();
+                          const TextureDrawQuad* quad,
+                          const gfx::QuadF* clip_region);
+  void FlushTextureQuadCache(BoundGeometry flush_binding);
   void DrawIOSurfaceQuad(const DrawingFrame* frame,
-                         const IOSurfaceDrawQuad* quad);
-  void DrawTileQuad(const DrawingFrame* frame, const TileDrawQuad* quad);
+                         const IOSurfaceDrawQuad* quad,
+                         const gfx::QuadF* clip_region);
+  void DrawTileQuad(const DrawingFrame* frame,
+                    const TileDrawQuad* quad,
+                    const gfx::QuadF* clip_region);
   void DrawContentQuad(const DrawingFrame* frame,
                        const ContentDrawQuadBase* quad,
-                       ResourceProvider::ResourceId resource_id);
+                       ResourceProvider::ResourceId resource_id,
+                       const gfx::QuadF* clip_region);
   void DrawContentQuadAA(const DrawingFrame* frame,
                          const ContentDrawQuadBase* quad,
                          ResourceProvider::ResourceId resource_id,
-                         const gfx::Transform& device_transform);
+                         const gfx::Transform& device_transform,
+                         const gfx::QuadF* clip_region);
   void DrawContentQuadNoAA(const DrawingFrame* frame,
                            const ContentDrawQuadBase* quad,
-                           ResourceProvider::ResourceId resource_id);
+                           ResourceProvider::ResourceId resource_id,
+                           const gfx::QuadF* clip_region);
   void DrawYUVVideoQuad(const DrawingFrame* frame,
-                        const YUVVideoDrawQuad* quad);
+                        const YUVVideoDrawQuad* quad,
+                        const gfx::QuadF* clip_region);
   void DrawPictureQuad(const DrawingFrame* frame,
-                       const PictureDrawQuad* quad);
+                       const PictureDrawQuad* quad,
+                       const gfx::QuadF* clip_region);
 
   void SetShaderOpacity(float opacity, int alpha_location);
   void SetShaderQuadF(const gfx::QuadF& quad, int quad_location);
+  void DrawQuadGeometryClippedByQuadF(const DrawingFrame* frame,
+                                      const gfx::Transform& draw_transform,
+                                      const gfx::RectF& quad_rect,
+                                      const gfx::QuadF& clipping_region_quad,
+                                      int matrix_location,
+                                      const float uv[8]);
   void DrawQuadGeometry(const DrawingFrame* frame,
                         const gfx::Transform& draw_transform,
                         const gfx::RectF& quad_rect,
@@ -237,7 +268,8 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
 
   unsigned offscreen_framebuffer_id_;
 
-  scoped_ptr<GeometryBinding> shared_geometry_;
+  scoped_ptr<StaticGeometryBinding> shared_geometry_;
+  scoped_ptr<DynamicGeometryBinding> clipped_geometry_;
   gfx::QuadF shared_geometry_quad_;
 
   // This block of bindings defines all of the programs used by the compositor
@@ -480,7 +512,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
 
   SkBitmap on_demand_tile_raster_bitmap_;
   ResourceProvider::ResourceId on_demand_tile_raster_resource_id_;
-
+  BoundGeometry bound_geometry_;
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 5590ec3..9090621 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -775,7 +775,10 @@ class OverlayInfoRendererGL : public GLRenderer {
                    0),
         expect_overlays_(false) {}
 
-  MOCK_METHOD2(DoDrawQuad, void(DrawingFrame* frame, const DrawQuad* quad));
+  MOCK_METHOD3(DoDrawQuad,
+               void(DrawingFrame* frame,
+                    const DrawQuad* quad,
+                    const gfx::QuadF* draw_region));
 
   using GLRenderer::BeginDrawingFrame;
 
@@ -875,7 +878,7 @@ TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) {
 
   // Candidate pass was taken out and extra skipped pass added,
   // so only draw 2 quads.
-  EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(2);
+  EXPECT_CALL(*renderer_, DoDrawQuad(_, _, _)).Times(2);
   EXPECT_CALL(scheduler_,
               Schedule(1,
                        gfx::OVERLAY_TRANSFORM_NONE,
@@ -913,7 +916,7 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadDrawn) {
   pass_list.push_back(pass.Pass());
 
   // 3 quads in the pass, all should draw.
-  EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3);
+  EXPECT_CALL(*renderer_, DoDrawQuad(_, _, _)).Times(3);
   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0);
   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 
@@ -946,7 +949,7 @@ TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) {
   pass_list.push_back(pass.Pass());
 
   // Should see no overlays.
-  EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3);
+  EXPECT_CALL(*renderer_, DoDrawQuad(_, _, _)).Times(3);
   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0);
   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index b30b0a5..295fc84 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -111,6 +111,52 @@ void CreateTestRenderPassDrawQuad(const SharedQuadState* shared_state,
                FilterOperations());  // background filters
 }
 
+void CreateTestTwoColoredTextureDrawQuad(const gfx::Rect& rect,
+                                         SkColor texel_color,
+                                         SkColor texel_stripe_color,
+                                         SkColor background_color,
+                                         bool premultiplied_alpha,
+                                         const SharedQuadState* shared_state,
+                                         ResourceProvider* resource_provider,
+                                         RenderPass* render_pass) {
+  SkPMColor pixel_color = premultiplied_alpha
+                              ? SkPreMultiplyColor(texel_color)
+                              : SkPackARGB32NoCheck(SkColorGetA(texel_color),
+                                                    SkColorGetR(texel_color),
+                                                    SkColorGetG(texel_color),
+                                                    SkColorGetB(texel_color));
+  SkPMColor pixel_stripe_color =
+      premultiplied_alpha
+          ? SkPreMultiplyColor(texel_stripe_color)
+          : SkPackARGB32NoCheck(SkColorGetA(texel_stripe_color),
+                                SkColorGetR(texel_stripe_color),
+                                SkColorGetG(texel_stripe_color),
+                                SkColorGetB(texel_stripe_color));
+  std::vector<uint32_t> pixels(rect.size().GetArea(), pixel_color);
+  for (int i = rect.height() / 4; i < (rect.height() * 3 / 4); ++i) {
+    for (int k = rect.width() / 4; k < (rect.width() * 3 / 4); ++k) {
+      pixels[i * rect.width() + k] = pixel_stripe_color;
+    }
+  }
+  ResourceProvider::ResourceId resource = resource_provider->CreateResource(
+      rect.size(), GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      RGBA_8888);
+  resource_provider->SetPixels(resource,
+                               reinterpret_cast<uint8_t*>(&pixels.front()),
+                               rect, rect, gfx::Vector2d());
+
+  float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
+  const gfx::PointF uv_top_left(0.0f, 0.0f);
+  const gfx::PointF uv_bottom_right(1.0f, 1.0f);
+  const bool flipped = false;
+  const bool nearest_neighbor = false;
+  TextureDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
+  quad->SetNew(shared_state, rect, gfx::Rect(), rect, resource,
+               premultiplied_alpha, uv_top_left, uv_bottom_right,
+               background_color, vertex_opacity, flipped, nearest_neighbor);
+}
+
 void CreateTestTextureDrawQuad(const gfx::Rect& rect,
                                SkColor texel_color,
                                SkColor background_color,
@@ -135,20 +181,216 @@ void CreateTestTextureDrawQuad(const gfx::Rect& rect,
 
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
 
+  const gfx::PointF uv_top_left(0.0f, 0.0f);
+  const gfx::PointF uv_bottom_right(1.0f, 1.0f);
+  const bool flipped = false;
+  const bool nearest_neighbor = false;
   TextureDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
-  quad->SetNew(shared_state,
-               rect,
-               gfx::Rect(),
-               rect,
-               resource,
-               premultiplied_alpha,
-               gfx::PointF(0.0f, 0.0f),  // uv_top_left
-               gfx::PointF(1.0f, 1.0f),  // uv_bottom_right
-               background_color,
-               vertex_opacity,
-               false,   // flipped
-               false);  // nearest_neighbor
+  quad->SetNew(shared_state, rect, gfx::Rect(), rect, resource,
+               premultiplied_alpha, uv_top_left, uv_bottom_right,
+               background_color, vertex_opacity, flipped, nearest_neighbor);
+}
+
+void CreateTestYUVVideoDrawQuad_FromVideoFrame(
+    const SharedQuadState* shared_state,
+    scoped_refptr<media::VideoFrame> video_frame,
+    uint8 alpha_value,
+    const gfx::RectF& tex_coord_rect,
+    RenderPass* render_pass,
+    VideoResourceUpdater* video_resource_updater,
+    const gfx::Rect& rect,
+    ResourceProvider* resource_provider) {
+  const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A);
+  const YUVVideoDrawQuad::ColorSpace color_space =
+      (video_frame->format() == media::VideoFrame::YV12J
+           ? YUVVideoDrawQuad::JPEG
+           : YUVVideoDrawQuad::REC_601);
+  const gfx::Rect opaque_rect(0, 0, 0, 0);
+
+  if (with_alpha) {
+    memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value,
+           video_frame->stride(media::VideoFrame::kAPlane) *
+               video_frame->rows(media::VideoFrame::kAPlane));
+  }
+
+  VideoFrameExternalResources resources =
+      video_resource_updater->CreateExternalResourcesFromVideoFrame(
+          video_frame);
+
+  EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
+  EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
+            resources.mailboxes.size());
+  EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
+            resources.release_callbacks.size());
+
+  ResourceProvider::ResourceId y_resource =
+      resource_provider->CreateResourceFromTextureMailbox(
+          resources.mailboxes[media::VideoFrame::kYPlane],
+          SingleReleaseCallbackImpl::Create(
+              resources.release_callbacks[media::VideoFrame::kYPlane]));
+  ResourceProvider::ResourceId u_resource =
+      resource_provider->CreateResourceFromTextureMailbox(
+          resources.mailboxes[media::VideoFrame::kUPlane],
+          SingleReleaseCallbackImpl::Create(
+              resources.release_callbacks[media::VideoFrame::kUPlane]));
+  ResourceProvider::ResourceId v_resource =
+      resource_provider->CreateResourceFromTextureMailbox(
+          resources.mailboxes[media::VideoFrame::kVPlane],
+          SingleReleaseCallbackImpl::Create(
+              resources.release_callbacks[media::VideoFrame::kVPlane]));
+  ResourceProvider::ResourceId a_resource = 0;
+  if (with_alpha) {
+    a_resource = resource_provider->CreateResourceFromTextureMailbox(
+        resources.mailboxes[media::VideoFrame::kAPlane],
+        SingleReleaseCallbackImpl::Create(
+            resources.release_callbacks[media::VideoFrame::kAPlane]));
+  }
+
+  YUVVideoDrawQuad* yuv_quad =
+      render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
+  yuv_quad->SetNew(shared_state, rect, opaque_rect, rect, tex_coord_rect,
+                   video_frame->coded_size(), y_resource, u_resource,
+                   v_resource, a_resource, color_space);
+}
+
+void CreateTestYUVVideoDrawQuad_Striped(
+    const SharedQuadState* shared_state,
+    media::VideoFrame::Format format,
+    bool is_transparent,
+    const gfx::RectF& tex_coord_rect,
+    RenderPass* render_pass,
+    VideoResourceUpdater* video_resource_updater,
+    const gfx::Rect& rect,
+    ResourceProvider* resource_provider) {
+  scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
+      format, rect.size(), rect, rect.size(), base::TimeDelta());
+
+  // YUV values representing a striped pattern, for validating texture
+  // coordinates for sampling.
+  uint8_t y_value = 0;
+  uint8_t u_value = 0;
+  uint8_t v_value = 0;
+  for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) {
+    uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) +
+                     video_frame->stride(media::VideoFrame::kYPlane) * i;
+    for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane);
+         ++j) {
+      y_row[j] = (y_value += 1);
+    }
+  }
+  for (int i = 0; i < video_frame->rows(media::VideoFrame::kUPlane); ++i) {
+    uint8_t* u_row = video_frame->data(media::VideoFrame::kUPlane) +
+                     video_frame->stride(media::VideoFrame::kUPlane) * i;
+    uint8_t* v_row = video_frame->data(media::VideoFrame::kVPlane) +
+                     video_frame->stride(media::VideoFrame::kVPlane) * i;
+    for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane);
+         ++j) {
+      u_row[j] = (u_value += 3);
+      v_row[j] = (v_value += 5);
+    }
+  }
+  uint8 alpha_value = is_transparent ? 0 : 128;
+  CreateTestYUVVideoDrawQuad_FromVideoFrame(
+      shared_state, video_frame, alpha_value, tex_coord_rect, render_pass,
+      video_resource_updater, rect, resource_provider);
+}
+
+// Creates a video frame of size background_size filled with yuv_background,
+// and then draws a foreground rectangle in a different color on top of
+// that. The foreground rectangle must have coordinates that are divisible
+// by 2 because YUV is a block format.
+void CreateTestYUVVideoDrawQuad_TwoColor(
+    const SharedQuadState* shared_state,
+    media::VideoFrame::Format format,
+    bool is_transparent,
+    const gfx::RectF& tex_coord_rect,
+    const gfx::Size& background_size,
+    uint8 y_background,
+    uint8 u_background,
+    uint8 v_background,
+    const gfx::Rect& foreground_rect,
+    uint8 y_foreground,
+    uint8 u_foreground,
+    uint8 v_foreground,
+    RenderPass* render_pass,
+    VideoResourceUpdater* video_resource_updater,
+    ResourceProvider* resource_provider) {
+  const gfx::Rect rect(background_size);
+
+  scoped_refptr<media::VideoFrame> video_frame =
+      media::VideoFrame::CreateFrame(format, background_size, foreground_rect,
+                                     foreground_rect.size(), base::TimeDelta());
+
+  int planes[] = {media::VideoFrame::kYPlane,
+                  media::VideoFrame::kUPlane,
+                  media::VideoFrame::kVPlane};
+  uint8 yuv_background[] = {y_background, u_background, v_background};
+  uint8 yuv_foreground[] = {y_foreground, u_foreground, v_foreground};
+  int sample_size[] = {1, 2, 2};
+
+  for (int i = 0; i < 3; ++i) {
+    memset(video_frame->data(planes[i]), yuv_background[i],
+           video_frame->stride(planes[i]) * video_frame->rows(planes[i]));
+  }
+
+  for (int i = 0; i < 3; ++i) {
+    // Since yuv encoding uses block encoding, widths have to be divisible
+    // by the sample size in order for this function to behave properly.
+    DCHECK_EQ(foreground_rect.x() % sample_size[i], 0);
+    DCHECK_EQ(foreground_rect.y() % sample_size[i], 0);
+    DCHECK_EQ(foreground_rect.width() % sample_size[i], 0);
+    DCHECK_EQ(foreground_rect.height() % sample_size[i], 0);
+
+    gfx::Rect sample_rect(foreground_rect.x() / sample_size[i],
+                          foreground_rect.y() / sample_size[i],
+                          foreground_rect.width() / sample_size[i],
+                          foreground_rect.height() / sample_size[i]);
+    for (int y = sample_rect.y(); y < sample_rect.bottom(); ++y) {
+      for (int x = sample_rect.x(); x < sample_rect.right(); ++x) {
+        size_t offset = y * video_frame->stride(planes[i]) + x;
+        video_frame->data(planes[i])[offset] = yuv_foreground[i];
+      }
+    }
+  }
+
+  uint8 alpha_value = 255;
+  CreateTestYUVVideoDrawQuad_FromVideoFrame(
+      shared_state, video_frame, alpha_value, tex_coord_rect, render_pass,
+      video_resource_updater, rect, resource_provider);
+}
+
+void CreateTestYUVVideoDrawQuad_Solid(
+    const SharedQuadState* shared_state,
+    media::VideoFrame::Format format,
+    bool is_transparent,
+    const gfx::RectF& tex_coord_rect,
+    uint8 y,
+    uint8 u,
+    uint8 v,
+    RenderPass* render_pass,
+    VideoResourceUpdater* video_resource_updater,
+    const gfx::Rect& rect,
+    ResourceProvider* resource_provider) {
+  scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
+      format, rect.size(), rect, rect.size(), base::TimeDelta());
+
+  // YUV values of a solid, constant, color. Useful for testing that color
+  // space/color range are being handled properly.
+  memset(video_frame->data(media::VideoFrame::kYPlane), y,
+         video_frame->stride(media::VideoFrame::kYPlane) *
+             video_frame->rows(media::VideoFrame::kYPlane));
+  memset(video_frame->data(media::VideoFrame::kUPlane), u,
+         video_frame->stride(media::VideoFrame::kUPlane) *
+             video_frame->rows(media::VideoFrame::kUPlane));
+  memset(video_frame->data(media::VideoFrame::kVPlane), v,
+         video_frame->stride(media::VideoFrame::kVPlane) *
+             video_frame->rows(media::VideoFrame::kVPlane));
+
+  uint8 alpha_value = is_transparent ? 0 : 128;
+  CreateTestYUVVideoDrawQuad_FromVideoFrame(
+      shared_state, video_frame, alpha_value, tex_coord_rect, render_pass,
+      video_resource_updater, rect, resource_provider);
 }
 
 typedef ::testing::Types<GLRenderer,
@@ -323,6 +565,278 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) {
       FuzzyPixelOffByOneComparator(true)));
 }
 
+template <typename QuadType>
+static const base::FilePath::CharType* IntersectingQuadImage() {
+  return FILE_PATH_LITERAL("intersecting_blue_green_squares.png");
+}
+template <>
+const base::FilePath::CharType* IntersectingQuadImage<SolidColorDrawQuad>() {
+  return FILE_PATH_LITERAL("intersecting_blue_green.png");
+}
+template <>
+const base::FilePath::CharType* IntersectingQuadImage<YUVVideoDrawQuad>() {
+  return FILE_PATH_LITERAL("intersecting_blue_green_squares_video.png");
+}
+
+template <typename TypeParam>
+class IntersectingQuadPixelTest : public RendererPixelTest<TypeParam> {
+ protected:
+  void SetupQuadStateAndRenderPass() {
+    // This sets up a pair of draw quads. They are both rotated
+    // relative to the root plane, they are also rotated relative to each other.
+    // The intersect in the middle at a non-perpendicular angle so that any
+    // errors are hopefully magnified.
+    // The quads should intersect correctly, as in the front quad should only
+    // be partially in front of the back quad, and partially behind.
+
+    viewport_rect_ = gfx::Rect(this->device_viewport_size_);
+    quad_rect_ = gfx::Rect(0, 0, this->device_viewport_size_.width(),
+                           this->device_viewport_size_.height() / 2.0);
+
+    RenderPassId id(1, 1);
+    render_pass_ = CreateTestRootRenderPass(id, viewport_rect_);
+
+    // Create the front quad rotated on the Z and Y axis.
+    gfx::Transform trans;
+    trans.Translate3d(0, 0, 0.707 * this->device_viewport_size_.width() / 2.0);
+    trans.RotateAboutZAxis(45.0);
+    trans.RotateAboutYAxis(45.0);
+    front_quad_state_ =
+        CreateTestSharedQuadState(trans, viewport_rect_, render_pass_.get());
+    front_quad_state_->clip_rect = quad_rect_;
+    // Make sure they end up in a 3d sorting context.
+    front_quad_state_->sorting_context_id = 1;
+
+    // Create the back quad, and rotate on just the y axis. This will intersect
+    // the first quad partially.
+    trans = gfx::Transform();
+    trans.Translate3d(0, 0, -0.707 * this->device_viewport_size_.width() / 2.0);
+    trans.RotateAboutYAxis(-45.0);
+    back_quad_state_ =
+        CreateTestSharedQuadState(trans, viewport_rect_, render_pass_.get());
+    back_quad_state_->sorting_context_id = 1;
+    back_quad_state_->clip_rect = quad_rect_;
+  }
+  template <typename T>
+  void AppendBackgroundAndRunTest(const PixelComparator& comparator) {
+    SharedQuadState* background_quad_state = CreateTestSharedQuadState(
+        gfx::Transform(), viewport_rect_, render_pass_.get());
+    SolidColorDrawQuad* background_quad =
+        render_pass_->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+    background_quad->SetNew(background_quad_state, viewport_rect_,
+                            viewport_rect_, SK_ColorWHITE, false);
+    pass_list_.push_back(render_pass_.Pass());
+    const base::FilePath::CharType* fileName = IntersectingQuadImage<T>();
+    EXPECT_TRUE(
+        this->RunPixelTest(&pass_list_, base::FilePath(fileName), comparator));
+  }
+  template <typename T>
+  T* CreateAndAppendDrawQuad() {
+    return render_pass_->CreateAndAppendDrawQuad<T>();
+  }
+
+  scoped_ptr<RenderPass> render_pass_;
+  gfx::Rect viewport_rect_;
+  SharedQuadState* front_quad_state_;
+  SharedQuadState* back_quad_state_;
+  gfx::Rect quad_rect_;
+  RenderPassList pass_list_;
+};
+
+template <typename TypeParam>
+class IntersectingQuadGLPixelTest
+    : public IntersectingQuadPixelTest<TypeParam> {
+ public:
+  void SetUp() override {
+    IntersectingQuadPixelTest<TypeParam>::SetUp();
+    video_resource_updater_.reset(
+        new VideoResourceUpdater(this->output_surface_->context_provider(),
+                                 this->resource_provider_.get()));
+    video_resource_updater2_.reset(
+        new VideoResourceUpdater(this->output_surface_->context_provider(),
+                                 this->resource_provider_.get()));
+  }
+
+ protected:
+  scoped_ptr<VideoResourceUpdater> video_resource_updater_;
+  scoped_ptr<VideoResourceUpdater> video_resource_updater2_;
+};
+
+template <typename TypeParam>
+class IntersectingQuadSoftwareTest
+    : public IntersectingQuadPixelTest<TypeParam> {};
+
+typedef ::testing::Types<SoftwareRenderer, SoftwareRendererWithExpandedViewport>
+    SoftwareRendererTypes;
+typedef ::testing::Types<GLRenderer, GLRendererWithExpandedViewport>
+    GLRendererTypes;
+
+TYPED_TEST_CASE(IntersectingQuadPixelTest, RendererTypes);
+TYPED_TEST_CASE(IntersectingQuadGLPixelTest, GLRendererTypes);
+TYPED_TEST_CASE(IntersectingQuadSoftwareTest, SoftwareRendererTypes);
+
+TYPED_TEST(IntersectingQuadPixelTest, SolidColorQuads) {
+  this->SetupQuadStateAndRenderPass();
+
+  SolidColorDrawQuad* quad =
+      this->template CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+  SolidColorDrawQuad* quad2 =
+      this->template CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+
+  quad->SetNew(this->front_quad_state_, this->quad_rect_, this->quad_rect_,
+               SK_ColorBLUE, false);
+  quad2->SetNew(this->back_quad_state_, this->quad_rect_, this->quad_rect_,
+                SK_ColorGREEN, false);
+  SCOPED_TRACE("IntersectingSolidColorQuads");
+  this->template AppendBackgroundAndRunTest<SolidColorDrawQuad>(
+      FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f));
+}
+
+template <typename TypeParam>
+SkColor GetColor(const SkColor& color) {
+  return color;
+}
+
+template <>
+SkColor GetColor<GLRenderer>(const SkColor& color) {
+  return SkColorSetARGB(SkColorGetA(color), SkColorGetB(color),
+                        SkColorGetG(color), SkColorGetR(color));
+}
+template <>
+SkColor GetColor<GLRendererWithExpandedViewport>(const SkColor& color) {
+  return GetColor<GLRenderer>(color);
+}
+
+TYPED_TEST(IntersectingQuadPixelTest, TexturedQuads) {
+  this->SetupQuadStateAndRenderPass();
+  CreateTestTwoColoredTextureDrawQuad(
+      this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 0)),
+      GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 255)), SK_ColorTRANSPARENT,
+      true, this->front_quad_state_, this->resource_provider_.get(),
+      this->render_pass_.get());
+  CreateTestTwoColoredTextureDrawQuad(
+      this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 255, 0)),
+      GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 0)), SK_ColorTRANSPARENT,
+      true, this->back_quad_state_, this->resource_provider_.get(),
+      this->render_pass_.get());
+
+  SCOPED_TRACE("IntersectingTexturedQuads");
+  this->template AppendBackgroundAndRunTest<TextureDrawQuad>(
+      FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f));
+}
+
+TYPED_TEST(IntersectingQuadSoftwareTest, PictureQuads) {
+  this->SetupQuadStateAndRenderPass();
+  gfx::RectF outer_rect(this->quad_rect_);
+  gfx::RectF inner_rect(this->quad_rect_.x() + (this->quad_rect_.width() / 4),
+                        this->quad_rect_.y() + (this->quad_rect_.height() / 4),
+                        this->quad_rect_.width() / 2,
+                        this->quad_rect_.height() / 2);
+
+  SkPaint black_paint;
+  black_paint.setColor(SK_ColorBLACK);
+  SkPaint blue_paint;
+  blue_paint.setColor(SK_ColorBLUE);
+  SkPaint green_paint;
+  green_paint.setColor(SK_ColorGREEN);
+
+  scoped_ptr<FakePicturePile> blue_recording =
+      FakePicturePile::CreateFilledPile(gfx::Size(1000, 1000),
+                                        this->quad_rect_.size());
+  blue_recording->add_draw_rect_with_paint(outer_rect, black_paint);
+  blue_recording->add_draw_rect_with_paint(inner_rect, blue_paint);
+  blue_recording->RerecordPile();
+  scoped_refptr<FakePicturePileImpl> blue_pile =
+      FakePicturePileImpl::CreateFromPile(blue_recording.get(), nullptr);
+
+  PictureDrawQuad* blue_quad =
+      this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>();
+
+  blue_quad->SetNew(this->front_quad_state_, this->quad_rect_, gfx::Rect(),
+                    this->quad_rect_, this->quad_rect_, this->quad_rect_.size(),
+                    false, RGBA_8888, this->quad_rect_, 1.f, blue_pile);
+
+  scoped_ptr<FakePicturePile> green_recording =
+      FakePicturePile::CreateFilledPile(this->quad_rect_.size(),
+                                        this->quad_rect_.size());
+  green_recording->add_draw_rect_with_paint(outer_rect, green_paint);
+  green_recording->add_draw_rect_with_paint(inner_rect, black_paint);
+  green_recording->RerecordPile();
+  scoped_refptr<FakePicturePileImpl> green_pile =
+      FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);
+
+  PictureDrawQuad* green_quad =
+      this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>();
+  green_quad->SetNew(this->back_quad_state_, this->quad_rect_, gfx::Rect(),
+                     this->quad_rect_, this->quad_rect_,
+                     this->quad_rect_.size(), false, RGBA_8888,
+                     this->quad_rect_, 1.f, green_pile);
+  SCOPED_TRACE("IntersectingPictureQuadsPass");
+  this->template AppendBackgroundAndRunTest<PictureDrawQuad>(
+      FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f));
+}
+
+TYPED_TEST(IntersectingQuadPixelTest, RenderPassQuads) {
+  this->SetupQuadStateAndRenderPass();
+  RenderPassId child_pass_id1(2, 2);
+  RenderPassId child_pass_id2(2, 3);
+  scoped_ptr<RenderPass> child_pass1 =
+      CreateTestRenderPass(child_pass_id1, this->quad_rect_, gfx::Transform());
+  SharedQuadState* child1_quad_state = CreateTestSharedQuadState(
+      gfx::Transform(), this->quad_rect_, child_pass1.get());
+  scoped_ptr<RenderPass> child_pass2 =
+      CreateTestRenderPass(child_pass_id2, this->quad_rect_, gfx::Transform());
+  SharedQuadState* child2_quad_state = CreateTestSharedQuadState(
+      gfx::Transform(), this->quad_rect_, child_pass2.get());
+
+  CreateTestTwoColoredTextureDrawQuad(
+      this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 0)),
+      GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 255)), SK_ColorTRANSPARENT,
+      true, child1_quad_state, this->resource_provider_.get(),
+      child_pass1.get());
+  CreateTestTwoColoredTextureDrawQuad(
+      this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 255, 0)),
+      GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 0)), SK_ColorTRANSPARENT,
+      true, child2_quad_state, this->resource_provider_.get(),
+      child_pass2.get());
+
+  CreateTestRenderPassDrawQuad(this->front_quad_state_, this->quad_rect_,
+                               child_pass_id1, this->render_pass_.get());
+  CreateTestRenderPassDrawQuad(this->back_quad_state_, this->quad_rect_,
+                               child_pass_id2, this->render_pass_.get());
+
+  this->pass_list_.push_back(child_pass1.Pass());
+  this->pass_list_.push_back(child_pass2.Pass());
+  SCOPED_TRACE("IntersectingRenderQuadsPass");
+  this->template AppendBackgroundAndRunTest<RenderPassDrawQuad>(
+      FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f));
+}
+
+TYPED_TEST(IntersectingQuadGLPixelTest, YUVVideoQuads) {
+  this->SetupQuadStateAndRenderPass();
+  gfx::Rect inner_rect(
+      ((this->quad_rect_.x() + (this->quad_rect_.width() / 4)) & ~0xF),
+      ((this->quad_rect_.y() + (this->quad_rect_.height() / 4)) & ~0xF),
+      (this->quad_rect_.width() / 2) & ~0xF,
+      (this->quad_rect_.height() / 2) & ~0xF);
+
+  CreateTestYUVVideoDrawQuad_TwoColor(
+      this->front_quad_state_, media::VideoFrame::YV12J, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), this->quad_rect_.size(), 0, 128, 128,
+      inner_rect, 29, 255, 107, this->render_pass_.get(),
+      this->video_resource_updater_.get(), this->resource_provider_.get());
+
+  CreateTestYUVVideoDrawQuad_TwoColor(
+      this->back_quad_state_, media::VideoFrame::YV12J, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), this->quad_rect_.size(), 149, 43, 21,
+      inner_rect, 0, 128, 128, this->render_pass_.get(),
+      this->video_resource_updater2_.get(), this->resource_provider_.get());
+
+  SCOPED_TRACE("IntersectingVideoQuads");
+  this->template AppendBackgroundAndRunTest<YUVVideoDrawQuad>(
+      FuzzyPixelOffByOneComparator(false));
+}
+
 // TODO(skaslev): The software renderer does not support non-premultplied alpha.
 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) {
   gfx::Rect rect(this->device_viewport_size_);
@@ -390,80 +904,6 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) {
 
 class VideoGLRendererPixelTest : public GLRendererPixelTest {
  protected:
-  void CreateTestYUVVideoDrawQuad_Striped(const SharedQuadState* shared_state,
-                                          media::VideoFrame::Format format,
-                                          bool is_transparent,
-                                          const gfx::RectF& tex_coord_rect,
-                                          RenderPass* render_pass) {
-    const gfx::Rect rect(this->device_viewport_size_);
-
-    scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::CreateFrame(
-            format, rect.size(), rect, rect.size(), base::TimeDelta());
-
-    // YUV values representing a striped pattern, for validating texture
-    // coordinates for sampling.
-    uint8_t y_value = 0;
-    uint8_t u_value = 0;
-    uint8_t v_value = 0;
-    for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) {
-      uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) +
-                       video_frame->stride(media::VideoFrame::kYPlane) * i;
-      for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane);
-           ++j) {
-        y_row[j] = (y_value += 1);
-      }
-    }
-    for (int i = 0; i < video_frame->rows(media::VideoFrame::kUPlane); ++i) {
-      uint8_t* u_row = video_frame->data(media::VideoFrame::kUPlane) +
-                       video_frame->stride(media::VideoFrame::kUPlane) * i;
-      uint8_t* v_row = video_frame->data(media::VideoFrame::kVPlane) +
-                       video_frame->stride(media::VideoFrame::kVPlane) * i;
-      for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane);
-           ++j) {
-        u_row[j] = (u_value += 3);
-        v_row[j] = (v_value += 5);
-      }
-    }
-    uint8 alpha_value = is_transparent ? 0 : 128;
-    CreateTestYUVVideoDrawQuad_FromVideoFrame(
-        shared_state, video_frame, alpha_value, tex_coord_rect, render_pass);
-  }
-
-  void CreateTestYUVVideoDrawQuad_Solid(const SharedQuadState* shared_state,
-                                        media::VideoFrame::Format format,
-                                        bool is_transparent,
-                                        const gfx::RectF& tex_coord_rect,
-                                        uint8 y,
-                                        uint8 u,
-                                        uint8 v,
-                                        RenderPass* render_pass) {
-    const gfx::Rect rect(this->device_viewport_size_);
-
-    scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::CreateFrame(
-            format, rect.size(), rect, rect.size(), base::TimeDelta());
-
-    // YUV values of a solid, constant, color. Useful for testing that color
-    // space/color range are being handled properly.
-    memset(video_frame->data(media::VideoFrame::kYPlane),
-           y,
-           video_frame->stride(media::VideoFrame::kYPlane) *
-               video_frame->rows(media::VideoFrame::kYPlane));
-    memset(video_frame->data(media::VideoFrame::kUPlane),
-           u,
-           video_frame->stride(media::VideoFrame::kUPlane) *
-               video_frame->rows(media::VideoFrame::kUPlane));
-    memset(video_frame->data(media::VideoFrame::kVPlane),
-           v,
-           video_frame->stride(media::VideoFrame::kVPlane) *
-               video_frame->rows(media::VideoFrame::kVPlane));
-
-    uint8 alpha_value = is_transparent ? 0 : 128;
-    CreateTestYUVVideoDrawQuad_FromVideoFrame(
-        shared_state, video_frame, alpha_value, tex_coord_rect, render_pass);
-  }
-
   void CreateEdgeBleedPass(media::VideoFrame::Format format,
                            RenderPassList* pass_list) {
     gfx::Rect rect(200, 200);
@@ -492,139 +932,19 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
     // green sub-rectangle that should be the only thing displayed in
     // the final image.  Bleeding will appear on all four sides of the video
     // if the tex coords are not clamped.
-    CreateTestYUVVideoDrawQuad_TwoColor(shared_state, format, false,
-                                        tex_coord_rect, background_size, 0, 0,
-                                        0, green_rect, 149, 43, 21, pass.get());
+    CreateTestYUVVideoDrawQuad_TwoColor(
+        shared_state, format, false, tex_coord_rect, background_size, 0, 0, 0,
+        green_rect, 149, 43, 21, pass.get(), video_resource_updater_.get(),
+        resource_provider_.get());
     pass_list->push_back(pass.Pass());
   }
 
-  // Creates a video frame of size background_size filled with yuv_background,
-  // and then draws a foreground rectangle in a different color on top of
-  // that. The foreground rectangle must have coordinates that are divisible
-  // by 2 because YUV is a block format.
-  void CreateTestYUVVideoDrawQuad_TwoColor(const SharedQuadState* shared_state,
-                                           media::VideoFrame::Format format,
-                                           bool is_transparent,
-                                           const gfx::RectF& tex_coord_rect,
-                                           const gfx::Size& background_size,
-                                           uint8 y_background,
-                                           uint8 u_background,
-                                           uint8 v_background,
-                                           const gfx::Rect& foreground_rect,
-                                           uint8 y_foreground,
-                                           uint8 u_foreground,
-                                           uint8 v_foreground,
-                                           RenderPass* render_pass) {
-    const gfx::Rect rect(background_size);
-
-    scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::CreateFrame(format, background_size, foreground_rect,
-                                       foreground_rect.size(),
-                                       base::TimeDelta());
-
-    int planes[] = {media::VideoFrame::kYPlane,
-                    media::VideoFrame::kUPlane,
-                    media::VideoFrame::kVPlane};
-    uint8 yuv_background[] = {y_background, u_background, v_background};
-    uint8 yuv_foreground[] = {y_foreground, u_foreground, v_foreground};
-    int sample_size[] = {1, 2, 2};
-
-    for (int i = 0; i < 3; ++i) {
-      memset(video_frame->data(planes[i]), yuv_background[i],
-             video_frame->stride(planes[i]) * video_frame->rows(planes[i]));
-    }
-
-    for (int i = 0; i < 3; ++i) {
-      // Since yuv encoding uses block encoding, widths have to be divisible
-      // by the sample size in order for this function to behave properly.
-      DCHECK_EQ(foreground_rect.x() % sample_size[i], 0);
-      DCHECK_EQ(foreground_rect.y() % sample_size[i], 0);
-      DCHECK_EQ(foreground_rect.width() % sample_size[i], 0);
-      DCHECK_EQ(foreground_rect.height() % sample_size[i], 0);
-
-      gfx::Rect sample_rect(foreground_rect.x() / sample_size[i],
-                            foreground_rect.y() / sample_size[i],
-                            foreground_rect.width() / sample_size[i],
-                            foreground_rect.height() / sample_size[i]);
-      for (int y = sample_rect.y(); y < sample_rect.bottom(); ++y) {
-        for (int x = sample_rect.x(); x < sample_rect.right(); ++x) {
-          size_t offset = y * video_frame->stride(planes[i]) + x;
-          video_frame->data(planes[i])[offset] = yuv_foreground[i];
-        }
-      }
-    }
-
-    uint8 alpha_value = 255;
-    CreateTestYUVVideoDrawQuad_FromVideoFrame(
-        shared_state, video_frame, alpha_value, tex_coord_rect, render_pass);
-  }
-
-  void CreateTestYUVVideoDrawQuad_FromVideoFrame(
-      const SharedQuadState* shared_state,
-      scoped_refptr<media::VideoFrame> video_frame,
-      uint8 alpha_value,
-      const gfx::RectF& tex_coord_rect,
-      RenderPass* render_pass) {
-    const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A);
-    const YUVVideoDrawQuad::ColorSpace color_space =
-        (video_frame->format() == media::VideoFrame::YV12J
-             ? YUVVideoDrawQuad::JPEG
-             : YUVVideoDrawQuad::REC_601);
-    const gfx::Rect rect(shared_state->content_bounds);
-    const gfx::Rect opaque_rect(0, 0, 0, 0);
-
-    if (with_alpha)
-      memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value,
-             video_frame->stride(media::VideoFrame::kAPlane) *
-                 video_frame->rows(media::VideoFrame::kAPlane));
-
-    VideoFrameExternalResources resources =
-        video_resource_updater_->CreateExternalResourcesFromVideoFrame(
-            video_frame);
-
-    EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
-    EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
-              resources.mailboxes.size());
-    EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
-              resources.release_callbacks.size());
-
-    ResourceProvider::ResourceId y_resource =
-        resource_provider_->CreateResourceFromTextureMailbox(
-            resources.mailboxes[media::VideoFrame::kYPlane],
-            SingleReleaseCallbackImpl::Create(
-                resources.release_callbacks[media::VideoFrame::kYPlane]));
-    ResourceProvider::ResourceId u_resource =
-        resource_provider_->CreateResourceFromTextureMailbox(
-            resources.mailboxes[media::VideoFrame::kUPlane],
-            SingleReleaseCallbackImpl::Create(
-                resources.release_callbacks[media::VideoFrame::kUPlane]));
-    ResourceProvider::ResourceId v_resource =
-        resource_provider_->CreateResourceFromTextureMailbox(
-            resources.mailboxes[media::VideoFrame::kVPlane],
-            SingleReleaseCallbackImpl::Create(
-                resources.release_callbacks[media::VideoFrame::kVPlane]));
-    ResourceProvider::ResourceId a_resource = 0;
-    if (with_alpha) {
-      a_resource = resource_provider_->CreateResourceFromTextureMailbox(
-          resources.mailboxes[media::VideoFrame::kAPlane],
-          SingleReleaseCallbackImpl::Create(
-              resources.release_callbacks[media::VideoFrame::kAPlane]));
-    }
-
-    YUVVideoDrawQuad* yuv_quad =
-        render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
-    yuv_quad->SetNew(shared_state, rect, opaque_rect, rect, tex_coord_rect,
-                     video_frame->coded_size(), y_resource, u_resource,
-                     v_resource, a_resource, color_space);
-  }
-
   void SetUp() override {
     GLRendererPixelTest::SetUp();
     video_resource_updater_.reset(new VideoResourceUpdater(
         output_surface_->context_provider(), resource_provider_.get()));
   }
 
- private:
   scoped_ptr<VideoResourceUpdater> video_resource_updater_;
 };
 
@@ -637,11 +957,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) {
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::YV12,
-                                     false,
-                                     gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                     pass.get());
+  CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12,
+                                     false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                     pass.get(), video_resource_updater_.get(),
+                                     rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -662,11 +981,10 @@ TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) {
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // Intentionally sets frame format to I420 for testing coverage.
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::I420,
-                                     false,
-                                     gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f),
-                                     pass.get());
+  CreateTestYUVVideoDrawQuad_Striped(
+      shared_state, media::VideoFrame::I420, false,
+      gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f), pass.get(),
+      video_resource_updater_.get(), rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -687,14 +1005,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) {
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // In MPEG color range YUV values of (15,128,128) should produce black.
-  CreateTestYUVVideoDrawQuad_Solid(shared_state,
-                                   media::VideoFrame::YV12,
-                                   false,
-                                   gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                   15,
-                                   128,
-                                   128,
-                                   pass.get());
+  CreateTestYUVVideoDrawQuad_Solid(
+      shared_state, media::VideoFrame::YV12, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(),
+      video_resource_updater_.get(), rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -716,14 +1030,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) {
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // YUV of (149,43,21) should be green (0,255,0) in RGB.
-  CreateTestYUVVideoDrawQuad_Solid(shared_state,
-                                   media::VideoFrame::YV12J,
-                                   false,
-                                   gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                   149,
-                                   43,
-                                   21,
-                                   pass.get());
+  CreateTestYUVVideoDrawQuad_Solid(
+      shared_state, media::VideoFrame::YV12J, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(),
+      video_resource_updater_.get(), rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -761,14 +1071,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) {
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // Dark grey in JPEG color range (in MPEG, this is black).
-  CreateTestYUVVideoDrawQuad_Solid(shared_state,
-                                   media::VideoFrame::YV12J,
-                                   false,
-                                   gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                   15,
-                                   128,
-                                   128,
-                                   pass.get());
+  CreateTestYUVVideoDrawQuad_Solid(
+      shared_state, media::VideoFrame::YV12J, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(),
+      video_resource_updater_.get(), rect, resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -788,11 +1094,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) {
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::YV12A,
-                                     false,
-                                     gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                     pass.get());
+  CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A,
+                                     false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                     pass.get(), video_resource_updater_.get(),
+                                     rect, resource_provider_.get());
 
   SolidColorDrawQuad* color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -816,11 +1121,10 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) {
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::YV12A,
-                                     true,
-                                     gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                     pass.get());
+  CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A,
+                                     true, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                     pass.get(), video_resource_updater_.get(),
+                                     rect, resource_provider_.get());
 
   SolidColorDrawQuad* color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index a4b5428..19c4fa3 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -25,6 +25,7 @@
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkMatrix.h"
+#include "third_party/skia/include/core/SkPoint.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/effects/SkLayerRasterizer.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ -235,7 +236,13 @@ bool SoftwareRenderer::IsSoftwareResource(
   return false;
 }
 
-void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
+void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame,
+                                  const DrawQuad* quad,
+                                  const gfx::QuadF* draw_region) {
+  if (draw_region) {
+    current_canvas_->save();
+  }
+
   TRACE_EVENT0("cc", "SoftwareRenderer::DoDrawQuad");
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
@@ -270,9 +277,31 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
     current_paint_.setXfermodeMode(SkXfermode::kSrc_Mode);
   }
 
+  if (draw_region) {
+    gfx::QuadF local_draw_region(*draw_region);
+    SkPath draw_region_clip_path;
+    local_draw_region -=
+        gfx::Vector2dF(quad->visible_rect.x(), quad->visible_rect.y());
+    local_draw_region.Scale(1.0f / quad->visible_rect.width(),
+                            1.0f / quad->visible_rect.height());
+    local_draw_region -= gfx::Vector2dF(0.5f, 0.5f);
+
+    SkPoint clip_points[4];
+    QuadFToSkPoints(local_draw_region, clip_points);
+    draw_region_clip_path.addPoly(clip_points, 4, true);
+
+    current_canvas_->clipPath(draw_region_clip_path, SkRegion::kIntersect_Op,
+                              false);
+  }
+
   switch (quad->material) {
     case DrawQuad::CHECKERBOARD:
-      DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
+      // TODO(enne) 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 (!draw_region) {
+        DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
+      }
       break;
     case DrawQuad::DEBUG_BORDER:
       DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
@@ -307,6 +336,9 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
   }
 
   current_canvas_->resetMatrix();
+  if (draw_region) {
+    current_canvas_->restore();
+  }
 }
 
 void SoftwareRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
diff --git a/cc/output/software_renderer.h b/cc/output/software_renderer.h
index 99868c3..dc8e2fb 100644
--- a/cc/output/software_renderer.h
+++ b/cc/output/software_renderer.h
@@ -52,7 +52,10 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
                      bool draw_rect_covers_full_surface) override;
   void ClearFramebuffer(DrawingFrame* frame,
                         bool has_external_stencil_test) override;
-  void DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) override;
+
+  void DoDrawQuad(DrawingFrame* frame,
+                  const DrawQuad* quad,
+                  const gfx::QuadF* draw_region) override;
   void BeginDrawingFrame(DrawingFrame* frame) override;
   void FinishDrawingFrame(DrawingFrame* frame) override;
   bool FlippedFramebuffer(const DrawingFrame* frame) const override;
diff --git a/cc/output/static_geometry_binding.cc b/cc/output/static_geometry_binding.cc
new file mode 100644
index 0000000..683db2d
--- /dev/null
+++ b/cc/output/static_geometry_binding.cc
@@ -0,0 +1,72 @@
+// Copyright 2015 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/static_geometry_binding.h"
+
+#include "cc/output/gl_renderer.h"  // For the GLC() macro.
+#include "gpu/command_buffer/client/gles2_interface.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+namespace cc {
+
+StaticGeometryBinding::StaticGeometryBinding(gpu::gles2::GLES2Interface* gl,
+                                             const gfx::RectF& quad_vertex_rect)
+    : gl_(gl), quad_vertices_vbo_(0), quad_elements_vbo_(0) {
+  GeometryBindingQuad quads[8];
+  GeometryBindingQuadIndex quad_indices[8];
+
+  static_assert(sizeof(GeometryBindingQuad) == 24 * sizeof(float),
+                "struct Quad should be densely packed");
+  static_assert(sizeof(GeometryBindingQuadIndex) == 6 * sizeof(uint16_t),
+                "struct QuadIndex should be densely packed");
+
+  for (size_t i = 0; i < 8; i++) {
+    GeometryBindingVertex v0 = {
+        {quad_vertex_rect.x(), quad_vertex_rect.bottom(), 0.0f},
+        {0.0f, 1.0f},
+        i * 4.0f + 0.0f};
+    GeometryBindingVertex v1 = {
+        {quad_vertex_rect.x(), quad_vertex_rect.y(), 0.0f},
+        {0.0f, 0.0f},
+        i * 4.0f + 1.0f};
+    GeometryBindingVertex v2 = {
+        {quad_vertex_rect.right(), quad_vertex_rect.y(), 0.0f},
+        {1.0f, 0.0f},
+        i * 4.0f + 2.0f};
+    GeometryBindingVertex v3 = {
+        {quad_vertex_rect.right(), quad_vertex_rect.bottom(), 0.0f},
+        {1.0f, 1.0f},
+        i * 4.0f + 3.0f};
+    GeometryBindingQuad x(v0, v1, v2, v3);
+    quads[i] = x;
+    GeometryBindingQuadIndex y(
+        static_cast<uint16>(0 + 4 * i), static_cast<uint16>(1 + 4 * i),
+        static_cast<uint16>(2 + 4 * i), static_cast<uint16>(3 + 4 * i),
+        static_cast<uint16>(0 + 4 * i), static_cast<uint16>(2 + 4 * i));
+    quad_indices[i] = y;
+  }
+
+  GLC(gl_, gl_->GenBuffers(1, &quad_vertices_vbo_));
+  GLC(gl_, gl_->GenBuffers(1, &quad_elements_vbo_));
+
+  GLC(gl_, gl_->BindBuffer(GL_ARRAY_BUFFER, quad_vertices_vbo_));
+  GLC(gl_, gl_->BufferData(GL_ARRAY_BUFFER, sizeof(GeometryBindingQuad) * 8,
+                           quads, GL_STATIC_DRAW));
+
+  GLC(gl_, gl_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_elements_vbo_));
+  GLC(gl_, gl_->BufferData(GL_ELEMENT_ARRAY_BUFFER,
+                           sizeof(GeometryBindingQuadIndex) * 8, &quad_indices,
+                           GL_STATIC_DRAW));
+}
+
+StaticGeometryBinding::~StaticGeometryBinding() {
+  gl_->DeleteBuffers(1, &quad_vertices_vbo_);
+  gl_->DeleteBuffers(1, &quad_elements_vbo_);
+}
+
+void StaticGeometryBinding::PrepareForDraw() {
+  SetupGLContext(gl_, quad_elements_vbo_, quad_vertices_vbo_);
+}
+
+}  // namespace cc
diff --git a/cc/output/static_geometry_binding.h b/cc/output/static_geometry_binding.h
new file mode 100644
index 0000000..bd6bfcc
--- /dev/null
+++ b/cc/output/static_geometry_binding.h
@@ -0,0 +1,33 @@
+// Copyright 2015 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.
+
+#ifndef CC_OUTPUT_STATIC_GEOMETRY_BINDING_H_
+#define CC_OUTPUT_STATIC_GEOMETRY_BINDING_H_
+
+#include "cc/output/geometry_binding.h"
+
+using gpu::gles2::GLES2Interface;
+
+namespace cc {
+
+class StaticGeometryBinding {
+ public:
+  StaticGeometryBinding(gpu::gles2::GLES2Interface* gl,
+                        const gfx::RectF& quad_vertex_rect);
+  ~StaticGeometryBinding();
+
+  void PrepareForDraw();
+
+ private:
+  gpu::gles2::GLES2Interface* gl_;
+
+  GLuint quad_vertices_vbo_;
+  GLuint quad_elements_vbo_;
+
+  DISALLOW_COPY_AND_ASSIGN(StaticGeometryBinding);
+};
+
+}  // namespace cc
+
+#endif  // CC_OUTPUT_STATIC_GEOMETRY_BINDING_H_
diff --git a/cc/quads/draw_polygon.cc b/cc/quads/draw_polygon.cc
index 026be2c..8d36f4f 100644
--- a/cc/quads/draw_polygon.cc
+++ b/cc/quads/draw_polygon.cc
@@ -12,7 +12,7 @@
 namespace {
 // This allows for some imperfection in the normal comparison when checking if
 // two pieces of geometry are coplanar.
-static const float coplanar_dot_epsilon = 0.01f;
+static const float coplanar_dot_epsilon = 0.001f;
 // This threshold controls how "thick" a plane is. If a point's distance is
 // <= |compare_threshold|, then it is considered on the plane. Only when this
 // boundary is crossed do we consider doing splitting.
@@ -25,21 +25,25 @@ static const float compare_threshold = 1.0f;
 // points that SHOULD be intersecting the "thick plane", but actually fail to
 // test positively for it because |split_threshold| allowed them to be outside
 // this range.
+// This is really supposd to be compare_threshold / 2.0f, but that would
+// create another static initializer.
 static const float split_threshold = 0.5f;
+
+static const float normalized_threshold = 0.001f;
 }  // namespace
 
 namespace cc {
 
-gfx::Vector3dF DrawPolygon::default_normal = gfx::Vector3dF(0.0f, 0.0f, -1.0f);
+gfx::Vector3dF DrawPolygon::default_normal = gfx::Vector3dF(0.0f, 0.0f, 1.0f);
 
 DrawPolygon::DrawPolygon() {
 }
 
-DrawPolygon::DrawPolygon(DrawQuad* original,
+DrawPolygon::DrawPolygon(const DrawQuad* original,
                          const std::vector<gfx::Point3F>& in_points,
                          const gfx::Vector3dF& normal,
                          int draw_order_index)
-    : order_index_(draw_order_index), original_ref_(original) {
+    : order_index_(draw_order_index), original_ref_(original), is_split_(true) {
   for (size_t i = 0; i < in_points.size(); i++) {
     points_.push_back(in_points[i]);
   }
@@ -49,12 +53,14 @@ DrawPolygon::DrawPolygon(DrawQuad* original,
 // This takes the original DrawQuad that this polygon should be based on,
 // a visible content rect to make the 4 corner points from, and a transformation
 // to move it and its normal into screen space.
-DrawPolygon::DrawPolygon(DrawQuad* original_ref,
+DrawPolygon::DrawPolygon(const DrawQuad* original_ref,
                          const gfx::RectF& visible_content_rect,
                          const gfx::Transform& transform,
                          int draw_order_index)
-    : order_index_(draw_order_index), original_ref_(original_ref) {
-  normal_ = default_normal;
+    : normal_(default_normal),
+      order_index_(draw_order_index),
+      original_ref_(original_ref),
+      is_split_(false) {
   gfx::Point3F points[8];
   int num_vertices_in_clipped_quad;
   gfx::QuadF send_quad(visible_content_rect);
@@ -97,6 +103,9 @@ float DrawPolygon::SignedPointDistance(const gfx::Point3F& point) const {
 // Assumes that layers are split and there are no intersecting planes.
 BspCompareResult DrawPolygon::SideCompare(const DrawPolygon& a,
                                           const DrawPolygon& b) {
+  // Let's make sure that both of these are normalized.
+  DCHECK_GE(normalized_threshold, std::abs(a.normal_.LengthSquared() - 1.0f));
+  DCHECK_GE(normalized_threshold, std::abs(b.normal_.LengthSquared() - 1.0f));
   // Right away let's check if they're coplanar
   double dot = gfx::DotProduct(a.normal_, b.normal_);
   float sign = 0.0f;
@@ -105,7 +114,7 @@ BspCompareResult DrawPolygon::SideCompare(const DrawPolygon& a,
   if (std::abs(dot) >= 1.0f - coplanar_dot_epsilon) {
     normal_match = true;
     // The normals are matching enough that we only have to test one point.
-    sign = gfx::DotProduct(a.points_[0] - b.points_[0], b.normal_);
+    sign = b.SignedPointDistance(a.points_[0]);
     // Is it on either side of the splitter?
     if (sign < -compare_threshold) {
       return BSP_BACK;
@@ -168,7 +177,7 @@ static bool LineIntersectPlane(const gfx::Point3F& line_start,
 
   // The case where one vertex lies on the thick-plane and the other
   // is outside of it.
-  if (std::abs(start_distance) < distance_threshold &&
+  if (std::abs(start_distance) <= distance_threshold &&
       std::abs(end_distance) > distance_threshold) {
     intersection->SetPoint(line_start.x(), line_start.y(), line_start.z());
     return true;
@@ -270,7 +279,7 @@ bool DrawPolygon::Split(const DrawPolygon& splitter,
         break;
       }
     }
-    if (current_vertex++ > points_size) {
+    if (current_vertex++ > (points_size)) {
       break;
     }
   }
@@ -284,6 +293,7 @@ bool DrawPolygon::Split(const DrawPolygon& splitter,
 
   // First polygon.
   out_points[0].push_back(intersections[0]);
+  DCHECK_GE(vertex_before[1], start1);
   for (size_t i = start1; i <= vertex_before[1]; i++) {
     out_points[0].push_back(points_[i]);
     --points_remaining;
@@ -306,6 +316,9 @@ bool DrawPolygon::Split(const DrawPolygon& splitter,
   scoped_ptr<DrawPolygon> poly2(
       new DrawPolygon(original_ref_, out_points[1], normal_, order_index_));
 
+  DCHECK_GE(poly1->points().size(), 3u);
+  DCHECK_GE(poly2->points().size(), 3u);
+
   if (SideCompare(*poly1, splitter) == BSP_FRONT) {
     *front = poly1.Pass();
     *back = poly2.Pass();
diff --git a/cc/quads/draw_polygon.h b/cc/quads/draw_polygon.h
index 32643ee..0ca9545 100644
--- a/cc/quads/draw_polygon.h
+++ b/cc/quads/draw_polygon.h
@@ -24,11 +24,11 @@ class CC_EXPORT DrawPolygon {
   DrawPolygon();
   ~DrawPolygon();
 
-  DrawPolygon(DrawQuad* original_ref,
+  DrawPolygon(const DrawQuad* original_ref,
               const std::vector<gfx::Point3F>& in_points,
               const gfx::Vector3dF& normal,
               int draw_order_index = 0);
-  DrawPolygon(DrawQuad* original_ref,
+  DrawPolygon(const DrawQuad* original_ref,
               const gfx::RectF& visible_content_rect,
               const gfx::Transform& transform,
               int draw_order_index = 0);
@@ -56,7 +56,7 @@ class CC_EXPORT DrawPolygon {
   const gfx::Vector3dF& normal() const { return normal_; }
   const DrawQuad* original_ref() const { return original_ref_; }
   int order_index() const { return order_index_; }
-
+  bool is_split() const { return is_split_; }
   scoped_ptr<DrawPolygon> CreateCopy();
 
   static gfx::Vector3dF default_normal;
@@ -76,7 +76,8 @@ class CC_EXPORT DrawPolygon {
   // we need.
   // This DrawQuad is owned by the caller and its lifetime must be preserved
   // as long as this DrawPolygon is alive.
-  DrawQuad* original_ref_;
+  const DrawQuad* original_ref_;
+  bool is_split_;
 };
 
 }  // namespace cc
diff --git a/cc/quads/draw_quad.cc b/cc/quads/draw_quad.cc
index 8b8fd78..ac1b43e 100644
--- a/cc/quads/draw_quad.cc
+++ b/cc/quads/draw_quad.cc
@@ -25,9 +25,7 @@
 namespace cc {
 
 DrawQuad::DrawQuad()
-    : material(INVALID),
-      needs_blending(false),
-      shared_quad_state() {
+    : material(INVALID), needs_blending(false), shared_quad_state(0) {
 }
 
 void DrawQuad::SetAll(const SharedQuadState* shared_quad_state,
diff --git a/cc/resources/layer_quad.cc b/cc/resources/layer_quad.cc
index 38ec7b3..ba92314 100644
--- a/cc/resources/layer_quad.cc
+++ b/cc/resources/layer_quad.cc
@@ -10,8 +10,11 @@
 namespace cc {
 
 LayerQuad::Edge::Edge(const gfx::PointF& p, const gfx::PointF& q) {
-  DCHECK(p != q);
-
+  if (p == q) {
+    degenerate_ = true;
+    return;
+  }
+  degenerate_ = false;
   gfx::Vector2dF tangent(p.y() - q.y(), q.x() - p.x());
   float cross2 = p.x() * q.y() - q.x() * p.y();
 
@@ -43,6 +46,22 @@ LayerQuad::LayerQuad(const Edge& left,
       bottom_(bottom) {}
 
 gfx::QuadF LayerQuad::ToQuadF() const {
+  if (left_.degenerate()) {
+    return gfx::QuadF(top_.Intersect(bottom_), top_.Intersect(right_),
+                      right_.Intersect(bottom_), bottom_.Intersect(top_));
+  }
+  if (right_.degenerate()) {
+    return gfx::QuadF(left_.Intersect(top_), top_.Intersect(bottom_),
+                      bottom_.Intersect(top_), bottom_.Intersect(left_));
+  }
+  if (top_.degenerate()) {
+    return gfx::QuadF(left_.Intersect(right_), right_.Intersect(left_),
+                      right_.Intersect(bottom_), bottom_.Intersect(left_));
+  }
+  if (bottom_.degenerate()) {
+    return gfx::QuadF(left_.Intersect(top_), top_.Intersect(right_),
+                      right_.Intersect(left_), left_.Intersect(right_));
+  }
   return gfx::QuadF(left_.Intersect(top_),
                     top_.Intersect(right_),
                     right_.Intersect(bottom_),
@@ -50,18 +69,42 @@ gfx::QuadF LayerQuad::ToQuadF() const {
 }
 
 void LayerQuad::ToFloatArray(float flattened[12]) const {
-  flattened[0] = left_.x();
-  flattened[1] = left_.y();
-  flattened[2] = left_.z();
-  flattened[3] = top_.x();
-  flattened[4] = top_.y();
-  flattened[5] = top_.z();
-  flattened[6] = right_.x();
-  flattened[7] = right_.y();
-  flattened[8] = right_.z();
-  flattened[9] = bottom_.x();
-  flattened[10] = bottom_.y();
-  flattened[11] = bottom_.z();
+  if (left_.degenerate()) {
+    flattened[0] = bottom_.x();
+    flattened[1] = bottom_.y();
+    flattened[2] = bottom_.z();
+  } else {
+    flattened[0] = left_.x();
+    flattened[1] = left_.y();
+    flattened[2] = left_.z();
+  }
+  if (top_.degenerate()) {
+    flattened[3] = left_.x();
+    flattened[4] = left_.y();
+    flattened[5] = left_.z();
+  } else {
+    flattened[3] = top_.x();
+    flattened[4] = top_.y();
+    flattened[5] = top_.z();
+  }
+  if (right_.degenerate()) {
+    flattened[6] = top_.x();
+    flattened[7] = top_.y();
+    flattened[8] = top_.z();
+  } else {
+    flattened[6] = right_.x();
+    flattened[7] = right_.y();
+    flattened[8] = right_.z();
+  }
+  if (bottom_.degenerate()) {
+    flattened[9] = right_.x();
+    flattened[10] = right_.y();
+    flattened[11] = right_.z();
+  } else {
+    flattened[9] = bottom_.x();
+    flattened[10] = bottom_.y();
+    flattened[11] = bottom_.z();
+  }
 }
 
 }  // namespace cc
diff --git a/cc/resources/layer_quad.h b/cc/resources/layer_quad.h
index ed1db10..7433645 100644
--- a/cc/resources/layer_quad.h
+++ b/cc/resources/layer_quad.h
@@ -22,7 +22,7 @@ class CC_EXPORT LayerQuad {
  public:
   class Edge {
    public:
-    Edge() : x_(0), y_(0), z_(0) {}
+    Edge() : x_(0), y_(0), z_(0), degenerate_(false) {}
     Edge(const gfx::PointF& p, const gfx::PointF& q);
 
     float x() const { return x_; }
@@ -57,6 +57,8 @@ class CC_EXPORT LayerQuad {
     }
     void scale(float s) { scale(s, s, s); }
 
+    bool degenerate() const { return degenerate_; }
+
     gfx::PointF Intersect(const Edge& e) const {
       return gfx::PointF(
           (y() * e.z() - e.y() * z()) / (x() * e.y() - e.x() * y()),
@@ -67,6 +69,7 @@ class CC_EXPORT LayerQuad {
     float x_;
     float y_;
     float z_;
+    bool degenerate_;
   };
 
   LayerQuad(const Edge& left,
diff --git a/cc/test/data/anti_aliasing.png b/cc/test/data/anti_aliasing.png
index 4abe9e1..eba7436 100644
--- a/cc/test/data/anti_aliasing.png
+++ b/cc/test/data/anti_aliasing.png
diff --git a/cc/test/data/background_filter_blur_off_axis.png b/cc/test/data/background_filter_blur_off_axis.png
index 5077171..5e9a0c2 100644
--- a/cc/test/data/background_filter_blur_off_axis.png
+++ b/cc/test/data/background_filter_blur_off_axis.png
diff --git a/cc/test/data/intersecting_blue_green.png b/cc/test/data/intersecting_blue_green.png
new file mode 100644
index 0000000..8262071
--- /dev/null
+++ b/cc/test/data/intersecting_blue_green.png
diff --git a/cc/test/data/intersecting_blue_green_squares.png b/cc/test/data/intersecting_blue_green_squares.png
new file mode 100644
index 0000000..22da4d3
--- /dev/null
+++ b/cc/test/data/intersecting_blue_green_squares.png
diff --git a/cc/test/data/intersecting_blue_green_squares_video.png b/cc/test/data/intersecting_blue_green_squares_video.png
new file mode 100644
index 0000000..e1bea4f
--- /dev/null
+++ b/cc/test/data/intersecting_blue_green_squares_video.png
diff --git a/cc/trees/layer_sorter.cc b/cc/trees/layer_sorter.cc
deleted file mode 100644
index bde4920..0000000
--- a/cc/trees/layer_sorter.cc
+++ /dev/null
@@ -1,470 +0,0 @@
-// Copyright 2011 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/trees/layer_sorter.h"
-
-#include <algorithm>
-#include <deque>
-#include <limits>
-#include <vector>
-
-#include "base/logging.h"
-#include "cc/base/math_util.h"
-#include "cc/layers/render_surface_impl.h"
-#include "ui/gfx/transform.h"
-
-namespace cc {
-
-// This epsilon is used to determine if two layers are too close to each other
-// to be able to tell which is in front of the other.  It's a relative epsilon
-// so it is robust to changes in scene scale.  This value was chosen by picking
-// a value near machine epsilon and then increasing it until the flickering on
-// the test scene went away.
-const float k_layer_epsilon = 1e-4f;
-
-inline static float PerpProduct(const gfx::Vector2dF& u,
-                                const gfx::Vector2dF& v) {
-  return u.x() * v.y() - u.y() * v.x();
-}
-
-// Tests if two edges defined by their endpoints (a,b) and (c,d) intersect.
-// Returns true and the point of intersection if they do and false otherwise.
-static bool EdgeEdgeTest(const gfx::PointF& a,
-                         const gfx::PointF& b,
-                         const gfx::PointF& c,
-                         const gfx::PointF& d,
-                         gfx::PointF* r) {
-  gfx::Vector2dF u = b - a;
-  gfx::Vector2dF v = d - c;
-  gfx::Vector2dF w = a - c;
-
-  float denom = PerpProduct(u, v);
-
-  // If denom == 0 then the edges are parallel. While they could be overlapping
-  // we don't bother to check here as the we'll find their intersections from
-  // the corner to quad tests.
-  if (!denom)
-    return false;
-
-  float s = PerpProduct(v, w) / denom;
-  if (s < 0.f || s > 1.f)
-    return false;
-
-  float t = PerpProduct(u, w) / denom;
-  if (t < 0.f || t > 1.f)
-    return false;
-
-  u.Scale(s);
-  *r = a + u;
-  return true;
-}
-
-GraphNode::GraphNode(LayerImpl* layer_impl)
-    : layer(layer_impl),
-      incoming_edge_weight(0.f) {}
-
-GraphNode::~GraphNode() {}
-
-LayerSorter::LayerSorter()
-    : z_range_(0.f) {}
-
-LayerSorter::~LayerSorter() {}
-
-static float CheckFloatingPointNumericAccuracy(float a, float b) {
-  float abs_dif = std::abs(b - a);
-  float abs_max = std::max(std::abs(b), std::abs(a));
-  // Check to see if we've got a result with a reasonable amount of error.
-  return abs_dif / abs_max;
-}
-
-// Checks whether layer "a" draws on top of layer "b". The weight value returned
-// is an indication of the maximum z-depth difference between the layers or zero
-// if the layers are found to be intesecting (some features are in front and
-// some are behind).
-LayerSorter::ABCompareResult LayerSorter::CheckOverlap(LayerShape* a,
-                                                       LayerShape* b,
-                                                       float z_threshold,
-                                                       float* weight) {
-  *weight = 0.f;
-
-  // Early out if the projected bounds don't overlap.
-  if (!a->projected_bounds.Intersects(b->projected_bounds))
-    return NONE;
-
-  gfx::PointF aPoints[4] = { a->projected_quad.p1(),
-                             a->projected_quad.p2(),
-                             a->projected_quad.p3(),
-                             a->projected_quad.p4() };
-  gfx::PointF bPoints[4] = { b->projected_quad.p1(),
-                             b->projected_quad.p2(),
-                             b->projected_quad.p3(),
-                             b->projected_quad.p4() };
-
-  // Make a list of points that inside both layer quad projections.
-  std::vector<gfx::PointF> overlap_points;
-
-  // Check all four corners of one layer against the other layer's quad.
-  for (int i = 0; i < 4; ++i) {
-    if (a->projected_quad.Contains(bPoints[i]))
-      overlap_points.push_back(bPoints[i]);
-    if (b->projected_quad.Contains(aPoints[i]))
-      overlap_points.push_back(aPoints[i]);
-  }
-
-  // Check all the edges of one layer for intersection with the other layer's
-  // edges.
-  gfx::PointF r;
-  for (int ea = 0; ea < 4; ++ea)
-    for (int eb = 0; eb < 4; ++eb)
-      if (EdgeEdgeTest(aPoints[ea], aPoints[(ea + 1) % 4],
-                       bPoints[eb], bPoints[(eb + 1) % 4],
-                       &r))
-        overlap_points.push_back(r);
-
-  if (overlap_points.empty())
-    return NONE;
-
-  // Check the corresponding layer depth value for all overlap points to
-  // determine which layer is in front.
-  float max_positive = 0.f;
-  float max_negative = 0.f;
-
-  // This flag tracks the existance of a numerically accurate seperation
-  // between two layers.  If there is no accurate seperation, the layers
-  // cannot be effectively sorted.
-  bool accurate = false;
-
-  for (size_t o = 0; o < overlap_points.size(); o++) {
-    float za = a->LayerZFromProjectedPoint(overlap_points[o]);
-    float zb = b->LayerZFromProjectedPoint(overlap_points[o]);
-
-    // Here we attempt to avoid numeric issues with layers that are too
-    // close together.  If we have 2-sided quads that are very close
-    // together then we will draw them in document order to avoid
-    // flickering.  The correct solution is for the content maker to turn
-    // on back-face culling or move the quads apart (if they're not two
-    // sides of one object).
-    if (CheckFloatingPointNumericAccuracy(za, zb) > k_layer_epsilon)
-      accurate = true;
-
-    float diff = za - zb;
-    if (diff > max_positive)
-      max_positive = diff;
-    if (diff < max_negative)
-      max_negative = diff;
-  }
-
-  // If we can't tell which should come first, we use document order.
-  if (!accurate)
-    return A_BEFORE_B;
-
-  float max_diff =
-      std::abs(max_positive) > std::abs(max_negative) ?
-          max_positive : max_negative;
-
-  // If the results are inconsistent (and the z difference substantial to rule
-  // out numerical errors) then the layers are intersecting. We will still
-  // return an order based on the maximum depth difference but with an edge
-  // weight of zero these layers will get priority if a graph cycle is present
-  // and needs to be broken.
-  if (max_positive > z_threshold && max_negative < -z_threshold)
-    *weight = 0.f;
-  else
-    *weight = std::abs(max_diff);
-
-  // Maintain relative order if the layers have the same depth at all
-  // intersection points.
-  if (max_diff <= 0.f)
-    return A_BEFORE_B;
-
-  return B_BEFORE_A;
-}
-
-LayerShape::LayerShape() {}
-
-LayerShape::LayerShape(float width,
-                       float height,
-                       const gfx::Transform& draw_transform) {
-  gfx::QuadF layer_quad(gfx::RectF(0.f, 0.f, width, height));
-
-  // Compute the projection of the layer quad onto the z = 0 plane.
-
-  gfx::PointF clipped_quad[8];
-  int num_vertices_in_clipped_quad;
-  MathUtil::MapClippedQuad(draw_transform,
-                           layer_quad,
-                           clipped_quad,
-                           &num_vertices_in_clipped_quad);
-
-  if (num_vertices_in_clipped_quad < 3) {
-    projected_bounds = gfx::RectF();
-    return;
-  }
-
-  projected_bounds =
-      MathUtil::ComputeEnclosingRectOfVertices(clipped_quad,
-                                               num_vertices_in_clipped_quad);
-
-  // NOTE: it will require very significant refactoring and overhead to deal
-  // with generalized polygons or multiple quads per layer here. For the sake of
-  // layer sorting it is equally correct to take a subsection of the polygon
-  // that can be made into a quad. This will only be incorrect in the case of
-  // intersecting layers, which are not supported yet anyway.
-  projected_quad.set_p1(clipped_quad[0]);
-  projected_quad.set_p2(clipped_quad[1]);
-  projected_quad.set_p3(clipped_quad[2]);
-  if (num_vertices_in_clipped_quad >= 4) {
-    projected_quad.set_p4(clipped_quad[3]);
-  } else {
-    // This will be a degenerate quad that is actually a triangle.
-    projected_quad.set_p4(clipped_quad[2]);
-  }
-
-  // Compute the normal of the layer's plane.
-  bool clipped = false;
-  gfx::Point3F c1 =
-      MathUtil::MapPoint(draw_transform, gfx::Point3F(0.f, 0.f, 0.f), &clipped);
-  gfx::Point3F c2 =
-      MathUtil::MapPoint(draw_transform, gfx::Point3F(0.f, 1.f, 0.f), &clipped);
-  gfx::Point3F c3 =
-      MathUtil::MapPoint(draw_transform, gfx::Point3F(1.f, 0.f, 0.f), &clipped);
-  // TODO(shawnsingh): Deal with clipping.
-  gfx::Vector3dF c12 = c2 - c1;
-  gfx::Vector3dF c13 = c3 - c1;
-  layer_normal = gfx::CrossProduct(c13, c12);
-
-  transform_origin = c1;
-}
-
-LayerShape::~LayerShape() {}
-
-// Returns the Z coordinate of a point on the layer that projects
-// to point p which lies on the z = 0 plane. It does it by computing the
-// intersection of a line starting from p along the Z axis and the plane
-// of the layer.
-float LayerShape::LayerZFromProjectedPoint(const gfx::PointF& p) const {
-  gfx::Vector3dF z_axis(0.f, 0.f, 1.f);
-  gfx::Vector3dF w = gfx::Point3F(p) - transform_origin;
-
-  float d = gfx::DotProduct(layer_normal, z_axis);
-  float n = -gfx::DotProduct(layer_normal, w);
-
-  // Check if layer is parallel to the z = 0 axis which will make it
-  // invisible and hence returning zero is fine.
-  if (!d)
-    return 0.f;
-
-  // The intersection point would be given by:
-  // p + (n / d) * u  but since we are only interested in the
-  // z coordinate and p's z coord is zero, all we need is the value of n/d.
-  return n / d;
-}
-
-void LayerSorter::CreateGraphNodes(LayerImplList::iterator first,
-                                   LayerImplList::iterator last) {
-  DVLOG(2) << "Creating graph nodes:";
-  float min_z = FLT_MAX;
-  float max_z = -FLT_MAX;
-  for (LayerImplList::const_iterator it = first; it < last; it++) {
-    nodes_.push_back(GraphNode(*it));
-    GraphNode& node = nodes_.at(nodes_.size() - 1);
-    RenderSurfaceImpl* render_surface = node.layer->render_surface();
-    if (!node.layer->DrawsContent() && !render_surface)
-      continue;
-
-    DVLOG(2) << "Layer " << node.layer->id() <<
-        " (" << node.layer->bounds().width() <<
-        " x " << node.layer->bounds().height() << ")";
-
-    gfx::Transform draw_transform;
-    float layer_width, layer_height;
-    if (render_surface) {
-      draw_transform = render_surface->draw_transform();
-      layer_width = render_surface->content_rect().width();
-      layer_height = render_surface->content_rect().height();
-    } else {
-      draw_transform = node.layer->draw_transform();
-      layer_width = node.layer->content_bounds().width();
-      layer_height = node.layer->content_bounds().height();
-    }
-
-    node.shape = LayerShape(layer_width, layer_height, draw_transform);
-
-    max_z = std::max(max_z, node.shape.transform_origin.z());
-    min_z = std::min(min_z, node.shape.transform_origin.z());
-  }
-
-  z_range_ = std::abs(max_z - min_z);
-}
-
-void LayerSorter::CreateGraphEdges() {
-  DVLOG(2) << "Edges:";
-  // Fraction of the total z_range below which z differences
-  // are not considered reliable.
-  const float z_threshold_factor = 0.01f;
-  float z_threshold = z_range_ * z_threshold_factor;
-
-  for (size_t na = 0; na < nodes_.size(); na++) {
-    GraphNode& node_a = nodes_[na];
-    if (!node_a.layer->DrawsContent() && !node_a.layer->render_surface())
-      continue;
-    for (size_t nb = na + 1; nb < nodes_.size(); nb++) {
-      GraphNode& node_b = nodes_[nb];
-      if (!node_b.layer->DrawsContent() && !node_b.layer->render_surface())
-        continue;
-      float weight = 0.f;
-      ABCompareResult overlap_result = CheckOverlap(&node_a.shape,
-                                                    &node_b.shape,
-                                                    z_threshold,
-                                                    &weight);
-      GraphNode* start_node = NULL;
-      GraphNode* end_node = NULL;
-      if (overlap_result == A_BEFORE_B) {
-        start_node = &node_a;
-        end_node = &node_b;
-      } else if (overlap_result == B_BEFORE_A) {
-        start_node = &node_b;
-        end_node = &node_a;
-      }
-
-      if (start_node) {
-        DVLOG(2) << start_node->layer->id() << " -> " << end_node->layer->id();
-        edges_.push_back(GraphEdge(start_node, end_node, weight));
-      }
-    }
-  }
-
-  for (size_t i = 0; i < edges_.size(); i++) {
-    GraphEdge& edge = edges_[i];
-    active_edges_[&edge] = &edge;
-    edge.from->outgoing.push_back(&edge);
-    edge.to->incoming.push_back(&edge);
-    edge.to->incoming_edge_weight += edge.weight;
-  }
-}
-
-// Finds and removes an edge from the list by doing a swap with the
-// last element of the list.
-void LayerSorter::RemoveEdgeFromList(GraphEdge* edge,
-                                     std::vector<GraphEdge*>* list) {
-  std::vector<GraphEdge*>::iterator iter =
-      std::find(list->begin(), list->end(), edge);
-  DCHECK(iter != list->end());
-  list->erase(iter);
-}
-
-// Sorts the given list of layers such that they can be painted in a
-// back-to-front order. Sorting produces correct results for non-intersecting
-// layers that don't have cyclical order dependencies. Cycles and intersections
-// are broken (somewhat) aribtrarily. Sorting of layers is done via a
-// topological sort of a directed graph whose nodes are the layers themselves.
-// An edge from node A to node B signifies that layer A needs to be drawn before
-// layer B. If A and B have no dependency between each other, then we preserve
-// the ordering of those layers as they were in the original list.
-//
-// The draw order between two layers is determined by projecting the two
-// triangles making up each layer quad to the Z = 0 plane, finding points of
-// intersection between the triangles and backprojecting those points to the
-// plane of the layer to determine the corresponding Z coordinate. The layer
-// with the lower Z coordinate (farther from the eye) needs to be rendered
-// first.
-//
-// If the layer projections don't intersect, then no edges (dependencies) are
-// created between them in the graph. HOWEVER, in this case we still need to
-// preserve the ordering of the original list of layers, since that list should
-// already have proper z-index ordering of layers.
-//
-void LayerSorter::Sort(LayerImplList::iterator first,
-                       LayerImplList::iterator last) {
-  DVLOG(2) << "Sorting start ----";
-  CreateGraphNodes(first, last);
-
-  CreateGraphEdges();
-
-  std::vector<GraphNode*> sorted_list;
-  std::deque<GraphNode*> no_incoming_edge_node_list;
-
-  // Find all the nodes that don't have incoming edges.
-  for (NodeList::iterator la = nodes_.begin(); la < nodes_.end(); la++) {
-    if (!la->incoming.size())
-      no_incoming_edge_node_list.push_back(&(*la));
-  }
-
-  DVLOG(2) << "Sorted list: ";
-  while (active_edges_.size() || no_incoming_edge_node_list.size()) {
-    while (no_incoming_edge_node_list.size()) {
-      // It is necessary to preserve the existing ordering of layers, when there
-      // are no explicit dependencies (because this existing ordering has
-      // correct z-index/layout ordering). To preserve this ordering, we process
-      // Nodes in the same order that they were added to the list.
-      GraphNode* from_node = no_incoming_edge_node_list.front();
-      no_incoming_edge_node_list.pop_front();
-
-      // Add it to the final list.
-      sorted_list.push_back(from_node);
-
-      DVLOG(2) << from_node->layer->id() << ", ";
-
-      // Remove all its outgoing edges from the graph.
-      for (size_t i = 0; i < from_node->outgoing.size(); i++) {
-        GraphEdge* outgoing_edge = from_node->outgoing[i];
-
-        active_edges_.erase(outgoing_edge);
-        RemoveEdgeFromList(outgoing_edge, &outgoing_edge->to->incoming);
-        outgoing_edge->to->incoming_edge_weight -= outgoing_edge->weight;
-
-        if (!outgoing_edge->to->incoming.size())
-          no_incoming_edge_node_list.push_back(outgoing_edge->to);
-      }
-      from_node->outgoing.clear();
-    }
-
-    if (!active_edges_.size())
-      break;
-
-    // If there are still active edges but the list of nodes without incoming
-    // edges is empty then we have run into a cycle. Break the cycle by finding
-    // the node with the smallest overall incoming edge weight and use it. This
-    // will favor nodes that have zero-weight incoming edges i.e. layers that
-    // are being occluded by a layer that intersects them.
-    float min_incoming_edge_weight = FLT_MAX;
-    GraphNode* next_node = NULL;
-    for (size_t i = 0; i < nodes_.size(); i++) {
-      if (nodes_[i].incoming.size() &&
-          nodes_[i].incoming_edge_weight < min_incoming_edge_weight) {
-        min_incoming_edge_weight = nodes_[i].incoming_edge_weight;
-        next_node = &nodes_[i];
-      }
-    }
-    DCHECK(next_node);
-    // Remove all its incoming edges.
-    for (size_t e = 0; e < next_node->incoming.size(); e++) {
-      GraphEdge* incoming_edge = next_node->incoming[e];
-
-      active_edges_.erase(incoming_edge);
-      RemoveEdgeFromList(incoming_edge, &incoming_edge->from->outgoing);
-    }
-    next_node->incoming.clear();
-    next_node->incoming_edge_weight = 0.f;
-    no_incoming_edge_node_list.push_back(next_node);
-    DVLOG(2) << "Breaking cycle by cleaning up incoming edges from " <<
-        next_node->layer->id() <<
-        " (weight = " << min_incoming_edge_weight << ")";
-  }
-
-  // Note: The original elements of the list are in no danger of having their
-  // ref count go to zero here as they are all nodes of the layer hierarchy and
-  // are kept alive by their parent nodes.
-  int count = 0;
-  for (LayerImplList::iterator it = first; it < last; it++)
-    *it = sorted_list[count++]->layer;
-
-  DVLOG(2) << "Sorting end ----";
-
-  nodes_.clear();
-  edges_.clear();
-  active_edges_.clear();
-}
-
-}  // namespace cc
diff --git a/cc/trees/layer_sorter.h b/cc/trees/layer_sorter.h
deleted file mode 100644
index 4cfa8fe..0000000
--- a/cc/trees/layer_sorter.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright 2011 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.
-
-#ifndef CC_TREES_LAYER_SORTER_H_
-#define CC_TREES_LAYER_SORTER_H_
-
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/containers/hash_tables.h"
-#include "cc/base/cc_export.h"
-#include "cc/layers/layer_impl.h"
-#include "ui/gfx/geometry/point3_f.h"
-#include "ui/gfx/geometry/quad_f.h"
-#include "ui/gfx/geometry/rect_f.h"
-#include "ui/gfx/geometry/vector3d_f.h"
-
-namespace gfx {
-class Transform;
-}
-
-namespace cc {
-struct GraphEdge;
-
-// Holds various useful properties derived from a layer's 3D outline.
-struct CC_EXPORT LayerShape {
-  LayerShape();
-  LayerShape(float width, float height, const gfx::Transform& draw_transform);
-  ~LayerShape();
-
-  float LayerZFromProjectedPoint(const gfx::PointF& p) const;
-
-  gfx::Vector3dF layer_normal;
-  gfx::Point3F transform_origin;
-  gfx::QuadF projected_quad;
-  gfx::RectF projected_bounds;
-};
-
-struct GraphNode {
-  explicit GraphNode(LayerImpl* layer_impl);
-  ~GraphNode();
-
-  LayerImpl* layer;
-  LayerShape shape;
-  std::vector<GraphEdge*> incoming;
-  std::vector<GraphEdge*> outgoing;
-  float incoming_edge_weight;
-};
-
-struct GraphEdge {
-  GraphEdge(GraphNode* from_node, GraphNode* to_node, float weight)
-      : from(from_node),
-        to(to_node),
-        weight(weight) {}
-
-  GraphNode* from;
-  GraphNode* to;
-  float weight;
-};
-
-
-
-class CC_EXPORT LayerSorter {
- public:
-  LayerSorter();
-  ~LayerSorter();
-
-  void Sort(LayerImplList::iterator first, LayerImplList::iterator last);
-
-  enum ABCompareResult { A_BEFORE_B, B_BEFORE_A, NONE };
-
-  static ABCompareResult CheckOverlap(LayerShape* a,
-                                      LayerShape* b,
-                                      float z_threshold,
-                                      float* weight);
-
- private:
-  typedef std::vector<GraphNode> NodeList;
-  typedef std::vector<GraphEdge> EdgeList;
-  NodeList nodes_;
-  EdgeList edges_;
-  float z_range_;
-
-  typedef base::hash_map<GraphEdge*, GraphEdge*> EdgeMap;
-  EdgeMap active_edges_;
-
-  void CreateGraphNodes(LayerImplList::iterator first,
-                        LayerImplList::iterator last);
-  void CreateGraphEdges();
-  void RemoveEdgeFromList(GraphEdge* graph, std::vector<GraphEdge*>* list);
-
-  DISALLOW_COPY_AND_ASSIGN(LayerSorter);
-};
-
-}  // namespace cc
-#endif  // CC_TREES_LAYER_SORTER_H_
diff --git a/cc/trees/layer_sorter_unittest.cc b/cc/trees/layer_sorter_unittest.cc
deleted file mode 100644
index 74d3cf5..0000000
--- a/cc/trees/layer_sorter_unittest.cc
+++ /dev/null
@@ -1,329 +0,0 @@
-// Copyright 2011 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/trees/layer_sorter.h"
-
-#include "cc/base/math_util.h"
-#include "cc/layers/layer_impl.h"
-#include "cc/test/fake_impl_proxy.h"
-#include "cc/test/fake_layer_tree_host_impl.h"
-#include "cc/test/test_shared_bitmap_manager.h"
-#include "cc/trees/single_thread_proxy.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "ui/gfx/transform.h"
-
-namespace cc {
-namespace {
-
-// Note: In the following overlap tests, the "camera" is looking down the
-// negative Z axis, meaning that layers with smaller z values (more negative)
-// are further from the camera and therefore must be drawn before layers with
-// higher z values.
-
-TEST(LayerSorterTest, BasicOverlap) {
-  LayerSorter::ABCompareResult overlap_result;
-  const float z_threshold = 0.1f;
-  float weight = 0.f;
-
-  // Trivial test, with one layer directly obscuring the other.
-  gfx::Transform neg4_translate;
-  neg4_translate.Translate3d(0.0, 0.0, -4.0);
-  LayerShape front(2.f, 2.f, neg4_translate);
-
-  gfx::Transform neg5_translate;
-  neg5_translate.Translate3d(0.0, 0.0, -5.0);
-  LayerShape back(2.f, 2.f, neg5_translate);
-
-  overlap_result =
-      LayerSorter::CheckOverlap(&front, &back, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::B_BEFORE_A, overlap_result);
-  EXPECT_EQ(1.f, weight);
-
-  overlap_result =
-      LayerSorter::CheckOverlap(&back, &front, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result);
-  EXPECT_EQ(1.f, weight);
-
-  // One layer translated off to the right. No overlap should be detected.
-  gfx::Transform right_translate;
-  right_translate.Translate3d(10.0, 0.0, -5.0);
-  LayerShape back_right(2.f, 2.f, right_translate);
-  overlap_result =
-      LayerSorter::CheckOverlap(&front, &back_right, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::NONE, overlap_result);
-
-  // When comparing a layer with itself, z difference is always 0.
-  overlap_result =
-      LayerSorter::CheckOverlap(&front, &front, z_threshold, &weight);
-  EXPECT_EQ(0.f, weight);
-}
-
-TEST(LayerSorterTest, RightAngleOverlap) {
-  LayerSorter::ABCompareResult overlap_result;
-  const float z_threshold = 0.1f;
-  float weight = 0.f;
-
-  gfx::Transform perspective_matrix;
-  perspective_matrix.ApplyPerspectiveDepth(1000.0);
-
-  // Two layers forming a right angle with a perspective viewing transform.
-  gfx::Transform left_face_matrix;
-  left_face_matrix.Translate3d(-1.0, 0.0, -5.0);
-  left_face_matrix.RotateAboutYAxis(-90.0);
-  left_face_matrix.Translate(-1.0, -1.0);
-  LayerShape left_face(2.f, 2.f, perspective_matrix * left_face_matrix);
-  gfx::Transform front_face_matrix;
-  front_face_matrix.Translate3d(0.0, 0.0, -4.0);
-  front_face_matrix.Translate(-1.0, -1.0);
-  LayerShape front_face(2.f, 2.f, perspective_matrix * front_face_matrix);
-
-  overlap_result =
-      LayerSorter::CheckOverlap(&front_face, &left_face, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::B_BEFORE_A, overlap_result);
-}
-
-TEST(LayerSorterTest, IntersectingLayerOverlap) {
-  LayerSorter::ABCompareResult overlap_result;
-  const float z_threshold = 0.1f;
-  float weight = 0.f;
-
-  gfx::Transform perspective_matrix;
-  perspective_matrix.ApplyPerspectiveDepth(1000.0);
-
-  // Intersecting layers. An explicit order will be returned based on relative z
-  // values at the overlapping features but the weight returned should be zero.
-  gfx::Transform front_face_matrix;
-  front_face_matrix.Translate3d(0.0, 0.0, -4.0);
-  front_face_matrix.Translate(-1.0, -1.0);
-  LayerShape front_face(2.f, 2.f, perspective_matrix * front_face_matrix);
-
-  gfx::Transform through_matrix;
-  through_matrix.Translate3d(0.0, 0.0, -4.0);
-  through_matrix.RotateAboutYAxis(45.0);
-  through_matrix.Translate(-1.0, -1.0);
-  LayerShape rotated_face(2.f, 2.f, perspective_matrix * through_matrix);
-  overlap_result = LayerSorter::CheckOverlap(&front_face,
-                                             &rotated_face,
-                                             z_threshold,
-                                             &weight);
-  EXPECT_NE(LayerSorter::NONE, overlap_result);
-  EXPECT_EQ(0.f, weight);
-}
-
-TEST(LayerSorterTest, LayersAtAngleOverlap) {
-  LayerSorter::ABCompareResult overlap_result;
-  const float z_threshold = 0.1f;
-  float weight = 0.f;
-
-  // Trickier test with layers at an angle.
-  //
-  //   -x . . . . 0 . . . . +x
-  // -z             /
-  //  :            /----B----
-  //  0           C
-  //  : ----A----/
-  // +z         /
-  //
-  // C is in front of A and behind B (not what you'd expect by comparing
-  // centers). A and B don't overlap, so they're incomparable.
-
-  gfx::Transform transform_a;
-  transform_a.Translate3d(-6.0, 0.0, 1.0);
-  transform_a.Translate(-4.0, -10.0);
-  LayerShape layer_a(8.f, 20.f, transform_a);
-
-  gfx::Transform transform_b;
-  transform_b.Translate3d(6.0, 0.0, -1.0);
-  transform_b.Translate(-4.0, -10.0);
-  LayerShape layer_b(8.f, 20.f, transform_b);
-
-  gfx::Transform transform_c;
-  transform_c.RotateAboutYAxis(40.0);
-  transform_c.Translate(-4.0, -10.0);
-  LayerShape layer_c(8.f, 20.f, transform_c);
-
-  overlap_result =
-      LayerSorter::CheckOverlap(&layer_a, &layer_c, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result);
-  overlap_result =
-      LayerSorter::CheckOverlap(&layer_c, &layer_b, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result);
-  overlap_result =
-      LayerSorter::CheckOverlap(&layer_a, &layer_b, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::NONE, overlap_result);
-}
-
-TEST(LayerSorterTest, LayersUnderPathologicalPerspectiveTransform) {
-  LayerSorter::ABCompareResult overlap_result;
-  const float z_threshold = 0.1f;
-  float weight = 0.f;
-
-  // On perspective projection, if w becomes negative, the re-projected point
-  // will be invalid and un-usable. Correct code needs to clip away portions of
-  // the geometry where w < 0. If the code uses the invalid value, it will think
-  // that a layer has different bounds than it really does, which can cause
-  // things to sort incorrectly.
-
-  gfx::Transform perspective_matrix;
-  perspective_matrix.ApplyPerspectiveDepth(1);
-
-  gfx::Transform transform_a;
-  transform_a.Translate3d(-15.0, 0.0, -2.0);
-  transform_a.Translate(-5.0, -5.0);
-  LayerShape layer_a(10.f, 10.f, perspective_matrix * transform_a);
-
-  // With this sequence of transforms, when layer B is correctly clipped, it
-  // will be visible on the left half of the projection plane, in front of
-  // layer_a. When it is not clipped, its bounds will actually incorrectly
-  // appear much smaller and the correct sorting dependency will not be found.
-  gfx::Transform transform_b;
-  transform_b.Translate3d(0.f, 0.f, 0.7f);
-  transform_b.RotateAboutYAxis(45.0);
-  transform_b.Translate(-5.0, -5.0);
-  LayerShape layer_b(10.f, 10.f, perspective_matrix * transform_b);
-
-  // Sanity check that the test case actually covers the intended scenario,
-  // where part of layer B go behind the w = 0 plane.
-  gfx::QuadF test_quad = gfx::QuadF(gfx::RectF(-0.5f, -0.5f, 1.f, 1.f));
-  bool clipped = false;
-  MathUtil::MapQuad(perspective_matrix * transform_b, test_quad, &clipped);
-  ASSERT_TRUE(clipped);
-
-  overlap_result =
-      LayerSorter::CheckOverlap(&layer_a, &layer_b, z_threshold, &weight);
-  EXPECT_EQ(LayerSorter::A_BEFORE_B, overlap_result);
-}
-
-TEST(LayerSorterTest, VerifyExistingOrderingPreservedWhenNoZDiff) {
-  // If there is no reason to re-sort the layers (i.e. no 3d z difference), then
-  // the existing ordering provided on input should be retained. This test
-  // covers the fix in https://bugs.webkit.org/show_bug.cgi?id=75046. Before
-  // this fix, ordering was accidentally reversed, causing bugs in z-index
-  // ordering on websites when preserves3D triggered the LayerSorter.
-
-  // Input list of layers: [1, 2, 3, 4, 5].
-  // Expected output: [3, 4, 1, 2, 5].
-  //    - 1, 2, and 5 do not have a 3d z difference, and therefore their
-  //      relative ordering should be retained.
-  //    - 3 and 4 do not have a 3d z difference, and therefore their relative
-  //      ordering should be retained.
-  //    - 3 and 4 should be re-sorted so they are in front of 1, 2, and 5.
-
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-
-  scoped_ptr<LayerImpl> layer1 = LayerImpl::Create(host_impl.active_tree(), 1);
-  scoped_ptr<LayerImpl> layer2 = LayerImpl::Create(host_impl.active_tree(), 2);
-  scoped_ptr<LayerImpl> layer3 = LayerImpl::Create(host_impl.active_tree(), 3);
-  scoped_ptr<LayerImpl> layer4 = LayerImpl::Create(host_impl.active_tree(), 4);
-  scoped_ptr<LayerImpl> layer5 = LayerImpl::Create(host_impl.active_tree(), 5);
-
-  gfx::Transform BehindMatrix;
-  BehindMatrix.Translate3d(0.0, 0.0, 2.0);
-  gfx::Transform FrontMatrix;
-  FrontMatrix.Translate3d(0.0, 0.0, 1.0);
-
-  layer1->SetBounds(gfx::Size(10, 10));
-  layer1->SetContentBounds(gfx::Size(10, 10));
-  layer1->draw_properties().target_space_transform = BehindMatrix;
-  layer1->SetDrawsContent(true);
-
-  layer2->SetBounds(gfx::Size(20, 20));
-  layer2->SetContentBounds(gfx::Size(20, 20));
-  layer2->draw_properties().target_space_transform = BehindMatrix;
-  layer2->SetDrawsContent(true);
-
-  layer3->SetBounds(gfx::Size(30, 30));
-  layer3->SetContentBounds(gfx::Size(30, 30));
-  layer3->draw_properties().target_space_transform = FrontMatrix;
-  layer3->SetDrawsContent(true);
-
-  layer4->SetBounds(gfx::Size(40, 40));
-  layer4->SetContentBounds(gfx::Size(40, 40));
-  layer4->draw_properties().target_space_transform = FrontMatrix;
-  layer4->SetDrawsContent(true);
-
-  layer5->SetBounds(gfx::Size(50, 50));
-  layer5->SetContentBounds(gfx::Size(50, 50));
-  layer5->draw_properties().target_space_transform = BehindMatrix;
-  layer5->SetDrawsContent(true);
-
-  LayerImplList layer_list;
-  layer_list.push_back(layer1.get());
-  layer_list.push_back(layer2.get());
-  layer_list.push_back(layer3.get());
-  layer_list.push_back(layer4.get());
-  layer_list.push_back(layer5.get());
-
-  ASSERT_EQ(5u, layer_list.size());
-  EXPECT_EQ(1, layer_list[0]->id());
-  EXPECT_EQ(2, layer_list[1]->id());
-  EXPECT_EQ(3, layer_list[2]->id());
-  EXPECT_EQ(4, layer_list[3]->id());
-  EXPECT_EQ(5, layer_list[4]->id());
-
-  LayerSorter layer_sorter;
-  layer_sorter.Sort(layer_list.begin(), layer_list.end());
-
-  ASSERT_EQ(5u, layer_list.size());
-  EXPECT_EQ(3, layer_list[0]->id());
-  EXPECT_EQ(4, layer_list[1]->id());
-  EXPECT_EQ(1, layer_list[2]->id());
-  EXPECT_EQ(2, layer_list[3]->id());
-  EXPECT_EQ(5, layer_list[4]->id());
-}
-
-TEST(LayerSorterTest, VerifyConcidentLayerPrecisionLossResultsInDocumentOrder) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-
-  scoped_ptr<LayerImpl> layer1 = LayerImpl::Create(host_impl.active_tree(), 1);
-  scoped_ptr<LayerImpl> layer2 = LayerImpl::Create(host_impl.active_tree(), 2);
-
-  // Layer 1 should occur before layer 2 in paint.  However, due to numeric
-  // issues in the sorter, it will put the layers in the wrong order
-  // in some situations.  Here we test a patch that results in  document
-  // order rather than calculated order when numeric percision is suspect
-  // in calculated order.
-
-  gfx::Transform BehindMatrix;
-  BehindMatrix.Translate3d(0.f, 0.f, 0.999999f);
-  BehindMatrix.RotateAboutXAxis(38.5);
-  BehindMatrix.RotateAboutYAxis(77.0);
-  gfx::Transform FrontMatrix;
-  FrontMatrix.Translate3d(0, 0, 1.0);
-  FrontMatrix.RotateAboutXAxis(38.5);
-  FrontMatrix.RotateAboutYAxis(77.0);
-
-  layer1->SetBounds(gfx::Size(10, 10));
-  layer1->SetContentBounds(gfx::Size(10, 10));
-  layer1->draw_properties().target_space_transform = BehindMatrix;
-  layer1->SetDrawsContent(true);
-
-  layer2->SetBounds(gfx::Size(10, 10));
-  layer2->SetContentBounds(gfx::Size(10, 10));
-  layer2->draw_properties().target_space_transform = FrontMatrix;
-  layer2->SetDrawsContent(true);
-
-  LayerImplList layer_list;
-  layer_list.push_back(layer1.get());
-  layer_list.push_back(layer2.get());
-
-  ASSERT_EQ(2u, layer_list.size());
-  EXPECT_EQ(1, layer_list[0]->id());
-  EXPECT_EQ(2, layer_list[1]->id());
-
-  LayerSorter layer_sorter;
-  layer_sorter.Sort(layer_list.begin(), layer_list.end());
-
-  ASSERT_EQ(2u, layer_list.size());
-  EXPECT_EQ(1, layer_list[0]->id());
-  EXPECT_EQ(2, layer_list[1]->id());
-}
-
-}  // namespace
-}  // namespace cc
-
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index f4c2029..e47ef0d 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -15,7 +15,6 @@
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/trees/draw_property_utils.h"
-#include "cc/trees/layer_sorter.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ -31,20 +30,6 @@ ScrollAndScaleSet::ScrollAndScaleSet()
 
 ScrollAndScaleSet::~ScrollAndScaleSet() {}
 
-static void SortLayers(LayerList::iterator first,
-                       LayerList::iterator end,
-                       void* layer_sorter) {
-  NOTREACHED();
-}
-
-static void SortLayers(LayerImplList::iterator first,
-                       LayerImplList::iterator end,
-                       LayerSorter* layer_sorter) {
-  DCHECK(layer_sorter);
-  TRACE_EVENT0("cc", "LayerTreeHostCommon::SortLayers");
-  layer_sorter->Sort(first, end);
-}
-
 template <typename LayerType>
 static gfx::Vector2dF GetEffectiveScrollDelta(LayerType* layer) {
   // Layer's scroll offset can have an integer part and fractional part.
@@ -1281,7 +1266,6 @@ static void PreCalculateMetaInformation(
 
 template <typename LayerType>
 struct SubtreeGlobals {
-  LayerSorter* layer_sorter;
   int max_texture_size;
   float device_scale_factor;
   float page_scale_factor;
@@ -2369,17 +2353,6 @@ static void CalculateDrawPropertiesInternal(
     return;
   }
 
-  // If preserves-3d then sort all the descendants in 3D so that they can be
-  // drawn from back to front. If the preserves-3d property is also set on the
-  // parent then skip the sorting as the parent will sort all the descendants
-  // anyway.
-  if (globals.layer_sorter && descendants.size() && layer->Is3dSorted() &&
-      !LayerIsInExisting3DRenderingContext(layer)) {
-    SortLayers(descendants.begin() + sorting_start_index,
-               descendants.end(),
-               globals.layer_sorter);
-  }
-
   UpdateAccumulatedSurfaceState<LayerType>(
       layer, local_drawable_content_rect_of_subtree, accumulated_surface_state);
 
@@ -2417,7 +2390,6 @@ static void ProcessCalcDrawPropsInputs(
   scaled_device_transform.Scale(inputs.device_scale_factor,
                                 inputs.device_scale_factor);
 
-  globals->layer_sorter = NULL;
   globals->max_texture_size = inputs.max_texture_size;
   globals->device_scale_factor =
       inputs.device_scale_factor * device_transform_scale;
@@ -2581,9 +2553,6 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   DataForRecursion<LayerImpl> data_for_recursion;
   ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
 
-  LayerSorter layer_sorter;
-  globals.layer_sorter = &layer_sorter;
-
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
   std::vector<AccumulatedSurfaceState<LayerImpl>> accumulated_surface_state;
diff --git a/cc/trees/layer_tree_host_common_perftest.cc b/cc/trees/layer_tree_host_common_perftest.cc
index 73d5c1d..1732e5588 100644
--- a/cc/trees/layer_tree_host_common_perftest.cc
+++ b/cc/trees/layer_tree_host_common_perftest.cc
@@ -25,7 +25,6 @@
 #include "cc/test/layer_tree_json_parser.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/paths.h"
-#include "cc/trees/layer_sorter.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/perf/perf_test.h"
 
@@ -162,55 +161,7 @@ class CalcDrawPropsImplTest : public LayerTreeHostCommonPerfTest {
   }
 };
 
-class LayerSorterMainTest : public CalcDrawPropsImplTest {
- public:
-  void RunSortLayers() { RunTest(false, false, false); }
-
-  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
-
-  void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
-    LayerTreeImpl* active_tree = host_impl->active_tree();
-    // First build the tree and then we'll start running tests on layersorter
-    // itself
-    bool can_render_to_separate_surface = true;
-    int max_texture_size = 8096;
-    DoCalcDrawPropertiesImpl(can_render_to_separate_surface,
-                             max_texture_size,
-                             active_tree,
-                             host_impl);
-
-    // Behaviour of this test is different from that of sorting in practice.
-    // In this case, all layers that exist in any 3D context are put into a list
-    // and are sorted as one big 3D context instead of several smaller ones.
-    BuildLayerImplList(active_tree->root_layer(), &base_list_);
-    timer_.Reset();
-    do {
-      // Here we'll move the layers into a LayerImpl list of their own to be
-      // sorted so we don't have a sorted list for every run after the first
-      LayerImplList test_list = base_list_;
-      layer_sorter_.Sort(test_list.begin(), test_list.end());
-      timer_.NextLap();
-    } while (!timer_.HasTimeLimitExpired());
-
-    EndTest();
-  }
-
-  void BuildLayerImplList(LayerImpl* layer, LayerImplList* list) {
-    if (layer->Is3dSorted()) {
-      list->push_back(layer);
-    }
-
-    for (size_t i = 0; i < layer->children().size(); i++) {
-      BuildLayerImplList(layer->children()[i], list);
-    }
-  }
-
- private:
-  LayerImplList base_list_;
-  LayerSorter layer_sorter_;
-};
-
-class BspTreePerfTest : public LayerSorterMainTest {
+class BspTreePerfTest : public CalcDrawPropsImplTest {
  public:
   void RunSortLayers() { RunTest(false, false, false); }
 
@@ -261,7 +212,18 @@ class BspTreePerfTest : public LayerSorterMainTest {
     EndTest();
   }
 
+  void BuildLayerImplList(LayerImpl* layer, LayerImplList* list) {
+    if (layer->Is3dSorted()) {
+      list->push_back(layer);
+    }
+
+    for (size_t i = 0; i < layer->children().size(); i++) {
+      BuildLayerImplList(layer->children()[i], list);
+    }
+  }
+
  private:
+  LayerImplList base_list_;
   int num_duplicates_;
 };
 
@@ -313,13 +275,13 @@ TEST_F(CalcDrawPropsImplTest, TouchRegionHeavy) {
   RunCalcDrawProps();
 }
 
-TEST_F(LayerSorterMainTest, LayerSorterCubes) {
+TEST_F(BspTreePerfTest, LayerSorterCubes) {
   SetTestName("layer_sort_cubes");
   ReadTestFile("layer_sort_cubes");
   RunSortLayers();
 }
 
-TEST_F(LayerSorterMainTest, LayerSorterRubik) {
+TEST_F(BspTreePerfTest, LayerSorterRubik) {
   SetTestName("layer_sort_rubik");
   ReadTestFile("layer_sort_rubik");
   // TODO(vollick): Remove verify_property_trees setting after
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 0a51ccc..7bd0634 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -2975,78 +2975,6 @@ TEST_F(LayerTreeHostCommonTest,
   EXPECT_FALSE(child->draw_properties().sorted_for_recursion);
 }
 
-TEST_F(LayerTreeHostCommonTest, WillSortAtContextBoundary) {
-  // Creates a layer tree that looks as follows:
-  // * root (sorting-context-id1)
-  //   * parent (sorting-context-id2)
-  //     * child1 (sorting-context-id2)
-  //     * child2 (sorting-context-id2)
-  //
-  // This test ensures that we sort at |parent| even though both it and root are
-  // set to be 3d sorted.
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-
-  scoped_ptr<LayerImpl> root_ptr(LayerImpl::Create(host_impl.active_tree(), 1));
-  LayerImpl* root = root_ptr.get();
-  scoped_ptr<LayerImpl> parent_ptr(
-      LayerImpl::Create(host_impl.active_tree(), 2));
-  LayerImpl* parent = parent_ptr.get();
-  scoped_ptr<LayerImpl> child1_ptr(
-      LayerImpl::Create(host_impl.active_tree(), 3));
-  LayerImpl* child1 = child1_ptr.get();
-  scoped_ptr<LayerImpl> child2_ptr(
-      LayerImpl::Create(host_impl.active_tree(), 4));
-  LayerImpl* child2 = child2_ptr.get();
-
-  gfx::Transform identity_matrix;
-  gfx::Transform below_matrix;
-  below_matrix.Translate3d(0.f, 0.f, -10.f);
-  gfx::Transform above_matrix;
-  above_matrix.Translate3d(0.f, 0.f, 10.f);
-
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, true,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, true,
-                               true);
-  SetLayerPropertiesForTesting(child1, above_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, true,
-                               false);
-  SetLayerPropertiesForTesting(child2, below_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, true,
-                               false);
-
-  root->Set3dSortingContextId(3);
-  root->SetDrawsContent(true);
-  parent->Set3dSortingContextId(7);
-  parent->SetDrawsContent(true);
-  child1->Set3dSortingContextId(7);
-  child1->SetDrawsContent(true);
-  child2->Set3dSortingContextId(7);
-  child2->SetDrawsContent(true);
-
-  parent->AddChild(child1_ptr.Pass());
-  parent->AddChild(child2_ptr.Pass());
-  root->AddChild(parent_ptr.Pass());
-
-  LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_ptr.get(), root->bounds(), &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-  EXPECT_TRUE(root->render_surface());
-  EXPECT_EQ(2u, render_surface_layer_list.size());
-
-  EXPECT_EQ(3u, parent->render_surface()->layer_list().size());
-  EXPECT_EQ(child2->id(), parent->render_surface()->layer_list().at(0)->id());
-  EXPECT_EQ(parent->id(), parent->render_surface()->layer_list().at(1)->id());
-  EXPECT_EQ(child1->id(), parent->render_surface()->layer_list().at(2)->id());
-}
-
 TEST_F(LayerTreeHostCommonTest,
        SingularNonAnimatingTransformDoesNotPreventClearingDrawProperties) {
   scoped_refptr<Layer> root = Layer::Create();
@@ -7592,110 +7520,6 @@ TEST_F(LayerTreeHostCommonTest, OutOfOrderClippingRequiresRSLLSorting) {
   EXPECT_TRUE(render_surface_layer_list.at(2)->render_surface());
 }
 
-TEST_F(LayerTreeHostCommonTest, DoNotClobberSorting) {
-  // We rearrange layer list contributions if we have to visit children out of
-  // order, but it should be a 'stable' rearrangement. That is, the layer list
-  // additions for a single layer should not be reordered, though their position
-  // wrt to the contributions due to a sibling may vary.
-  //
-  // + root
-  //   + scroll_child
-  //     + top_content
-  //     + bottom_content
-  //   + scroll_parent_border
-  //     + scroll_parent_clip
-  //       + scroll_parent
-  //
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  host_impl.CreatePendingTree();
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
-  scoped_ptr<LayerImpl> scroll_parent_border =
-      LayerImpl::Create(host_impl.active_tree(), 2);
-  scoped_ptr<LayerImpl> scroll_parent_clip =
-      LayerImpl::Create(host_impl.active_tree(), 3);
-  scoped_ptr<LayerImpl> scroll_parent =
-      LayerImpl::Create(host_impl.active_tree(), 4);
-  scoped_ptr<LayerImpl> scroll_child =
-      LayerImpl::Create(host_impl.active_tree(), 5);
-  scoped_ptr<LayerImpl> bottom_content =
-      LayerImpl::Create(host_impl.active_tree(), 6);
-  scoped_ptr<LayerImpl> top_content =
-      LayerImpl::Create(host_impl.active_tree(), 7);
-
-  scroll_parent_clip->SetMasksToBounds(true);
-
-  scroll_child->SetScrollParent(scroll_parent.get());
-  scoped_ptr<std::set<LayerImpl*>> scroll_children(new std::set<LayerImpl*>);
-  scroll_children->insert(scroll_child.get());
-  scroll_parent->SetScrollChildren(scroll_children.release());
-
-  scroll_child->SetDrawsContent(true);
-  scroll_parent->SetDrawsContent(true);
-  top_content->SetDrawsContent(true);
-  bottom_content->SetDrawsContent(true);
-
-  gfx::Transform identity_transform;
-  gfx::Transform top_transform;
-  top_transform.Translate3d(0.0, 0.0, 5.0);
-  gfx::Transform bottom_transform;
-  bottom_transform.Translate3d(0.0, 0.0, 3.0);
-
-  SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(scroll_parent_border.get(), identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent_clip.get(), identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent.get(), identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_child.get(), identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, false);
-  SetLayerPropertiesForTesting(top_content.get(), top_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), false, true,
-                               true);
-  SetLayerPropertiesForTesting(bottom_content.get(), bottom_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               false, true, true);
-
-  scroll_child->SetShouldFlattenTransform(false);
-  scroll_child->Set3dSortingContextId(1);
-
-  scroll_child->AddChild(top_content.Pass());
-  scroll_child->AddChild(bottom_content.Pass());
-  root->AddChild(scroll_child.Pass());
-
-  scroll_parent_clip->AddChild(scroll_parent.Pass());
-  scroll_parent_border->AddChild(scroll_parent_clip.Pass());
-  root->AddChild(scroll_parent_border.Pass());
-
-  LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
-
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-  EXPECT_TRUE(root->render_surface());
-
-  // If we don't sort by depth and let the layers get added in the order they
-  // would normally be visited in, then layers 6 and 7 will be out of order. In
-  // other words, although we've had to shift 5, 6, and 7 to appear before 4
-  // in the list (because of the scroll parent relationship), this should not
-  // have an effect on the the order of 5, 6, and 7 (which had been reordered
-  // due to layer sorting).
-  EXPECT_EQ(4u, root->render_surface()->layer_list().size());
-  EXPECT_EQ(5, root->render_surface()->layer_list().at(0)->id());
-  EXPECT_EQ(6, root->render_surface()->layer_list().at(1)->id());
-  EXPECT_EQ(7, root->render_surface()->layer_list().at(2)->id());
-  EXPECT_EQ(4, root->render_surface()->layer_list().at(3)->id());
-}
-
 TEST_F(LayerTreeHostCommonTest, ScrollCompensationWithRounding) {
   // This test verifies that a scrolling layer that gets snapped to
   // integer coordinates doesn't move a fixed position child.
diff --git a/cc/trees/layer_tree_host_pixeltest_filters.cc b/cc/trees/layer_tree_host_pixeltest_filters.cc
index 76acaa8..dd3cf73 100644
--- a/cc/trees/layer_tree_host_pixeltest_filters.cc
+++ b/cc/trees/layer_tree_host_pixeltest_filters.cc
@@ -97,8 +97,8 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOutsets) {
 }
 
 TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOffAxis) {
-  scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
-      gfx::Rect(200, 200), SK_ColorWHITE);
+  scoped_refptr<SolidColorLayer> background =
+      CreateSolidColorLayer(gfx::Rect(200, 200), SK_ColorTRANSPARENT);
 
   // This verifies that the perspective of the clear layer (with black border)
   // does not influence the blending of the green box behind it. Also verifies
diff --git a/cc/trees/layer_tree_impl_unittest.cc b/cc/trees/layer_tree_impl_unittest.cc
index 67f98e65..06df3c2 100644
--- a/cc/trees/layer_tree_impl_unittest.cc
+++ b/cc/trees/layer_tree_impl_unittest.cc
@@ -920,14 +920,6 @@ TEST_F(LayerTreeImplTest, HitTestingForMultipleLayersAtVaryingDepths) {
   ASSERT_TRUE(grand_child1);
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 
-  RenderSurfaceImpl* root_render_surface =
-      host_impl().active_tree()->root_layer()->render_surface();
-  ASSERT_EQ(4u, root_render_surface->layer_list().size());
-  ASSERT_EQ(3, root_render_surface->layer_list().at(0)->id());
-  ASSERT_EQ(1, root_render_surface->layer_list().at(1)->id());
-  ASSERT_EQ(2, root_render_surface->layer_list().at(2)->id());
-  ASSERT_EQ(4, root_render_surface->layer_list().at(3)->id());
-
   // Nothing overlaps the root_layer at (1, 1), so hit testing there should find
   // the root layer.
   gfx::Point test_point = gfx::Point(1, 1);
diff --git a/cc/trees/occlusion_tracker.cc b/cc/trees/occlusion_tracker.cc
index 388eb6e..0f0ce15 100644
--- a/cc/trees/occlusion_tracker.cc
+++ b/cc/trees/occlusion_tracker.cc
@@ -155,7 +155,7 @@ static inline bool LayerIsInUnsorted3dRenderingContext(const Layer* layer) {
   return layer->Is3dSorted();
 }
 static inline bool LayerIsInUnsorted3dRenderingContext(const LayerImpl* layer) {
-  return false;
+  return layer->Is3dSorted();
 }
 
 template <typename LayerType>
diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc
index e3639ad..f3f2185 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc
@@ -1540,56 +1540,6 @@ class OcclusionTrackerTestLayerBehindCameraDoesNotOcclude
   }
 };
 
-// This test requires accumulating occlusion of 3d layers, which are skipped by
-// the occlusion tracker on the main thread. So this test should run on the impl
-// thread.
-IMPL_THREAD_TEST(OcclusionTrackerTestLayerBehindCameraDoesNotOcclude);
-
-template <class Types>
-class OcclusionTrackerTestLargePixelsOccludeInsideClipRect
-    : public OcclusionTrackerTest<Types> {
- protected:
-  explicit OcclusionTrackerTestLargePixelsOccludeInsideClipRect(
-      bool opaque_layers)
-      : OcclusionTrackerTest<Types>(opaque_layers) {}
-  void RunMyTest() override {
-    gfx::Transform transform;
-    transform.Translate(50.0, 50.0);
-    transform.ApplyPerspectiveDepth(100.0);
-    transform.Translate3d(0.0, 0.0, 99.0);
-    transform.Translate(-50.0, -50.0);
-
-    typename Types::ContentLayerType* parent = this->CreateRoot(
-        this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
-    parent->SetMasksToBounds(true);
-    typename Types::ContentLayerType* layer = this->CreateDrawingLayer(
-        parent, transform, gfx::PointF(), gfx::Size(100, 100), true);
-    parent->SetShouldFlattenTransform(false);
-    parent->Set3dSortingContextId(1);
-    layer->SetShouldFlattenTransform(false);
-    layer->Set3dSortingContextId(1);
-    this->CalcDrawEtc(parent);
-
-    TestOcclusionTrackerWithClip<typename Types::LayerType> occlusion(
-        gfx::Rect(0, 0, 1000, 1000));
-
-    // This is very close to the camera, so pixels in its visible_content_rect()
-    // will actually go outside of the layer's clip rect.  Ensure that those
-    // pixels don't occlude things outside the clip rect.
-    this->VisitLayer(layer, &occlusion);
-    this->EnterLayer(parent, &occlusion);
-    EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
-              occlusion.occlusion_from_inside_target().ToString());
-    EXPECT_EQ(gfx::Rect().ToString(),
-              occlusion.occlusion_from_outside_target().ToString());
-  }
-};
-
-// This test requires accumulating occlusion of 3d layers, which are skipped by
-// the occlusion tracker on the main thread. So this test should run on the impl
-// thread.
-IMPL_THREAD_TEST(OcclusionTrackerTestLargePixelsOccludeInsideClipRect);
-
 template <class Types>
 class OcclusionTrackerTestAnimationOpacity1OnMainThread
     : public OcclusionTrackerTest<Types> {
diff --git a/ui/gfx/geometry/quad_f.h b/ui/gfx/geometry/quad_f.h
index ada5c54..d795064 100644
--- a/ui/gfx/geometry/quad_f.h
+++ b/ui/gfx/geometry/quad_f.h
@@ -10,6 +10,7 @@
 #include <iosfwd>
 #include <string>
 
+#include "base/logging.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/gfx_export.h"
@@ -67,6 +68,18 @@ class GFX_EXPORT QuadF {
     return RectF(rl, rt, rr - rl, rb - rt);
   }
 
+  // Realigns the corners in the quad by rotating them n corners to the right.
+  void Realign(size_t times) {
+    DCHECK_LE(times, 4u);
+    for (size_t i = 0; i < times; ++i) {
+      PointF temp = p1_;
+      p1_ = p2_;
+      p2_ = p3_;
+      p3_ = p4_;
+      p4_ = temp;
+    }
+  }
+
   // Add a vector to the quad, offseting each point in the quad by the vector.
   void operator+=(const Vector2dF& rhs);
   // Subtract a vector from the quad, offseting each point in the quad by the
diff --git a/ui/gfx/skia_util.cc b/ui/gfx/skia_util.cc
index 63827e3..ef07241 100644
--- a/ui/gfx/skia_util.cc
+++ b/ui/gfx/skia_util.cc
@@ -11,6 +11,7 @@
 #include "third_party/skia/include/effects/SkBlurMaskFilter.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "third_party/skia/include/effects/SkLayerDrawLooper.h"
+#include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/image/image_skia_rep.h"
@@ -199,4 +200,11 @@ void ConvertSkiaToRGBA(const unsigned char* skia,
   }
 }
 
+void QuadFToSkPoints(const gfx::QuadF& quad, SkPoint points[4]) {
+  points[0] = SkPoint::Make(quad.p1().x(), quad.p1().y());
+  points[1] = SkPoint::Make(quad.p2().x(), quad.p2().y());
+  points[2] = SkPoint::Make(quad.p3().x(), quad.p3().y());
+  points[3] = SkPoint::Make(quad.p4().x(), quad.p4().y());
+}
+
 }  // namespace gfx
diff --git a/ui/gfx/skia_util.h b/ui/gfx/skia_util.h
index 303044d..44c9a09 100644
--- a/ui/gfx/skia_util.h
+++ b/ui/gfx/skia_util.h
@@ -12,6 +12,7 @@
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkShader.h"
+#include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gfx_export.h"
 
@@ -35,6 +36,8 @@ GFX_EXPORT RectF SkRectToRectF(const SkRect& rect);
 GFX_EXPORT SkSize SizeFToSkSize(const SizeF& size);
 GFX_EXPORT SizeF SkSizeToSizeF(const SkSize& size);
 
+GFX_EXPORT void QuadFToSkPoints(const gfx::QuadF& quad, SkPoint points[4]);
+
 GFX_EXPORT void TransformToFlattenedSkMatrix(const gfx::Transform& transform,
                                              SkMatrix* flattened);