Move VISUAL_STATE promise to activation

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/location.h"
@@ skipping 4806 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface);
 
 struct TestSwapPromiseResult {
   TestSwapPromiseResult()
       : did_swap_called(false),
         did_not_swap_called(false),
         dtor_called(false),
-        reason(SwapPromise::DID_NOT_SWAP_UNKNOWN) {}
+        reason(Promise::DidNotSwap::UNKNOWN) {}
 
   bool did_swap_called;
   bool did_not_swap_called;
   bool dtor_called;
-  SwapPromise::DidNotSwapReason reason;
+  Promise::DidNotSwap::Reason reason;
   base::Lock lock;
 };
 
 class TestSwapPromise : public SwapPromise {
  public:
   explicit TestSwapPromise(TestSwapPromiseResult* result) : result_(result) {}
 
   ~TestSwapPromise() override {
     base::AutoLock lock(result_->lock);
     result_->dtor_called = true;
   }
 
   void DidSwap(CompositorFrameMetadata* metadata) override {
     base::AutoLock lock(result_->lock);
     EXPECT_FALSE(result_->did_swap_called);
     EXPECT_FALSE(result_->did_not_swap_called);
     result_->did_swap_called = true;
   }
 
-  void DidNotSwap(DidNotSwapReason reason) override {
+  void DidNotSwap(DidNotSwap::Reason reason) override {
     base::AutoLock lock(result_->lock);
     EXPECT_FALSE(result_->did_swap_called);
     EXPECT_FALSE(result_->did_not_swap_called);
     result_->did_not_swap_called = true;
     result_->reason = reason;
   }
 
   int64 TraceId() const override { return 0; }
 
  private:
   // Not owned.
   TestSwapPromiseResult* result_;
 };
 
 class LayerTreeHostTestBreakSwapPromise : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestBreakSwapPromise()
       : commit_count_(0), commit_complete_count_(0) {}
 
   void WillBeginMainFrame() override {
     ASSERT_LE(commit_count_, 2);
-    scoped_ptr<SwapPromise> swap_promise(
+    scoped_ptr<Promise> swap_promise(
         new TestSwapPromise(&swap_promise_result_[commit_count_]));
-    layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
+    layer_tree_host()->QueuePromise(swap_promise.Pass());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     commit_count_++;
     if (commit_count_ == 2) {
       // This commit will finish.
       layer_tree_host()->SetNeedsCommit();
     }
@@ skipping 21 matching lines @@
       EXPECT_TRUE(swap_promise_result_[0].did_swap_called);
       EXPECT_FALSE(swap_promise_result_[0].did_not_swap_called);
       EXPECT_TRUE(swap_promise_result_[0].dtor_called);
     }
 
     {
       // The second commit is aborted since it contains no updates.
       base::AutoLock lock(swap_promise_result_[1].lock);
       EXPECT_FALSE(swap_promise_result_[1].did_swap_called);
       EXPECT_TRUE(swap_promise_result_[1].did_not_swap_called);
-      EXPECT_EQ(SwapPromise::COMMIT_NO_UPDATE, swap_promise_result_[1].reason);
+      EXPECT_EQ(Promise::DidNotSwap::COMMIT_NO_UPDATE, swap_promise_result_[1].reason);
       EXPECT_TRUE(swap_promise_result_[1].dtor_called);
     }
 
     {
       // The last commit completes but it does not cause swap buffer because
       // there is no damage in the frame data.
       base::AutoLock lock(swap_promise_result_[2].lock);
       EXPECT_FALSE(swap_promise_result_[2].did_swap_called);
       EXPECT_TRUE(swap_promise_result_[2].did_not_swap_called);
-      EXPECT_EQ(SwapPromise::SWAP_FAILS, swap_promise_result_[2].reason);
+      EXPECT_EQ(Promise::DidNotSwap::SWAP_FAILS, swap_promise_result_[2].reason);
       EXPECT_TRUE(swap_promise_result_[2].dtor_called);
     }
   }
 
   int commit_count_;
   int commit_complete_count_;
   TestSwapPromiseResult swap_promise_result_[3];
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromise);
@@ skipping 15 matching lines @@
   void DidCommit() override {
     MainThreadTaskRunner()->PostTask(
         FROM_HERE, base::Bind(&LayerTreeHostTestKeepSwapPromise::ChangeFrame,
                               base::Unretained(this)));
   }
 
   void ChangeFrame() {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         layer_->SetBounds(gfx::Size(10, 11));
-        layer_tree_host()->QueueSwapPromise(
+        layer_tree_host()->QueuePromise(
             make_scoped_ptr(new TestSwapPromise(&swap_promise_result_)));
         break;
       case 2:
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
@@ skipping 18 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestKeepSwapPromise);
 
 class LayerTreeHostTestBreakSwapPromiseForVisibility
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetVisibleFalseAndQueueSwapPromise() {
     layer_tree_host()->SetVisible(false);
-    scoped_ptr<SwapPromise> swap_promise(
+    scoped_ptr<Promise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
-    layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
+    layer_tree_host()->QueuePromise(swap_promise.Pass());
   }
 
   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_EQ(Promise::DidNotSwap::COMMIT_FAILS, swap_promise_result_.reason);
       EXPECT_TRUE(swap_promise_result_.dtor_called);
     }
   }
 
   TestSwapPromiseResult swap_promise_result_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromiseForVisibility);
 
 class LayerTreeHostTestBreakSwapPromiseForContext : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestBreakSwapPromiseForContext()
       : output_surface_lost_triggered_(false) {
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void LoseOutputSurfaceAndQueueSwapPromise() {
     layer_tree_host()->DidLoseOutputSurface();
-    scoped_ptr<SwapPromise> swap_promise(
+    scoped_ptr<Promise> swap_promise(
         new TestSwapPromise(&swap_promise_result_));
-    layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
+    layer_tree_host()->QueuePromise(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)));
   }
 
   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_EQ(Promise::DidNotSwap::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(
     LayerTreeHostTestBreakSwapPromiseForContext);
@@ skipping 533 matching lines @@
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSynchronousCompositeSwapPromise() : commit_count_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
   }
 
   void BeginTest() override {
     // Successful composite.
-    scoped_ptr<SwapPromise> swap_promise0(
+    scoped_ptr<Promise> swap_promise0(
         new TestSwapPromise(&swap_promise_result_[0]));
-    layer_tree_host()->QueueSwapPromise(swap_promise0.Pass());
+    layer_tree_host()->QueuePromise(swap_promise0.Pass());
     layer_tree_host()->Composite(gfx::FrameTime::Now());
 
     // Fail to swap (no damage).
-    scoped_ptr<SwapPromise> swap_promise1(
+    scoped_ptr<Promise> swap_promise1(
         new TestSwapPromise(&swap_promise_result_[1]));
-    layer_tree_host()->QueueSwapPromise(swap_promise1.Pass());
+    layer_tree_host()->QueuePromise(swap_promise1.Pass());
     layer_tree_host()->SetNeedsCommit();
     layer_tree_host()->Composite(gfx::FrameTime::Now());
 
     // Fail to draw (not visible).
-    scoped_ptr<SwapPromise> swap_promise2(
+    scoped_ptr<Promise> swap_promise2(
         new TestSwapPromise(&swap_promise_result_[2]));
-    layer_tree_host()->QueueSwapPromise(swap_promise2.Pass());
+    layer_tree_host()->QueuePromise(swap_promise2.Pass());
     layer_tree_host()->SetNeedsDisplayOnAllLayers();
     layer_tree_host()->SetVisible(false);
     layer_tree_host()->Composite(gfx::FrameTime::Now());
 
     EndTest();
   }
 
   void DidCommit() override {
     commit_count_++;
     ASSERT_LE(commit_count_, 3);
   }
 
   void AfterTest() override {
     EXPECT_EQ(3, commit_count_);
 
     // Initial swap promise should have succeded.
     {
       base::AutoLock lock(swap_promise_result_[0].lock);
       EXPECT_TRUE(swap_promise_result_[0].did_swap_called);
       EXPECT_FALSE(swap_promise_result_[0].did_not_swap_called);
       EXPECT_TRUE(swap_promise_result_[0].dtor_called);
     }
 
     // Second swap promise fails to swap.
     {
       base::AutoLock lock(swap_promise_result_[1].lock);
       EXPECT_FALSE(swap_promise_result_[1].did_swap_called);
       EXPECT_TRUE(swap_promise_result_[1].did_not_swap_called);
-      EXPECT_EQ(SwapPromise::SWAP_FAILS, swap_promise_result_[1].reason);
+      EXPECT_EQ(Promise::DidNotSwap::SWAP_FAILS, swap_promise_result_[1].reason);
       EXPECT_TRUE(swap_promise_result_[1].dtor_called);
     }
 
     // Third swap promises also fails to swap (and draw).
     {
       base::AutoLock lock(swap_promise_result_[2].lock);
       EXPECT_FALSE(swap_promise_result_[2].did_swap_called);
       EXPECT_TRUE(swap_promise_result_[2].did_not_swap_called);
-      EXPECT_EQ(SwapPromise::SWAP_FAILS, swap_promise_result_[2].reason);
+      EXPECT_EQ(Promise::DidNotSwap::SWAP_FAILS, swap_promise_result_[2].reason);
       EXPECT_TRUE(swap_promise_result_[2].dtor_called);
     }
   }
 
   int commit_count_;
   TestSwapPromiseResult swap_promise_result_[3];
 };
 
 // Impl-side painting is not supported for synchronous compositing.
 SINGLE_THREAD_NOIMPL_TEST_F(LayerTreeHostTestSynchronousCompositeSwapPromise);
@@ skipping 1293 matching lines @@
   void AfterTest() override {}
 
   scoped_refptr<FakePictureLayer> content_child_layer_;
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeTestReflectionMaskLayerForSurfaceWithUnclippedChild);
 
 }  // namespace cc