Fix ThreadSafeAssociatedInterfacePtrProvider raciness.

mojo/public/cpp/bindings/thread_safe_interface_ptr.h

 // Copyright 2016 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_
 
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 42 matching lines @@
   using ProxyType = typename Interface::Proxy_;
 
   static scoped_refptr<ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>>
   Create(InterfacePtrType<Interface> interface_ptr) {
     scoped_refptr<ThreadSafeInterfacePtrBase> ptr(
         new ThreadSafeInterfacePtrBase());
     return ptr->Bind(std::move(interface_ptr)) ? ptr : nullptr;
   }
 
   // Creates a ThreadSafeInterfacePtrBase with no associated InterfacePtr.
-  // Call Bind() with the InterfacePtr once available.
+  // Call Bind() with the InterfacePtr once available, which must be called on
+  // the |bind_task_runner|.
+  // Providing the TaskRunner here allows you to post a task to
+  // |bind_task_runner| to do the bind and then immediately start calling
+  // methods on the returned interface.
   static scoped_refptr<ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>>
-  CreateUnbound() {
-    return new ThreadSafeInterfacePtrBase();
+  CreateUnbound(
+      const scoped_refptr<base::SingleThreadTaskRunner>& bind_task_runner) {
+    scoped_refptr<ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>> ptr =
+        new ThreadSafeInterfacePtrBase();
+    ptr->interface_ptr_task_runner_ = bind_task_runner;
+    return ptr;
   }
 
   // Binds a ThreadSafeInterfacePtrBase previously created with CreateUnbound().
   // This must be called on the thread that |interface_ptr| should be used.
+  // If created with CreateUnbound() that thread should be the same as the one
+  // provided at creation time.
   bool Bind(InterfacePtrType<Interface> interface_ptr) {
-    DCHECK(!interface_ptr_task_runner_);
+    DCHECK(!interface_ptr_task_runner_ ||
+        interface_ptr_task_runner_ == base::ThreadTaskRunnerHandle::Get());
     if (!interface_ptr.is_bound()) {
       LOG(ERROR) << "Attempting to bind a ThreadSafe[Associated]InterfacePtr "
                     "from an unbound InterfacePtr.";
       return false;
     }
     interface_ptr_ = std::move(interface_ptr);
     interface_ptr_task_runner_ = base::ThreadTaskRunnerHandle::Get();
     return true;
   }
 
@@ skipping 100 matching lines @@
 using ThreadSafeAssociatedInterfacePtr =
     ThreadSafeInterfacePtrBase<Interface, AssociatedInterfacePtr>;
 
 template <typename Interface>
 using ThreadSafeInterfacePtr =
     ThreadSafeInterfacePtrBase<Interface, InterfacePtr>;
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_