base::Lock -> Mutex in RawChannel.

mojo/edk/system/raw_channel_win.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/raw_channel.h"
 
 #include <windows.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 207 matching lines @@
 
 void RawChannelWin::RawChannelIOHandler::OnPendingReadStarted() {
   DCHECK(owner_);
   DCHECK_EQ(base::MessageLoop::current(), owner_->message_loop_for_io());
   DCHECK(!pending_read_);
   pending_read_ = true;
 }
 
 bool RawChannelWin::RawChannelIOHandler::pending_write_no_lock() const {
   DCHECK(owner_);
-  owner_->write_lock().AssertAcquired();
+  owner_->write_mutex().AssertHeld();
   return pending_write_;
 }
 
 base::MessageLoopForIO::IOContext*
 RawChannelWin::RawChannelIOHandler::write_context_no_lock() {
   DCHECK(owner_);
-  owner_->write_lock().AssertAcquired();
+  owner_->write_mutex().AssertHeld();
   return &write_context_;
 }
 
 void RawChannelWin::RawChannelIOHandler::OnPendingWriteStartedNoLock(
     size_t platform_handles_written) {
   DCHECK(owner_);
-  owner_->write_lock().AssertAcquired();
+  owner_->write_mutex().AssertHeld();
   DCHECK(!pending_write_);
   pending_write_ = true;
   platform_handles_written_ = platform_handles_written;
 }
 
 void RawChannelWin::RawChannelIOHandler::OnIOCompleted(
     base::MessageLoopForIO::IOContext* context,
     DWORD bytes_transferred,
     DWORD error) {
   DCHECK(!owner_ ||
@@ skipping 16 matching lines @@
 
   if (ShouldSelfDestruct())
     delete this;
 }
 
 void RawChannelWin::RawChannelIOHandler::DetachFromOwnerNoLock(
     scoped_ptr<ReadBuffer> read_buffer,
     scoped_ptr<WriteBuffer> write_buffer) {
   DCHECK(owner_);
   DCHECK_EQ(base::MessageLoop::current(), owner_->message_loop_for_io());
-  owner_->write_lock().AssertAcquired();
+  owner_->write_mutex().AssertHeld();
 
   // If read/write is pending, we have to retain the corresponding buffer.
   if (pending_read_)
     preserved_read_buffer_after_detach_ = read_buffer.Pass();
   if (pending_write_)
     preserved_write_buffer_after_detach_ = write_buffer.Pass();
 
   owner_ = nullptr;
   if (ShouldSelfDestruct())
     delete this;
@@ skipping 39 matching lines @@
   DCHECK(suppress_self_destruct_);
 
   if (!owner_) {
     // No lock needed.
     CHECK(pending_write_);
     pending_write_ = false;
     return;
   }
 
   {
-    base::AutoLock locker(owner_->write_lock());
+    MutexLocker locker(&owner_->write_mutex());
     CHECK(pending_write_);
     pending_write_ = false;
   }
 
   // Note: |OnWriteCompleted()| may detach us from |owner_|.
   if (error == ERROR_SUCCESS) {
     // Reset |platform_handles_written_| before calling |OnWriteCompleted()|
     // since that function may call back to this class and set it again.
     size_t local_platform_handles_written_ = platform_handles_written_;
     platform_handles_written_ = 0;
@@ skipping 125 matching lines @@
                         FALSE, DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
     DCHECK(dup_result);
     rv->push_back(embedder::PlatformHandle(target_handle));
   }
   return rv.Pass();
 }
 
 RawChannel::IOResult RawChannelWin::WriteNoLock(
     size_t* platform_handles_written,
     size_t* bytes_written) {
-  write_lock().AssertAcquired();
+  write_mutex().AssertHeld();
 
   DCHECK(io_handler_);
   DCHECK(!io_handler_->pending_write_no_lock());
 
   size_t num_platform_handles = 0;
   if (write_buffer_no_lock()->HavePlatformHandlesToSend()) {
     // Since we're not sure which process might ultimately deserialize this
     // message, we can't duplicate the handle now. Instead, write the process ID
     // and handle now and let the receiver duplicate it.
     embedder::PlatformHandle* platform_handles;
@@ skipping 48 matching lines @@
   // TODO(yzshen): it seems there isn't document saying that all error cases
   // (other than ERROR_IO_PENDING) are guaranteed to *not* queue a completion
   // packet. If we do get one for errors, |RawChannelIOHandler::OnIOCompleted()|
   // will crash so we will learn about it.
 
   io_handler_->OnPendingWriteStartedNoLock(num_platform_handles);
   return IO_PENDING;
 }
 
 RawChannel::IOResult RawChannelWin::ScheduleWriteNoLock() {
-  write_lock().AssertAcquired();
+  write_mutex().AssertHeld();
 
   DCHECK(io_handler_);
   DCHECK(!io_handler_->pending_write_no_lock());
 
   size_t platform_handles_written = 0;
   size_t bytes_written = 0;
   IOResult io_result = WriteNoLock(&platform_handles_written, &bytes_written);
   if (io_result == IO_SUCCEEDED) {
     DCHECK(skip_completion_port_on_success_);
 
@@ skipping 26 matching lines @@
 
   DCHECK(!io_handler_);
   io_handler_ = new RawChannelIOHandler(this, handle_.Pass());
 }
 
 void RawChannelWin::OnShutdownNoLock(scoped_ptr<ReadBuffer> read_buffer,
                                      scoped_ptr<WriteBuffer> write_buffer) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
   DCHECK(io_handler_);
 
-  write_lock().AssertAcquired();
+  write_mutex().AssertHeld();
 
   if (io_handler_->pending_read() || io_handler_->pending_write_no_lock()) {
     // |io_handler_| will be alive until pending read/write (if any) completes.
     // Call |CancelIoEx()| or |CancelIo()| so that resources can be freed up as
     // soon as possible.
     // Note: |CancelIo()| only cancels read/write requests started from this
     // thread.
     if (g_vista_or_higher_functions.Get().is_vista_or_higher()) {
       g_vista_or_higher_functions.Get().CancelIoEx(io_handler_->handle(),
                                                    nullptr);
@@ skipping 12 matching lines @@
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return make_scoped_ptr(new RawChannelWin(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo