Update from https://crrev.com/314320

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 76 matching lines @@
     for (const auto& layer : layers) {
       FakePictureLayerImpl* fake_layer =
           static_cast<FakePictureLayerImpl*>(layer);
       required_for_activation_count_ +=
           fake_layer->CountTilesRequiredForActivation();
     }
   }
 
   void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
     did_notify_ready_to_activate_ = true;
-    const std::vector<PictureLayerImpl*>& layers = impl->GetPictureLayers();
-    all_tiles_required_for_activation_are_ready_to_draw_ = true;
-    for (const auto& layer : layers) {
-      if (!layer->AllTilesRequiredForActivationAreReadyToDraw())
-        all_tiles_required_for_activation_are_ready_to_draw_ = false;
-    }
+    all_tiles_required_for_activation_are_ready_to_draw_ =
+        impl->tile_manager()->IsReadyToActivate();
     EndTest();
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_activate_);
     EXPECT_TRUE(all_tiles_required_for_activation_are_ready_to_draw_);
     EXPECT_EQ(size_t(0), required_for_activation_count_);
   }
 
  protected:
@@ skipping 39 matching lines @@
   LayerTreeHostTestReadyToDrawEmpty()
       : did_notify_ready_to_draw_(false),
         all_tiles_required_for_draw_are_ready_to_draw_(false),
         required_for_draw_count_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void NotifyReadyToDrawOnThread(LayerTreeHostImpl* impl) override {
     did_notify_ready_to_draw_ = true;
     const std::vector<PictureLayerImpl*>& layers = impl->GetPictureLayers();
-    all_tiles_required_for_draw_are_ready_to_draw_ = true;
+    all_tiles_required_for_draw_are_ready_to_draw_ =
+        impl->tile_manager()->IsReadyToDraw();
     for (const auto& layer : layers) {
-      if (!layer->AllTilesRequiredForDrawAreReadyToDraw())
-        all_tiles_required_for_draw_are_ready_to_draw_ = false;
       FakePictureLayerImpl* fake_layer =
           static_cast<FakePictureLayerImpl*>(layer);
       required_for_draw_count_ += fake_layer->CountTilesRequiredForDraw();
     }
 
     EndTest();
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_draw_);
@@ skipping 1849 matching lines @@
   scoped_refptr<Layer> layer_;
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousInvalidate);
 
 class LayerTreeHostTestDeferCommits : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeferCommits()
-      : num_commits_deferred_(0), num_complete_commits_(0) {}
+      : num_will_begin_impl_frame_(0),
+        num_send_begin_main_frame_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void DidDeferCommit() override {
-    num_commits_deferred_++;
-    layer_tree_host()->SetDeferCommits(false);
+  void WillBeginImplFrame(const BeginFrameArgs& args) override {
+    num_will_begin_impl_frame_++;
+    switch (num_will_begin_impl_frame_) {
+      case 1:
+        break;
+      case 2:
+        PostSetNeedsCommitToMainThread();
+        break;
+      case 3:
+        PostSetDeferCommitsToMainThread(false);
+        break;
+      default:
+        // Sometimes |num_will_begin_impl_frame_| will be greater than 3 if the
+        // main thread is slow to respond.
+        break;
+    }
   }
 
-  void DidCommit() override {
-    num_complete_commits_++;
-    switch (num_complete_commits_) {
+  void ScheduledActionSendBeginMainFrame() override {
+    num_send_begin_main_frame_++;
+    switch (num_send_begin_main_frame_) {
       case 1:
-        EXPECT_EQ(0, num_commits_deferred_);
-        layer_tree_host()->SetDeferCommits(true);
-        PostSetNeedsCommitToMainThread();
+        PostSetDeferCommitsToMainThread(true);
         break;
       case 2:
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   void AfterTest() override {
-    EXPECT_EQ(1, num_commits_deferred_);
-    EXPECT_EQ(2, num_complete_commits_);
+    EXPECT_GE(3, num_will_begin_impl_frame_);
+    EXPECT_EQ(2, num_send_begin_main_frame_);
   }
 
  private:
-  int num_commits_deferred_;
-  int num_complete_commits_;
+  int num_will_begin_impl_frame_;
+  int num_send_begin_main_frame_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
 
 class LayerTreeHostWithProxy : public LayerTreeHost {
  public:
   LayerTreeHostWithProxy(FakeLayerTreeHostClient* client,
                          const LayerTreeSettings& settings,
                          scoped_ptr<FakeProxy> proxy)
       : LayerTreeHost(client, NULL, NULL, settings) {
@@ skipping 2693 matching lines @@
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> layer_;
   TestSwapPromiseResult swap_promise_result_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestKeepSwapPromise);
 
-class LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit
+class LayerTreeHostTestBreakSwapPromiseForVisibility
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void DidCommit() override {
-    layer_tree_host()->SetDeferCommits(true);
-    layer_tree_host()->SetNeedsCommit();
-  }
-
-  void DidDeferCommit() override {
+  void SetVisibleFalseAndQueueSwapPromise() {
     layer_tree_host()->SetVisible(false);
     scoped_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
     layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
-    layer_tree_host()->SetDeferCommits(false);
+  }
+
+  void ScheduledActionWillSendBeginMainFrame() override {
+    MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&LayerTreeHostTestBreakSwapPromiseForVisibility
+                       ::SetVisibleFalseAndQueueSwapPromise,
+            base::Unretained(this)));
   }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
                                      CommitEarlyOutReason reason) override {
     EndTest();
   }
 
   void AfterTest() override {
     {
       base::AutoLock lock(swap_promise_result_.lock);
       EXPECT_FALSE(swap_promise_result_.did_swap_called);
       EXPECT_TRUE(swap_promise_result_.did_not_swap_called);
       EXPECT_EQ(SwapPromise::COMMIT_FAILS, swap_promise_result_.reason);
       EXPECT_TRUE(swap_promise_result_.dtor_called);
     }
   }
 
   TestSwapPromiseResult swap_promise_result_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostTestBreakSwapPromiseForVisibilityAbortedCommit);
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromiseForVisibility);
 
-class LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit
-    : public LayerTreeHostTest {
+class LayerTreeHostTestBreakSwapPromiseForContext : public LayerTreeHostTest {
  protected:
+  LayerTreeHostTestBreakSwapPromiseForContext()
+      : output_surface_lost_triggered_(false) {
+  }
+
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
-  void DidCommit() override {
-    if (TestEnded())
-      return;
-    layer_tree_host()->SetDeferCommits(true);
-    layer_tree_host()->SetNeedsCommit();
-  }
-
-  void DidDeferCommit() override {
+  void LoseOutputSurfaceAndQueueSwapPromise() {
     layer_tree_host()->DidLoseOutputSurface();
     scoped_ptr<SwapPromise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
     layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
-    layer_tree_host()->SetDeferCommits(false);
+  }
+
+  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)));
   }
 
   void BeginMainFrameAbortedOnThread(LayerTreeHostImpl* host_impl,
                                      CommitEarlyOutReason reason) override {
     // This is needed so that the impl-thread state matches main-thread state.
     host_impl->DidLoseOutputSurface();
     EndTest();
   }
 
   void AfterTest() override {
     {
       base::AutoLock lock(swap_promise_result_.lock);
       EXPECT_FALSE(swap_promise_result_.did_swap_called);
       EXPECT_TRUE(swap_promise_result_.did_not_swap_called);
       EXPECT_EQ(SwapPromise::COMMIT_FAILS, swap_promise_result_.reason);
       EXPECT_TRUE(swap_promise_result_.dtor_called);
     }
   }
 
+  bool output_surface_lost_triggered_;
   TestSwapPromiseResult swap_promise_result_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
-    LayerTreeHostTestBreakSwapPromiseForContextAbortedCommit);
+    LayerTreeHostTestBreakSwapPromiseForContext);
 
 class SimpleSwapPromiseMonitor : public SwapPromiseMonitor {
  public:
   SimpleSwapPromiseMonitor(LayerTreeHost* layer_tree_host,
                            LayerTreeHostImpl* layer_tree_host_impl,
                            int* set_needs_commit_count,
                            int* set_needs_redraw_count)
       : SwapPromiseMonitor(layer_tree_host, layer_tree_host_impl),
         set_needs_commit_count_(set_needs_commit_count) {}
 
@@ skipping 1282 matching lines @@
 
   void AfterTest() override { EXPECT_TRUE(did_commit_); }
 
  private:
   bool did_commit_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoTasksBetweenWillAndDidCommit);
 
 }  // namespace cc