base::Lock -> Mutex in RawChannel.

mojo/edk/system/raw_channel_posix.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 <errno.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
@@ skipping 24 matching lines @@
   explicit RawChannelPosix(embedder::ScopedPlatformHandle handle);
   ~RawChannelPosix() override;
 
   // |RawChannel| public methods:
   size_t GetSerializedPlatformHandleSize() const override;
 
  private:
   // |RawChannel| protected methods:
   // Actually override this so that we can send multiple messages with (only)
   // FDs if necessary.
-  void EnqueueMessageNoLock(scoped_ptr<MessageInTransit> message) override;
+  void EnqueueMessageNoLock(scoped_ptr<MessageInTransit> message) override
+      MOJO_EXCLUSIVE_LOCKS_REQUIRED(write_mutex());
   // Override this to handle those extra FD-only messages.
   bool OnReadMessageForRawChannel(
       const MessageInTransit::View& message_view) override;
   IOResult Read(size_t* bytes_read) override;
   IOResult ScheduleRead() override;
   embedder::ScopedPlatformHandleVectorPtr GetReadPlatformHandles(
       size_t num_platform_handles,
       const void* platform_handle_table) override;
   IOResult WriteNoLock(size_t* platform_handles_written,
                        size_t* bytes_written) override;
@@ skipping 15 matching lines @@
   embedder::ScopedPlatformHandle fd_;
 
   // The following members are only used on the I/O thread:
   scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> read_watcher_;
   scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> write_watcher_;
 
   bool pending_read_;
 
   std::deque<embedder::PlatformHandle> read_platform_handles_;
 
-  // The following members are used on multiple threads and protected by
-  // |write_lock()|:
-  bool pending_write_;
+  bool pending_write_ MOJO_GUARDED_BY(write_mutex());
 
-  // This is used for posting tasks from write threads to the I/O thread. It
-  // must only be accessed under |write_lock_|. The weak pointers it produces
-  // are only used/invalidated on the I/O thread.
-  base::WeakPtrFactory<RawChannelPosix> weak_ptr_factory_;
+  // This is used for posting tasks from write threads to the I/O thread. The
+  // weak pointers it produces are only used/invalidated on the I/O thread.
+  base::WeakPtrFactory<RawChannelPosix> weak_ptr_factory_
+      MOJO_GUARDED_BY(write_mutex());
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RawChannelPosix);
 };
 
 RawChannelPosix::RawChannelPosix(embedder::ScopedPlatformHandle handle)
     : fd_(handle.Pass()),
       pending_read_(false),
       pending_write_(false),
       weak_ptr_factory_(this) {
   DCHECK(fd_.is_valid());
 }
 
 RawChannelPosix::~RawChannelPosix() {
   DCHECK(!pending_read_);
   DCHECK(!pending_write_);
 
-  // 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());
 
   // These must have been shut down/destroyed on the I/O thread.
   DCHECK(!read_watcher_);
   DCHECK(!write_watcher_);
 
   embedder::CloseAllPlatformHandles(&read_platform_handles_);
 }
@@ skipping 92 matching lines @@
              read_platform_handles_.begin() + num_platform_handles);
   read_platform_handles_.erase(
       read_platform_handles_.begin(),
       read_platform_handles_.begin() + num_platform_handles);
   return rv.Pass();
 }
 
 RawChannel::IOResult RawChannelPosix::WriteNoLock(
     size_t* platform_handles_written,
     size_t* bytes_written) {
-  write_lock().AssertAcquired();
+  write_mutex().AssertHeld();
 
   DCHECK(!pending_write_);
 
   size_t num_platform_handles = 0;
   ssize_t write_result;
   if (write_buffer_no_lock()->HavePlatformHandlesToSend()) {
     embedder::PlatformHandle* platform_handles;
     void* serialization_data;  // Actually unused.
     write_buffer_no_lock()->GetPlatformHandlesToSend(
         &num_platform_handles, &platform_handles, &serialization_data);
@@ skipping 52 matching lines @@
 
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     PLOG(WARNING) << "sendmsg/write/writev";
     return IO_FAILED_UNKNOWN;
   }
 
   return ScheduleWriteNoLock();
 }
 
 RawChannel::IOResult RawChannelPosix::ScheduleWriteNoLock() {
-  write_lock().AssertAcquired();
+  write_mutex().AssertHeld();
 
   DCHECK(!pending_write_);
 
   // Set up to wait for the FD to become writable.
   // If we're not on the I/O thread, we have to post a task to do this.
   if (base::MessageLoop::current() != message_loop_for_io()) {
     message_loop_for_io()->PostTask(FROM_HERE,
                                     base::Bind(&RawChannelPosix::WaitToWrite,
                                                weak_ptr_factory_.GetWeakPtr()));
     pending_write_ = true;
@@ skipping 23 matching lines @@
   // fails cleanly.
   CHECK(message_loop_for_io()->WatchFileDescriptor(
       fd_.get().fd, true, base::MessageLoopForIO::WATCH_READ,
       read_watcher_.get(), this));
 }
 
 void RawChannelPosix::OnShutdownNoLock(
     scoped_ptr<ReadBuffer> /*read_buffer*/,
     scoped_ptr<WriteBuffer> /*write_buffer*/) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
-  write_lock().AssertAcquired();
+  write_mutex().AssertHeld();
 
   read_watcher_.reset();   // This will stop watching (if necessary).
   write_watcher_.reset();  // This will stop watching (if necessary).
 
   pending_read_ = false;
   pending_write_ = false;
 
   DCHECK(fd_.is_valid());
   fd_.reset();
 
@@ skipping 32 matching lines @@
 }
 
 void RawChannelPosix::OnFileCanWriteWithoutBlocking(int fd) {
   DCHECK_EQ(fd, fd_.get().fd);
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
 
   IOResult io_result;
   size_t platform_handles_written = 0;
   size_t bytes_written = 0;
   {
-    base::AutoLock locker(write_lock());
+    MutexLocker locker(&write_mutex());
 
     DCHECK(pending_write_);
 
     pending_write_ = false;
     io_result = WriteNoLock(&platform_handles_written, &bytes_written);
   }
 
   if (io_result != IO_PENDING) {
     OnWriteCompleted(io_result, platform_handles_written, bytes_written);
     return;  // |this| may have been destroyed in |OnWriteCompleted()|.
@@ skipping 48 matching lines @@
 
 void RawChannelPosix::WaitToWrite() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io());
 
   DCHECK(write_watcher_);
 
   if (!message_loop_for_io()->WatchFileDescriptor(
           fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE,
           write_watcher_.get(), this)) {
     {
-      base::AutoLock locker(write_lock());
+      MutexLocker locker(&write_mutex());
 
       DCHECK(pending_write_);
       pending_write_ = false;
     }
     OnWriteCompleted(IO_FAILED_UNKNOWN, 0, 0);
     return;  // |this| may have been destroyed in |OnWriteCompleted()|.
   }
 }
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 // Static factory method declared in raw_channel.h.
 // static
 scoped_ptr<RawChannel> RawChannel::Create(
     embedder::ScopedPlatformHandle handle) {
   return make_scoped_ptr(new RawChannelPosix(handle.Pass()));
 }
 
 }  // namespace system
 }  // namespace mojo