Provide a Mojo equivalent of ThreadSafeSender.

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_BASE_H_
-#define MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_BASE_H_
+#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"
 #include "base/memory/ref_counted.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/message.h"
 
 namespace mojo {
 
 struct ThreadSafeInterfacePtrDeleter;
 
 // ThreadSafeInterfacePtr and ThreadSafeAssociatedInterfacePtr are versions of
-// InterfacePtr and AssociatedInterfacePtr that let caller invoke
+// InterfacePtr and AssociatedInterfacePtr that let callers invoke
 // interface methods from any threads. Callbacks are received on the thread that
 // performed the interface call.
 //
 // To create a ThreadSafeInterfacePtr/ThreadSafeAssociatedInterfacePtr, first
 // create a regular InterfacePtr/AssociatedInterfacePtr that
 // you then provide to ThreadSafeInterfacePtr/AssociatedInterfacePtr::Create.
 // You can then call methods on the
 // ThreadSafeInterfacePtr/AssociatedInterfacePtr instance from any thread.
 //
 // Ex for ThreadSafeInterfacePtr:
 // frob::FrobinatorPtr frobinator;
 // frob::FrobinatorImpl impl(GetProxy(&frobinator));
 // scoped_refptr<frob::ThreadSafeFrobinatorPtr> thread_safe_frobinator =
 //     frob::ThreadSafeFrobinatorPtr::Create(std::move(frobinator));
 // (*thread_safe_frobinator)->FrobinateToTheMax();
+//
+// An alternate way is to create the ThreadSafeInterfacePtr unbound (not
+// associated with an InterfacePtr) and call Bind() at a later time when the
+// InterfacePtr becomes available. Note that you shouldn't call any interface
+// methods on the ThreadSafeInterfacePtr before it is bound.
 
 template <typename Interface, template <typename> class InterfacePtrType>
 class ThreadSafeInterfacePtrBase
     : public MessageReceiverWithResponder,
       public base::RefCountedThreadSafe<
           ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>,
           ThreadSafeInterfacePtrDeleter> {
  public:
   using ProxyType = typename Interface::Proxy_;
 
   static scoped_refptr<ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>>
   Create(InterfacePtrType<Interface> interface_ptr) {
+    scoped_refptr<ThreadSafeInterfacePtrBase> ptr(
+        new ThreadSafeInterfacePtrBase());
+    return ptr->BindToCurrentThread(std::move(interface_ptr)) ? ptr : nullptr;
+  }
+
+  // Creates a ThreadSafeInterfacePtrBase with no associated InterfacePtr.
+  // Call Bind() with the InterfacePtr once available.
+  static scoped_refptr<ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>>
+  CreateUnbound() {
+    return new ThreadSafeInterfacePtrBase();
+  }
+
+  // Binds a ThreadSafeInterfacePtrBase previously created with CreateUnbound().
+  bool BindToCurrentThread(InterfacePtrType<Interface> interface_ptr) {

[yzshen1, 2016/11/28 18:05:45]

Comment on line 42/62 calls this method "Bind()".
Maybe the name "Bind()" makes more sense: BindToCurrentThread() sounds like this
ThreadSafeInterfacePtr should only be used on this particular thread. WDYT?

[Jay Civelli, 2016/11/28 18:46:10]

Good point, changed to Bind() and added a comment to emphasize this should be
called on the InterfacePtr's thread.

+    DCHECK(!interface_ptr_task_runner_);
     if (!interface_ptr.is_bound()) {
-      LOG(ERROR) << "Attempting to create a ThreadSafe[Associated]InterfacePtr "
-          "from an unbound InterfacePtr.";
-      return nullptr;
+      LOG(ERROR) << "Attempting to bind a ThreadSafe[Associated]InterfacePtr "
+                    "from an unbound InterfacePtr.";
+      return false;
     }
-    return new ThreadSafeInterfacePtrBase(std::move(interface_ptr),
-                                          base::ThreadTaskRunnerHandle::Get());
+    interface_ptr_ = std::move(interface_ptr);
+    interface_ptr_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+    return true;
   }
 
   ~ThreadSafeInterfacePtrBase() override {}
 
   Interface* get() { return &proxy_; }
   Interface* operator->() { return get(); }
   Interface& operator*() { return *get(); }
 
- protected:
-  ThreadSafeInterfacePtrBase(
-      InterfacePtrType<Interface> interface_ptr,
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-      : interface_ptr_task_runner_(task_runner),
-        proxy_(this),
-        interface_ptr_(std::move(interface_ptr)),
-        weak_ptr_factory_(this) {}
-
  private:
   friend class base::RefCountedThreadSafe<
       ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>>;
   friend struct ThreadSafeInterfacePtrDeleter;
 
+  ThreadSafeInterfacePtrBase() : proxy_(this), weak_ptr_factory_(this) {}
+
   void DeleteOnCorrectThread() const {
-    if (!interface_ptr_task_runner_->BelongsToCurrentThread() &&
+    if (interface_ptr_task_runner_ &&
+        !interface_ptr_task_runner_->BelongsToCurrentThread() &&
         interface_ptr_task_runner_->DeleteSoon(FROM_HERE, this)) {
       return;
     }
     delete this;
   }
 
   // MessageReceiverWithResponder implementation:
   bool Accept(Message* message) override {
     interface_ptr_task_runner_->PostTask(
         FROM_HERE,
@@ skipping 73 matching lines @@
 template <typename Interface>
 using ThreadSafeAssociatedInterfacePtr =
     ThreadSafeInterfacePtrBase<Interface, AssociatedInterfacePtr>;
 
 template <typename Interface>
 using ThreadSafeInterfacePtr =
     ThreadSafeInterfacePtrBase<Interface, InterfacePtr>;
 
 }  // namespace mojo
 
-#endif  // MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_BASE_H_
+#endif  // MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_