Assert sequence validity on non-thread-safe RefCount manipulations (2)

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 409 matching lines @@
 }
 
 InterfaceId MultiplexRouter::AssociateInterface(
     ScopedInterfaceEndpointHandle handle_to_send) {
   if (!handle_to_send.pending_association())
     return kInvalidInterfaceId;
 
   uint32_t id = 0;
   {
     MayAutoLock locker(lock_.get());
+    // Relax the cross-thread access restriction to non-thread-safe RefCount.
+    // The lock above protects |endpoint|.
+    base::ScopedAllowCrossThreadRefCountAccess
+        allow_cross_thread_ref_count_access;
     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;
@@ skipping 17 matching lines @@
   }
   return id;
 }
 
 ScopedInterfaceEndpointHandle MultiplexRouter::CreateLocalEndpointHandle(
     InterfaceId id) {
   if (!IsValidInterfaceId(id))
     return ScopedInterfaceEndpointHandle();
 
   MayAutoLock locker(lock_.get());
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects |endpoint|.
+  base::ScopedAllowCrossThreadRefCountAccess
+      allow_cross_thread_ref_count_access;
   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());
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects |endpoint|.
+  base::ScopedAllowCrossThreadRefCountAccess
+      allow_cross_thread_ref_count_access;
   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());
     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());
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects |endpoint|.
+  base::ScopedAllowCrossThreadRefCountAccess
+      allow_cross_thread_ref_count_access;
   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;
@@ skipping 149 matching lines @@
   // 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());
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects |endpoint|.
+  base::ScopedAllowCrossThreadRefCountAccess
+      allow_cross_thread_ref_count_access;
 
   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())
       tasks_.push_back(Task::CreateNotifyErrorTask(endpoint));
 
     UpdateEndpointStateMayRemove(endpoint, PEER_ENDPOINT_CLOSED);
   }
 
   ProcessTasks(connector_.during_sync_handle_watcher_callback()
                    ? ALLOW_DIRECT_CLIENT_CALLS_FOR_SYNC_MESSAGES
                    : ALLOW_DIRECT_CLIENT_CALLS,
                connector_.task_runner());
 }
 
 void MultiplexRouter::ProcessTasks(
     ClientCallBehavior client_call_behavior,
     base::SingleThreadTaskRunner* current_task_runner) {
   AssertLockAcquired();
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // The lock above protects |endpoint|.
+  base::ScopedAllowCrossThreadRefCountAccess
+      allow_cross_thread_ref_count_access;
 
   if (posted_to_process_tasks_)
     return;
 
   while (!tasks_.empty() && !paused_) {
     std::unique_ptr<Task> task(std::move(tasks_.front()));
     tasks_.pop_front();
 
     InterfaceId id = kInvalidInterfaceId;
     bool sync_message =
@@ skipping 250 matching lines @@
 
 void MultiplexRouter::AssertLockAcquired() {
 #if DCHECK_IS_ON()
   if (lock_)
     lock_->AssertAcquired();
 #endif
 }
 
 }  // namespace internal
 }  // namespace mojo