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

mojo/public/cpp/bindings/lib/scoped_interface_endpoint_handle.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/scoped_interface_endpoint_handle.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/synchronization/lock.h"
 #include "mojo/public/cpp/bindings/associated_group_controller.h"
 #include "mojo/public/cpp/bindings/lib/may_auto_lock.h"
 
 namespace mojo {
 
 // ScopedInterfaceEndpointHandle::State ----------------------------------------
 
 // State could be called from multiple threads.
 class ScopedInterfaceEndpointHandle::State
     : public base::RefCountedThreadSafe<State> {
  public:
   State() = default;
 
   State(InterfaceId id,
         scoped_refptr<AssociatedGroupController> group_controller)
       : id_(id), group_controller_(group_controller) {}
 
   void InitPendingState(scoped_refptr<State> peer) {
     DCHECK(!lock_);
     DCHECK(!pending_association_);
 
-    lock_ = base::MakeUnique<base::Lock>();
+    lock_.emplace();
     pending_association_ = true;
     peer_state_ = std::move(peer);
   }
 
   void Close(const base::Optional<DisconnectReason>& reason) {
     scoped_refptr<AssociatedGroupController> cached_group_controller;
     InterfaceId cached_id = kInvalidInterfaceId;
     scoped_refptr<State> cached_peer_state;
 
     {
-      internal::MayAutoLock locker(lock_.get());
+      internal::MayAutoLock locker(&lock_);
 
       if (!association_event_handler_.is_null()) {
         association_event_handler_.Reset();
         runner_ = nullptr;
       }
 
       if (!pending_association_) {
         if (IsValidInterfaceId(id_)) {
           // Intentionally keep |group_controller_| unchanged.
           // That is because the callback created by
@@ skipping 32 matching lines @@
     }
 
     if (cached_group_controller) {
       cached_group_controller->CloseEndpointHandle(cached_id, reason);
     } else if (cached_peer_state) {
       cached_peer_state->OnPeerClosedBeforeAssociation(reason);
     }
   }
 
   void SetAssociationEventHandler(AssociationEventCallback handler) {
-    internal::MayAutoLock locker(lock_.get());
+    internal::MayAutoLock locker(&lock_);
 
     if (!pending_association_ && !IsValidInterfaceId(id_))
       return;
 
     association_event_handler_ = std::move(handler);
     if (association_event_handler_.is_null()) {
       runner_ = nullptr;
       return;
     }
 
@@ skipping 11 matching lines @@
               &ScopedInterfaceEndpointHandle::State::RunAssociationEventHandler,
               this, runner_, PEER_CLOSED_BEFORE_ASSOCIATION));
     }
   }
 
   bool NotifyAssociation(
       InterfaceId id,
       scoped_refptr<AssociatedGroupController> peer_group_controller) {
     scoped_refptr<State> cached_peer_state;
     {
-      internal::MayAutoLock locker(lock_.get());
+      internal::MayAutoLock locker(&lock_);
 
       DCHECK(pending_association_);
       pending_association_ = false;
       cached_peer_state = std::move(peer_state_);
     }
 
     if (cached_peer_state) {
       cached_peer_state->OnAssociated(id, std::move(peer_group_controller));
       return true;
     }
     return false;
   }
 
   bool is_valid() const {
-    internal::MayAutoLock locker(lock_.get());
+    internal::MayAutoLock locker(&lock_);
     return pending_association_ || IsValidInterfaceId(id_);
   }
 
   bool pending_association() const {
-    internal::MayAutoLock locker(lock_.get());
+    internal::MayAutoLock locker(&lock_);
     return pending_association_;
   }
 
   InterfaceId id() const {
-    internal::MayAutoLock locker(lock_.get());
+    internal::MayAutoLock locker(&lock_);
     return id_;
   }
 
   AssociatedGroupController* group_controller() const {
-    internal::MayAutoLock locker(lock_.get());
+    internal::MayAutoLock locker(&lock_);
     return group_controller_.get();
   }
 
   const base::Optional<DisconnectReason>& disconnect_reason() const {
-    internal::MayAutoLock locker(lock_.get());
+    internal::MayAutoLock locker(&lock_);
     return disconnect_reason_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<State>;
 
   ~State() {
     DCHECK(!pending_association_);
     DCHECK(!IsValidInterfaceId(id_));
   }
 
   // Called by the peer, maybe from a different thread.
   void OnAssociated(InterfaceId id,
                     scoped_refptr<AssociatedGroupController> group_controller) {
     AssociationEventCallback handler;
     {
-      internal::MayAutoLock locker(lock_.get());
+      internal::MayAutoLock locker(&lock_);
 
       // There may be race between Close() of endpoint A and
       // NotifyPeerAssociation() of endpoint A_peer on different threads.
       // Therefore, it is possible that endpoint A has been closed but it
       // still gets OnAssociated() call from its peer.
       if (!pending_association_)
         return;
 
       pending_association_ = false;
       peer_state_ = nullptr;
@@ skipping 15 matching lines @@
 
     if (!handler.is_null())
       std::move(handler).Run(ASSOCIATED);
   }
 
   // Called by the peer, maybe from a different thread.
   void OnPeerClosedBeforeAssociation(
       const base::Optional<DisconnectReason>& reason) {
     AssociationEventCallback handler;
     {
-      internal::MayAutoLock locker(lock_.get());
+      internal::MayAutoLock locker(&lock_);
 
       // There may be race between Close()/NotifyPeerAssociation() of endpoint
       // A and Close() of endpoint A_peer on different threads.
       // Therefore, it is possible that endpoint A is not in pending association
       // state but still gets OnPeerClosedBeforeAssociation() call from its
       // peer.
       if (!pending_association_)
         return;
 
       disconnect_reason_ = reason;
@@ skipping 17 matching lines @@
     if (!handler.is_null())
       std::move(handler).Run(PEER_CLOSED_BEFORE_ASSOCIATION);
   }
 
   void RunAssociationEventHandler(
       scoped_refptr<base::SingleThreadTaskRunner> posted_to_runner,
       AssociationEvent event) {
     AssociationEventCallback handler;
 
     {
-      internal::MayAutoLock locker(lock_.get());
+      internal::MayAutoLock locker(&lock_);
       if (posted_to_runner == runner_) {
         runner_ = nullptr;
         handler = std::move(association_event_handler_);
       }
     }
 
     if (!handler.is_null())
       std::move(handler).Run(event);
   }
 
   // Protects the following members if the handle is initially set to pending
   // association.
-  std::unique_ptr<base::Lock> lock_;
+  mutable base::Optional<base::Lock> lock_;
 
   bool pending_association_ = false;
   base::Optional<DisconnectReason> disconnect_reason_;
 
   scoped_refptr<State> peer_state_;
 
   AssociationEventCallback association_event_handler_;
   scoped_refptr<base::SingleThreadTaskRunner> runner_;
 
   InterfaceId id_ = kInvalidInterfaceId;
@@ skipping 96 matching lines @@
 
 base::Callback<AssociatedGroupController*()>
 ScopedInterfaceEndpointHandle::CreateGroupControllerGetter() const {
   // We allow this callback to be run on any thread. If this handle is created
   // in non-pending state, we don't have a lock but it should still be safe
   // because the group controller never changes.
   return base::Bind(&State::group_controller, state_);
 }
 
 }  // namespace mojo