cc: Make PrepareToDraw return an enum for why it aborts

This is mostly a cosmetic patch to change a boolean into an enum.

BUG=335289

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@247869 0039d316-1c4b-4281-b951-d872f2087c98

25 files changed, 579 insertions, 403 deletions

diff --git a/cc/cc.gyp b/cc/cc.gyp
index 1b3b482..b6129b1 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -405,6 +405,7 @@
         'resources/video_resource_updater.h',
         'scheduler/delay_based_time_source.cc',
         'scheduler/delay_based_time_source.h',
+        'scheduler/draw_swap_readback_result.h',
         'scheduler/frame_rate_controller.cc',
         'scheduler/frame_rate_controller.h',
         'scheduler/rolling_time_delta_history.cc',
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 8cb0f3e..2b8e8fa 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -136,7 +136,8 @@ class DelegatedRendererLayerImplTestSimple
 
 TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
@@ -170,7 +171,8 @@ TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) {
 TEST_F(DelegatedRendererLayerImplTestSimple,
        AddsQuadsToContributingRenderPasses) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
@@ -205,7 +207,8 @@ TEST_F(DelegatedRendererLayerImplTestSimple,
 
 TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
@@ -233,7 +236,8 @@ TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) {
 TEST_F(DelegatedRendererLayerImplTestSimple,
        QuadsFromRootRenderPassAreModifiedForTheTarget) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
@@ -266,7 +270,8 @@ TEST_F(DelegatedRendererLayerImplTestSimple,
 
 TEST_F(DelegatedRendererLayerImplTestSimple, RenderPassTransformIsModified) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // The delegated layer has a surface between it and the root.
   EXPECT_TRUE(delegated_renderer_layer_->render_target()->parent());
@@ -302,7 +307,8 @@ TEST_F(DelegatedRendererLayerImplTestSimple, RenderPassTransformIsModified) {
 
 TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // If the DelegatedRendererLayer is axis aligned and has opacity 1, then it
   // has no need to be a RenderSurface for the quads it carries.
@@ -316,7 +322,8 @@ TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) {
   delegated_renderer_layer_->SetOpacity(0.5f);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // This test case has quads from multiple layers in the delegated renderer, so
   // if the DelegatedRendererLayer has opacity < 1, it should end up with a
@@ -334,7 +341,8 @@ TEST_F(DelegatedRendererLayerImplTestSimple,
   delegated_renderer_layer_->SetTransform(rotation);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // This test case has quads from multiple layers in the delegated renderer, so
   // if the DelegatedRendererLayer has opacity < 1, it should end up with a
@@ -356,7 +364,8 @@ class DelegatedRendererLayerImplTestOwnSurface
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
@@ -395,7 +404,8 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
        AddsQuadsToContributingRenderPasses) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
@@ -431,7 +441,8 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface,
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
@@ -457,7 +468,8 @@ TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) {
 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
        QuadsFromRootRenderPassAreNotModifiedForTheTarget) {
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
@@ -669,7 +681,8 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
@@ -725,7 +738,8 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
@@ -790,7 +804,8 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
@@ -846,7 +861,8 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
@@ -1049,7 +1065,8 @@ TEST_F(DelegatedRendererLayerImplTestClip,
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
@@ -1078,7 +1095,8 @@ TEST_F(DelegatedRendererLayerImplTestClip,
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
@@ -1107,7 +1125,8 @@ TEST_F(DelegatedRendererLayerImplTestClip,
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
@@ -1137,7 +1156,8 @@ TEST_F(DelegatedRendererLayerImplTestClip,
   SetUpTest();
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
@@ -1168,7 +1188,8 @@ TEST_F(DelegatedRendererLayerImplTestClip,
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
@@ -1197,7 +1218,8 @@ TEST_F(DelegatedRendererLayerImplTestClip,
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
@@ -1227,7 +1249,8 @@ TEST_F(DelegatedRendererLayerImplTestClip,
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
@@ -1255,7 +1278,8 @@ TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
   delegated_renderer_layer_->SetForceRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
@@ -1319,7 +1343,8 @@ TEST_F(DelegatedRendererLayerImplTest, InvalidRenderPassDrawQuad) {
   host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   // The DelegatedRendererLayerImpl should drop the bad RenderPassDrawQuad.
   ASSERT_EQ(1u, frame.render_passes.size());
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index f38809f..cd97f81 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -257,8 +257,15 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
   FakeImplProxy proxy;
   FakeLayerTreeHostImpl host_impl(&proxy);
   EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface()));
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
-  root->SetScrollable(true);
+  host_impl.active_tree()->SetRootLayer(
+      LayerImpl::Create(host_impl.active_tree(), 1));
+  LayerImpl* root = host_impl.active_tree()->root_layer();
+  scoped_ptr<LayerImpl> layer_ptr =
+      LayerImpl::Create(host_impl.active_tree(), 2);
+  LayerImpl* layer = layer_ptr.get();
+  root->AddChild(layer_ptr.Pass());
+  layer->SetScrollable(true);
+  DCHECK(host_impl.CanDraw());
 
   gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f);
   float arbitrary_number = 0.352f;
@@ -277,83 +284,88 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
   SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode;
 
   // Related filter functions.
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(FilterOperations()));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(FilterOperations()));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
 
   // Related scrolling functions.
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMaxScrollOffset(large_vector2d));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
+      layer->SetMaxScrollOffset(large_vector2d));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetMaxScrollOffset(large_vector2d));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(arbitrary_vector2d));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(gfx::Vector2d()));
-  root->SetScrollDelta(gfx::Vector2d(0, 0));
+      layer->SetMaxScrollOffset(large_vector2d));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(arbitrary_vector2d));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(gfx::Vector2d()));
+  layer->SetScrollDelta(gfx::Vector2d(0, 0));
   host_impl.ForcePrepareToDraw();
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitrary_vector2d));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
+      layer->SetScrollDelta(arbitrary_vector2d));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetScrollDelta(arbitrary_vector2d));
+      layer->SetScrollDelta(arbitrary_vector2d));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetScrollOffset(arbitrary_vector2d));
+      layer->SetScrollOffset(arbitrary_vector2d));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetScrollOffset(arbitrary_vector2d));
+      layer->SetScrollOffset(arbitrary_vector2d));
 
   // Unrelated functions, always set to new values, always set needs update.
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetAnchorPointZ(arbitrary_number));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetAnchorPointZ(arbitrary_number));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMasksToBounds(true));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentsOpaque(true));
+      layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5)));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPosition(arbitrary_point_f));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPreserves3d(true));
+      layer->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5)));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPosition(arbitrary_point_f));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPreserves3d(true));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetDoubleSided(false));  // constructor initializes it to "true".
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentBounds(arbitrary_size));
+      layer->SetDoubleSided(false));  // constructor initializes it to "true".
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentBounds(arbitrary_size));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetContentsScale(arbitrary_number, arbitrary_number));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetDrawsContent(true));
+      layer->SetContentsScale(arbitrary_number, arbitrary_number));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetBackgroundColor(arbitrary_color));
+      layer->SetBackgroundColor(arbitrary_color));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetBackgroundFilters(arbitrary_filters));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetOpacity(arbitrary_number));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBlendMode(arbitrary_blend_mode));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetTransform(arbitrary_transform));
+      layer->SetBackgroundFilters(arbitrary_filters));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetOpacity(arbitrary_number));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetSublayerTransform(arbitrary_transform));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(arbitrary_size));
+      layer->SetBlendMode(arbitrary_blend_mode));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetTransform(arbitrary_transform));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
+      layer->SetSublayerTransform(arbitrary_transform));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size));
 
   // Unrelated functions, set to the same values, no needs update.
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetAnchorPointZ(arbitrary_number));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetIsRootForIsolatedGroup(true));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMasksToBounds(true));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentsOpaque(true));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPosition(arbitrary_point_f));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPreserves3d(true));
+      layer->SetAnchorPointZ(arbitrary_number));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetDoubleSided(false));  // constructor initializes it to "true".
+      layer->SetIsRootForIsolatedGroup(true));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPosition(arbitrary_point_f));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPreserves3d(true));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetContentBounds(arbitrary_size));
+      layer->SetDoubleSided(false));  // constructor initializes it to "true".
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetContentsScale(arbitrary_number, arbitrary_number));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetDrawsContent(true));
+      layer->SetContentBounds(arbitrary_size));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetBackgroundColor(arbitrary_color));
+      layer->SetContentsScale(arbitrary_number, arbitrary_number));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetBackgroundFilters(arbitrary_filters));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetOpacity(arbitrary_number));
+      layer->SetBackgroundColor(arbitrary_color));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetBlendMode(arbitrary_blend_mode));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetIsRootForIsolatedGroup(true));
+      layer->SetBackgroundFilters(arbitrary_filters));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetOpacity(arbitrary_number));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetTransform(arbitrary_transform));
+      layer->SetBlendMode(arbitrary_blend_mode));
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
-      root->SetSublayerTransform(arbitrary_transform));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(arbitrary_size));
+      layer->SetIsRootForIsolatedGroup(true));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
+      layer->SetTransform(arbitrary_transform));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
+      layer->SetSublayerTransform(arbitrary_transform));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size));
 }
 
 TEST(LayerImplTest, SafeOpaqueBackgroundColor) {
diff --git a/cc/layers/texture_layer_unittest.cc b/cc/layers/texture_layer_unittest.cc
index feaa585..24d0500 100644
--- a/cc/layers/texture_layer_unittest.cc
+++ b/cc/layers/texture_layer_unittest.cc
@@ -1402,11 +1402,12 @@ class TextureLayerClientTest
     expected_used_textures_on_draw_ = expected_used_textures_on_commit_;
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     ContextForImplThread(host_impl)->ResetUsedTextures();
-    return true;
+    return DrawSwapReadbackResult::DRAW_SUCCESS;
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
@@ -1548,11 +1549,12 @@ class TextureLayerChangeInvisibleTest
     expected_texture_on_draw_ = texture_;
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     ContextForImplThread(host_impl)->ResetUsedTextures();
-    return true;
+    return DrawSwapReadbackResult::DRAW_SUCCESS;
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
@@ -1982,9 +1984,10 @@ class TextureLayerLostContextTest
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     LayerImpl* root = host_impl->RootLayer();
     TextureLayerImpl* texture_layer =
         static_cast<TextureLayerImpl*>(root->children()[0]);
@@ -1992,7 +1995,7 @@ class TextureLayerLostContextTest
       EXPECT_EQ(0u, texture_layer->texture_id());
     else
       EXPECT_EQ(1u, texture_layer->texture_id());
-    return true;
+    return DrawSwapReadbackResult::DRAW_SUCCESS;
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
diff --git a/cc/output/delegating_renderer_unittest.cc b/cc/output/delegating_renderer_unittest.cc
index ffa7e4f..a1d21d4 100644
--- a/cc/output/delegating_renderer_unittest.cc
+++ b/cc/output/delegating_renderer_unittest.cc
@@ -39,10 +39,10 @@ class DelegatingRendererTestDraw : public DelegatingRendererTest {
 
   virtual void AfterTest() OVERRIDE {}
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame,
-                                     bool result)
-      OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     EXPECT_EQ(0u, output_surface_->num_sent_frames());
 
     const CompositorFrame& last_frame = output_surface_->last_sent_frame();
@@ -50,7 +50,7 @@ class DelegatingRendererTestDraw : public DelegatingRendererTest {
     EXPECT_FALSE(last_frame.gl_frame_data);
     EXPECT_EQ(0.f, last_frame.metadata.min_page_scale_factor);
     EXPECT_EQ(0.f, last_frame.metadata.max_page_scale_factor);
-    return true;
+    return DrawSwapReadbackResult::DRAW_SUCCESS;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -89,10 +89,10 @@ class DelegatingRendererTestResources : public DelegatingRendererTest {
 
   virtual void AfterTest() OVERRIDE {}
 
-  virtual bool PrepareToDrawOnThread(
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      bool result) OVERRIDE {
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     frame->render_passes.clear();
     frame->render_passes_by_id.clear();
 
@@ -111,7 +111,7 @@ class DelegatingRendererTestResources : public DelegatingRendererTest {
         gfx::Transform());
     pass->AppendOneOfEveryQuadType(
         host_impl->resource_provider(), child_pass->id);
-    return true;
+    return draw_result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
diff --git a/cc/scheduler/draw_swap_readback_result.h b/cc/scheduler/draw_swap_readback_result.h
new file mode 100644
index 0000000..7bcf3df
--- /dev/null
+++ b/cc/scheduler/draw_swap_readback_result.h
@@ -0,0 +1,32 @@
+// Copyright 2014 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_SCHEDULER_DRAW_SWAP_READBACK_RESULT_H_
+#define CC_SCHEDULER_DRAW_SWAP_READBACK_RESULT_H_
+
+namespace cc {
+
+struct DrawSwapReadbackResult {
+  enum DrawResult {
+    INVALID_RESULT,
+    DRAW_SUCCESS,
+    DRAW_ABORTED_CHECKERBOARD_ANIMATIONS,
+  };
+
+  DrawSwapReadbackResult()
+      : draw_result(INVALID_RESULT), did_swap(false), did_readback(false) {}
+  DrawSwapReadbackResult(DrawResult draw_result,
+                         bool did_swap,
+                         bool did_readback)
+      : draw_result(draw_result),
+        did_swap(did_swap),
+        did_readback(did_readback) {}
+  DrawResult draw_result;
+  bool did_swap;
+  bool did_readback;
+};
+
+}  // namespace cc
+
+#endif  // CC_SCHEDULER_DRAW_SWAP_READBACK_RESULT_H_
diff --git a/cc/scheduler/scheduler.cc b/cc/scheduler/scheduler.cc
index d31f042..ed8114c 100644
--- a/cc/scheduler/scheduler.cc
+++ b/cc/scheduler/scheduler.cc
@@ -300,7 +300,7 @@ void Scheduler::PollForAnticipatedDrawTriggers() {
 void Scheduler::DrawAndSwapIfPossible() {
   DrawSwapReadbackResult result =
       client_->ScheduledActionDrawAndSwapIfPossible();
-  state_machine_.DidDrawIfPossibleCompleted(result.did_draw);
+  state_machine_.DidDrawIfPossibleCompleted(result.draw_result);
 }
 
 void Scheduler::DrawAndSwapForced() {
diff --git a/cc/scheduler/scheduler.h b/cc/scheduler/scheduler.h
index 9209782..34473ad 100644
--- a/cc/scheduler/scheduler.h
+++ b/cc/scheduler/scheduler.h
@@ -13,6 +13,7 @@
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/begin_frame_args.h"
+#include "cc/scheduler/draw_swap_readback_result.h"
 #include "cc/scheduler/scheduler_settings.h"
 #include "cc/scheduler/scheduler_state_machine.h"
 #include "cc/trees/layer_tree_host.h"
@@ -21,16 +22,6 @@ namespace cc {
 
 class Thread;
 
-struct DrawSwapReadbackResult {
-  DrawSwapReadbackResult()
-      : did_draw(false), did_swap(false), did_readback(false) {}
-  DrawSwapReadbackResult(bool did_draw, bool did_swap, bool did_readback)
-      : did_draw(did_draw), did_swap(did_swap), did_readback(did_readback) {}
-  bool did_draw;
-  bool did_swap;
-  bool did_readback;
-};
-
 class SchedulerClient {
  public:
   virtual void SetNeedsBeginImplFrame(bool enable) = 0;
diff --git a/cc/scheduler/scheduler_state_machine.cc b/cc/scheduler/scheduler_state_machine.cc
index 334c848..36397e1 100644
--- a/cc/scheduler/scheduler_state_machine.cc
+++ b/cc/scheduler/scheduler_state_machine.cc
@@ -27,7 +27,7 @@ SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
       last_frame_number_begin_main_frame_sent_(-1),
       last_frame_number_update_visible_tiles_was_called_(-1),
       manage_tiles_funnel_(0),
-      consecutive_failed_draws_(0),
+      consecutive_checkerboard_animations_(0),
       needs_redraw_(false),
       needs_manage_tiles_(false),
       swap_used_incomplete_tile_(false),
@@ -240,8 +240,8 @@ scoped_ptr<base::Value> SchedulerStateMachine::AsValue() const  {
       last_frame_number_update_visible_tiles_was_called_);
 
   minor_state->SetInteger("manage_tiles_funnel", manage_tiles_funnel_);
-  minor_state->SetInteger("consecutive_failed_draws",
-                          consecutive_failed_draws_);
+  minor_state->SetInteger("consecutive_checkerboard_animations",
+                          consecutive_checkerboard_animations_);
   minor_state->SetBoolean("needs_redraw", needs_redraw_);
   minor_state->SetBoolean("needs_manage_tiles", needs_manage_tiles_);
   minor_state->SetBoolean("swap_used_incomplete_tile",
@@ -1022,29 +1022,35 @@ void SchedulerStateMachine::SetSmoothnessTakesPriority(
   smoothness_takes_priority_ = smoothness_takes_priority;
 }
 
-void SchedulerStateMachine::DidDrawIfPossibleCompleted(bool success) {
-  draw_if_possible_failed_ = !success;
-  if (draw_if_possible_failed_) {
-    needs_redraw_ = true;
-
-    // If we're already in the middle of a redraw, we don't need to
-    // restart it.
-    if (forced_redraw_state_ != FORCED_REDRAW_STATE_IDLE)
-      return;
-
-    needs_commit_ = true;
-    consecutive_failed_draws_++;
-    if (settings_.timeout_and_draw_when_animation_checkerboards &&
-        consecutive_failed_draws_ >=
-            settings_.maximum_number_of_failed_draws_before_draw_is_forced_) {
-      consecutive_failed_draws_ = 0;
-      // We need to force a draw, but it doesn't make sense to do this until
-      // we've committed and have new textures.
-      forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_COMMIT;
-    }
-  } else {
-    consecutive_failed_draws_ = 0;
-    forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE;
+void SchedulerStateMachine::DidDrawIfPossibleCompleted(
+    DrawSwapReadbackResult::DrawResult result) {
+  switch (result) {
+    case DrawSwapReadbackResult::INVALID_RESULT:
+      NOTREACHED() << "Uninitialized DrawSwapReadbackResult.";
+      break;
+    case DrawSwapReadbackResult::DRAW_SUCCESS:
+      consecutive_checkerboard_animations_ = 0;
+      forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE;
+      break;
+    case DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS:
+      needs_redraw_ = true;
+
+      // If we're already in the middle of a redraw, we don't need to
+      // restart it.
+      if (forced_redraw_state_ != FORCED_REDRAW_STATE_IDLE)
+        return;
+
+      needs_commit_ = true;
+      consecutive_checkerboard_animations_++;
+      if (settings_.timeout_and_draw_when_animation_checkerboards &&
+          consecutive_checkerboard_animations_ >=
+              settings_.maximum_number_of_failed_draws_before_draw_is_forced_) {
+        consecutive_checkerboard_animations_ = 0;
+        // We need to force a draw, but it doesn't make sense to do this until
+        // we've committed and have new textures.
+        forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_COMMIT;
+      }
+      break;
   }
 }
 
diff --git a/cc/scheduler/scheduler_state_machine.h b/cc/scheduler/scheduler_state_machine.h
index 069384b..7f0ef89 100644
--- a/cc/scheduler/scheduler_state_machine.h
+++ b/cc/scheduler/scheduler_state_machine.h
@@ -12,6 +12,7 @@
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/begin_frame_args.h"
+#include "cc/scheduler/draw_swap_readback_result.h"
 #include "cc/scheduler/scheduler_settings.h"
 
 namespace base {
@@ -180,7 +181,7 @@ class CC_EXPORT SchedulerStateMachine {
   void SetSmoothnessTakesPriority(bool smoothness_takes_priority);
 
   // Indicates whether ACTION_DRAW_AND_SWAP_IF_POSSIBLE drew to the screen.
-  void DidDrawIfPossibleCompleted(bool success);
+  void DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DrawResult result);
 
   // Indicates that a new commit flow needs to be performed, either to pull
   // updates from the main thread to the impl, or to push deltas from the impl
@@ -287,7 +288,7 @@ class CC_EXPORT SchedulerStateMachine {
   // we start throttling ACTION_MANAGE_TILES such that we average one
   // ManageTile per BeginImplFrame.
   int manage_tiles_funnel_;
-  int consecutive_failed_draws_;
+  int consecutive_checkerboard_animations_;
   bool needs_redraw_;
   bool needs_manage_tiles_;
   bool swap_used_incomplete_tile_;
diff --git a/cc/scheduler/scheduler_state_machine_unittest.cc b/cc/scheduler/scheduler_state_machine_unittest.cc
index 67925a0..4fbc224 100644
--- a/cc/scheduler/scheduler_state_machine_unittest.cc
+++ b/cc/scheduler/scheduler_state_machine_unittest.cc
@@ -198,7 +198,8 @@ TEST(SchedulerStateMachineTest,
   EXPECT_FALSE(state.CommitPending());
 
   // Failing the draw makes us require a commit.
-  state.DidDrawIfPossibleCompleted(false);
+  state.DidDrawIfPossibleCompleted(
+      DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
   state.OnBeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -235,8 +236,9 @@ TEST(SchedulerStateMachineTest,
   state.SetNeedsRedraw(true);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
-  // Failing the draw makes us require a commit.
-  state.DidDrawIfPossibleCompleted(false);
+  // Failing the draw for animation checkerboards makes us require a commit.
+  state.DidDrawIfPossibleCompleted(
+      DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
   state.OnBeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
@@ -277,7 +279,8 @@ void TestFailedDrawsWillEventuallyForceADrawAfterTheNextCommit(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
 
   // Fail the draw.
-  state.DidDrawIfPossibleCompleted(false);
+  state.DidDrawIfPossibleCompleted(
+      DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   EXPECT_TRUE(state.BeginImplFrameNeeded());
   EXPECT_TRUE(state.RedrawPending());
@@ -316,9 +319,9 @@ TEST(SchedulerStateMachineTest,
 void TestFailedDrawsDoNotRestartForcedDraw(
     bool deadline_scheduling_enabled) {
   SchedulerSettings scheduler_settings;
-  int drawLimit = 1;
+  int draw_limit = 1;
   scheduler_settings.maximum_number_of_failed_draws_before_draw_is_forced_ =
-    drawLimit;
+      draw_limit;
   scheduler_settings.deadline_scheduling_enabled = deadline_scheduling_enabled;
   scheduler_settings.impl_side_painting = true;
   StateMachine state(scheduler_settings);
@@ -351,9 +354,10 @@ void TestFailedDrawsDoNotRestartForcedDraw(
 
   // Fail the draw enough times to force a redraw,
   // then once more for good measure.
-  for (int i = 0; i < drawLimit; ++i)
-    state.DidDrawIfPossibleCompleted(false);
-  state.DidDrawIfPossibleCompleted(false);
+  for (int i = 0; i < draw_limit + 1; ++i) {
+    state.DidDrawIfPossibleCompleted(
+        DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
+  }
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   EXPECT_TRUE(state.BeginImplFrameNeeded());
   EXPECT_TRUE(state.RedrawPending());
@@ -374,9 +378,10 @@ void TestFailedDrawsDoNotRestartForcedDraw(
 
   // After failing additional draws, we should still be in a forced
   // redraw, but not back in WAITING_FOR_COMMIT.
-  for (int i = 0; i < drawLimit; ++i)
-    state.DidDrawIfPossibleCompleted(false);
-  state.DidDrawIfPossibleCompleted(false);
+  for (int i = 0; i < draw_limit + 1; ++i) {
+    state.DidDrawIfPossibleCompleted(
+        DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
+  }
   EXPECT_TRUE(state.RedrawPending());
   EXPECT_TRUE(state.ForcedRedrawState() ==
     SchedulerStateMachine::FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION);
@@ -415,8 +420,9 @@ TEST(SchedulerStateMachineTest, TestFailedDrawIsRetriedInNextBeginImplFrame) {
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
 
-  // Fail the draw
-  state.DidDrawIfPossibleCompleted(false);
+  // Failing the draw for animation checkerboards makes us require a commit.
+  state.DidDrawIfPossibleCompleted(
+      DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -453,7 +459,7 @@ TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame) {
   state.OnBeginImplFrameDeadline();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
-  state.DidDrawIfPossibleCompleted(true);
+  state.DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DRAW_SUCCESS);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
   // Before the next BeginImplFrame, set needs redraw again.
@@ -470,7 +476,7 @@ TEST(SchedulerStateMachineTest, TestDoestDrawTwiceInSameFrame) {
   state.OnBeginImplFrameDeadline();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
-  state.DidDrawIfPossibleCompleted(true);
+  state.DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DRAW_SUCCESS);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
   // We just swapped, so we should proactively request another BeginImplFrame.
@@ -715,7 +721,7 @@ TEST(SchedulerStateMachineTest, TestsetNeedsCommitIsNotLost) {
             state.CommitState());
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
-  state.DidDrawIfPossibleCompleted(true);
+  state.DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DRAW_SUCCESS);
 
   // Verify that another commit will start immediately after draw.
   EXPECT_ACTION_UPDATE_STATE(
@@ -762,7 +768,7 @@ TEST(SchedulerStateMachineTest, TestFullCycle) {
   state.OnBeginImplFrameDeadline();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
-  state.DidDrawIfPossibleCompleted(true);
+  state.DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DRAW_SUCCESS);
 
   // Should be synchronized, no draw needed, no action needed.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -813,7 +819,7 @@ TEST(SchedulerStateMachineTest, TestFullCycleWithCommitRequestInbetween) {
   state.OnBeginImplFrameDeadline();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE);
-  state.DidDrawIfPossibleCompleted(true);
+  state.DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DRAW_SUCCESS);
 
   // Should be synchronized, no draw needed, no action needed.
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
@@ -1449,7 +1455,7 @@ TEST(SchedulerStateMachineTest, TestImmediateFinishCommit) {
             state.CommitState());
 
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_READBACK);
-  state.DidDrawIfPossibleCompleted(true);
+  state.DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DRAW_SUCCESS);
 
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
@@ -1492,7 +1498,7 @@ void TestImmediateFinishCommitDuringCommit(bool deadline_scheduling_enabled) {
             state.CommitState());
 
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_READBACK);
-  state.DidDrawIfPossibleCompleted(true);
+  state.DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DRAW_SUCCESS);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
   // Should be waiting for the normal BeginMainFrame.
@@ -1546,7 +1552,7 @@ void ImmediateBeginMainFrameAbortedWhileInvisible(
             state.CommitState());
 
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_READBACK);
-  state.DidDrawIfPossibleCompleted(true);
+  state.DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DRAW_SUCCESS);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
   // Should be waiting for BeginMainFrame.
@@ -1602,7 +1608,7 @@ TEST(SchedulerStateMachineTest, ImmediateFinishCommitWhileCantDraw) {
             state.CommitState());
 
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_READBACK);
-  state.DidDrawIfPossibleCompleted(true);
+  state.DidDrawIfPossibleCompleted(DrawSwapReadbackResult::DRAW_SUCCESS);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 }
 
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index b323b82..2099b8a 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -110,26 +110,30 @@ class FakeSchedulerClient : public SchedulerClient {
     states_.push_back(scheduler_->StateAsValue().release());
     num_draws_++;
     bool did_readback = false;
+    DrawSwapReadbackResult::DrawResult result =
+        draw_will_happen_
+            ? DrawSwapReadbackResult::DRAW_SUCCESS
+            : DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
     return DrawSwapReadbackResult(
-        draw_will_happen_,
+        result,
         draw_will_happen_ && swap_will_happen_if_draw_happens_,
         did_readback);
   }
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapForced");
     states_.push_back(scheduler_->StateAsValue().release());
-    bool did_draw = true;
     bool did_swap = swap_will_happen_if_draw_happens_;
     bool did_readback = false;
-    return DrawSwapReadbackResult(did_draw, did_swap, did_readback);
+    return DrawSwapReadbackResult(
+        DrawSwapReadbackResult::DRAW_SUCCESS, did_swap, did_readback);
   }
   virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndReadback");
     states_.push_back(scheduler_->StateAsValue().release());
-    bool did_draw = true;
     bool did_swap = false;
     bool did_readback = true;
-    return DrawSwapReadbackResult(did_draw, did_swap, did_readback);
+    return DrawSwapReadbackResult(
+        DrawSwapReadbackResult::DRAW_SUCCESS, did_swap, did_readback);
   }
   virtual void ScheduledActionCommit() OVERRIDE {
     actions_.push_back("ScheduledActionCommit");
@@ -689,10 +693,10 @@ class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
 
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     NOTREACHED();
-    bool did_draw = true;
     bool did_swap = true;
     bool did_readback = false;
-    return DrawSwapReadbackResult(did_draw, did_swap, did_readback);
+    return DrawSwapReadbackResult(
+        DrawSwapReadbackResult::DRAW_SUCCESS, did_swap, did_readback);
   }
 
   virtual void ScheduledActionCommit() OVERRIDE {}
@@ -805,10 +809,10 @@ class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
 
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     NOTREACHED();
-    bool did_draw = true;
     bool did_swap = false;
     bool did_readback = false;
-    return DrawSwapReadbackResult(did_draw, did_swap, did_readback);
+    return DrawSwapReadbackResult(
+        DrawSwapReadbackResult::DRAW_SUCCESS, did_swap, did_readback);
   }
 
   virtual void ScheduledActionCommit() OVERRIDE {}
diff --git a/cc/test/fake_layer_tree_host_impl.cc b/cc/test/fake_layer_tree_host_impl.cc
index 1050f48..8c39d2e 100644
--- a/cc/test/fake_layer_tree_host_impl.cc
+++ b/cc/test/fake_layer_tree_host_impl.cc
@@ -16,6 +16,7 @@ FakeLayerTreeHostImpl::FakeLayerTreeHostImpl(Proxy* proxy)
                         0) {
   // Explicitly clear all debug settings.
   SetDebugState(LayerTreeDebugState());
+  SetViewportSize(gfx::Size(100, 100));
 }
 
 FakeLayerTreeHostImpl::FakeLayerTreeHostImpl(const LayerTreeSettings& settings,
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index 373f92b..a253782 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -35,10 +35,11 @@ TestHooks::TestHooks() {}
 
 TestHooks::~TestHooks() {}
 
-bool TestHooks::PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                      LayerTreeHostImpl::FrameData* frame_data,
-                                      bool result) {
-  return true;
+DrawSwapReadbackResult::DrawResult TestHooks::PrepareToDrawOnThread(
+    LayerTreeHostImpl* host_impl,
+    LayerTreeHostImpl::FrameData* frame_data,
+    DrawSwapReadbackResult::DrawResult draw_result) {
+  return draw_result;
 }
 
 base::TimeDelta TestHooks::LowFrequencyAnimationInterval() const {
@@ -101,12 +102,12 @@ class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
     }
   }
 
-  virtual bool PrepareToDraw(FrameData* frame,
-                             const gfx::Rect& damage_rect) OVERRIDE {
-    bool result = LayerTreeHostImpl::PrepareToDraw(frame, damage_rect);
-    if (!test_hooks_->PrepareToDrawOnThread(this, frame, result))
-      result = false;
-    return result;
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDraw(
+      FrameData* frame,
+      const gfx::Rect& damage_rect) OVERRIDE {
+    DrawSwapReadbackResult::DrawResult draw_result =
+        LayerTreeHostImpl::PrepareToDraw(frame, damage_rect);
+    return test_hooks_->PrepareToDrawOnThread(this, frame, draw_result);
   }
 
   virtual void DrawLayers(FrameData* frame,
diff --git a/cc/test/layer_tree_test.h b/cc/test/layer_tree_test.h
index 5646d7a..a3eaec4 100644
--- a/cc/test/layer_tree_test.h
+++ b/cc/test/layer_tree_test.h
@@ -46,9 +46,10 @@ class TestHooks : public AnimationDelegate {
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) {}
   virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                            bool success) {}
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result);
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) {}
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) {}
   virtual void SwapBuffersCompleteOnThread(LayerTreeHostImpl* host_impl) {}
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 146c0e0..3eb98bf21 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -697,11 +697,11 @@ static void AppendQuadsToFillScreen(
   }
 }
 
-bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
+DrawSwapReadbackResult::DrawResult LayerTreeHostImpl::CalculateRenderPasses(
+    FrameData* frame) {
   DCHECK(frame->render_passes.empty());
-
-  if (!CanDraw() || !active_tree_->root_layer())
-    return false;
+  DCHECK(CanDraw());
+  DCHECK(active_tree_->root_layer());
 
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
                             *frame->render_surface_layer_list);
@@ -725,7 +725,7 @@ bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
     DCHECK_EQ(0u, active_tree_->LayersWithCopyOutputRequest().size());
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
-    return true;
+    return DrawSwapReadbackResult::DRAW_SUCCESS;
   }
 
   TRACE_EVENT1("cc",
@@ -779,7 +779,8 @@ bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   // still draw the frame. However when the layer being checkerboarded is moving
   // due to an impl-animation, we drop the frame to avoid flashing due to the
   // texture suddenly appearing in the future.
-  bool draw_frame = true;
+  DrawSwapReadbackResult::DrawResult draw_result =
+      DrawSwapReadbackResult::DRAW_SUCCESS;
   // When we have a copy request for a layer, we need to draw no matter
   // what, as the layer may disappear after this frame.
   bool have_copy_request = false;
@@ -865,8 +866,10 @@ bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
       bool layer_has_animating_transform =
           it->screen_space_transform_is_animating() ||
           it->draw_transform_is_animating();
-      if (layer_has_animating_transform)
-        draw_frame = false;
+      if (layer_has_animating_transform) {
+        draw_result =
+            DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
+      }
     }
 
     if (append_quads_data.had_incomplete_tile)
@@ -877,7 +880,7 @@ bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
 
   if (have_copy_request ||
       output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
-    draw_frame = true;
+    draw_result = DrawSwapReadbackResult::DRAW_SUCCESS;
 
 #ifndef NDEBUG
   for (size_t i = 0; i < frame->render_passes.size(); ++i) {
@@ -901,7 +904,7 @@ bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
         occlusion_tracker);
   }
 
-  if (draw_frame)
+  if (draw_result == DrawSwapReadbackResult::DRAW_SUCCESS)
     occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
   else
     DCHECK(!have_copy_request);
@@ -926,7 +929,7 @@ bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   if (output_surface_->ForcedDrawToSoftwareDevice())
     DCHECK_EQ(1u, frame->render_passes.size());
 
-  return draw_frame;
+  return draw_result;
 }
 
 void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
@@ -1078,8 +1081,9 @@ void LayerTreeHostImpl::RemoveRenderPasses(RenderPassCuller culler,
   }
 }
 
-bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame,
-                                      const gfx::Rect& damage_rect) {
+DrawSwapReadbackResult::DrawResult LayerTreeHostImpl::PrepareToDraw(
+    FrameData* frame,
+    const gfx::Rect& damage_rect) {
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::PrepareToDraw",
                "SourceFrameNumber",
@@ -1109,15 +1113,16 @@ bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame,
         AddDamageNextUpdate(device_viewport_damage_rect);
   }
 
-  if (!CalculateRenderPasses(frame)) {
+  DrawSwapReadbackResult::DrawResult draw_result = CalculateRenderPasses(frame);
+  if (draw_result != DrawSwapReadbackResult::DRAW_SUCCESS) {
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
-    return false;
+    return draw_result;
   }
 
-  // If we return true, then we expect DrawLayers() to be called before this
-  // function is called again.
-  return true;
+  // If we return DRAW_SUCCESS, then we expect DrawLayers() to be called before
+  // this function is called again.
+  return draw_result;
 }
 
 void LayerTreeHostImpl::EvictTexturesForTesting() {
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 3b8e65b..fa76602 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -30,6 +30,7 @@
 #include "cc/quads/render_pass.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/tile_manager.h"
+#include "cc/scheduler/draw_swap_readback_result.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/rect.h"
@@ -179,8 +180,9 @@ class CC_EXPORT LayerTreeHostImpl
   // to avoid displaying the frame. If PrepareToDraw is called, DidDrawAllLayers
   // must also be called, regardless of whether DrawLayers is called between the
   // two.
-  virtual bool PrepareToDraw(FrameData* frame,
-                             const gfx::Rect& damage_rect);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDraw(
+      FrameData* frame,
+      const gfx::Rect& damage_rect);
   virtual void DrawLayers(FrameData* frame, base::TimeTicks frame_begin_time);
   // Must be called if and only if PrepareToDraw was called.
   void DidDrawAllLayers(const FrameData& frame);
@@ -481,10 +483,10 @@ class CC_EXPORT LayerTreeHostImpl
 
   void UpdateTileManagerMemoryPolicy(const ManagedMemoryPolicy& policy);
 
-  // Returns false if the frame should not be displayed. This function should
-  // only be called from PrepareToDraw, as DidDrawAllLayers must be called
-  // if this helper function is called.
-  bool CalculateRenderPasses(FrameData* frame);
+  // This function should only be called from PrepareToDraw, as DidDrawAllLayers
+  // must be called if this helper function is called.  Returns DRAW_SUCCESS if
+  // the frame should be drawn.
+  DrawSwapReadbackResult::DrawResult CalculateRenderPasses(FrameData* frame);
 
   void SendReleaseResourcesRecursive(LayerImpl* current);
   bool EnsureRenderSurfaceLayerList();
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 6825599..59b19bb 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -260,7 +260,8 @@ class LayerTreeHostImplTest : public testing::Test,
 
   void DrawFrame() {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
@@ -1483,7 +1484,8 @@ TEST_F(LayerTreeHostImplTest, WillDrawReturningFalseDoesNotCall) {
 
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect(10, 10)));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect(10, 10)));
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
 
@@ -1498,7 +1500,8 @@ TEST_F(LayerTreeHostImplTest, WillDrawReturningFalseDoesNotCall) {
     layer->set_will_draw_returns_false();
     layer->ClearDidDrawCheck();
 
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect(10, 10)));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect(10, 10)));
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
 
@@ -1530,7 +1533,8 @@ TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -1545,7 +1549,8 @@ TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -1584,7 +1589,8 @@ TEST_F(LayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) {
   EXPECT_FALSE(top_layer->will_draw_called());
   EXPECT_FALSE(top_layer->did_draw_called());
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -1616,7 +1622,8 @@ TEST_F(LayerTreeHostImplTest, DidDrawCalledOnAllLayers) {
   EXPECT_FALSE(layer2->did_draw_called());
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -1689,7 +1696,8 @@ TEST_F(LayerTreeHostImplTest, PrepareToDrawFailsWhenAnimationUsesCheckerboard) {
 
   LayerTreeHostImpl::FrameData frame;
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -1707,7 +1715,8 @@ TEST_F(LayerTreeHostImplTest, PrepareToDrawFailsWhenAnimationUsesCheckerboard) {
                                            false,
                                            host_impl_->resource_provider()));
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -1725,7 +1734,8 @@ TEST_F(LayerTreeHostImplTest, PrepareToDrawFailsWhenAnimationUsesCheckerboard) {
                                            true,
                                            host_impl_->resource_provider()));
 
-  EXPECT_FALSE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -2035,7 +2045,8 @@ TEST_F(LayerTreeHostImplTest, PageScaleDeltaAppliedToRootScrollLayerOnly) {
   // 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, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -2851,7 +2862,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetContentsOpaque(true);
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
@@ -2860,7 +2872,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetContentsOpaque(false);
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
@@ -2870,7 +2883,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetOpacity(0.5f);
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
@@ -2880,7 +2894,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetOpacity(0.5f);
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
@@ -2902,7 +2917,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer2->SetOpacity(1.f);
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
@@ -2915,7 +2931,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
@@ -2929,7 +2946,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
@@ -2946,7 +2964,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
@@ -2962,7 +2981,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer2->SetOpacity(0.5f);
   layer2->SetExpectation(true, false);
   layer2->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
@@ -2977,7 +2997,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer2->SetOpacity(1.f);
   layer2->SetExpectation(true, false);
   layer2->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
@@ -2993,7 +3014,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer2->SetOpacity(1.f);
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
@@ -3006,7 +3028,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
@@ -3018,7 +3041,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
@@ -3030,7 +3054,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
@@ -3043,7 +3068,8 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   layer1->SetOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::RectF(layer1->content_bounds()));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
@@ -3088,7 +3114,8 @@ class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     EXPECT_EQ(0u, CountGutterQuads(frame.render_passes[0]->quad_list));
@@ -3109,7 +3136,8 @@ class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     EXPECT_EQ(1u, CountGutterQuads(frame.render_passes[0]->quad_list));
@@ -3130,7 +3158,8 @@ class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     EXPECT_EQ(4u, CountGutterQuads(frame.render_passes[0]->quad_list));
@@ -3152,7 +3181,8 @@ class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     EXPECT_EQ(0u, CountGutterQuads(frame.render_passes[0]->quad_list));
@@ -3371,7 +3401,8 @@ TEST_F(LayerTreeHostImplTest, ReshapeNotCalledUntilDraw) {
   LayerTreeHostImpl::FrameData frame;
   host_impl_->SetViewportSize(gfx::Size(10, 10));
   host_impl_->SetDeviceScaleFactor(1.f);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(provider->TestContext3d()->reshape_called());
   EXPECT_EQ(provider->TestContext3d()->width(), 10);
@@ -3381,7 +3412,8 @@ TEST_F(LayerTreeHostImplTest, ReshapeNotCalledUntilDraw) {
   provider->TestContext3d()->clear_reshape_called();
 
   host_impl_->SetViewportSize(gfx::Size(20, 30));
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(provider->TestContext3d()->reshape_called());
   EXPECT_EQ(provider->TestContext3d()->width(), 20);
@@ -3391,7 +3423,8 @@ TEST_F(LayerTreeHostImplTest, ReshapeNotCalledUntilDraw) {
   provider->TestContext3d()->clear_reshape_called();
 
   host_impl_->SetDeviceScaleFactor(2.f);
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   EXPECT_TRUE(provider->TestContext3d()->reshape_called());
   EXPECT_EQ(provider->TestContext3d()->width(), 20);
@@ -3441,7 +3474,8 @@ TEST_F(LayerTreeHostImplTest, PartialSwapReceivesDamageRect) {
   LayerTreeHostImpl::FrameData frame;
 
   // First frame, the entire screen should get swapped.
-  EXPECT_TRUE(layer_tree_host_impl->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            layer_tree_host_impl->PrepareToDraw(&frame, gfx::Rect()));
   layer_tree_host_impl->DrawLayers(&frame, gfx::FrameTime::Now());
   layer_tree_host_impl->DidDrawAllLayers(frame);
   layer_tree_host_impl->SwapBuffers(frame);
@@ -3454,7 +3488,8 @@ TEST_F(LayerTreeHostImplTest, PartialSwapReceivesDamageRect) {
   // 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, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            layer_tree_host_impl->PrepareToDraw(&frame, gfx::Rect()));
   layer_tree_host_impl->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
   layer_tree_host_impl->SwapBuffers(frame);
@@ -3473,7 +3508,8 @@ TEST_F(LayerTreeHostImplTest, PartialSwapReceivesDamageRect) {
   // This will damage everything.
   layer_tree_host_impl->active_tree()->root_layer()->SetBackgroundColor(
       SK_ColorBLACK);
-  EXPECT_TRUE(layer_tree_host_impl->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            layer_tree_host_impl->PrepareToDraw(&frame, gfx::Rect()));
   layer_tree_host_impl->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
   layer_tree_host_impl->SwapBuffers(frame);
@@ -3502,7 +3538,8 @@ TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) {
 
   LayerTreeHostImpl::FrameData frame;
 
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            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);
@@ -3637,7 +3674,8 @@ TEST_F(LayerTreeHostImplTest, NoPartialSwap) {
   harness.MustSetNoScissor();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
@@ -3650,7 +3688,8 @@ TEST_F(LayerTreeHostImplTest, NoPartialSwap) {
   harness.MustSetScissor(0, 0, 10, 10);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
@@ -3674,7 +3713,8 @@ TEST_F(LayerTreeHostImplTest, PartialSwap) {
   harness.MustDrawSolidQuad();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
@@ -3689,7 +3729,8 @@ TEST_F(LayerTreeHostImplTest, PartialSwap) {
   harness.MustDrawSolidQuad();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
@@ -3780,7 +3821,8 @@ TEST_F(LayerTreeHostImplTest, ContributingLayerEmptyScissorPartialSwap) {
       SetupLayersForOpacity(true, this, &proxy_, &stats_instrumentation_);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Verify all quads have been computed
     ASSERT_EQ(2U, frame.render_passes.size());
@@ -3801,7 +3843,8 @@ TEST_F(LayerTreeHostImplTest, ContributingLayerEmptyScissorNoPartialSwap) {
       SetupLayersForOpacity(false, this, &proxy_, &stats_instrumentation_);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
 
     // Verify all quads have been computed
     ASSERT_EQ(2U, frame.render_passes.size());
@@ -3857,7 +3900,8 @@ TEST_F(LayerTreeHostImplTest, LayersFreeTextures) {
   EXPECT_EQ(0u, context3d->NumTextures());
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
   host_impl_->SwapBuffers(frame);
@@ -3902,7 +3946,8 @@ TEST_F(LayerTreeHostImplTest, HasTransparentBackground) {
   EXPECT_CALL(*mock_context, drawElements(_, _, _, _))
       .Times(1);
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
   Mock::VerifyAndClearExpectations(&mock_context);
@@ -3910,7 +3955,8 @@ TEST_F(LayerTreeHostImplTest, HasTransparentBackground) {
   // Verify no quads are drawn when transparent background is set.
   host_impl_->active_tree()->set_has_transparent_background(true);
   host_impl_->SetFullRootLayerDamage();
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
   Mock::VerifyAndClearExpectations(&mock_context);
@@ -3967,7 +4013,8 @@ class LayerTreeHostImplTestWithDelegatingRenderer
     bool expect_to_draw = !expected_damage.IsEmpty();
 
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     if (!expect_to_draw) {
       // With no damage, we don't draw, and no quads are created.
@@ -4118,7 +4165,8 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithScaling) {
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
@@ -4146,7 +4194,8 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithScaling) {
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
@@ -4176,7 +4225,8 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithScaling) {
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
@@ -4239,7 +4289,8 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithDifferentBounds) {
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
@@ -4266,7 +4317,8 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithDifferentBounds) {
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
@@ -4296,7 +4348,8 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithDifferentBounds) {
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
@@ -4321,7 +4374,8 @@ TEST_F(LayerTreeHostImplTest, MaskLayerWithDifferentBounds) {
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
@@ -4389,7 +4443,8 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerWithDifferentBounds) {
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
@@ -4417,7 +4472,8 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerWithDifferentBounds) {
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
@@ -4448,7 +4504,8 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerWithDifferentBounds) {
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
@@ -4474,7 +4531,8 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerWithDifferentBounds) {
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
@@ -4554,7 +4612,8 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerForSurfaceWithUnclippedChild) {
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
@@ -4588,7 +4647,8 @@ TEST_F(LayerTreeHostImplTest, ReflectionMaskLayerForSurfaceWithUnclippedChild) {
   content_child_layer->SetPosition(gfx::Point(-50, 0));
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
@@ -4687,7 +4747,8 @@ TEST_F(LayerTreeHostImplTest, MaskLayerForSurfaceWithClippedLayer) {
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
@@ -4769,7 +4830,8 @@ TEST_F(LayerTreeHostImplTest, FarAwayQuadsDontNeedAA) {
   ASSERT_EQ(1u, host_impl_->active_tree()->RenderSurfaceLayerList().size());
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
   ASSERT_EQ(1u, frame.render_passes.size());
   ASSERT_LE(1u, frame.render_passes[0]->quad_list.size());
@@ -4803,7 +4865,8 @@ TEST_F(CompositorFrameMetadataTest, CompositorFrameAckCountsAsSwapComplete) {
   SetupRootLayerImpl(FakeLayerWithQuads::Create(host_impl_->active_tree(), 1));
   {
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+              host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, base::TimeTicks());
     host_impl_->DidDrawAllLayers(frame);
   }
@@ -4883,7 +4946,8 @@ TEST_F(LayerTreeHostImplTest,
   SetupRootLayerImpl(root_layer.PassAs<LayerImpl>());
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -5188,7 +5252,8 @@ TEST_F(LayerTreeHostImplTest, ShutdownReleasesContext) {
   host_impl_->active_tree()->root_layer()->PassCopyRequests(&requests);
 
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 
@@ -5376,7 +5441,8 @@ TEST_F(LayerTreeHostImplTest, LatencyInfoPassedToCompositorFrameMetadata) {
 
   gfx::Rect full_frame_damage(host_impl_->DrawViewportSize());
   LayerTreeHostImpl::FrameData frame;
-  EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
+  EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS,
+            host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
   EXPECT_TRUE(host_impl_->SwapBuffers(frame));
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index dd241af..da4bb54 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -285,10 +285,11 @@ class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
@@ -302,7 +303,7 @@ class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
       EXPECT_TRUE(root_damage_rect.Contains(invalid_rect_));
     }
 
-    return result;
+    return draw_result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
@@ -516,9 +517,10 @@ class LayerTreeHostTestCompositeAndReadbackDuringForcedDraw
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     int sfn = host_impl->active_tree()->source_frame_number();
     EXPECT_TRUE(sfn == kFirstCommitSourceFrameNumber ||
                 sfn == kReadbackSourceFrameNumber ||
@@ -532,8 +534,8 @@ class LayerTreeHostTestCompositeAndReadbackDuringForcedDraw
       PostReadbackToMainThread();
     }
 
-    // Returning false will result in a forced draw.
-    return false;
+    // Aborting for checkerboarding animations will result in a forced draw.
+    return DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -576,9 +578,10 @@ class LayerTreeHostTestCompositeAndReadbackAfterForcedDraw
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     int sfn = host_impl->active_tree()->source_frame_number();
     EXPECT_TRUE(sfn == kFirstCommitSourceFrameNumber ||
                 sfn == kForcedDrawSourceFrameNumber ||
@@ -586,8 +589,8 @@ class LayerTreeHostTestCompositeAndReadbackAfterForcedDraw
                 sfn == kReadbackReplacementSourceFrameNumber)
         << sfn;
 
-    // Returning false will result in a forced draw.
-    return false;
+    // Aborting for checkerboarding animations will result in a forced draw.
+    return DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   virtual void DidCommit() OVERRIDE {
@@ -652,10 +655,11 @@ class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
       host_impl->SetNeedsRedrawRect(invalid_rect_);
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
@@ -679,7 +683,7 @@ class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
         NOTREACHED();
     }
 
-    return result;
+    return draw_result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -749,10 +753,11 @@ class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
@@ -776,7 +781,7 @@ class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
         NOTREACHED();
     }
 
-    return result;
+    return draw_result;
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
@@ -2584,11 +2589,12 @@ class LayerTreeHostTestBeginImplFrameNotification : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     EndTest();
-    return true;
+    return DrawSwapReadbackResult::DRAW_SUCCESS;
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ -2871,9 +2877,10 @@ class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
     EXPECT_CALL(*mock_context_, bindTexture(_, 0)).Times(AnyNumber());
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     Mock::VerifyAndClearExpectations(&mock_context_);
 
     // The io surface layer's texture is drawn.
@@ -2883,7 +2890,7 @@ class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
     EXPECT_CALL(*mock_context_, drawElements(GL_TRIANGLES, 6, _, _))
         .Times(AtLeast(1));
 
-    return result;
+    return draw_result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -4127,9 +4134,10 @@ class LayerTreeHostTestTreeActivationCallback : public LayerTreeHostTest {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     ++num_commits_;
     switch (num_commits_) {
       case 1:
@@ -4155,7 +4163,7 @@ class LayerTreeHostTestTreeActivationCallback : public LayerTreeHostTest {
         break;
     }
     return LayerTreeHostTest::PrepareToDrawOnThread(
-        host_impl, frame_data, result);
+        host_impl, frame_data, draw_result);
   }
 
   virtual void AfterTest() OVERRIDE { EXPECT_EQ(3, num_commits_); }
diff --git a/cc/trees/layer_tree_host_unittest_animation.cc b/cc/trees/layer_tree_host_unittest_animation.cc
index 22c8965..92c113e 100644
--- a/cc/trees/layer_tree_host_unittest_animation.cc
+++ b/cc/trees/layer_tree_host_unittest_animation.cc
@@ -201,11 +201,11 @@ class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws
       EndTest();
   }
 
-  virtual bool PrepareToDrawOnThread(
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
-      bool result) OVERRIDE {
-    return false;
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    return DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   virtual void AfterTest() OVERRIDE { }
@@ -893,16 +893,17 @@ class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     if (added_animations_ < 2)
-      return result;
+      return draw_result;
     if (TestEnded())
-      return result;
+      return draw_result;
     // Act like there is checkerboard when the second animation wants to draw.
     ++prevented_draw_;
-    return false;
+    return DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index 57c780b..8db1faa2 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -127,12 +127,13 @@ class LayerTreeHostContextTest : public LayerTreeTest {
     return offscreen_contexts_;
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
     if (!times_to_lose_during_draw_)
-      return result;
+      return draw_result;
 
     --times_to_lose_during_draw_;
     LoseContext();
@@ -142,7 +143,7 @@ class LayerTreeHostContextTest : public LayerTreeTest {
     times_to_fail_create_offscreen_ = times_to_fail_recreate_offscreen_;
     times_to_fail_recreate_offscreen_ = 0;
 
-    return result;
+    return draw_result;
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -1114,15 +1115,16 @@ class LayerTreeHostContextTestDontUseLostResources
     }
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() == 2) {
       // Lose the context during draw on the second commit. This will cause
       // a third commit to recover.
       context3d_->set_times_bind_texture_succeeds(0);
     }
-    return true;
+    return draw_result;
   }
 
   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
@@ -1209,12 +1211,13 @@ class LayerTreeHostContextTestCompositeAndReadbackBeforeOutputSurfaceInit
     EXPECT_EQ(1, times_output_surface_created_);
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     EXPECT_GE(host_impl->active_tree()->source_frame_number(), 0);
     EXPECT_LE(host_impl->active_tree()->source_frame_number(), 1);
-    return true;
+    return draw_result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
@@ -1260,9 +1263,10 @@ class LayerTreeHostContextTestLoseOutputSurfaceDuringReadbackAndForcedDraw
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     int sfn = host_impl->active_tree()->source_frame_number();
     EXPECT_TRUE(sfn == kFirstOutputSurfaceInitSourceFrameNumber ||
                 sfn == kSecondOutputSurfaceInitSourceFrameNumber ||
@@ -1279,7 +1283,7 @@ class LayerTreeHostContextTestLoseOutputSurfaceDuringReadbackAndForcedDraw
       LoseContext();
     }
 
-    return false;
+    return DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
@@ -1338,9 +1342,10 @@ class LayerTreeHostContextTestReadbackWithForcedDrawAndOutputSurfaceInit
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     int sfn = host_impl->active_tree()->source_frame_number();
     EXPECT_TRUE(sfn == kFirstOutputSurfaceInitSourceFrameNumber ||
                 sfn == kSecondOutputSurfaceInitSourceFrameNumber ||
@@ -1356,7 +1361,7 @@ class LayerTreeHostContextTestReadbackWithForcedDrawAndOutputSurfaceInit
     }
 
     // Returning false will result in a forced draw.
-    return false;
+    return DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   virtual void DidInitializeOutputSurface(bool succeeded) OVERRIDE {
diff --git a/cc/trees/layer_tree_host_unittest_damage.cc b/cc/trees/layer_tree_host_unittest_damage.cc
index 7f008b4..9c1c912 100644
--- a/cc/trees/layer_tree_host_unittest_damage.cc
+++ b/cc/trees/layer_tree_host_unittest_damage.cc
@@ -48,10 +48,11 @@ class LayerTreeHostDamageTestSetNeedsRedraw
     }
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
 
     RenderSurfaceImpl* root_surface =
         impl->active_tree()->root_layer()->render_surface();
@@ -73,7 +74,7 @@ class LayerTreeHostDamageTestSetNeedsRedraw
     }
 
     ++draw_count_;
-    return result;
+    return draw_result;
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ -109,10 +110,11 @@ class LayerTreeHostDamageTestSetViewportSize
     }
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
 
     RenderSurfaceImpl* root_surface =
         impl->active_tree()->root_layer()->render_surface();
@@ -134,7 +136,7 @@ class LayerTreeHostDamageTestSetViewportSize
     }
 
     ++draw_count_;
-    return result;
+    return draw_result;
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ -167,10 +169,11 @@ class LayerTreeHostDamageTestNoDamageDoesNotSwap
     LayerTreeHostDamageTest::SetupTree();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
 
     int source_frame = host_impl->active_tree()->source_frame_number();
     switch (source_frame) {
@@ -191,7 +194,7 @@ class LayerTreeHostDamageTestNoDamageDoesNotSwap
         EndTest();
         break;
     }
-    return result;
+    return draw_result;
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
@@ -256,10 +259,11 @@ class LayerTreeHostDamageTestNoDamageReadbackDoesDraw
     LayerTreeHostDamageTest::SetupTree();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
 
     int source_frame = host_impl->active_tree()->source_frame_number();
     switch (source_frame) {
@@ -284,7 +288,7 @@ class LayerTreeHostDamageTestNoDamageReadbackDoesDraw
         NOTREACHED();
         break;
     }
-    return result;
+    return draw_result;
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
@@ -326,10 +330,11 @@ class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest {
     LayerTreeHostDamageTest::SetupTree();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
 
     RenderSurfaceImpl* root_surface =
         host_impl->active_tree()->root_layer()->render_surface();
@@ -398,7 +403,7 @@ class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest {
         EndTest();
         break;
     }
-    return result;
+    return draw_result;
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
@@ -461,10 +466,11 @@ class LayerTreeHostDamageTestScrollbarDoesDamage
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
     RenderSurfaceImpl* root_surface =
         host_impl->active_tree()->root_layer()->render_surface();
     gfx::RectF root_damage =
@@ -488,7 +494,7 @@ class LayerTreeHostDamageTestScrollbarDoesDamage
         EndTest();
         break;
     }
-    return result;
+    return draw_result;
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
@@ -532,10 +538,11 @@ class LayerTreeHostDamageTestScrollbarCommitDoesNoDamage
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
     RenderSurfaceImpl* root_surface =
         host_impl->active_tree()->root_layer()->render_surface();
     gfx::RectF root_damage =
@@ -561,7 +568,7 @@ class LayerTreeHostDamageTestScrollbarCommitDoesNoDamage
         NOTREACHED();
         break;
     }
-    return result;
+    return draw_result;
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
@@ -622,10 +629,11 @@ class LayerTreeHostDamageTestVisibleTilesStillTriggerDraws
     update_visible_tile_count_ = 0;
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame_data,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame_data,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
     prepare_to_draw_count_++;
     switch (prepare_to_draw_count_) {
       case 1:
@@ -651,7 +659,7 @@ class LayerTreeHostDamageTestVisibleTilesStillTriggerDraws
         break;
     }
 
-    return result;
+    return draw_result;
   }
 
   virtual void UpdateVisibleTilesOnThread(
diff --git a/cc/trees/layer_tree_host_unittest_delegated.cc b/cc/trees/layer_tree_host_unittest_delegated.cc
index 7b0926f..7c42b80 100644
--- a/cc/trees/layer_tree_host_unittest_delegated.cc
+++ b/cc/trees/layer_tree_host_unittest_delegated.cc
@@ -709,13 +709,14 @@ class LayerTreeHostDelegatedTestLayerUsesFrameDamage
     first_draw_for_source_frame_ = true;
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame,
-                                     bool result) OVERRIDE {
-    EXPECT_TRUE(result);
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
 
     if (!first_draw_for_source_frame_)
-      return result;
+      return draw_result;
 
     gfx::RectF damage_rect;
     if (!frame->has_no_damage) {
@@ -811,7 +812,7 @@ class LayerTreeHostDelegatedTestLayerUsesFrameDamage
         break;
     }
 
-    return result;
+    return draw_result;
   }
 
  protected:
diff --git a/cc/trees/layer_tree_host_unittest_video.cc b/cc/trees/layer_tree_host_unittest_video.cc
index 5413a60..55defd6 100644
--- a/cc/trees/layer_tree_host_unittest_video.cc
+++ b/cc/trees/layer_tree_host_unittest_video.cc
@@ -46,9 +46,10 @@ class LayerTreeHostVideoTestSetNeedsDisplay
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                     LayerTreeHostImpl::FrameData* frame,
-                                     bool result) OVERRIDE {
+  virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
+      LayerTreeHostImpl* host_impl,
+      LayerTreeHostImpl::FrameData* frame,
+      DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
     LayerImpl* root_layer = host_impl->active_tree()->root_layer();
     RenderSurfaceImpl* root_surface = root_layer->render_surface();
     gfx::RectF damage_rect =
@@ -68,8 +69,8 @@ class LayerTreeHostVideoTestSetNeedsDisplay
         break;
     }
 
-    EXPECT_TRUE(result);
-    return result;
+    EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
+    return draw_result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index 15a1521..5aa3533 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -1110,17 +1110,9 @@ DrawSwapReadbackResult ThreadProxy::DrawSwapReadbackInternal(
     bool readback_requested) {
   TRACE_EVENT_SYNTHETIC_DELAY("cc.DrawAndSwap");
   DrawSwapReadbackResult result;
-  result.did_draw = false;
-  result.did_swap = false;
-  result.did_readback = false;
+
   DCHECK(IsImplThread());
   DCHECK(impl().layer_tree_host_impl.get());
-  if (!impl().layer_tree_host_impl)
-    return result;
-
-  DCHECK(impl().layer_tree_host_impl->renderer());
-  if (!impl().layer_tree_host_impl->renderer())
-    return result;
 
   base::TimeTicks start_time = base::TimeTicks::HighResNow();
   base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
@@ -1161,15 +1153,18 @@ DrawSwapReadbackResult ThreadProxy::DrawSwapReadbackInternal(
     if (drawing_for_readback)
       readback_rect = impl().readback_request->rect;
 
-    if (impl().layer_tree_host_impl->PrepareToDraw(&frame, readback_rect) ||
-        forced_draw)
-      draw_frame = true;
+    result.draw_result =
+        impl().layer_tree_host_impl->PrepareToDraw(&frame, readback_rect);
+    draw_frame = forced_draw ||
+                 result.draw_result == DrawSwapReadbackResult::DRAW_SUCCESS;
   }
 
   if (draw_frame) {
     impl().layer_tree_host_impl->DrawLayers(
         &frame, impl().scheduler->LastBeginImplFrameTime());
-    result.did_draw = true;
+    result.draw_result = DrawSwapReadbackResult::DRAW_SUCCESS;
+  } else {
+    DCHECK_NE(DrawSwapReadbackResult::DRAW_SUCCESS, result.draw_result);
   }
   impl().layer_tree_host_impl->DidDrawAllLayers(frame);