Update mojo sdk to rev c02a28868825edfa57ab77947b8cb15e741c5598

third_party/mojo/src/mojo/edk/system/message_pipe_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/edk/system/message_pipe_dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/local_message_pipe_endpoint.h"
 #include "mojo/edk/system/memory.h"
@@ skipping 87 matching lines @@
 
 MessagePipeDispatcher::MessagePipeDispatcher() : port_(kInvalidPort) {
 }
 
 MessagePipeDispatcher::~MessagePipeDispatcher() {
   // |Close()|/|CloseImplNoLock()| should have taken care of the pipe.
   DCHECK(!message_pipe_);
 }
 
 MessagePipe* MessagePipeDispatcher::GetMessagePipeNoLock() const {
-  lock().AssertAcquired();
+  mutex().AssertHeld();
   return message_pipe_.get();
 }
 
 unsigned MessagePipeDispatcher::GetPortNoLock() const {
-  lock().AssertAcquired();
+  mutex().AssertHeld();
   return port_;
 }
 
 void MessagePipeDispatcher::CancelAllAwakablesNoLock() {
-  lock().AssertAcquired();
+  mutex().AssertHeld();
   message_pipe_->CancelAllAwakables(port_);
 }
 
 void MessagePipeDispatcher::CloseImplNoLock() {
-  lock().AssertAcquired();
+  mutex().AssertHeld();
   message_pipe_->Close(port_);
   message_pipe_ = nullptr;
   port_ = kInvalidPort;
 }
 
 scoped_refptr<Dispatcher>
 MessagePipeDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
-  lock().AssertAcquired();
+  mutex().AssertHeld();
 
   // TODO(vtl): Currently, there are no options, so we just use
   // |kDefaultCreateOptions|. Eventually, we'll have to duplicate the options
   // too.
   scoped_refptr<MessagePipeDispatcher> rv = Create(kDefaultCreateOptions);
   rv->Init(message_pipe_, port_);
   message_pipe_ = nullptr;
   port_ = kInvalidPort;
   return scoped_refptr<Dispatcher>(rv.get());
 }
 
 MojoResult MessagePipeDispatcher::WriteMessageImplNoLock(
     UserPointer<const void> bytes,
     uint32_t num_bytes,
     std::vector<DispatcherTransport>* transports,
     MojoWriteMessageFlags flags) {
   DCHECK(!transports ||
          (transports->size() > 0 &&
           transports->size() <= GetConfiguration().max_message_num_handles));
 
-  lock().AssertAcquired();
+  mutex().AssertHeld();
 
   if (num_bytes > GetConfiguration().max_message_num_bytes)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   return message_pipe_->WriteMessage(port_, bytes, num_bytes, transports,
                                      flags);
 }
 
 MojoResult MessagePipeDispatcher::ReadMessageImplNoLock(
     UserPointer<void> bytes,
     UserPointer<uint32_t> num_bytes,
     DispatcherVector* dispatchers,
     uint32_t* num_dispatchers,
     MojoReadMessageFlags flags) {
-  lock().AssertAcquired();
+  mutex().AssertHeld();
   return message_pipe_->ReadMessage(port_, bytes, num_bytes, dispatchers,
                                     num_dispatchers, flags);
 }
 
 HandleSignalsState MessagePipeDispatcher::GetHandleSignalsStateImplNoLock()
     const {
-  lock().AssertAcquired();
+  mutex().AssertHeld();
   return message_pipe_->GetHandleSignalsState(port_);
 }
 
 MojoResult MessagePipeDispatcher::AddAwakableImplNoLock(
     Awakable* awakable,
     MojoHandleSignals signals,
     uint32_t context,
     HandleSignalsState* signals_state) {
-  lock().AssertAcquired();
+  mutex().AssertHeld();
   return message_pipe_->AddAwakable(port_, awakable, signals, context,
                                     signals_state);
 }
 
 void MessagePipeDispatcher::RemoveAwakableImplNoLock(
     Awakable* awakable,
     HandleSignalsState* signals_state) {
-  lock().AssertAcquired();
+  mutex().AssertHeld();
   message_pipe_->RemoveAwakable(port_, awakable, signals_state);
 }
 
 void MessagePipeDispatcher::StartSerializeImplNoLock(
     Channel* channel,
     size_t* max_size,
     size_t* max_platform_handles) {
   DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   return message_pipe_->StartSerialize(port_, channel, max_size,
                                        max_platform_handles);
@@ skipping 17 matching lines @@
 
 MessagePipeDispatcherTransport::MessagePipeDispatcherTransport(
     DispatcherTransport transport)
     : DispatcherTransport(transport) {
   DCHECK_EQ(message_pipe_dispatcher()->GetType(),
             Dispatcher::Type::MESSAGE_PIPE);
 }
 
 }  // namespace system
 }  // namespace mojo