cc: Don't draw and swap if the frame will not change.

cc/trees/layer_tree_host_impl_unittest.cc

 // 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_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 206 matching lines @@
     layer->SetBounds(size);
     layer->SetContentBounds(size);
     layer->SetMaxScrollOffset(gfx::Vector2d(size.width() * 2,
                                             size.height() * 2));
     return layer.Pass();
   }
 
   void InitializeRendererAndDrawFrame() {
     host_impl_->InitializeRenderer(CreateOutputSurface());
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
   void pinch_zoom_pan_viewport_forces_commit_redraw(float device_scale_factor);
   void pinch_zoom_pan_viewport_test(float device_scale_factor);
   void pinch_zoom_pan_viewport_and_scroll_test(float device_scale_factor);
   void pinch_zoom_pan_viewport_and_scroll_boundary_test(
       float device_scale_factor);
 
  protected:
   virtual scoped_ptr<OutputSurface> CreateOutputSurface() {
     return CreateFakeOutputSurface();
   }
 
   void DrawOneFrame() {
     LayerTreeHostImpl::FrameData frame_data;
-    host_impl_->PrepareToDraw(&frame_data);
+    host_impl_->PrepareToDraw(&frame_data, gfx::Rect());
     host_impl_->DidDrawAllLayers(frame_data);
   }
 
   FakeProxy proxy_;
   DebugScopedSetImplThread always_impl_thread_;
   DebugScopedSetMainThreadBlocked always_main_thread_blocked_;
 
   scoped_ptr<LayerTreeHostImpl> host_impl_;
   FakeRenderingStatsInstrumentation stats_instrumentation_;
   bool on_can_draw_state_changed_called_;
@@ skipping 795 matching lines @@
   // Ensure visible_content_rect for layer is empty.
   layer->SetPosition(gfx::PointF(100.f, 100.f));
   layer->SetBounds(gfx::Size(10, 10));
   layer->SetContentBounds(gfx::Size(10, 10));
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
 
   EXPECT_TRUE(layer->visible_content_rect().IsEmpty());
 
   // Ensure visible_content_rect for layer is not empty
   layer->SetPosition(gfx::PointF());
 
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_TRUE(layer->will_draw_called());
   EXPECT_TRUE(layer->did_draw_called());
 
   EXPECT_FALSE(layer->visible_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) {
@@ skipping 18 matching lines @@
   top_layer->SetContentBounds(big_size);
   top_layer->SetContentsOpaque(true);
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_FALSE(occluded_layer->will_draw_called());
   EXPECT_FALSE(occluded_layer->did_draw_called());
   EXPECT_FALSE(top_layer->will_draw_called());
   EXPECT_FALSE(top_layer->did_draw_called());
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_FALSE(occluded_layer->will_draw_called());
   EXPECT_FALSE(occluded_layer->did_draw_called());
   EXPECT_TRUE(top_layer->will_draw_called());
   EXPECT_TRUE(top_layer->did_draw_called());
 }
 
 TEST_F(LayerTreeHostImplTest, DidDrawCalledOnAllLayers) {
@@ skipping 11 matching lines @@
       static_cast<DidDrawCheckLayer*>(layer1->children()[0]);
 
   layer1->SetOpacity(0.3f);
   layer1->SetPreserves3d(false);
 
   EXPECT_FALSE(root->did_draw_called());
   EXPECT_FALSE(layer1->did_draw_called());
   EXPECT_FALSE(layer2->did_draw_called());
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_TRUE(root->did_draw_called());
   EXPECT_TRUE(layer1->did_draw_called());
   EXPECT_TRUE(layer2->did_draw_called());
 
   EXPECT_NE(root->render_surface(), layer1->render_surface());
   EXPECT_TRUE(!!layer1->render_surface());
 }
@@ skipping 51 matching lines @@
   root->AddChild(
       MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
                                            2,
                                            false,
                                            false,
                                            true,
                                            host_impl_->resource_provider()));
 
   LayerTreeHostImpl::FrameData frame;
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 
   // When a texture is missing and we're not animating, we draw as usual with
   // checkerboarding.
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
   root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   root->AddChild(
       MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
                                            4,
                                            true,
                                            false,
                                            false,
                                            host_impl_->resource_provider()));
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 
   // When a texture is missing and we're animating, we don't want to draw
   // anything.
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 5));
   root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   root->AddChild(
       MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
                                            6,
                                            true,
                                            false,
                                            true,
                                            host_impl_->resource_provider()));
 
-  EXPECT_FALSE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_FALSE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 
   // When the layer skips draw and we're animating, we still draw the frame.
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 7));
   root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   root->AddChild(
       MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
                                            8,
                                            false,
                                            true,
                                            true,
                                            host_impl_->resource_provider()));
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootIgnored) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetScrollable(false);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   InitializeRendererAndDrawFrame();
 
@@ skipping 18 matching lines @@
 
   gfx::Size layer_size(5, 5);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetScrollable(true);
   root->SetMaxScrollOffset(gfx::Vector2d(layer_size.width(),
                                          layer_size.height()));
   root->SetBounds(layer_size);
   root->SetContentBounds(layer_size);
   root->SetPosition(gfx::PointF());
   root->SetAnchorPoint(gfx::PointF());
+  root->SetDrawsContent(false);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->FindRootScrollLayer();
   InitializeRendererAndDrawFrame();
 
   EXPECT_EQ(InputHandlerClient::ScrollIgnored,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Gesture));
 
   host_impl_->top_controls_manager()->ScrollBegin();
   host_impl_->top_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 50.f));
   host_impl_->top_controls_manager()->ScrollEnd();
@@ skipping 282 matching lines @@
   DrawOneFrame();
 
   // The page scale delta should only be applied to the scrollable root layer.
   EXPECT_EQ(root->impl_transform(), new_page_scale_matrix);
   EXPECT_EQ(child->impl_transform(), default_page_scale_matrix);
   EXPECT_EQ(grand_child->impl_transform(), default_page_scale_matrix);
 
   // Make sure all the layers are drawn with the page scale delta applied, i.e.,
   // the page scale delta on the root layer is applied hierarchically.
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_EQ(new_page_scale, root->draw_transform().matrix().getDouble(0, 0));
   EXPECT_EQ(new_page_scale, root->draw_transform().matrix().getDouble(1, 1));
   EXPECT_EQ(new_page_scale, child->draw_transform().matrix().getDouble(0, 0));
   EXPECT_EQ(new_page_scale, child->draw_transform().matrix().getDouble(1, 1));
   EXPECT_EQ(new_page_scale,
             grand_child->draw_transform().matrix().getDouble(0, 0));
   EXPECT_EQ(new_page_scale,
@@ skipping 515 matching lines @@
                                    host_impl_->resource_provider()));
   BlendStateCheckLayer* layer1 =
       static_cast<BlendStateCheckLayer*>(root->children()[0]);
   layer1->SetPosition(gfx::PointF(2.f, 2.f));
 
   LayerTreeHostImpl::FrameData frame;
 
   // Opaque layer, drawn without blending.
   layer1->SetContentsOpaque(true);
   layer1->SetExpectation(false, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with translucent content and painting, so drawn with blending.
   layer1->SetContentsOpaque(false);
   layer1->SetExpectation(true, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with translucent opacity, drawn with blending.
   layer1->SetContentsOpaque(true);
   layer1->SetOpacity(0.5f);
   layer1->SetExpectation(true, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with translucent opacity and painting, drawn with blending.
   layer1->SetContentsOpaque(true);
   layer1->SetOpacity(0.5f);
   layer1->SetExpectation(true, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   layer1->AddChild(
       BlendStateCheckLayer::Create(host_impl_->active_tree(),
                                    3,
                                    host_impl_->resource_provider()));
   BlendStateCheckLayer* layer2 =
       static_cast<BlendStateCheckLayer*>(layer1->children()[0]);
   layer2->SetPosition(gfx::PointF(4.f, 4.f));
 
   // 2 opaque layers, drawn without blending.
   layer1->SetContentsOpaque(true);
   layer1->SetOpacity(1.f);
   layer1->SetExpectation(false, false);
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
   layer2->SetContentsOpaque(true);
   layer2->SetOpacity(1.f);
   layer2->SetExpectation(false, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer2->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Parent layer with translucent content, drawn with blending.
   // Child layer with opaque content, drawn without blending.
   layer1->SetContentsOpaque(false);
   layer1->SetExpectation(true, false);
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
   layer2->SetExpectation(false, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer2->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Parent layer with translucent content but opaque painting, drawn without
   // blending.
   // Child layer with opaque content, drawn without blending.
   layer1->SetContentsOpaque(true);
   layer1->SetExpectation(false, false);
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
   layer2->SetExpectation(false, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer2->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Parent layer with translucent opacity and opaque content. Since it has a
   // drawing child, it's drawn to a render surface which carries the opacity,
   // so it's itself drawn without blending.
   // Child layer with opaque content, drawn without blending (parent surface
   // carries the inherited opacity).
   layer1->SetContentsOpaque(true);
   layer1->SetOpacity(0.5f);
   layer1->SetExpectation(false, true);
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
   layer2->SetExpectation(false, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer2->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Draw again, but with child non-opaque, to make sure
   // layer1 not culled.
   layer1->SetContentsOpaque(true);
   layer1->SetOpacity(1.f);
   layer1->SetExpectation(false, false);
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
   layer2->SetContentsOpaque(true);
   layer2->SetOpacity(0.5f);
   layer2->SetExpectation(true, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer2->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // A second way of making the child non-opaque.
   layer1->SetContentsOpaque(true);
   layer1->SetOpacity(1.f);
   layer1->SetExpectation(false, false);
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
   layer2->SetContentsOpaque(false);
   layer2->SetOpacity(1.f);
   layer2->SetExpectation(true, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer2->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // And when the layer says its not opaque but is painted opaque, it is not
   // blended.
   layer1->SetContentsOpaque(true);
   layer1->SetOpacity(1.f);
   layer1->SetExpectation(false, false);
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
   layer2->SetContentsOpaque(true);
   layer2->SetOpacity(1.f);
   layer2->SetExpectation(false, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer2->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with partially opaque contents, drawn with blending.
   layer1->SetContentsOpaque(false);
   layer1->SetQuadRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetQuadVisibleRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(true, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with partially opaque contents partially culled, drawn with blending.
   layer1->SetContentsOpaque(false);
   layer1->SetQuadRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetQuadVisibleRect(gfx::Rect(5, 5, 5, 2));
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(true, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with partially opaque contents culled, drawn with blending.
   layer1->SetContentsOpaque(false);
   layer1->SetQuadRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetQuadVisibleRect(gfx::Rect(7, 5, 3, 5));
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(true, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
   // Layer with partially opaque contents and translucent contents culled, drawn
   // without blending.
   layer1->SetContentsOpaque(false);
   layer1->SetQuadRect(gfx::Rect(5, 5, 5, 5));
   layer1->SetQuadVisibleRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(false, false);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  layer1->set_update_rect(gfx::RectF(layer1->content_bounds()));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, ViewportCovered) {
   host_impl_->InitializeRenderer(CreateOutputSurface());
   host_impl_->active_tree()->set_background_color(SK_ColorGRAY);
 
   gfx::Size viewport_size(1000, 1000);
@@ skipping 13 matching lines @@
   // No gutter rects
   {
     gfx::Rect layer_rect(0, 0, 1000, 1000);
     child->SetPosition(layer_rect.origin());
     child->SetBounds(layer_rect.size());
     child->SetContentBounds(layer_rect.size());
     child->SetQuadRect(gfx::Rect(layer_rect.size()));
     child->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     size_t num_gutter_quads = 0;
     for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
       num_gutter_quads += (frame.render_passes[0]->quad_list[i]->material ==
                            DrawQuad::SOLID_COLOR) ? 1 : 0;
     EXPECT_EQ(0u, num_gutter_quads);
     EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(
         frame.render_passes[0]->quad_list, gfx::Rect(viewport_size));
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Empty visible content area (fullscreen gutter rect)
   {
     gfx::Rect layer_rect(0, 0, 0, 0);
     child->SetPosition(layer_rect.origin());
     child->SetBounds(layer_rect.size());
     child->SetContentBounds(layer_rect.size());
     child->SetQuadRect(gfx::Rect(layer_rect.size()));
     child->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     size_t num_gutter_quads = 0;
     for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
       num_gutter_quads += (frame.render_passes[0]->quad_list[i]->material ==
                            DrawQuad::SOLID_COLOR) ? 1 : 0;
     EXPECT_EQ(1u, num_gutter_quads);
     EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(
         frame.render_passes[0]->quad_list, gfx::Rect(viewport_size));
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Content area in middle of clip rect (four surrounding gutter rects)
   {
     gfx::Rect layer_rect(500, 500, 200, 200);
     child->SetPosition(layer_rect.origin());
     child->SetBounds(layer_rect.size());
     child->SetContentBounds(layer_rect.size());
     child->SetQuadRect(gfx::Rect(layer_rect.size()));
     child->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     size_t num_gutter_quads = 0;
     for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
       num_gutter_quads += (frame.render_passes[0]->quad_list[i]->material ==
                            DrawQuad::SOLID_COLOR) ? 1 : 0;
     EXPECT_EQ(4u, num_gutter_quads);
     EXPECT_EQ(5u, frame.render_passes[0]->quad_list.size());
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(
@@ skipping 35 matching lines @@
       scoped_ptr<WebKit::WebGraphicsContext3D>(new ReshapeTrackerContext))
       .PassAs<OutputSurface>();
   ReshapeTrackerContext* reshape_tracker =
       static_cast<ReshapeTrackerContext*>(output_surface->context3d());
   host_impl_->InitializeRenderer(output_surface.Pass());
 
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetAnchorPoint(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
+  root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   EXPECT_FALSE(reshape_tracker->reshape_called());
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(reshape_tracker->reshape_called());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 class PartialSwapTrackerContext : public TestWebGraphicsContext3D {
  public:
   virtual void postSubBufferCHROMIUM(int x, int y, int width, int height)
       OVERRIDE {
     partial_swap_rect_ = gfx::Rect(x, y, width, height);
@@ skipping 48 matching lines @@
   root->SetAnchorPoint(gfx::PointF());
   root->SetBounds(gfx::Size(500, 500));
   root->SetContentBounds(gfx::Size(500, 500));
   root->SetDrawsContent(true);
   root->AddChild(child.Pass());
   layer_tree_host_impl->active_tree()->SetRootLayer(root.Pass());
 
   LayerTreeHostImpl::FrameData frame;
 
   // First frame, the entire screen should get swapped.
-  EXPECT_TRUE(layer_tree_host_impl->PrepareToDraw(&frame));
+  EXPECT_TRUE(layer_tree_host_impl->PrepareToDraw(&frame, gfx::Rect()));
   layer_tree_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
   layer_tree_host_impl->DidDrawAllLayers(frame);
-  layer_tree_host_impl->SwapBuffers();
+  layer_tree_host_impl->SwapBuffers(frame);
   gfx::Rect actual_swap_rect = partial_swap_tracker->partial_swap_rect();
   gfx::Rect expected_swap_rect = gfx::Rect(0, 0, 500, 500);
   EXPECT_EQ(expected_swap_rect.x(), actual_swap_rect.x());
   EXPECT_EQ(expected_swap_rect.y(), actual_swap_rect.y());
   EXPECT_EQ(expected_swap_rect.width(), actual_swap_rect.width());
   EXPECT_EQ(expected_swap_rect.height(), actual_swap_rect.height());
 
   // Second frame, only the damaged area should get swapped. Damage should be
   // the union of old and new child rects.
   // expected damage rect: gfx::Rect(26, 28);
   // expected swap rect: vertically flipped, with origin at bottom left corner.
   layer_tree_host_impl->active_tree()->root_layer()->children()[0]->SetPosition(
       gfx::PointF());
-  EXPECT_TRUE(layer_tree_host_impl->PrepareToDraw(&frame));
+  EXPECT_TRUE(layer_tree_host_impl->PrepareToDraw(&frame, gfx::Rect()));
   layer_tree_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
-  layer_tree_host_impl->SwapBuffers();
+  layer_tree_host_impl->SwapBuffers(frame);
   actual_swap_rect = partial_swap_tracker->partial_swap_rect();
   expected_swap_rect = gfx::Rect(0, 500-28, 26, 28);
   EXPECT_EQ(expected_swap_rect.x(), actual_swap_rect.x());
   EXPECT_EQ(expected_swap_rect.y(), actual_swap_rect.y());
   EXPECT_EQ(expected_swap_rect.width(), actual_swap_rect.width());
   EXPECT_EQ(expected_swap_rect.height(), actual_swap_rect.height());
 
   // Make sure that partial swap is constrained to the viewport dimensions
   // expected damage rect: gfx::Rect(500, 500);
   // expected swap rect: flipped damage rect, but also clamped to viewport
   layer_tree_host_impl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
   // This will damage everything.
   layer_tree_host_impl->active_tree()->root_layer()->SetOpacity(0.7f);
-  EXPECT_TRUE(layer_tree_host_impl->PrepareToDraw(&frame));
+  EXPECT_TRUE(layer_tree_host_impl->PrepareToDraw(&frame, gfx::Rect()));
   layer_tree_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
-  layer_tree_host_impl->SwapBuffers();
+  layer_tree_host_impl->SwapBuffers(frame);
   actual_swap_rect = partial_swap_tracker->partial_swap_rect();
   expected_swap_rect = gfx::Rect(10, 10);
   EXPECT_EQ(expected_swap_rect.x(), actual_swap_rect.x());
   EXPECT_EQ(expected_swap_rect.y(), actual_swap_rect.y());
   EXPECT_EQ(expected_swap_rect.width(), actual_swap_rect.width());
   EXPECT_EQ(expected_swap_rect.height(), actual_swap_rect.height());
 }
 
 TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) {
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   scoped_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 2);
   child->SetAnchorPoint(gfx::PointF());
   child->SetBounds(gfx::Size(10, 10));
   child->SetContentBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   root->SetAnchorPoint(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetOpacity(0.7f);
   root->AddChild(child.Pass());
 
   host_impl_->active_tree()->SetRootLayer(root.Pass());
 
   LayerTreeHostImpl::FrameData frame;
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   EXPECT_EQ(1u, frame.render_surface_layer_list->size());
   EXPECT_EQ(1u, frame.render_passes.size());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 class FakeLayerWithQuads : public LayerImpl {
  public:
   static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
     return scoped_ptr<LayerImpl>(new FakeLayerWithQuads(tree_impl, id));
   }
@@ skipping 125 matching lines @@
 
   // Run test case
   CreateLayerTreeHost(false, output_surface.Pass());
   SetupRootLayerImpl(FakeLayerWithQuads::Create(host_impl_->active_tree(), 1));
 
   // Without partial swap, and no clipping, no scissor is set.
   harness.MustDrawSolidQuad();
   harness.MustSetNoScissor();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
   Mock::VerifyAndClearExpectations(&mock_context);
 
   // Without partial swap, but a layer does clip its subtree, one scissor is
   // set.
   host_impl_->active_tree()->root_layer()->SetMasksToBounds(true);
   harness.MustDrawSolidQuad();
   harness.MustSetScissor(0, 0, 10, 10);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
   Mock::VerifyAndClearExpectations(&mock_context);
 }
 
 TEST_F(LayerTreeHostImplTest, PartialSwap) {
   scoped_ptr<OutputSurface> output_surface =
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new MockContext)).PassAs<OutputSurface>();
   MockContext* mock_context =
       static_cast<MockContext*>(output_surface->context3d());
   MockContextHarness harness(mock_context);
 
   CreateLayerTreeHost(true, output_surface.Pass());
   SetupRootLayerImpl(FakeLayerWithQuads::Create(host_impl_->active_tree(), 1));
 
   // The first frame is not a partially-swapped one.
   harness.MustSetScissor(0, 0, 10, 10);
   harness.MustDrawSolidQuad();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
   Mock::VerifyAndClearExpectations(&mock_context);
 
   // Damage a portion of the frame.
   host_impl_->active_tree()->root_layer()->set_update_rect(
       gfx::Rect(0, 0, 2, 3));
 
   // The second frame will be partially-swapped (the y coordinates are flipped).
   harness.MustSetScissor(0, 7, 2, 3);
   harness.MustDrawSolidQuad();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
   Mock::VerifyAndClearExpectations(&mock_context);
 }
 
 class PartialSwapContext : public TestWebGraphicsContext3D {
  public:
   virtual WebKit::WebString getString(WebKit::WGC3Denum name) OVERRIDE {
     if (name == GL_EXTENSIONS)
@@ skipping 88 matching lines @@
 
   my_host_impl->active_tree()->SetRootLayer(root.Pass());
   return my_host_impl.Pass();
 }
 
 TEST_F(LayerTreeHostImplTest, ContributingLayerEmptyScissorPartialSwap) {
   scoped_ptr<LayerTreeHostImpl> my_host_impl =
       SetupLayersForOpacity(true, this, &proxy_, &stats_instrumentation_);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Verify all quads have been computed
     ASSERT_EQ(2U, frame.render_passes.size());
     ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR,
               frame.render_passes[0]->quad_list[0]->material);
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[1]->quad_list[0]->material);
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ContributingLayerEmptyScissorNoPartialSwap) {
   scoped_ptr<LayerTreeHostImpl> my_host_impl =
       SetupLayersForOpacity(false, this, &proxy_, &stats_instrumentation_);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Verify all quads have been computed
     ASSERT_EQ(2U, frame.render_passes.size());
     ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR,
               frame.render_passes[0]->quad_list[0]->material);
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[1]->quad_list[0]->material);
 
@@ skipping 74 matching lines @@
   io_surface_layer->SetContentBounds(gfx::Size(10, 10));
   io_surface_layer->SetDrawsContent(true);
   io_surface_layer->SetIOSurfaceProperties(1, gfx::Size(10, 10));
   root_layer->AddChild(io_surface_layer.PassAs<LayerImpl>());
 
   host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
-  host_impl_->SwapBuffers();
+  host_impl_->SwapBuffers(frame);
 
   EXPECT_GT(context3d->NumTextures(), 0u);
 
   // Kill the layer tree.
   host_impl_->active_tree()->SetRootLayer(
       LayerImpl::Create(host_impl_->active_tree(), 100));
   // There should be no textures left in use after.
   EXPECT_EQ(0u, context3d->NumTextures());
 }
 
@@ skipping 19 matching lines @@
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
   host_impl_->active_tree()->set_background_color(SK_ColorWHITE);
 
   // Verify one quad is drawn when transparent background set is not set.
   host_impl_->active_tree()->set_has_transparent_background(false);
   EXPECT_CALL(*mock_context, useProgram(_))
       .Times(1);
   EXPECT_CALL(*mock_context, drawElements(_, _, _, _))
       .Times(1);
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
   Mock::VerifyAndClearExpectations(&mock_context);
 
   // Verify no quads are drawn when transparent background is set.
   host_impl_->active_tree()->set_has_transparent_background(true);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+  host_impl_->SetFullRootLayerDamage();
+  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
   Mock::VerifyAndClearExpectations(&mock_context);
 }
 
 static void AddDrawingLayerTo(LayerImpl* parent,
                               int id,
                               gfx::Rect layer_rect,
                               LayerImpl** result) {
   scoped_ptr<LayerImpl> layer =
@@ skipping 124 matching lines @@
   AddDrawingLayerTo(layer_s1_ptr, 4, gfx::Rect(0, 0, 30, 30), 0);  // L12
 
   AddDrawingLayerTo(root_ptr, 5, gfx::Rect(550, 250, 300, 400), &layer_s2_ptr);
   layer_s2_ptr->SetForceRenderSurface(true);
 
   AddDrawingLayerTo(layer_s2_ptr, 6, gfx::Rect(20, 20, 5, 5), 0);  // L21
 
   // Initial draw - must receive all quads
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 3 render passes.
     // For Root, there are 2 quads; for S1, there are 2 quads (1 is occluded);
     // for S2, there is 2 quads.
     ASSERT_EQ(3U, frame.render_passes.size());
 
     EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
     EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // "Unocclude" surface S1 and repeat draw.
   // Must remove S2's render pass since it's cached;
   // Must keep S1 quads because texture contained external occlusion.
   gfx::Transform transform = layer_s2_ptr->transform();
   transform.Translate(150.0, 150.0);
   layer_s2_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 2 render passes.
     // For Root, there are 2 quads
     // For S1, the number of quads depends on what got unoccluded, so not
     // asserted beyond being positive.
     // For S2, there is no render pass
     ASSERT_EQ(2U, frame.render_passes.size());
 
     EXPECT_GT(frame.render_passes[0]->quad_list.size(), 0U);
     EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // "Re-occlude" surface S1 and repeat draw.
   // Must remove S1's render pass since it is now available in full.
   // S2 has no change so must also be removed.
   transform = layer_s2_ptr->transform();
   transform.Translate(-15.0, -15.0);
   layer_s2_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 1 render pass - for the root.
     ASSERT_EQ(1U, frame.render_passes.size());
 
     EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 }
@@ skipping 53 matching lines @@
   AddDrawingLayerTo(layer_s1_ptr, 5, gfx::Rect(500, 0, 300, 300), 0);  // L13
   AddDrawingLayerTo(layer_s1_ptr, 6, gfx::Rect(500, 500, 300, 300), 0);  // L14
   AddDrawingLayerTo(layer_s1_ptr, 9, gfx::Rect(500, 500, 300, 300), 0);  // L14
 
   AddDrawingLayerTo(root_ptr, 7, gfx::Rect(450, 450, 450, 450), &layer_s2_ptr);
   layer_s2_ptr->SetForceRenderSurface(true);
 
   // Initial draw - must receive all quads
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 3 render passes.
     // For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is
     // 1 quad.
     ASSERT_EQ(3U, frame.render_passes.size());
 
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
     // L14 is culled, so only 3 quads.
     EXPECT_EQ(3U, frame.render_passes[1]->quad_list.size());
     EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // "Unocclude" surface S1 and repeat draw.
   // Must remove S2's render pass since it's cached;
   // Must keep S1 quads because texture contained external occlusion.
   gfx::Transform transform = layer_s2_ptr->transform();
   transform.Translate(100.0, 100.0);
   layer_s2_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 2 render passes.
     // For Root, there are 2 quads
     // For S1, the number of quads depends on what got unoccluded, so not
     // asserted beyond being positive.
     // For S2, there is no render pass
     ASSERT_EQ(2U, frame.render_passes.size());
 
     EXPECT_GT(frame.render_passes[0]->quad_list.size(), 0U);
     EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // "Re-occlude" surface S1 and repeat draw.
   // Must remove S1's render pass since it is now available in full.
   // S2 has no change so must also be removed.
   transform = layer_s2_ptr->transform();
   transform.Translate(-15.0, -15.0);
   layer_s2_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 1 render pass - for the root.
     ASSERT_EQ(1U, frame.render_passes.size());
 
     EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 }
@@ skipping 47 matching lines @@
 
   AddDrawingLayerTo(layer_s1_ptr, 3, gfx::Rect(0, 0, 300, 300), 0);  // L11
   AddDrawingLayerTo(layer_s1_ptr, 4, gfx::Rect(100, 0, 300, 300), 0);  // L12
 
   AddDrawingLayerTo(root_ptr, 7, gfx::Rect(200, 0, 300, 300), &layer_s2_ptr);
   layer_s2_ptr->SetForceRenderSurface(true);
 
   // Initial draw - must receive all quads
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 3 render passes.
     // For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is
     // 1 quad.
     ASSERT_EQ(3U, frame.render_passes.size());
 
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(3U, frame.render_passes[1]->quad_list.size());
     EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // "Unocclude" surface S1 and repeat draw.
   // Must remove S2's render pass since it's cached;
   // Must keep S1 quads because texture contained external occlusion.
   gfx::Transform transform = layer_s2_ptr->transform();
   transform.Translate(300.0, 0.0);
   layer_s2_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 2 render passes.
     // For Root, there are 2 quads
     // For S1, the number of quads depends on what got unoccluded, so not
     // asserted beyond being positive.
     // For S2, there is no render pass
     ASSERT_EQ(2U, frame.render_passes.size());
 
     EXPECT_GT(frame.render_passes[0]->quad_list.size(), 0U);
     EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
@@ skipping 47 matching lines @@
   transform.Translate(200.0, 200.0);
   transform.Rotate(45.0);
   transform.Translate(-200.0, -200.0);
   layer_s1_ptr->SetTransform(transform);
 
   AddDrawingLayerTo(layer_s1_ptr, 3, gfx::Rect(200, 0, 200, 400), 0);  // L11
 
   // Initial draw - must receive all quads
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 2 render passes.
     ASSERT_EQ(2U, frame.render_passes.size());
 
     EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Change opacity and draw. Verify we used cached texture.
   layer_s1_ptr->SetOpacity(0.2f);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // One render pass must be gone due to cached texture.
     ASSERT_EQ(1U, frame.render_passes.size());
 
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 }
@@ skipping 55 matching lines @@
   AddDrawingLayerTo(layer_s1_ptr, 4, gfx::Rect(0, 0, 30, 30), 0);  // L12
 
   AddDrawingLayerTo(root_ptr, 5, gfx::Rect(550, 250, 300, 400), &layer_s2_ptr);
   layer_s2_ptr->SetForceRenderSurface(true);
 
   AddDrawingLayerTo(layer_s2_ptr, 6, gfx::Rect(20, 20, 5, 5), 0);  // L21
 
   // Initial draw - must receive all quads
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 3 render passes.
     // For Root, there are 2 quads; for S1, there are 2 quads (one is occluded);
     // for S2, there is 2 quads.
     ASSERT_EQ(3U, frame.render_passes.size());
 
     EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
     EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // "Unocclude" surface S1 and repeat draw.
   // Must remove S2's render pass since it's cached;
   // Must keep S1 quads because texture contained external occlusion.
   gfx::Transform transform = layer_s2_ptr->transform();
   transform.Translate(150.0, 150.0);
   layer_s2_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive 2 render passes.
     // For Root, there are 2 quads.
     // For S1, there are 2 quads.
     // For S2, there is no render pass
     ASSERT_EQ(2U, frame.render_passes.size());
 
     EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // "Re-occlude" surface S1 and repeat draw.
   // Must remove S1's render pass since it is now available in full.
   // S2 has no change so must also be removed.
   transform = layer_s2_ptr->transform();
   transform.Translate(-15.0, -15.0);
   layer_s2_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Root render pass only.
     ASSERT_EQ(1U, frame.render_passes.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, TextureCachingWithScissor) {
@@ skipping 73 matching lines @@
 
   child->AddChild(grand_child.Pass());
   root->AddChild(child.PassAs<LayerImpl>());
   my_host_impl->active_tree()->SetRootLayer(root.Pass());
   my_host_impl->SetViewportSize(root_rect.size(), root_rect.size());
 
   EXPECT_FALSE(my_host_impl->renderer()->HaveCachedResourcesForRenderPassId(
       child_pass_id));
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    host_impl_->SetFullRootLayerDamage();
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // We should have cached textures for surface 2.
   EXPECT_TRUE(my_host_impl->renderer()->HaveCachedResourcesForRenderPassId(
       child_pass_id));
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    host_impl_->SetFullRootLayerDamage();
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // We should still have cached textures for surface 2 after drawing with no
   // damage.
   EXPECT_TRUE(my_host_impl->renderer()->HaveCachedResourcesForRenderPassId(
       child_pass_id));
 
   // Damage a single tile of surface 2.
   child_ptr->set_update_rect(gfx::Rect(10, 10, 10, 10));
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    host_impl_->SetFullRootLayerDamage();
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // We should have a cached texture for surface 2 again even though it was
   // damaged.
   EXPECT_TRUE(my_host_impl->renderer()->HaveCachedResourcesForRenderPassId(
       child_pass_id));
 }
 
@@ skipping 14 matching lines @@
   LayerImpl* child_ptr;
 
   SetupLayersForTextureCaching(my_host_impl.get(),
                                root_ptr,
                                intermediate_layer_ptr,
                                surface_layer_ptr,
                                child_ptr,
                                gfx::Size(100, 100));
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive two render passes, each with one quad
     ASSERT_EQ(2U, frame.render_passes.size());
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
 
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[1]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
     RenderPass* target_pass = frame.render_passes_by_id[quad->render_pass_id];
     ASSERT_TRUE(target_pass);
     EXPECT_FALSE(target_pass->damage_rect.IsEmpty());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Draw without any change
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    my_host_impl->SetFullRootLayerDamage();
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive one render pass, as the other one should be culled
     ASSERT_EQ(1U, frame.render_passes.size());
 
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) ==
                 frame.render_passes_by_id.end());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Change opacity and draw
   surface_layer_ptr->SetOpacity(0.6f);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive one render pass, as the other one should be culled
     ASSERT_EQ(1U, frame.render_passes.size());
 
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) ==
                 frame.render_passes_by_id.end());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Change less benign property and draw - should have contents changed flag
   surface_layer_ptr->SetStackingOrderChanged(true);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive two render passes, each with one quad
     ASSERT_EQ(2U, frame.render_passes.size());
 
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR,
               frame.render_passes[0]->quad_list[0]->material);
 
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[1]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
     RenderPass* target_pass = frame.render_passes_by_id[quad->render_pass_id];
     ASSERT_TRUE(target_pass);
     EXPECT_FALSE(target_pass->damage_rect.IsEmpty());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Change opacity again, and evict the cached surface texture.
   surface_layer_ptr->SetOpacity(0.5f);
   static_cast<GLRendererWithReleaseTextures*>(
       my_host_impl->renderer())->ReleaseRenderPassTextures();
 
   // Change opacity and draw
   surface_layer_ptr->SetOpacity(0.6f);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive two render passes
     ASSERT_EQ(2U, frame.render_passes.size());
 
     // Even though not enough properties changed, the entire thing must be
     // redrawn as we don't have cached textures
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
 
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[1]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
     RenderPass* target_pass = frame.render_passes_by_id[quad->render_pass_id];
     ASSERT_TRUE(target_pass);
     EXPECT_TRUE(target_pass->damage_rect.IsEmpty());
 
     // Was our surface evicted?
     EXPECT_FALSE(my_host_impl->renderer()->HaveCachedResourcesForRenderPassId(
         target_pass->id));
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Draw without any change, to make sure the state is clear
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    my_host_impl->SetFullRootLayerDamage();
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive one render pass, as the other one should be culled
     ASSERT_EQ(1U, frame.render_passes.size());
 
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) ==
                 frame.render_passes_by_id.end());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Change location of the intermediate layer
   gfx::Transform transform = intermediate_layer_ptr->transform();
   transform.matrix().setDouble(0, 3, 1.0001);
   intermediate_layer_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive one render pass, as the other one should be culled.
     ASSERT_EQ(1U, frame.render_passes.size());
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) ==
@@ skipping 20 matching lines @@
   LayerImpl* child_ptr;
 
   SetupLayersForTextureCaching(my_host_impl.get(),
                                root_ptr,
                                intermediate_layer_ptr,
                                surface_layer_ptr,
                                child_ptr,
                                gfx::Size(100, 100));
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive two render passes, each with one quad
     ASSERT_EQ(2U, frame.render_passes.size());
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
 
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[1]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
     RenderPass* target_pass = frame.render_passes_by_id[quad->render_pass_id];
     EXPECT_FALSE(target_pass->damage_rect.IsEmpty());
 
     EXPECT_FALSE(frame.render_passes[0]->damage_rect.IsEmpty());
     EXPECT_FALSE(frame.render_passes[1]->damage_rect.IsEmpty());
 
     EXPECT_FALSE(
         frame.render_passes[0]->has_occlusion_from_outside_target_surface);
     EXPECT_FALSE(
         frame.render_passes[1]->has_occlusion_from_outside_target_surface);
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Draw without any change
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    my_host_impl->SetFullRootLayerDamage();
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Even though there was no change, we set the damage to entire viewport.
     // One of the passes should be culled as a result, since contents didn't
     // change and we have cached texture.
     ASSERT_EQ(1U, frame.render_passes.size());
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
-    EXPECT_TRUE(frame.render_passes[0]->damage_rect.IsEmpty());
-
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Change opacity and draw
   surface_layer_ptr->SetOpacity(0.6f);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive one render pass, as the other one should be culled
     ASSERT_EQ(1U, frame.render_passes.size());
 
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) ==
                 frame.render_passes_by_id.end());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Change less benign property and draw - should have contents changed flag
   surface_layer_ptr->SetStackingOrderChanged(true);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive two render passes, each with one quad
     ASSERT_EQ(2U, frame.render_passes.size());
 
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR,
               frame.render_passes[0]->quad_list[0]->material);
 
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[1]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
     RenderPass* target_pass = frame.render_passes_by_id[quad->render_pass_id];
     ASSERT_TRUE(target_pass);
     EXPECT_FALSE(target_pass->damage_rect.IsEmpty());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Change opacity again, and evict the cached surface texture.
   surface_layer_ptr->SetOpacity(0.5f);
   static_cast<GLRendererWithReleaseTextures*>(
       my_host_impl->renderer())->ReleaseRenderPassTextures();
 
   // Change opacity and draw
   surface_layer_ptr->SetOpacity(0.6f);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive two render passes
     ASSERT_EQ(2U, frame.render_passes.size());
 
     // Even though not enough properties changed, the entire thing must be
     // redrawn as we don't have cached textures
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
     EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
 
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[1]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
     RenderPass* target_pass = frame.render_passes_by_id[quad->render_pass_id];
     ASSERT_TRUE(target_pass);
     EXPECT_TRUE(target_pass->damage_rect.IsEmpty());
 
     // Was our surface evicted?
     EXPECT_FALSE(my_host_impl->renderer()->HaveCachedResourcesForRenderPassId(
         target_pass->id));
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Draw without any change, to make sure the state is clear
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    my_host_impl->SetFullRootLayerDamage();
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Even though there was no change, we set the damage to entire viewport.
     // One of the passes should be culled as a result, since contents didn't
     // change and we have cached texture.
     ASSERT_EQ(1U, frame.render_passes.size());
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 
   // Change location of the intermediate layer
   gfx::Transform transform = intermediate_layer_ptr->transform();
   transform.matrix().setDouble(0, 3, 1.0001);
   intermediate_layer_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame));
+    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Must receive one render pass, as the other one should be culled.
     ASSERT_EQ(1U, frame.render_passes.size());
     EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
 
     EXPECT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) ==
@@ skipping 458 matching lines @@
 }
 
 class LayerTreeHostImplTestWithDelegatingRenderer
     : public LayerTreeHostImplTest {
  protected:
   virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
     return FakeOutputSurface::CreateDelegating3d().PassAs<OutputSurface>();
   }
 
   void DrawFrameAndTestDamage(const gfx::RectF& expected_damage) {
+    bool expect_to_draw = !expected_damage.IsEmpty();
+
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
-    ASSERT_EQ(1u, frame.render_passes.size());
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
-    // Verify the damage rect for the root render pass.
-    const RenderPass* root_render_pass = frame.render_passes.back();
-    EXPECT_RECT_EQ(expected_damage, root_render_pass->damage_rect);
+    if (!expect_to_draw) {
+      // With no damage, we don't draw, and no quads are created.
+      ASSERT_EQ(0u, frame.render_passes.size());
+    } else {
+      ASSERT_EQ(1u, frame.render_passes.size());
 
-    // Verify the root layer's quad is generated and not being culled.
-    ASSERT_EQ(1u, root_render_pass->quad_list.size());
-    gfx::Rect expected_visible_rect(
-        host_impl_->active_tree()->root_layer()->content_bounds());
-    EXPECT_RECT_EQ(expected_visible_rect,
-                   root_render_pass->quad_list[0]->visible_rect);
+      // Verify the damage rect for the root render pass.
+      const RenderPass* root_render_pass = frame.render_passes.back();
+      EXPECT_RECT_EQ(expected_damage, root_render_pass->damage_rect);
+
+      // Verify the root and child layers' quads are generated and not being
+      // culled.
+      ASSERT_EQ(2u, root_render_pass->quad_list.size());
+
+      LayerImpl* child = host_impl_->active_tree()->root_layer()->children()[0];
+      gfx::RectF expected_child_visible_rect(child->content_bounds());
+      EXPECT_RECT_EQ(expected_child_visible_rect,
+                     root_render_pass->quad_list[0]->visible_rect);
+
+      LayerImpl* root = host_impl_->active_tree()->root_layer();
+      gfx::RectF expected_root_visible_rect(root->content_bounds());
+      EXPECT_RECT_EQ(expected_root_visible_rect,
+                     root_render_pass->quad_list[1]->visible_rect);
+    }
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
+    EXPECT_EQ(expect_to_draw, host_impl_->SwapBuffers(frame));
   }
 };
 
 TEST_F(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect) {
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetAnchorPoint(gfx::PointF());
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
+
+  // Child layer is in the bottom right corner.
+  scoped_ptr<SolidColorLayerImpl> child =
+      SolidColorLayerImpl::Create(host_impl_->active_tree(), 2);
+  child->SetAnchorPoint(gfx::PointF(0.f, 0.f));
+  child->SetPosition(gfx::PointF(9.f, 9.f));
+  child->SetBounds(gfx::Size(1, 1));
+  child->SetContentBounds(gfx::Size(1, 1));
+  child->SetDrawsContent(true);
+  root->AddChild(child.PassAs<LayerImpl>());
+
   host_impl_->active_tree()->SetRootLayer(root.PassAs<LayerImpl>());
 
   // Draw a frame. In the first frame, the entire viewport should be damaged.
   gfx::Rect full_frame_damage = gfx::Rect(host_impl_->device_viewport_size());
   DrawFrameAndTestDamage(full_frame_damage);
 
-  // The second frame should have no damage, but the quads should still be
-  // generated.
+  // The second frame has damage that doesn't touch the child layer. Its quads
+  // should still be generated.
+  gfx::Rect small_damage = gfx::Rect(0, 0, 1, 1);
+  host_impl_->active_tree()->root_layer()->set_update_rect(small_damage);
+  DrawFrameAndTestDamage(small_damage);
+
+  // The third frame should have no damage, so no quads should be generated.
   gfx::Rect no_damage;
   DrawFrameAndTestDamage(no_damage);
 }
 
 class FakeMaskLayerImpl : public LayerImpl {
  public:
   static scoped_ptr<FakeMaskLayerImpl> Create(LayerTreeImpl* tree_impl,
                                               int id) {
     return make_scoped_ptr(new FakeMaskLayerImpl(tree_impl, id));
   }
@@ skipping 62 matching lines @@
   mask_layer->SetDrawsContent(true);
 
 
   // Check that the tree scaling is correctly taken into account for the mask,
   // that should fully map onto the quad.
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size, root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
 
   // Applying a DSF should change the render surface size, but won't affect
   // which part of the mask is used.
   device_scale_factor = 2.f;
   gfx::Size device_viewport =
       gfx::ToFlooredSize(gfx::ScaleSize(root_size, device_scale_factor));
   host_impl_->SetViewportSize(root_size, device_viewport);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
 
   // Applying an equivalent content scale on the content layer and the mask
   // should still result in the same part of the mask being used.
   gfx::Size content_bounds =
       gfx::ToRoundedSize(gfx::ScaleSize(scaling_layer_size,
                                         device_scale_factor));
   content_layer->SetContentBounds(content_bounds);
   content_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   mask_layer->SetContentBounds(content_bounds);
   mask_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
@@ skipping 43 matching lines @@
   mask_layer->SetAnchorPoint(gfx::PointF());
   mask_layer->SetDrawsContent(true);
 
 
   // Check that the mask fills the surface.
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size, root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
 
   // Applying a DSF should change the render surface size, but won't affect
   // which part of the mask is used.
   device_scale_factor = 2.f;
   gfx::Size device_viewport =
       gfx::ToFlooredSize(gfx::ScaleSize(root_size, device_scale_factor));
   host_impl_->SetViewportSize(root_size, device_viewport);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
@@ skipping 10 matching lines @@
       gfx::ToRoundedSize(gfx::ScaleSize(layer_size, device_scale_factor));
   content_layer->SetContentBounds(layer_size_large);
   content_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   gfx::Size mask_size_large =
       gfx::ToRoundedSize(gfx::ScaleSize(mask_size, device_scale_factor));
   mask_layer->SetContentBounds(mask_size_large);
   mask_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Applying a different contents scale to the mask layer will still result
   // in the mask covering the owning layer.
   mask_layer->SetContentBounds(mask_size);
   mask_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
+    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
 
 }  // namespace
 }  // namespace cc