cc: Make PrepareToDraw return an enum for why it aborts

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 267 matching lines @@
         root_layer_(ContentLayer::Create(&client_)) {}
 
   virtual void BeginTest() OVERRIDE {
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     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::DID_DRAW, draw_result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
       root_damage_rect = frame_data->render_passes.back()->damage_rect;
 
     if (!num_draws_) {
       // If this is the first frame, expect full frame damage.
       EXPECT_RECT_EQ(root_damage_rect, gfx::Rect(bounds_));
     } else {
       // Check that invalid_rect_ is indeed repainted.
       EXPECT_TRUE(root_damage_rect.Contains(invalid_rect_));
     }
 
-    return result;
+    return draw_result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (!num_draws_) {
       PostSetNeedsRedrawRectToMainThread(invalid_rect_);
     } else {
       EndTest();
     }
     num_draws_++;
   }
@@ skipping 193 matching lines @@
       : did_post_readback_(false) {}
 
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     // This enables forced draws after a single prepare to draw failure.
     settings->timeout_and_draw_when_animation_checkerboards = true;
     settings->maximum_number_of_failed_draws_before_draw_is_forced_ = 1;
   }
 
   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 ||
                 sfn == kReadbackReplacementAndForcedDrawSourceFrameNumber)
         << sfn;
 
     // Before we react to the failed draw by initiating the forced draw
     // sequence, start a readback on the main thread.
     if (sfn == kFirstCommitSourceFrameNumber && !did_post_readback_) {
       did_post_readback_ = true;
       PostReadbackToMainThread();
     }
 
     // Returning false will result in a forced draw.
-    return false;
+    return DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     // We should only draw for the readback and the forced draw.
     int sfn = host_impl->active_tree()->source_frame_number();
     EXPECT_TRUE(sfn == kReadbackSourceFrameNumber ||
                 sfn == kReadbackReplacementAndForcedDrawSourceFrameNumber)
         << sfn;
   }
 
@@ skipping 22 matching lines @@
   static const int kReadbackReplacementSourceFrameNumber = 3;
 
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     // This enables forced draws after a single prepare to draw failure.
     settings->timeout_and_draw_when_animation_checkerboards = true;
     settings->maximum_number_of_failed_draws_before_draw_is_forced_ = 1;
   }
 
   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 ||
                 sfn == kReadbackSourceFrameNumber ||
                 sfn == kReadbackReplacementSourceFrameNumber)
         << sfn;
 
     // Returning false will result in a forced draw.
-    return false;
+    return DrawSwapReadbackResult::DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   virtual void DidCommit() OVERRIDE {
     if (layer_tree_host()->source_frame_number() ==
         kForcedDrawSourceFrameNumber) {
       // Avoid aborting the forced draw commit so source_frame_number
       // increments.
       layer_tree_host()->SetNeedsCommit();
     } else if (layer_tree_host()->source_frame_number() ==
                kReadbackSourceFrameNumber) {
@@ skipping 44 matching lines @@
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (num_draws_ == 3 && host_impl->settings().impl_side_painting)
       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::DID_DRAW, draw_result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
       root_damage_rect = frame_data->render_passes.back()->damage_rect;
 
     switch (num_draws_) {
       case 0:
         EXPECT_RECT_EQ(gfx::Rect(bounds_), root_damage_rect);
         break;
       case 1:
       case 2:
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 0, 0), root_damage_rect);
         break;
       case 3:
         EXPECT_RECT_EQ(invalid_rect_, root_damage_rect);
         break;
       case 4:
         EXPECT_RECT_EQ(gfx::Rect(bounds_), root_damage_rect);
         break;
       default:
         NOTREACHED();
     }
 
-    return result;
+    return draw_result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     switch (num_draws_) {
       case 0:
       case 1:
         // Cycle through a couple of empty commits to ensure we're observing the
         // right behavior
         PostSetNeedsCommitToMainThread();
         break;
@@ skipping 49 matching lines @@
 
     child_layer_ = FakeContentLayer::Create(&client_);
     child_layer_->SetBounds(gfx::Size(25, 25));
     parent_layer_->AddChild(child_layer_);
 
     LayerTreeHostTest::SetupTree();
   }
 
   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::DID_DRAW, draw_result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
       root_damage_rect = frame_data->render_passes.back()->damage_rect;
 
     // The first time, the whole view needs be drawn.
     // Afterwards, just the opacity of surface_layer1 is changed a few times,
     // and each damage should be the bounding box of it and its child. If this
     // was working improperly, the damage might not include its childs bounding
     // box.
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         EXPECT_RECT_EQ(gfx::Rect(root_layer_->bounds()), root_damage_rect);
         break;
       case 2:
       case 3:
       case 4:
         EXPECT_RECT_EQ(gfx::Rect(child_layer_->bounds()), root_damage_rect);
         break;
       default:
         NOTREACHED();
     }
 
-    return result;
+    return draw_result;
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Test not owning the surface.
         parent_layer_->SetOpacity(1.0f);
         break;
       case 2:
         parent_layer_->SetOpacity(0.0f);
@@ skipping 1787 matching lines @@
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->begin_impl_frame_scheduling_enabled = true;
   }
 
   virtual void BeginTest() OVERRIDE {
     // This will trigger a SetNeedsBeginImplFrame which will trigger a
     // BeginImplFrame.
     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::DID_DRAW;
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   base::TimeTicks frame_time_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestBeginImplFrameNotification);
 
@@ skipping 262 matching lines @@
     EXPECT_CALL(*mock_context_,
                 texImageIOSurface2DCHROMIUM(GL_TEXTURE_RECTANGLE_ARB,
                                             io_surface_size_.width(),
                                             io_surface_size_.height(),
                                             io_surface_id_,
                                             0)).Times(1);
 
     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.
     EXPECT_CALL(*mock_context_, activeTexture(GL_TEXTURE0)).Times(AtLeast(1));
     EXPECT_CALL(*mock_context_, bindTexture(GL_TEXTURE_RECTANGLE_ARB, 1))
         .Times(1);
     EXPECT_CALL(*mock_context_, drawElements(GL_TRIANGLES, 6, _, _))
         .Times(AtLeast(1));
 
-    return result;
+    return draw_result;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     Mock::VerifyAndClearExpectations(&mock_context_);
 
     EXPECT_CALL(*mock_context_, deleteTexture(1)).Times(1);
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ skipping 1223 matching lines @@
 class LayerTreeHostTestTreeActivationCallback : public LayerTreeHostTest {
  public:
   LayerTreeHostTestTreeActivationCallback()
       : num_commits_(0), callback_count_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     EXPECT_TRUE(HasImplThread());
     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:
         EXPECT_EQ(0, callback_count_);
         callback_count_ = 0;
         SetCallback(true);
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_EQ(1, callback_count_);
         callback_count_ = 0;
         SetCallback(false);
         PostSetNeedsCommitToMainThread();
         break;
       case 3:
         EXPECT_EQ(0, callback_count_);
         callback_count_ = 0;
         EndTest();
         break;
       default:
         ADD_FAILURE() << num_commits_;
         EndTest();
         break;
     }
     return LayerTreeHostTest::PrepareToDrawOnThread(
-        host_impl, frame_data, result);
+        host_impl, frame_data, draw_result);
   }
 
   virtual void AfterTest() OVERRIDE { EXPECT_EQ(3, num_commits_); }
 
   void SetCallback(bool enable) {
     output_surface()->SetTreeActivationCallback(
         enable
             ? base::Bind(
                   &LayerTreeHostTestTreeActivationCallback::ActivationCallback,
                   base::Unretained(this))
@@ skipping 780 matching lines @@
 
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestSimpleSwapPromiseMonitor);
 
 }  // namespace cc