Add SwapPromise support to LayerTreeHost and LayerTreeImpl

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"
 #include "cc/animation/timing_function.h"
+#include "cc/base/swap_promise.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/debug/test_web_graphics_context_3d.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/io_surface_layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/video_layer.h"
@@ skipping 5173 matching lines @@
   size_t first_output_surface_memory_limit_;
   size_t second_output_surface_memory_limit_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
 };
 
 // No output to copy for delegated renderers.
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestSetMemoryPolicyOnLostOutputSurface);
 
+
+class LayerTreeHostTestAbortedCommitBreakSwapPromise
+    : public LayerTreeHostTest {
+ protected:
+  LayerTreeHostTestAbortedCommitBreakSwapPromise()
+      : commit_count_(0), commit_complete_count_(0), finish_promise_count_(0),
+        break_promise_count_(0) {}
+
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    settings->begin_impl_frame_scheduling_enabled = true;
+  }
+
+  void FinishPromise() {
+    finish_promise_count_++;
+  }
+
+  void BreakPromise(const std::string& msg) {
+    break_promise_count_++;
+  }
+
+  virtual void WillBeginMainFrame() OVERRIDE {
+    SwapPromise swap_promise(
+        base::Bind(
+            &LayerTreeHostTestAbortedCommitBreakSwapPromise::FinishPromise,
+            base::Unretained(this)),
+        base::Bind(
+            &LayerTreeHostTestAbortedCommitBreakSwapPromise::BreakPromise,
+            base::Unretained(this)));
+    layer_tree_host()->QueueSwapPromise(swap_promise);
+  }
+
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+
+  virtual void DidCommit() OVERRIDE {
+    commit_count_++;
+    if (commit_count_ == 2) {
+      // This commit will finish.
+      layer_tree_host()->SetNeedsCommit();
+    }
+  }
+
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    commit_complete_count_++;
+    if (commit_complete_count_ == 1) {
+      // This commit will be aborted.
+      host_impl->SetNeedsCommit();
+    } else {
+      EndTest();
+    }
+  }
+
+  virtual void AfterTest() OVERRIDE {
+    // 3 commits are scheduled. 2 completes. 1 is aborted.
+    // The first completed commit casues swap buffer wihch finishes the promise.
+    // The last completed commit does not reach swap buffer cause the
+    // test is already ended.
+    EXPECT_EQ(commit_count_, 3);
+    EXPECT_EQ(commit_complete_count_, 2);
+    EXPECT_EQ(finish_promise_count_, 1);
+    EXPECT_EQ(break_promise_count_, 1);
+  }
+
+  int commit_count_;
+  int commit_complete_count_;
+  int finish_promise_count_;
+  int break_promise_count_;
+};
+
+MULTI_THREAD_TEST_F(LayerTreeHostTestAbortedCommitBreakSwapPromise);
+
+
+class LayerTreeHostTestNoSwapBreakSwapPromise
+    : public LayerTreeHostTest {
+ protected:
+  LayerTreeHostTestNoSwapBreakSwapPromise()
+      : commit_count_(0), commit_complete_count_(0), finish_promise_count_(0),
+        break_promise_count_(0) {}
+
+  virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+    settings->begin_impl_frame_scheduling_enabled = true;
+  }
+
+  void FinishPromise() {
+    finish_promise_count_++;
+  }
+
+  void BreakPromise(const std::string& msg) {
+    break_promise_count_++;
+  }
+
+  virtual void WillBeginMainFrame() OVERRIDE {
+    SwapPromise swap_promise(
+        base::Bind(&LayerTreeHostTestNoSwapBreakSwapPromise::FinishPromise,
+                   base::Unretained(this)),
+        base::Bind(&LayerTreeHostTestNoSwapBreakSwapPromise::BreakPromise,
+                   base::Unretained(this)));
+    layer_tree_host()->QueueSwapPromise(swap_promise);
+  }
+
+  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+
+  virtual void DidCommit() OVERRIDE {
+    commit_count_++;
+    // Schedule a new commit.
+    layer_tree_host()->SetNeedsCommit();
+  }
+
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    commit_complete_count_++;
+    if (commit_complete_count_ == 3)
+      EndTest();
+  }
+
+  virtual void AfterTest() OVERRIDE {
+    // 3 commits are scheduled. 3 completes.
+    // 2 completed commits reach swap buffer. the first swap buffer finishes
+    // the promise. For the second swap buffer, no damage for the frame, so it
+    // breaks the swap promise. The third commit does not reach the swap buffer
+    // cause the test is ended.
+    EXPECT_EQ(commit_count_, 3);
+    EXPECT_EQ(commit_complete_count_, 3);
+    EXPECT_EQ(finish_promise_count_, 1);
+    EXPECT_EQ(break_promise_count_, 1);
+  }
+
+  int commit_count_;
+  int commit_complete_count_;
+  int finish_promise_count_;
+  int break_promise_count_;
+};
+
+MULTI_THREAD_TEST_F(LayerTreeHostTestNoSwapBreakSwapPromise);
+
 }  // namespace cc