Mojo: Dispatcher::MessageInTransitAccess functions don't need to take the lock.

mojo/system/dispatcher.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/system/dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/system/constants.h"
 #include "mojo/system/message_pipe_dispatcher.h"
 
@@ skipping 335 matching lines @@
 
 void Dispatcher::RemoveWaiterImplNoLock(Waiter* /*waiter*/) {
   lock_.AssertAcquired();
   DCHECK(!is_closed_);
   // By default, waiting isn't supported. Only dispatchers that can be waited on
   // will do something nontrivial.
 }
 
 size_t Dispatcher::GetMaximumSerializedSizeImplNoLock(
       const Channel* /*channel*/) const {
-  lock_.AssertAcquired();
+  DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   DCHECK(!is_closed_);
   // By default, serializing isn't supported.
   return 0;
 }
 
 bool Dispatcher::SerializeAndCloseImplNoLock(Channel* /*channel*/,
                                              void* /*destination*/,
                                              size_t* /*actual_size*/) {
-  lock_.AssertAcquired();
+  DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   DCHECK(is_closed_);
   // By default, serializing isn't supported, so just close.
   CloseImplNoLock();
   return 0;
 }
 
 bool Dispatcher::IsBusyNoLock() const {
   lock_.AssertAcquired();
   DCHECK(!is_closed_);
   // Most dispatchers support only "atomic" operations, so they are never busy
@@ skipping 15 matching lines @@
   lock_.AssertAcquired();
   DCHECK(!is_closed_);
 
   is_closed_ = true;
   CancelAllWaitersNoLock();
   return CreateEquivalentDispatcherAndCloseImplNoLock();
 }
 
 size_t Dispatcher::GetMaximumSerializedSize(const Channel* channel) const {
   DCHECK(channel);
-  DCHECK(HasOneRef());
-
-  base::AutoLock locker(lock_);
+  DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   DCHECK(!is_closed_);
   return GetMaximumSerializedSizeImplNoLock(channel);
 }
 
 bool Dispatcher::SerializeAndClose(Channel* channel,
                                    void* destination,
                                    size_t* actual_size) {
   DCHECK(destination);
   DCHECK(channel);
   DCHECK(actual_size);
-  DCHECK(HasOneRef());
-
-  base::AutoLock locker(lock_);
+  DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   DCHECK(!is_closed_);
 
   // We have to call |GetMaximumSerializedSizeImplNoLock()| first, because we
   // leave it to |SerializeAndCloseImplNoLock()| to close the thing.
 #if DCHECK_IS_ON
   size_t max_size = GetMaximumSerializedSizeImplNoLock(channel);
 #else
   size_t max_size = static_cast<size_t>(-1);
 #endif
 
@@ skipping 13 matching lines @@
 // DispatcherTransport ---------------------------------------------------------
 
 void DispatcherTransport::End() {
   DCHECK(dispatcher_);
   dispatcher_->lock_.Release();
   dispatcher_ = NULL;
 }
 
 }  // namespace system
 }  // namespace mojo