Mojo C++ bindings: change some std::unique_ptr<base::Lock> to base::Optional<base::Lock>.

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

 // Copyright 2015 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/lib/multiplex_router.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 160 matching lines @@
   }
 
   void OnHandleReady(MojoResult result) {
     DCHECK(task_runner_->BelongsToCurrentThread());
     scoped_refptr<MultiplexRouter> router_protector(router_);
 
     // Because we never close |sync_message_event_{sender,receiver}_| before
     // destruction or set a deadline, |result| should always be MOJO_RESULT_OK.
     DCHECK_EQ(MOJO_RESULT_OK, result);
 
-    MayAutoLock locker(router_->lock_.get());
+    MayAutoLock locker(&router_->lock_);
     scoped_refptr<InterfaceEndpoint> self_protector(this);
 
     bool more_to_process = router_->ProcessFirstSyncMessageForEndpoint(id_);
 
     if (!more_to_process)
       ResetSyncMessageSignal();
 
     // Currently there are no queued sync messages and the peer has closed so
     // there won't be incoming sync messages in the future.
     if (!more_to_process && peer_closed_) {
       // If a SyncWatch() call (or multiple ones) of this interface endpoint is
       // on the call stack, resetting the sync watcher will allow it to exit
       // when the call stack unwinds to that frame.
       sync_watcher_.reset();
     }
   }
 
   void EnsureSyncWatcherExists() {
     DCHECK(task_runner_->BelongsToCurrentThread());
     if (sync_watcher_)
       return;
 
     {
-      MayAutoLock locker(router_->lock_.get());
+      MayAutoLock locker(&router_->lock_);
       EnsureEventMessagePipeExists();
 
       auto iter = router_->sync_message_tasks_.find(id_);
       if (iter != router_->sync_message_tasks_.end() && !iter->second.empty())
         SignalSyncMessageEvent();
     }
 
     sync_watcher_.reset(new SyncHandleWatcher(
         sync_message_event_receiver_.get(), MOJO_HANDLE_SIGNAL_READABLE,
         base::Bind(&InterfaceEndpoint::OnHandleReady, base::Unretained(this))));
@@ skipping 66 matching lines @@
 
   MessageWrapper(MessageWrapper&& other)
       : router_(other.router_), value_(std::move(other.value_)) {}
 
   ~MessageWrapper() {
     if (value_.associated_endpoint_handles()->empty())
       return;
 
     router_->AssertLockAcquired();
     {
-      MayAutoUnlock unlocker(router_->lock_.get());
+      MayAutoUnlock unlocker(&router_->lock_);
       value_.mutable_associated_endpoint_handles()->clear();
     }
   }
 
   MessageWrapper& operator=(MessageWrapper&& other) {
     router_ = other.router_;
     value_ = std::move(other.value_);
     return *this;
   }
 
@@ skipping 45 matching lines @@
     bool set_interface_id_namesapce_bit,
     scoped_refptr<base::SingleThreadTaskRunner> runner)
     : set_interface_id_namespace_bit_(set_interface_id_namesapce_bit),
       task_runner_(runner),
       header_validator_(nullptr),
       filters_(this),
       connector_(std::move(message_pipe),
                  config == MULTI_INTERFACE ? Connector::MULTI_THREADED_SEND
                                            : Connector::SINGLE_THREADED_SEND,
                  std::move(runner)),
-      lock_(config == MULTI_INTERFACE ? new base::Lock : nullptr),
       control_message_handler_(this),
       control_message_proxy_(&connector_),
       next_interface_id_value_(1),
       posted_to_process_tasks_(false),
       encountered_error_(false),
       paused_(false),
       testing_mode_(false) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
+  if (config == MULTI_INTERFACE)
+    lock_.emplace();
+
   if (config == SINGLE_INTERFACE_WITH_SYNC_METHODS ||
       config == MULTI_INTERFACE) {
     // Always participate in sync handle watching in multi-interface mode,
     // because even if it doesn't expect sync requests during sync handle
     // watching, it may still need to dispatch messages to associated endpoints
     // on a different thread.
     connector_.AllowWokenUpBySyncWatchOnSameThread();
   }
   connector_.set_incoming_receiver(&filters_);
   connector_.set_connection_error_handler(
       base::Bind(&MultiplexRouter::OnPipeConnectionError,
                  base::Unretained(this)));
 
   std::unique_ptr<MessageHeaderValidator> header_validator =
       base::MakeUnique<MessageHeaderValidator>();
   header_validator_ = header_validator.get();
   filters_.Append(std::move(header_validator));
 }
 
 MultiplexRouter::~MultiplexRouter() {
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
 
   sync_message_tasks_.clear();
   tasks_.clear();
 
   for (auto iter = endpoints_.begin(); iter != endpoints_.end();) {
     InterfaceEndpoint* endpoint = iter->second.get();
     // Increment the iterator before calling UpdateEndpointStateMayRemove()
     // because it may remove the corresponding value from the map.
     ++iter;
 
@@ skipping 20 matching lines @@
   connector_.SetWatcherHeapProfilerTag(name);
 }
 
 InterfaceId MultiplexRouter::AssociateInterface(
     ScopedInterfaceEndpointHandle handle_to_send) {
   if (!handle_to_send.pending_association())
     return kInvalidInterfaceId;
 
   uint32_t id = 0;
   {
-    MayAutoLock locker(lock_.get());
+    MayAutoLock locker(&lock_);
     do {
       if (next_interface_id_value_ >= kInterfaceIdNamespaceMask)
         next_interface_id_value_ = 1;
       id = next_interface_id_value_++;
       if (set_interface_id_namespace_bit_)
         id |= kInterfaceIdNamespaceMask;
     } while (base::ContainsKey(endpoints_, id));
 
     InterfaceEndpoint* endpoint = new InterfaceEndpoint(this, id);
     endpoints_[id] = endpoint;
     if (encountered_error_)
       UpdateEndpointStateMayRemove(endpoint, PEER_ENDPOINT_CLOSED);
     endpoint->set_handle_created();
   }
 
   if (!NotifyAssociation(&handle_to_send, id)) {
     // The peer handle of |handle_to_send|, which is supposed to join this
     // associated group, has been closed.
     {
-      MayAutoLock locker(lock_.get());
+      MayAutoLock locker(&lock_);
       InterfaceEndpoint* endpoint = FindEndpoint(id);
       if (endpoint)
         UpdateEndpointStateMayRemove(endpoint, ENDPOINT_CLOSED);
     }
 
     control_message_proxy_.NotifyPeerEndpointClosed(
         id, handle_to_send.disconnect_reason());
   }
   return id;
 }
 
 ScopedInterfaceEndpointHandle MultiplexRouter::CreateLocalEndpointHandle(
     InterfaceId id) {
   if (!IsValidInterfaceId(id))
     return ScopedInterfaceEndpointHandle();
 
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
   bool inserted = false;
   InterfaceEndpoint* endpoint = FindOrInsertEndpoint(id, &inserted);
   if (inserted) {
     DCHECK(!endpoint->handle_created());
 
     if (encountered_error_)
       UpdateEndpointStateMayRemove(endpoint, PEER_ENDPOINT_CLOSED);
   } else {
     // If the endpoint already exist, it is because we have received a
     // notification that the peer endpoint has closed.
     CHECK(!endpoint->closed());
     CHECK(endpoint->peer_closed());
 
     if (endpoint->handle_created())
       return ScopedInterfaceEndpointHandle();
   }
 
   endpoint->set_handle_created();
   return CreateScopedInterfaceEndpointHandle(id);
 }
 
 void MultiplexRouter::CloseEndpointHandle(
     InterfaceId id,
     const base::Optional<DisconnectReason>& reason) {
   if (!IsValidInterfaceId(id))
     return;
 
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
   DCHECK(base::ContainsKey(endpoints_, id));
   InterfaceEndpoint* endpoint = endpoints_[id].get();
   DCHECK(!endpoint->client());
   DCHECK(!endpoint->closed());
   UpdateEndpointStateMayRemove(endpoint, ENDPOINT_CLOSED);
 
   if (!IsMasterInterfaceId(id) || reason) {
-    MayAutoUnlock unlocker(lock_.get());
+    MayAutoUnlock unlocker(&lock_);
     control_message_proxy_.NotifyPeerEndpointClosed(id, reason);
   }
 
   ProcessTasks(NO_DIRECT_CLIENT_CALLS, nullptr);
 }
 
 InterfaceEndpointController* MultiplexRouter::AttachEndpointClient(
     const ScopedInterfaceEndpointHandle& handle,
     InterfaceEndpointClient* client,
     scoped_refptr<base::SingleThreadTaskRunner> runner) {
   const InterfaceId id = handle.id();
 
   DCHECK(IsValidInterfaceId(id));
   DCHECK(client);
 
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
   DCHECK(base::ContainsKey(endpoints_, id));
 
   InterfaceEndpoint* endpoint = endpoints_[id].get();
   endpoint->AttachClient(client, std::move(runner));
 
   if (endpoint->peer_closed())
     tasks_.push_back(Task::CreateNotifyErrorTask(endpoint));
   ProcessTasks(NO_DIRECT_CLIENT_CALLS, nullptr);
 
   return endpoint;
 }
 
 void MultiplexRouter::DetachEndpointClient(
     const ScopedInterfaceEndpointHandle& handle) {
   const InterfaceId id = handle.id();
 
   DCHECK(IsValidInterfaceId(id));
 
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
   DCHECK(base::ContainsKey(endpoints_, id));
 
   InterfaceEndpoint* endpoint = endpoints_[id].get();
   endpoint->DetachClient();
 }
 
 void MultiplexRouter::RaiseError() {
   if (task_runner_->BelongsToCurrentThread()) {
     connector_.RaiseError();
   } else {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&MultiplexRouter::RaiseError, this));
   }
 }
 
 void MultiplexRouter::CloseMessagePipe() {
   DCHECK(thread_checker_.CalledOnValidThread());
   connector_.CloseMessagePipe();
   // CloseMessagePipe() above won't trigger connection error handler.
   // Explicitly call OnPipeConnectionError() so that associated endpoints will
   // get notified.
   OnPipeConnectionError();
 }
 
 void MultiplexRouter::PauseIncomingMethodCallProcessing() {
   DCHECK(thread_checker_.CalledOnValidThread());
   connector_.PauseIncomingMethodCallProcessing();
 
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
   paused_ = true;
 
   for (auto iter = endpoints_.begin(); iter != endpoints_.end(); ++iter)
     iter->second->ResetSyncMessageSignal();
 }
 
 void MultiplexRouter::ResumeIncomingMethodCallProcessing() {
   DCHECK(thread_checker_.CalledOnValidThread());
   connector_.ResumeIncomingMethodCallProcessing();
 
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
   paused_ = false;
 
   for (auto iter = endpoints_.begin(); iter != endpoints_.end(); ++iter) {
     auto sync_iter = sync_message_tasks_.find(iter->first);
     if (sync_iter != sync_message_tasks_.end() && !sync_iter->second.empty())
       iter->second->SignalSyncMessageEvent();
   }
 
   ProcessTasks(NO_DIRECT_CLIENT_CALLS, nullptr);
 }
 
 bool MultiplexRouter::HasAssociatedEndpoints() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
 
   if (endpoints_.size() > 1)
     return true;
   if (endpoints_.size() == 0)
     return false;
 
   return !base::ContainsKey(endpoints_, kMasterInterfaceId);
 }
 
 void MultiplexRouter::EnableTestingMode() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
 
   testing_mode_ = true;
   connector_.set_enforce_errors_from_incoming_receiver(false);
 }
 
 bool MultiplexRouter::Accept(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!message->DeserializeAssociatedEndpointHandles(this))
     return false;
 
   scoped_refptr<MultiplexRouter> protector(this);
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
 
   DCHECK(!paused_);
 
   ClientCallBehavior client_call_behavior =
       connector_.during_sync_handle_watcher_callback()
           ? ALLOW_DIRECT_CLIENT_CALLS_FOR_SYNC_MESSAGES
           : ALLOW_DIRECT_CLIENT_CALLS;
 
   bool processed =
       tasks_.empty() && ProcessIncomingMessage(message, client_call_behavior,
@@ skipping 23 matching lines @@
   // Always return true. If we see errors during message processing, we will
   // explicitly call Connector::RaiseError() to disconnect the message pipe.
   return true;
 }
 
 bool MultiplexRouter::OnPeerAssociatedEndpointClosed(
     InterfaceId id,
     const base::Optional<DisconnectReason>& reason) {
   DCHECK(!IsMasterInterfaceId(id) || reason);
 
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
   InterfaceEndpoint* endpoint = FindOrInsertEndpoint(id, nullptr);
 
   if (reason)
     endpoint->set_disconnect_reason(reason);
 
   // It is possible that this endpoint has been set as peer closed. That is
   // because when the message pipe is closed, all the endpoints are updated with
   // PEER_ENDPOINT_CLOSED. We continue to process remaining tasks in the queue,
   // as long as there are refs keeping the router alive. If there is a
   // PeerAssociatedEndpointClosedEvent control message in the queue, we will get
   // here and see that the endpoint has been marked as peer closed.
   if (!endpoint->peer_closed()) {
     if (endpoint->client())
       tasks_.push_back(Task::CreateNotifyErrorTask(endpoint));
     UpdateEndpointStateMayRemove(endpoint, PEER_ENDPOINT_CLOSED);
   }
 
   // No need to trigger a ProcessTasks() because it is already on the stack.
 
   return true;
 }
 
 void MultiplexRouter::OnPipeConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_refptr<MultiplexRouter> protector(this);
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
 
   encountered_error_ = true;
 
   for (auto iter = endpoints_.begin(); iter != endpoints_.end();) {
     InterfaceEndpoint* endpoint = iter->second.get();
     // Increment the iterator before calling UpdateEndpointStateMayRemove()
     // because it may remove the corresponding value from the map.
     ++iter;
 
     if (endpoint->client())
@@ skipping 112 matching lines @@
   InterfaceEndpointClient* client = endpoint->client();
   base::Optional<DisconnectReason> disconnect_reason(
       endpoint->disconnect_reason());
 
   {
     // We must unlock before calling into |client| because it may call this
     // object within NotifyError(). Holding the lock will lead to deadlock.
     //
     // It is safe to call into |client| without the lock. Because |client| is
     // always accessed on the same thread, including DetachEndpointClient().
-    MayAutoUnlock unlocker(lock_.get());
+    MayAutoUnlock unlocker(&lock_);
     client->NotifyError(disconnect_reason);
   }
   return true;
 }
 
 bool MultiplexRouter::ProcessIncomingMessage(
     Message* message,
     ClientCallBehavior client_call_behavior,
     base::SingleThreadTaskRunner* current_task_runner) {
   DCHECK(!current_task_runner || current_task_runner->BelongsToCurrentThread());
   DCHECK(!paused_);
   DCHECK(message);
   AssertLockAcquired();
 
   if (message->IsNull()) {
     // This is a sync message and has been processed during sync handle
     // watching.
     return true;
   }
 
   if (PipeControlMessageHandler::IsPipeControlMessage(message)) {
     bool result = false;
 
     {
-      MayAutoUnlock unlocker(lock_.get());
+      MayAutoUnlock unlocker(&lock_);
       result = control_message_handler_.Accept(message);
     }
 
     if (!result)
       RaiseErrorInNonTestingMode();
 
     return true;
   }
 
   InterfaceId id = message->interface_id();
@@ skipping 27 matching lines @@
 
   InterfaceEndpointClient* client = endpoint->client();
   bool result = false;
   {
     // We must unlock before calling into |client| because it may call this
     // object within HandleIncomingMessage(). Holding the lock will lead to
     // deadlock.
     //
     // It is safe to call into |client| without the lock. Because |client| is
     // always accessed on the same thread, including DetachEndpointClient().
-    MayAutoUnlock unlocker(lock_.get());
+    MayAutoUnlock unlocker(&lock_);
     result = client->HandleIncomingMessage(message);
   }
   if (!result)
     RaiseErrorInNonTestingMode();
 
   return true;
 }
 
 void MultiplexRouter::MaybePostToProcessTasks(
     base::SingleThreadTaskRunner* task_runner) {
   AssertLockAcquired();
   if (posted_to_process_tasks_)
     return;
 
   posted_to_process_tasks_ = true;
   posted_to_task_runner_ = task_runner;
   task_runner->PostTask(
       FROM_HERE, base::Bind(&MultiplexRouter::LockAndCallProcessTasks, this));
 }
 
 void MultiplexRouter::LockAndCallProcessTasks() {
   // There is no need to hold a ref to this class in this case because this is
   // always called using base::Bind(), which holds a ref.
-  MayAutoLock locker(lock_.get());
+  MayAutoLock locker(&lock_);
   posted_to_process_tasks_ = false;
   scoped_refptr<base::SingleThreadTaskRunner> runner(
       std::move(posted_to_task_runner_));
   ProcessTasks(ALLOW_DIRECT_CLIENT_CALLS, runner.get());
 }
 
 void MultiplexRouter::UpdateEndpointStateMayRemove(
     InterfaceEndpoint* endpoint,
     EndpointStateUpdateType type) {
   switch (type) {
@@ skipping 45 matching lines @@
 
 void MultiplexRouter::AssertLockAcquired() {
 #if DCHECK_IS_ON()
   if (lock_)
     lock_->AssertAcquired();
 #endif
 }
 
 }  // namespace internal
 }  // namespace mojo