Revert of cc: Control defer_commits logic by Scheduler

cc/trees/layer_tree_host_unittest.cc

Index: cc/trees/layer_tree_host_unittest.cc
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 737869409e61819ecf42db3cf02b581d7a1181d6..ab1224ef1f9a28ba9193145db3f7db77a852633a 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -2029,21 +2029,25 @@
 class LayerTreeHostTestDeferCommits : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeferCommits()
-      : num_will_begin_impl_frame_(0),
-        num_send_begin_main_frame_(0) {}
+      : num_commits_deferred_(0), num_complete_commits_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void WillBeginImplFrame(const BeginFrameArgs& args) override {
-    num_will_begin_impl_frame_++;
-    switch (num_will_begin_impl_frame_) {
+  void DidDeferCommit() override {
+    num_commits_deferred_++;
+    layer_tree_host()->SetDeferCommits(false);
+  }
+
+  void DidCommit() override {
+    num_complete_commits_++;
+    switch (num_complete_commits_) {
       case 1:
+        EXPECT_EQ(0, num_commits_deferred_);
+        layer_tree_host()->SetDeferCommits(true);
+        PostSetNeedsCommitToMainThread();
         break;
       case 2:
-        PostSetNeedsCommitToMainThread();
-        break;
-      case 3:
-        PostSetDeferCommitsToMainThread(false);
+        EndTest();
         break;
       default:
         NOTREACHED();
@@ -2051,29 +2055,14 @@
     }
   }
 
-  void ScheduledActionSendBeginMainFrame() override {
-    num_send_begin_main_frame_++;
-    switch (num_send_begin_main_frame_) {
-      case 1:
-        PostSetDeferCommitsToMainThread(true);
-        break;
-      case 2:
-        EndTest();
-        break;
-      default:
-        NOTREACHED();
-        break;
-    }
-  }
-
   void AfterTest() override {
-    EXPECT_GE(3, num_will_begin_impl_frame_);
-    EXPECT_EQ(2, num_send_begin_main_frame_);
+    EXPECT_EQ(1, num_commits_deferred_);
+    EXPECT_EQ(2, num_complete_commits_);
   }
 
  private:
-  int num_will_begin_impl_frame_;
-  int num_send_begin_main_frame_;
+  int num_commits_deferred_;
+  int num_complete_commits_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
@@ -4809,24 +4798,22 @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestKeepSwapPromise);
 
-class LayerTreeHostTestBreakSwapPromiseForVisibility
+class LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void SetVisibleFalseAndQueueSwapPromise() {
+  void DidCommit() override {
+    layer_tree_host()->SetDeferCommits(true);
+    layer_tree_host()->SetNeedsCommit();
+  }
+
+  void DidDeferCommit() override {
     layer_tree_host()->SetVisible(false);
     scoped_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
     layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
-  }
-
-  void ScheduledActionWillSendBeginMainFrame() override {
-    MainThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LayerTreeHostTestBreakSwapPromiseForVisibility
-                       ::SetVisibleFalseAndQueueSwapPromise,
-            base::Unretained(this)));
+    layer_tree_host()->SetDeferCommits(false);
   }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
@@ -4847,33 +4834,27 @@
   TestSwapPromiseResult swap_promise_result_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromiseForVisibility);
-
-class LayerTreeHostTestBreakSwapPromiseForContext : public LayerTreeHostTest {
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit);
+
+class LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit
+    : public LayerTreeHostTest {
  protected:
-  LayerTreeHostTestBreakSwapPromiseForContext()
-      : output_surface_lost_triggered_(false) {
-  }
-
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void LoseOutputSurfaceAndQueueSwapPromise() {
+  void DidCommit() override {
+    if (TestEnded())
+      return;
+    layer_tree_host()->SetDeferCommits(true);
+    layer_tree_host()->SetNeedsCommit();
+  }
+
+  void DidDeferCommit() override {
     layer_tree_host()->DidLoseOutputSurface();
     scoped_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
     layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
-  }
-
-  void ScheduledActionWillSendBeginMainFrame() override {
-    if (output_surface_lost_triggered_)
-      return;
-    output_surface_lost_triggered_ = true;
-
-    MainThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LayerTreeHostTestBreakSwapPromiseForContext
-                       ::LoseOutputSurfaceAndQueueSwapPromise,
-                   base::Unretained(this)));
+    layer_tree_host()->SetDeferCommits(false);
   }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
@@ -4893,12 +4874,11 @@
     }
   }
 
-  bool output_surface_lost_triggered_;
   TestSwapPromiseResult swap_promise_result_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostTestBreakSwapPromiseForContext);
+    LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit);
 
 class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
  public: