Eliminate deferred destruction of AssociatedGroupController

mojo/public/cpp/bindings/lib/connector.cc

 // Copyright 2013 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 "mojo/public/cpp/bindings/connector.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 29 matching lines @@
 };
 
 }  // namespace
 
 // ----------------------------------------------------------------------------
 
 Connector::Connector(ScopedMessagePipeHandle message_pipe,
                      ConnectorConfig config,
                      scoped_refptr<base::SingleThreadTaskRunner> runner)
     : message_pipe_(std::move(message_pipe)),
-      incoming_receiver_(nullptr),
       task_runner_(std::move(runner)),
       handle_watcher_(task_runner_),
-      error_(false),
-      drop_writes_(false),
-      enforce_errors_from_incoming_receiver_(true),
-      paused_(false),
       lock_(config == MULTI_THREADED_SEND ? new base::Lock : nullptr),
-      allow_woken_up_by_others_(false),
-      sync_handle_watcher_callback_count_(0),
       weak_factory_(this) {
   weak_self_ = weak_factory_.GetWeakPtr();
   // Even though we don't have an incoming receiver, we still want to monitor
   // the message pipe to know if is closed or encounters an error.
   WaitToReadMore();
 }
 
 Connector::~Connector() {
+  {
+    // Allow for quick destruction on any thread if the pipe is already closed.
+    base::AutoLock lock(connected_lock_);
+    if (!connected_)
+      return;
+  }
+
   DCHECK(thread_checker_.CalledOnValidThread());
-
   CancelWait();
 }
 
 void Connector::CloseMessagePipe() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CancelWait();
   MayAutoLock locker(lock_.get());
   message_pipe_.reset();
+
+  base::AutoLock lock(connected_lock_);
+  connected_ = false;
 }
 
 ScopedMessagePipeHandle Connector::PassMessagePipe() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CancelWait();
   MayAutoLock locker(lock_.get());
-  return std::move(message_pipe_);
+  ScopedMessagePipeHandle message_pipe = std::move(message_pipe_);

[yzshen1, 2016/07/26 22:11:30]

this should be returned.

+
+  base::AutoLock lock(connected_lock_);
+  connected_ = false;
 }
 
 void Connector::RaiseError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   HandleError(true, true);
 }
 
 bool Connector::WaitForIncomingMessage(MojoDeadline deadline) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 249 matching lines @@
 void Connector::EnsureSyncWatcherExists() {
   if (sync_watcher_)
     return;
   sync_watcher_.reset(new SyncHandleWatcher(
       message_pipe_.get(), MOJO_HANDLE_SIGNAL_READABLE,
       base::Bind(&Connector::OnSyncHandleWatcherHandleReady,
                  base::Unretained(this))));
 }
 
 }  // namespace mojo