cc: Abort frame when becoming invisible and waiting for ready to draw.

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 184 matching lines @@
   }
 
  private:
   FakeContentLayerClient client_;
 };
 
 // Multi-thread only because in single thread the commit goes directly to the
 // active tree, so notify ready to activate is skipped.
 MULTI_THREAD_TEST_F(LayerTreeHostTestReadyToActivateNonEmpty);
 
+// This tests if we get the READY_TO_ACTIVATE signal if we become invisible and
+// then become visible again.
+class LayerTreeHostTestReadyToActivateVisibility
+    : public LayerTreeHostTestReadyToActivateNonEmpty {
+ public:
+  LayerTreeHostTestReadyToActivateVisibility()
+      : LayerTreeHostTestReadyToActivateNonEmpty(),
+        commit_count_(0),
+        toggled_visibility_(false) {}
+
+  void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+    LayerTreeHostTestReadyToActivateNonEmpty::CommitCompleteOnThread(host_impl);
+    commit_count_++;
+    if (commit_count_ == 1)
+      PostSetVisibleToMainThread(false);
+  }
+
+  void DidFinishImplFrameOnThread(LayerTreeHostImpl* host_impl) override {
+    if (commit_count_ == 1)
+      PostSetVisibleToMainThread(true);

[brianderson, 2015/07/23 02:00:23]

I think it's possible this races with the DidSetVisibleOnImplTree(false) we'd
expect to get the main thread round trip of PostSetVisibleToMainThread(false).
Is that okay?

[sunnyps, 2015/07/23 22:20:44]

That works for the ready to draw test because that's only for STP but it won't
work for this test. I'm removing this test because there's no way to make this
race free without a lot of complexity. Also this isn't being addressed by the CL
anyway.

+  }
+
+  void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
+                               bool visible) override {
+    if (!visible)
+      toggled_visibility_ = true;
+  }
+
+  void AfterTest() override {
+    LayerTreeHostTestReadyToActivateNonEmpty::AfterTest();
+    EXPECT_LE(1, commit_count_);

[brianderson, 2015/07/23 02:00:23]

I'm not sure if this test has a race between READY_TO_ACTIVATE and
DidSetVisibleOnImplTree(false).

Could you override DrawLayersOnThread and verify this test only draws after
toggled_visibility_ is true?

[sunnyps, 2015/07/23 22:20:44]

See reply above.

+    EXPECT_TRUE(toggled_visibility_);
+  }
+
+ private:
+  int commit_count_;
+  bool toggled_visibility_;
+};
+
+// Multi-thread only because in single thread the commit goes directly to the
+// active tree, so notify ready to activate is skipped.
+MULTI_THREAD_TEST_F(LayerTreeHostTestReadyToActivateVisibility);
+
 // Test if the LTHI receives ReadyToDraw notifications from the TileManager when
 // no raster tasks get scheduled.
 class LayerTreeHostTestReadyToDrawEmpty : public LayerTreeHostTest {
  public:
   LayerTreeHostTestReadyToDrawEmpty()
       : did_notify_ready_to_draw_(false),
         all_tiles_required_for_draw_are_ready_to_draw_(false),
         required_for_draw_count_(0) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 50 matching lines @@
   }
 
  private:
   FakeContentLayerClient client_;
 };
 
 // Note: With this test setup, we only get tiles flagged as REQUIRED_FOR_DRAW in
 // single threaded mode.
 SINGLE_THREAD_TEST_F(LayerTreeHostTestReadyToDrawNonEmpty);
 
+// This tests if we get the READY_TO_DRAW signal if we become invisible and then
+// become visible again.
+class LayerTreeHostTestReadyToDrawVisibility

[brianderson, 2015/07/23 02:00:23]

See comments about other test.

+    : public LayerTreeHostTestReadyToDrawNonEmpty {
+ public:
+  LayerTreeHostTestReadyToDrawVisibility()
+      : LayerTreeHostTestReadyToDrawNonEmpty(),
+        commit_count_(0),
+        toggled_visibility_(false) {}
+
+  void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+    commit_count_++;
+    if (commit_count_ == 1)
+      PostSetVisibleToMainThread(false);
+  }
+
+  void DidFinishImplFrameOnThread(LayerTreeHostImpl* host_impl) override {
+    if (commit_count_ == 1)
+      PostSetVisibleToMainThread(true);
+  }
+
+  void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
+                               bool visible) override {
+    if (!visible)
+      toggled_visibility_ = true;
+  }
+
+  void AfterTest() override {
+    LayerTreeHostTestReadyToDrawNonEmpty::AfterTest();
+    EXPECT_LE(1, commit_count_);
+    EXPECT_TRUE(toggled_visibility_);
+  }
+
+ private:
+  int commit_count_;
+  bool toggled_visibility_;
+};
+
+// Note: With this test setup, we only get tiles flagged as REQUIRED_FOR_DRAW in
+// single threaded mode.
+SINGLE_THREAD_TEST_F(LayerTreeHostTestReadyToDrawVisibility);
+
 class LayerTreeHostFreeWorkerContextResourcesTest : public LayerTreeHostTest {
  public:
   scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
     auto output_surface = make_scoped_ptr(new testing::StrictMock<
         MockSetWorkerContextShouldAggressivelyFreeResourcesOutputSurface>(
         delegating_renderer()));
 
     // At init, we expect one call to set visibility to true.
     testing::Expectation visibility_true =
         EXPECT_CALL(*output_surface,
@@ skipping 5770 matching lines @@
   void AfterTest() override {}
 
   std::vector<int> affected_by_page_scale_;
   std::vector<int> not_affected_by_page_scale_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeTestPageScaleFlags);
 
 }  // namespace
 }  // namespace cc