Make RenderViewImpl::OnForceRedraw more robust

cc/trees/layer_tree_impl_unittest.cc

 // Copyright 2014 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_impl.h"
 
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
@@ skipping 2202 matching lines @@
   CHECK_EQ(1u, RenderSurfaceLayerList().size());
 
   gfx::PointF test_point = gfx::PointF(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 
   CHECK(result_layer);
   EXPECT_EQ(2, result_layer->id());
 }
 
+namespace {
+
+class CC_EXPORT PersistentSwapPromise
+    : public SwapPromise,
+      public base::SupportsWeakPtr<PersistentSwapPromise> {
+ public:
+  PersistentSwapPromise() = default;
+  ~PersistentSwapPromise() override = default;
+
+  void DidActivate() override {}
+  void DidSwap(CompositorFrameMetadata* metadata) override {}
+
+  DidNotSwapAction DidNotSwap(DidNotSwapReason reason) override {
+    return DidNotSwapAction::KEEP_ACTIVE;
+  }
+
+  void OnCommit() override {}
+  int64_t TraceId() const override { return 0; }
+};
+
+class CC_EXPORT NotPersistentSwapPromise
+    : public SwapPromise,
+      public base::SupportsWeakPtr<NotPersistentSwapPromise> {
+ public:
+  NotPersistentSwapPromise() = default;
+  ~NotPersistentSwapPromise() override = default;
+
+  void DidActivate() override {}
+  void DidSwap(CompositorFrameMetadata* metadata) override {}
+
+  DidNotSwapAction DidNotSwap(DidNotSwapReason reason) override {
+    return DidNotSwapAction::DEFAULT_ACTION;
+  }
+
+  void OnCommit() override {}
+  int64_t TraceId() const override { return 0; }
+};
+
+}  // namespace
+
+TEST_F(LayerTreeImplTest, PersistentSwapPromisesAreKeptAlive) {
+  const size_t promises_count = 2;
+
+  std::vector<base::WeakPtr<PersistentSwapPromise>> persistent_promises;
+  std::vector<std::unique_ptr<PersistentSwapPromise>>
+      persistent_promises_to_pass;
+  for (size_t i = 0; i < promises_count; ++i) {
+    persistent_promises_to_pass.push_back(
+        base::WrapUnique(new PersistentSwapPromise()));
+  }
+
+  for (auto& promise : persistent_promises_to_pass) {
+    persistent_promises.push_back(promise->AsWeakPtr());
+    host_impl().active_tree()->QueueSwapPromise(std::move(promise));
+  }
+
+  std::vector<std::unique_ptr<SwapPromise>> promises;
+  host_impl().active_tree()->PassSwapPromises(&promises);
+  host_impl().active_tree()->BreakSwapPromises(
+      SwapPromise::DidNotSwapReason::SWAP_FAILS);
+
+  ASSERT_EQ(promises_count, persistent_promises.size());
+  for (size_t i = 0; i < persistent_promises.size(); ++i) {
+    EXPECT_TRUE(persistent_promises[i]) << "While checking case #" << i;

[danakj, 2016/08/10 01:04:15]

Instead of checking the destructor didn't run (what this does essentially) you
could instead check that breaking swap promise a 2nd time still reports
DidNotSwap, and that drawing eventually would report DidSwap?

[svartmetal, 2016/08/10 17:38:22]

Reasonable. Made EXPECT_CALL for DidSwap.

+  }
+}
+
+TEST_F(LayerTreeImplTest, NotPersistentSwapPromisesAreDroppedWhenSwapFails) {
+  const size_t promises_count = 2;
+
+  std::vector<base::WeakPtr<NotPersistentSwapPromise>> not_persistent_promises;
+  std::vector<std::unique_ptr<NotPersistentSwapPromise>>
+      not_persistent_promises_to_pass;
+  for (size_t i = 0; i < promises_count; ++i) {
+    not_persistent_promises_to_pass.push_back(
+        base::WrapUnique(new NotPersistentSwapPromise()));
+  }
+
+  for (auto& promise : not_persistent_promises_to_pass) {
+    not_persistent_promises.push_back(promise->AsWeakPtr());
+    host_impl().active_tree()->QueueSwapPromise(std::move(promise));
+  }
+  std::vector<std::unique_ptr<SwapPromise>> promises;
+  host_impl().active_tree()->PassSwapPromises(&promises);
+
+  ASSERT_EQ(promises_count, not_persistent_promises.size());
+  for (size_t i = 0; i < not_persistent_promises.size(); ++i) {
+    EXPECT_FALSE(not_persistent_promises[i]) << "While checking case #" << i;
+  }
+
+  // Finally, check that not persistent promise doesn't survive
+  // |LayerTreeImpl::BreakSwapPromises|.
+  {
+    std::unique_ptr<NotPersistentSwapPromise> promise(
+        new NotPersistentSwapPromise());
+    auto weak_promise = promise->AsWeakPtr();
+    host_impl().active_tree()->QueueSwapPromise(std::move(promise));
+
+    host_impl().active_tree()->BreakSwapPromises(
+        SwapPromise::DidNotSwapReason::SWAP_FAILS);
+    EXPECT_FALSE(weak_promise);
+  }
+}
+
 }  // namespace
 }  // namespace cc