Mojo: Add a RawChannel::EnqueueMessage() that can be overridden by subclasses.

mojo/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/system/raw_channel.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 201 matching lines @@
 
 // Reminder: This must be thread-safe.
 bool RawChannel::WriteMessage(scoped_ptr<MessageInTransit> message) {
   DCHECK(message);
 
   base::AutoLock locker(write_lock_);
   if (write_stopped_)
     return false;
 
   if (!write_buffer_->message_queue_.empty()) {
-    write_buffer_->message_queue_.push_back(message.release());
+    EnqueueMessageNoLock(message.Pass());
     return true;
   }
 
-  write_buffer_->message_queue_.push_front(message.release());
+  EnqueueMessageNoLock(message.Pass());
   DCHECK_EQ(write_buffer_->data_offset_, 0u);
 
   size_t platform_handles_written = 0;
   size_t bytes_written = 0;
   IOResult io_result = WriteNoLock(&platform_handles_written, &bytes_written);
   if (io_result == IO_PENDING)
     return true;
 
   bool result = OnWriteCompletedNoLock(io_result == IO_SUCCEEDED,
                                        platform_handles_written,
@@ skipping 10 matching lines @@
 
   return result;
 }
 
 // Reminder: This must be thread-safe.
 bool RawChannel::IsWriteBufferEmpty() {
   base::AutoLock locker(write_lock_);
   return write_buffer_->message_queue_.empty();
 }
 
-RawChannel::ReadBuffer* RawChannel::read_buffer() {
-  DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
-  return read_buffer_.get();
-}
-
-RawChannel::WriteBuffer* RawChannel::write_buffer_no_lock() {
-  write_lock_.AssertAcquired();
-  return write_buffer_.get();
-}
-
 void RawChannel::OnReadCompleted(bool result, size_t bytes_read) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
 
   if (read_stopped_) {
     NOTREACHED();
     return;
   }
 
   IOResult io_result = result ? IO_SUCCEEDED : IO_FAILED;
 
@@ skipping 139 matching lines @@
 
     did_fail = !OnWriteCompletedNoLock(result,
                                        platform_handles_written,
                                        bytes_written);
   }
 
   if (did_fail)
     CallOnFatalError(Delegate::FATAL_ERROR_FAILED_WRITE);
 }
 
+void RawChannel::EnqueueMessageNoLock(scoped_ptr<MessageInTransit> message) {
+  write_lock_.AssertAcquired();
+  write_buffer_->message_queue_.push_back(message.release());
+}
+
 void RawChannel::CallOnFatalError(Delegate::FatalError fatal_error) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
   // TODO(vtl): Add a "write_lock_.AssertNotAcquired()"?
   if (delegate_)
     delegate_->OnFatalError(fatal_error);
 }
 
 bool RawChannel::OnWriteCompletedNoLock(bool result,
                                         size_t platform_handles_written,
                                         size_t bytes_written) {
@@ skipping 28 matching lines @@
 
   write_stopped_ = true;
   STLDeleteElements(&write_buffer_->message_queue_);
   write_buffer_->platform_handles_offset_ = 0;
   write_buffer_->data_offset_ = 0;
   return false;
 }
 
 }  // namespace system
 }  // namespace mojo