base::Lock -> Mutex in RawChannel.

mojo/edk/system/raw_channel.cc

 // Copyright 2014 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/raw_channel.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 145 matching lines @@
       delegate_(nullptr),
       set_on_shutdown_(nullptr),
       write_stopped_(false),
       weak_ptr_factory_(this) {
 }
 
 RawChannel::~RawChannel() {
   DCHECK(!read_buffer_);
   DCHECK(!write_buffer_);
 
-  // No need to take the |write_lock_| here -- if there are still weak pointers
+  // No need to take |write_mutex_| here -- if there are still weak pointers
   // outstanding, then we're hosed anyway (since we wouldn't be able to
   // invalidate them cleanly, since we might not be on the I/O thread).
   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
 }
 
 void RawChannel::Init(Delegate* delegate) {
   DCHECK(delegate);
 
   DCHECK(!delegate_);
   delegate_ = delegate;
@@ skipping 19 matching lines @@
         FROM_HERE, base::Bind(&RawChannel::OnReadCompleted,
                               weak_ptr_factory_.GetWeakPtr(), io_result, 0));
   }
   // Note: |ScheduleRead()| failure is treated as a read failure (by notifying
   // the delegate), not an initialization failure.
 }
 
 void RawChannel::Shutdown() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
 
-  base::AutoLock locker(write_lock_);
+  MutexLocker locker(&write_mutex_);
 
   LOG_IF(WARNING, !write_buffer_->message_queue_.IsEmpty())
       << "Shutting down RawChannel with write buffer nonempty";
 
   // Reset the delegate so that it won't receive further calls.
   delegate_ = nullptr;
   if (set_on_shutdown_) {
     *set_on_shutdown_ = true;
     set_on_shutdown_ = nullptr;
   }
   write_stopped_ = true;
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   OnShutdownNoLock(read_buffer_.Pass(), write_buffer_.Pass());
 }
 
 // Reminder: This must be thread-safe.
 bool RawChannel::WriteMessage(scoped_ptr<MessageInTransit> message) {
   DCHECK(message);
 
-  base::AutoLock locker(write_lock_);
+  MutexLocker locker(&write_mutex_);
   if (write_stopped_)
     return false;
 
   if (!write_buffer_->message_queue_.IsEmpty()) {
     EnqueueMessageNoLock(message.Pass());
     return true;
   }
 
   EnqueueMessageNoLock(message.Pass());
   DCHECK_EQ(write_buffer_->data_offset_, 0u);
@@ skipping 13 matching lines @@
         FROM_HERE,
         base::Bind(&RawChannel::CallOnError, weak_ptr_factory_.GetWeakPtr(),
                    Delegate::ERROR_WRITE));
   }
 
   return result;
 }
 
 // Reminder: This must be thread-safe.
 bool RawChannel::IsWriteBufferEmpty() {
-  base::AutoLock locker(write_lock_);
+  MutexLocker locker(&write_mutex_);
   return write_buffer_->message_queue_.IsEmpty();
 }
 
 void RawChannel::OnReadCompleted(IOResult io_result, size_t bytes_read) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
 
   // Keep reading data in a loop, and dispatch messages if enough data is
   // received. Exit the loop if any of the following happens:
   //   - one or more messages were dispatched;
   //   - the last read failed, was a partial read or would block;
@@ skipping 133 matching lines @@
 }
 
 void RawChannel::OnWriteCompleted(IOResult io_result,
                                   size_t platform_handles_written,
                                   size_t bytes_written) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
   DCHECK_NE(io_result, IO_PENDING);
 
   bool did_fail = false;
   {
-    base::AutoLock locker(write_lock_);
+    MutexLocker locker(&write_mutex_);
     DCHECK_EQ(write_stopped_, write_buffer_->message_queue_.IsEmpty());
 
     if (write_stopped_) {
       NOTREACHED();
       return;
     }
 
     did_fail = !OnWriteCompletedNoLock(io_result, platform_handles_written,
                                        bytes_written);
   }
 
   if (did_fail) {
     CallOnError(Delegate::ERROR_WRITE);
     return;  // |this| may have been destroyed in |CallOnError()|.
   }
 }
 
 void RawChannel::EnqueueMessageNoLock(scoped_ptr<MessageInTransit> message) {
-  write_lock_.AssertAcquired();
+  write_mutex_.AssertHeld();
   write_buffer_->message_queue_.AddMessage(message.Pass());
 }
 
 bool RawChannel::OnReadMessageForRawChannel(
     const MessageInTransit::View& message_view) {
   // No non-implementation specific |RawChannel| control messages.
   LOG(ERROR) << "Invalid control message (subtype " << message_view.subtype()
              << ")";
   return false;
 }
@@ skipping 11 matching lines @@
     case IO_SUCCEEDED:
     case IO_PENDING:
       NOTREACHED();
       break;
   }
   return Delegate::ERROR_READ_UNKNOWN;
 }
 
 void RawChannel::CallOnError(Delegate::Error error) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
-  // TODO(vtl): Add a "write_lock_.AssertNotAcquired()"?
+  // TODO(vtl): Add a "write_mutex_.AssertNotHeld()"?
   if (delegate_) {
     delegate_->OnError(error);
     return;  // |this| may have been destroyed in |OnError()|.
   }
 }
 
 bool RawChannel::OnWriteCompletedNoLock(IOResult io_result,
                                         size_t platform_handles_written,
                                         size_t bytes_written) {
-  write_lock_.AssertAcquired();
+  write_mutex_.AssertHeld();
 
   DCHECK(!write_stopped_);
   DCHECK(!write_buffer_->message_queue_.IsEmpty());
 
   if (io_result == IO_SUCCEEDED) {
     write_buffer_->platform_handles_offset_ += platform_handles_written;
     write_buffer_->data_offset_ += bytes_written;
 
     MessageInTransit* message = write_buffer_->message_queue_.PeekMessage();
     if (write_buffer_->data_offset_ >= message->total_size()) {
@@ skipping 16 matching lines @@
 
   write_stopped_ = true;
   write_buffer_->message_queue_.Clear();
   write_buffer_->platform_handles_offset_ = 0;
   write_buffer_->data_offset_ = 0;
   return false;
 }
 
 }  // namespace system
 }  // namespace mojo