Fix flakiness in TextureLayerImplWithMailboxThreadedCallback

cc/layers/texture_layer_unittest.cc

 // Copyright 2012 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/layers/texture_layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 636 matching lines @@
     // will be returned inside the commit that replaces them.
     bool force_disable_reclaim_resources = false;
     return base::MakeUnique<TestCompositorFrameSink>(
         compositor_context_provider, std::move(worker_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         layer_tree_host()->GetSettings().renderer_settings,
         ImplThreadTaskRunner(), synchronous_composite,
         force_disable_reclaim_resources);
   }
 
+  void AdvanceTestCase() {
+    ++test_case_;
+    switch (test_case_) {
+      case 1:
+        // Case #1: change mailbox before the commit. The old mailbox should be
+        // released immediately.
+        SetMailbox('2');
+        EXPECT_EQ(1, callback_count_);
+        PostSetNeedsCommitToMainThread();
+
+        // Case 2 does not rely on callbacks to advance.
+        pending_callback_ = false;
+        break;
+      case 2:
+        // Case #2: change mailbox after the commit (and draw), where the
+        // layer draws. The old mailbox should be released during the next
+        // commit.
+        SetMailbox('3');
+        EXPECT_EQ(1, callback_count_);
+
+        // Cases 3-5 rely on a callback to advance.
+        pending_callback_ = true;
+        break;
+      case 3:
+        EXPECT_EQ(2, callback_count_);
+        // Case #3: change mailbox when the layer doesn't draw. The old
+        // mailbox should be released during the next commit.
+        layer_->SetBounds(gfx::Size());
+        SetMailbox('4');
+        break;
+      case 4:
+        EXPECT_EQ(3, callback_count_);
+        // Case #4: release mailbox that was committed but never drawn. The
+        // old mailbox should be released during the next commit.
+        layer_->SetTextureMailbox(TextureMailbox(), nullptr);
+        break;
+      case 5:
+        EXPECT_EQ(4, callback_count_);
+        // Restore a mailbox for the next step.
+        SetMailbox('5');
+
+        // Cases 6 and 7 do not rely on callbacks to advance.
+        pending_callback_ = false;
+        break;
+      case 6:
+        // Case #5: remove layer from tree. Callback should *not* be called, the
+        // mailbox is returned to the main thread.
+        EXPECT_EQ(4, callback_count_);
+        layer_->RemoveFromParent();
+        break;
+      case 7:
+        EXPECT_EQ(4, callback_count_);
+        // Resetting the mailbox will call the callback now.
+        layer_->SetTextureMailbox(TextureMailbox(), nullptr);
+        EXPECT_EQ(5, callback_count_);
+        EndTest();
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+
   // Make sure callback is received on main and doesn't block the impl thread.
   void ReleaseCallback(char mailbox_char,
                        const gpu::SyncToken& sync_token,
                        bool lost_resource) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     EXPECT_FALSE(lost_resource);
     ++callback_count_;
+
+    // If we are waiting on a callback, advance now.
+    if (pending_callback_)
+      AdvanceTestCase();
   }
 
   void SetMailbox(char mailbox_char) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     std::unique_ptr<SingleReleaseCallback> callback =
         SingleReleaseCallback::Create(base::Bind(
             &TextureLayerImplWithMailboxThreadedCallback::ReleaseCallback,
             base::Unretained(this), mailbox_char));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char),
@@ skipping 15 matching lines @@
     layer_ = TextureLayer::CreateForMailbox(nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree()->SetRootLayer(root_);
     layer_tree()->SetViewportSize(bounds);
     SetMailbox('1');
     EXPECT_EQ(0, callback_count_);
 
-    // Case #1: change mailbox before the commit. The old mailbox should be
-    // released immediately.
-    SetMailbox('2');
-    EXPECT_EQ(1, callback_count_);
-    PostSetNeedsCommitToMainThread();
+    // Setup is complete - advance to test case 1.
+    AdvanceTestCase();
   }
 
   void DidCommit() override {
-    ++commit_count_;
-    switch (commit_count_) {
-      case 1:
-        // Case #2: change mailbox after the commit (and draw), where the
-        // layer draws. The old mailbox should be released during the next
-        // commit.
-        SetMailbox('3');
-        EXPECT_EQ(1, callback_count_);
-        break;
-      case 2:
-        EXPECT_EQ(2, callback_count_);
-        // Case #3: change mailbox when the layer doesn't draw. The old
-        // mailbox should be released during the next commit.
-        layer_->SetBounds(gfx::Size());
-        SetMailbox('4');
-        break;
-      case 3:
-        EXPECT_EQ(3, callback_count_);
-        // Case #4: release mailbox that was committed but never drawn. The
-        // old mailbox should be released during the next commit.
-        layer_->SetTextureMailbox(TextureMailbox(), nullptr);
-        break;
-      case 4:
-        EXPECT_EQ(4, callback_count_);
-        // Restore a mailbox for the next step.
-        SetMailbox('5');
-        break;
-      case 5:
-        // Case #5: remove layer from tree. Callback should *not* be called, the
-        // mailbox is returned to the main thread.
-        EXPECT_EQ(4, callback_count_);
-        layer_->RemoveFromParent();
-        break;
-      case 6:
-        EXPECT_EQ(4, callback_count_);
-        // Resetting the mailbox will call the callback now.
-        layer_->SetTextureMailbox(TextureMailbox(), nullptr);
-        EXPECT_EQ(5, callback_count_);
-        EndTest();
-        break;
-      default:
-        NOTREACHED();
-        break;
-    }
+    // If we are not waiting on a callback, advance now.
+    if (!pending_callback_)
+      AdvanceTestCase();
   }
 
   void AfterTest() override {}
 
  private:
   base::ThreadChecker main_thread_;
   int callback_count_ = 0;
-  int commit_count_ = 0;
+  int test_case_ = 0;
+  // Whether we are waiting on a callback to advance the test case.
+  bool pending_callback_ = false;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerImplWithMailboxThreadedCallback);
 
 class TextureLayerMailboxIsActivatedDuringCommit : public LayerTreeTest {
  protected:
   TextureLayerMailboxIsActivatedDuringCommit() : activate_count_(0) {}
 
@@ skipping 685 matching lines @@
   base::ThreadChecker main_thread_;
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc