Mojo C++ Bindings: Eliminate unbound ThreadSafeInterfacePtr

ipc/ipc_mojo_bootstrap.cc

 // Copyright 2014 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 "ipc/ipc_mojo_bootstrap.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
@@ skipping 867 matching lines @@
 
   std::map<uint32_t, scoped_refptr<Endpoint>> endpoints_;
 
   DISALLOW_COPY_AND_ASSIGN(ChannelAssociatedGroupController);
 };
 
 class MojoBootstrapImpl : public MojoBootstrap {
  public:
   MojoBootstrapImpl(
       mojo::ScopedMessagePipeHandle handle,
-      Delegate* delegate,
       const scoped_refptr<ChannelAssociatedGroupController> controller)
-            : controller_(controller),
-        handle_(std::move(handle)),
-        delegate_(delegate) {
+      : controller_(controller), handle_(std::move(handle)) {
     associated_group_ = controller_->CreateAssociatedGroup();
   }
 
   ~MojoBootstrapImpl() override {
     controller_->ShutDown();
   }
 
  private:
-  // MojoBootstrap:
-  void Connect() override {
+  void Connect(mojom::ChannelAssociatedPtr* sender,
+               mojom::ChannelAssociatedRequest* receiver) override {
+    controller_->CreateChannelEndpoints(sender, receiver);
     controller_->Bind(std::move(handle_));
-
-    IPC::mojom::ChannelAssociatedPtr sender;
-    IPC::mojom::ChannelAssociatedRequest receiver;
-    controller_->CreateChannelEndpoints(&sender, &receiver);
-
-    delegate_->OnPipesAvailable(std::move(sender), std::move(receiver));
   }
 
   void Pause() override {
     controller_->Pause();
   }
 
   void Unpause() override {
     controller_->Unpause();
   }
 
   void Flush() override {
     controller_->FlushOutgoingMessages();
   }
 
   mojo::AssociatedGroup* GetAssociatedGroup() override {
     return associated_group_.get();
   }
 
   scoped_refptr<ChannelAssociatedGroupController> controller_;
 
   mojo::ScopedMessagePipeHandle handle_;
-  Delegate* delegate_;
   std::unique_ptr<mojo::AssociatedGroup> associated_group_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoBootstrapImpl);
 };
 
 }  // namespace
 
 // static
 std::unique_ptr<MojoBootstrap> MojoBootstrap::Create(
     mojo::ScopedMessagePipeHandle handle,
     Channel::Mode mode,
-    Delegate* delegate,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner) {
   return base::MakeUnique<MojoBootstrapImpl>(
-      std::move(handle), delegate,
+      std::move(handle),
       new ChannelAssociatedGroupController(mode == Channel::MODE_SERVER,
                                            ipc_task_runner));
 }
 
 }  // namespace IPC