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 4909 matching lines @@
   size_t second_output_surface_memory_limit_;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface);
 
 struct TestSwapPromiseResult {
   TestSwapPromiseResult()
-      : did_swap_called(false),
+      : did_activate_called(false),
+        did_swap_called(false),
         did_not_swap_called(false),
         dtor_called(false),
-        reason(SwapPromise::DID_NOT_SWAP_UNKNOWN) {}
+        reason(SwapPromise::COMMIT_FAILS) {}
 
+  bool did_activate_called;
   bool did_swap_called;
   bool did_not_swap_called;
   bool dtor_called;
   SwapPromise::DidNotSwapReason 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 DidActivate() override {
+    base::AutoLock lock(result_->lock);
+    EXPECT_FALSE(result_->did_swap_called);
+    EXPECT_FALSE(result_->did_not_swap_called);

[boliu, 2015/05/13 16:07:46]

EXPECT_FALSE(did_activate_called) as well

[Tobias Sargeant, 2015/05/14 11:31:59]

Done.

+    result_->did_activate_called = true;
+  }
+
   void DidSwap(CompositorFrameMetadata* metadata) override {
     base::AutoLock lock(result_->lock);
+    EXPECT_TRUE(result_->did_activate_called);
     EXPECT_FALSE(result_->did_swap_called);
     EXPECT_FALSE(result_->did_not_swap_called);
     result_->did_swap_called = true;
   }
 
   void DidNotSwap(DidNotSwapReason reason) override {
     base::AutoLock lock(result_->lock);
     EXPECT_FALSE(result_->did_swap_called);
     EXPECT_FALSE(result_->did_not_swap_called);
+    EXPECT_FALSE(reason == DidNotSwapReason::ACTIVATION_FAILS &&

[boliu, 2015/05/13 16:07:46]

There is DCHECK_IMPLIES, could use that to make this clearer?

[Tobias Sargeant, 2015/05/14 11:31:59]

I think that it's a good idea to stick with gtest-based macros here. To that end
I did something a bit different here to make it more readable. Tell me what you
think.

+                 result_->did_activate_called);
     result_->did_not_swap_called = true;
     result_->reason = reason;
   }
 
   int64 TraceId() const override { return 0; }
 
  private:
   // Not owned.
   TestSwapPromiseResult* result_;
 };
@@ skipping 40 matching lines @@
       // the promise.
       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);
     }
 
     {
       // 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_activate_called);
       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_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_TRUE(swap_promise_result_[2].did_activate_called);
       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_TRUE(swap_promise_result_[2].dtor_called);
     }
   }
 
   int commit_count_;
   int commit_complete_count_;
   TestSwapPromiseResult swap_promise_result_[3];
@@ skipping 78 matching lines @@
   }
 
   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_activate_called);
       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_;
 };
 
@@ skipping 29 matching lines @@
   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_activate_called);
       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_;
 };
@@ skipping 633 matching lines @@
     {
       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_TRUE(swap_promise_result_[1].did_activate_called);
       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_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_TRUE(swap_promise_result_[2].did_activate_called);
       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_TRUE(swap_promise_result_[2].dtor_called);
     }
   }
 
   int commit_count_;
   TestSwapPromiseResult swap_promise_result_[3];
 };
@@ skipping 1335 matching lines @@
   void AfterTest() override {}
 
   scoped_refptr<FakePictureLayer> content_child_layer_;
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeTestReflectionMaskLayerForSurfaceWithUnclippedChild);
 
 }  // namespace cc