Eliminate deferred destruction of AssociatedGroupController

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 30 matching lines @@
 namespace {
 
 class ChannelAssociatedGroupController
     : public mojo::AssociatedGroupController,
       public mojo::MessageReceiver,
       public mojo::PipeControlMessageHandlerDelegate {
  public:
   ChannelAssociatedGroupController(
       bool set_interface_id_namespace_bit,
       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner)
-      : mojo::AssociatedGroupController(base::ThreadTaskRunnerHandle::Get()),
-        task_runner_(ipc_task_runner),
+      : task_runner_(ipc_task_runner),
         proxy_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         set_interface_id_namespace_bit_(set_interface_id_namespace_bit),
         header_validator_(
             "IPC::mojom::Bootstrap [master] MessageHeaderValidator", this),
         control_message_handler_(this),
         control_message_proxy_thunk_(this),
         control_message_proxy_(&control_message_proxy_thunk_) {
     thread_checker_.DetachFromThread();
     control_message_handler_.SetDescription(
         "IPC::mojom::Bootstrap [master] PipeControlMessageHandler");
@@ skipping 275 matching lines @@
     bool Accept(mojo::Message* message) override {
       return controller_->SendMessage(message);
     }
 
     ChannelAssociatedGroupController* controller_;
 
     DISALLOW_COPY_AND_ASSIGN(ControlMessageProxyThunk);
   };
 
   ~ChannelAssociatedGroupController() override {
+    DCHECK(!connector_);
+
     base::AutoLock locker(lock_);
     for (auto iter = endpoints_.begin(); iter != endpoints_.end();) {
       Endpoint* endpoint = iter->second.get();
       ++iter;
 
       DCHECK(endpoint->closed());
       MarkPeerClosedAndMaybeRemove(endpoint);
     }
 
     DCHECK(endpoints_.empty());
@@ skipping 335 matching lines @@
     Channel::Mode mode,
     Delegate* delegate,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner) {
   return base::MakeUnique<MojoBootstrapImpl>(
       std::move(handle), delegate,
       new ChannelAssociatedGroupController(mode == Channel::MODE_SERVER,
                                            ipc_task_runner));
 }
 
 }  // namespace IPC