Queue latency info swap promises in a separate already-active queue.

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 3907 matching lines @@
   void DidActivate() override {
     base::AutoLock lock(result_->lock);
     EXPECT_FALSE(result_->did_activate_called);
     EXPECT_FALSE(result_->did_swap_called);
     EXPECT_FALSE(result_->did_not_swap_called);
     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(result_->did_activate_called &&
                  reason != DidNotSwapReason::SWAP_FAILS);
     result_->did_not_swap_called = true;
     result_->reason = reason;
   }
 
   int64 TraceId() const override { return 0; }
 
  private:
   // Not owned.
   TestSwapPromiseResult* result_;
 };
 
+class PinnedLayerTreeSwapPromise : public LayerTreeHostTest {
+ protected:
+  void BeginTest() override {
+    PostSetNextCommitForcesRedrawToMainThread();
+    PostSetNeedsCommitToMainThread();
+  }
+
+  void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+    int frame = host_impl->active_tree()->source_frame_number();
+    if (frame == -1) {
+      host_impl->active_tree()->QueuePinnedSwapPromise(make_scoped_ptr(
+          new TestSwapPromise(&pinned_active_swap_promise_result_)));
+      host_impl->pending_tree()->QueueSwapPromise(
+          make_scoped_ptr(new TestSwapPromise(&pending_swap_promise_result_)));
+      host_impl->active_tree()->QueueSwapPromise(
+          make_scoped_ptr(new TestSwapPromise(&active_swap_promise_result_)));
+    }
+  }
+
+  void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
+    EndTest();
+  }
+
+  void AfterTest() override {
+    // The pending swap promise should activate and swap.
+    EXPECT_TRUE(pending_swap_promise_result_.did_activate_called);
+    EXPECT_TRUE(pending_swap_promise_result_.did_swap_called);
+
+    // The active swap promise should fail to swap (it is cancelled by
+    // the activation of a new frame).
+    EXPECT_FALSE(active_swap_promise_result_.did_activate_called);
+    EXPECT_FALSE(active_swap_promise_result_.did_swap_called);
+    EXPECT_TRUE(active_swap_promise_result_.did_not_swap_called);
+    EXPECT_EQ(active_swap_promise_result_.reason, SwapPromise::SWAP_FAILS);
+
+    // The pinned active swap promise should not activate, but should swap.
+    EXPECT_FALSE(pinned_active_swap_promise_result_.did_activate_called);
+    EXPECT_TRUE(pinned_active_swap_promise_result_.did_swap_called);
+  }
+
+  TestSwapPromiseResult pending_swap_promise_result_;
+  TestSwapPromiseResult active_swap_promise_result_;
+  TestSwapPromiseResult pinned_active_swap_promise_result_;
+};
+
+MULTI_THREAD_TEST_F(PinnedLayerTreeSwapPromise);
+
 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(
         new TestSwapPromise(&swap_promise_result_[commit_count_]));
     layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
@@ skipping 2299 matching lines @@
   ScrollAndScaleSet scale_info_;
   ScrollAndScaleSet no_op_info_;
   bool requested_update_layers_;
   int commit_count_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollingAndScalingUpdatesLayers);
 
 }  // namespace
 }  // namespace cc