Mojo C++ bindings: remove the lock in MultiplexRouter if it only serves a single interface.

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"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
+#include "mojo/public/cpp/bindings/lib/may_auto_lock.h"
 #include "mojo/public/cpp/bindings/sync_handle_watcher.h"
 
 namespace mojo {
 
-namespace {
-
-// Similar to base::AutoLock, except that it does nothing if |lock| passed into
-// the constructor is null.
-class MayAutoLock {
- public:
-  explicit MayAutoLock(base::Lock* lock) : lock_(lock) {
-    if (lock_)
-      lock_->Acquire();
-  }
-
-  ~MayAutoLock() {
-    if (lock_) {
-      lock_->AssertAcquired();
-      lock_->Release();
-    }
-  }
-
- private:
-  base::Lock* lock_;
-  DISALLOW_COPY_AND_ASSIGN(MayAutoLock);
-};
-
-}  // namespace
-
-// ----------------------------------------------------------------------------
-
 Connector::Connector(ScopedMessagePipeHandle message_pipe,
                      ConnectorConfig config,
                      scoped_refptr<base::SingleThreadTaskRunner> runner)
     : message_pipe_(std::move(message_pipe)),
       task_runner_(std::move(runner)),
       handle_watcher_(task_runner_),
       lock_(config == MULTI_THREADED_SEND ? new base::Lock : nullptr),
       weak_factory_(this) {
   weak_self_ = weak_factory_.GetWeakPtr();
   // Even though we don't have an incoming receiver, we still want to monitor
@@ skipping 10 matching lines @@
   }
 
   DCHECK(thread_checker_.CalledOnValidThread());
   CancelWait();
 }
 
 void Connector::CloseMessagePipe() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CancelWait();
-  MayAutoLock locker(lock_.get());
+  internal::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());
+  internal::MayAutoLock locker(lock_.get());
   ScopedMessagePipeHandle message_pipe = std::move(message_pipe_);
 
   base::AutoLock lock(connected_lock_);
   connected_ = false;
   return message_pipe;
 }
 
 void Connector::RaiseError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 44 matching lines @@
 
 bool Connector::Accept(Message* message) {
   DCHECK(lock_ || thread_checker_.CalledOnValidThread());
 
   // It shouldn't hurt even if |error_| may be changed by a different thread at
   // the same time. The outcome is that we may write into |message_pipe_| after
   // encountering an error, which should be fine.
   if (error_)
     return false;
 
-  MayAutoLock locker(lock_.get());
+  internal::MayAutoLock locker(lock_.get());
 
   if (!message_pipe_.is_valid() || drop_writes_)
     return true;
 
   MojoResult rv =
       WriteMessageNew(message_pipe_.get(), message->TakeMojoMessage(),
                       MOJO_WRITE_MESSAGE_FLAG_NONE);
 
   switch (rv) {
     case MOJO_RESULT_OK:
@@ skipping 161 matching lines @@
     // receiving messages. We need to wait until the user starts receiving
     // messages again.
     force_async_handler = true;
   }
 
   if (!force_pipe_reset && force_async_handler)
     force_pipe_reset = true;
 
   if (force_pipe_reset) {
     CancelWait();
-    MayAutoLock locker(lock_.get());
+    internal::MayAutoLock locker(lock_.get());
     message_pipe_.reset();
     MessagePipe dummy_pipe;
     message_pipe_ = std::move(dummy_pipe.handle0);
   } else {
     CancelWait();
   }
 
   if (force_async_handler) {
     if (!paused_)
       WaitToReadMore();
   } else {
     error_ = true;
     if (!connection_error_handler_.is_null())
       connection_error_handler_.Run();
   }
 }
 
 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