Fix ThreadSafeAssociatedInterfacePtrProvider raciness.

mojo/public/cpp/bindings/tests/associated_interface_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/lib/multiplex_router.h"
@@ skipping 1023 matching lines @@
   // Block until the method callback is called on the background thread.
   run_loop.Run();
 }
 
 struct ForwarderTestContext {
   IntegerSenderConnectionPtr connection_ptr;
   std::unique_ptr<IntegerSenderConnectionImpl> interface_impl;
 };
 
 TEST_F(AssociatedInterfaceTest, BindLaterThreadSafeAssociatedInterfacePtr) {
-  // Create a ThreadSafeAssociatedPtr that we'll bind from a different thread.
-  scoped_refptr<ThreadSafeIntegerSenderAssociatedPtr> thread_safe_ptr =
-      ThreadSafeIntegerSenderAssociatedPtr::CreateUnbound();
-
   // Start the thread from where we'll bind the interface pointer.
   base::Thread other_thread("service test thread");
   other_thread.Start();
   const scoped_refptr<base::SingleThreadTaskRunner>& other_thread_task_runner =
       other_thread.message_loop()->task_runner();
   ForwarderTestContext* context = new ForwarderTestContext();
-  {
-    base::RunLoop run_loop;
-    auto run_method = base::Bind(
-        [](const scoped_refptr<base::TaskRunner>& main_task_runner,
-           const base::Closure& quit_closure,
-           const scoped_refptr<ThreadSafeIntegerSenderAssociatedPtr>&
-               thread_safe_ptr,
-           ForwarderTestContext* context) {
-          // We are on the background thread, create the interface ptr.
-          context->interface_impl =
-              base::MakeUnique<IntegerSenderConnectionImpl>(
-                  MakeRequest(&(context->connection_ptr)));
-          IntegerSenderAssociatedPtr sender;
-          context->connection_ptr->GetSender(
-              MakeRequest(&sender, context->connection_ptr.associated_group()));
-          thread_safe_ptr->Bind(std::move(sender));
-          main_task_runner->PostTask(FROM_HERE, quit_closure);
-        },
-        base::SequencedTaskRunnerHandle::Get(), run_loop.QuitClosure(),
-        thread_safe_ptr, context);
 
-    other_thread_task_runner->PostTask(FROM_HERE, run_method);
-    // Block until the associated pointer is bound.
-    run_loop.Run();
-  }
+  base::WaitableEvent echo_called_event(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+
+  // Create a ThreadSafeAssociatedPtr that we'll bind from a different thread.
+  scoped_refptr<ThreadSafeIntegerSenderAssociatedPtr> thread_safe_ptr =
+      ThreadSafeIntegerSenderAssociatedPtr::CreateUnbound(
+          other_thread_task_runner);
+
+  base::RunLoop bind_run_loop;
+  auto run_method = base::Bind(
+      [](base::WaitableEvent* echo_called_event,
+         const scoped_refptr<ThreadSafeIntegerSenderAssociatedPtr>&
+             thread_safe_ptr,
+          ForwarderTestContext* context) {
+        // Wait for echo to be called on the main thread so the interface method
+        // call happens before the bind.
+        echo_called_event->Wait();
+
+        // We are on the background thread, create the interface ptr.
+        context->interface_impl =
+            base::MakeUnique<IntegerSenderConnectionImpl>(
+                MakeRequest(&(context->connection_ptr)));
+        IntegerSenderAssociatedPtr sender;
+        context->connection_ptr->GetSender(
+            MakeRequest(&sender, context->connection_ptr.associated_group()));
+        thread_safe_ptr->Bind(std::move(sender));
+      },
+      &echo_called_event, thread_safe_ptr, context);
+
+  other_thread_task_runner->PostTask(FROM_HERE, run_method);
 
   {
     // Now we can call methods on the interface from the main thread.
     auto echo_callback =
         base::Bind([](const base::Closure& quit_closure, int32_t result) {
           EXPECT_EQ(123, result);
           quit_closure.Run();
         });
     base::RunLoop run_loop;
     (*thread_safe_ptr)
         ->Echo(123, base::Bind(echo_callback, run_loop.QuitClosure()));
+
+    // Let the bind happen on the background thread.
+    echo_called_event.Signal();
+
     // Block until the method callback is called.
     run_loop.Run();
   }
 
   other_thread_task_runner->DeleteSoon(FROM_HERE, context);
 
   // Reset the pointer now so the InterfacePtr associated resources can be
   // deleted before the background thread's message loop is invalidated.
   thread_safe_ptr = nullptr;
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo