Fixing flakiness of TextureLayerMailboxIsActivatedDuringCommit

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 769 matching lines @@
   // 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) {}
-
-  static void ReleaseCallback(const gpu::SyncToken& original_sync_token,
-                              const gpu::SyncToken& release_sync_token,
-                              bool lost_resource) {}
+  void ReleaseCallback(const gpu::SyncToken& original_sync_token,
+                       const gpu::SyncToken& release_sync_token,
+                       bool lost_resource) {
+    released_count_++;
+    switch (released_count_) {
+      case 1:
+        break;
+      case 2:
+        EXPECT_EQ(3, layer_tree_host()->SourceFrameNumber());
+        EndTest();
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
 
   void SetMailbox(char mailbox_char) {
     const gpu::SyncToken sync_token =
         SyncTokenFromUInt(static_cast<uint32_t>(mailbox_char));
     std::unique_ptr<SingleReleaseCallback> callback =
         SingleReleaseCallback::Create(base::Bind(
             &TextureLayerMailboxIsActivatedDuringCommit::ReleaseCallback,
-            sync_token));
+            base::Unretained(this), sync_token));
     layer_->SetTextureMailbox(TextureMailbox(MailboxFromChar(mailbox_char),
                                              sync_token, GL_TEXTURE_2D),
                               std::move(callback));
   }
 
   void BeginTest() override {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetBounds(bounds);
 
@@ skipping 29 matching lines @@
         // expect the next commit to finish *after* it is activated.
         SetMailbox('2');
         break;
       case 2:
         // The second mailbox has been activated. Remove the layer from
         // the tree to cause another commit/activation. The commit should
         // finish *after* the layer is removed from the active tree.
         layer_->RemoveFromParent();
         break;
       case 3:
-        EndTest();
+        // This ensures all texture mailboxes are released before the end of the
+        // test.
+        layer_->ClearClient();
         break;
+      default:
+        NOTREACHED();
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // The activate didn't happen before commit is done on the impl side (but it
     // should happen before the main thread is done).
     EXPECT_EQ(activate_count_, host_impl->sync_tree()->source_frame_number());
   }
 
   void AfterTest() override {}
 
   base::Lock activate_count_lock_;
-  int activate_count_;
+  int activate_count_ = 0;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
+  int released_count_ = 0;
 };
 
-// Flaky on windows and linux. https://crbug.com/641613
-#if !defined(OS_WIN) && !defined(OS_LINUX)
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerMailboxIsActivatedDuringCommit);
-#endif
 
 class TextureLayerImplWithMailboxTest : public TextureLayerTest {
  protected:
   void SetUp() override {
     TextureLayerTest::SetUp();
     layer_tree_host_ = MockLayerTreeHost::Create(
         &fake_client_, &task_graph_runner_, animation_host_.get());
     host_impl_.SetVisible(true);
     EXPECT_TRUE(host_impl_.InitializeRenderer(compositor_frame_sink_.get()));
   }
@@ skipping 591 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