Mojo: Factor MessageInTransit secondary buffer stuff out into a separate class.

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>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "mojo/system/message_in_transit.h"
+#include "mojo/system/transport_data.h"
 
 namespace mojo {
 namespace system {
 
 const size_t kReadSize = 4096;
 
 RawChannel::ReadBuffer::ReadBuffer() : buffer_(kReadSize), num_valid_bytes_(0) {
 }
 
 RawChannel::ReadBuffer::~ReadBuffer() {}
@@ skipping 11 matching lines @@
 }
 
 void RawChannel::WriteBuffer::GetBuffers(std::vector<Buffer>* buffers) const {
   buffers->clear();
 
   size_t bytes_to_write = GetTotalBytesToWrite();
   if (bytes_to_write == 0)
     return;
 
   MessageInTransit* message = message_queue_.front();
-  if (!message->secondary_buffer_size()) {
+  size_t transport_data_buffer_size = message->transport_data() ?
+      message->transport_data()->buffer_size() : 0;
+
+  if (!transport_data_buffer_size) {
     // Only write from the main buffer.
     DCHECK_LT(offset_, message->main_buffer_size());
     DCHECK_LE(bytes_to_write, message->main_buffer_size());
     Buffer buffer = {
         static_cast<const char*>(message->main_buffer()) + offset_,
         bytes_to_write};
     buffers->push_back(buffer);
     return;
   }
 
   if (offset_ >= message->main_buffer_size()) {
-    // Only write from the secondary buffer.
+    // Only write from the transport data buffer.
     DCHECK_LT(offset_ - message->main_buffer_size(),
-              message->secondary_buffer_size());
-    DCHECK_LE(bytes_to_write, message->secondary_buffer_size());
+              transport_data_buffer_size);
+    DCHECK_LE(bytes_to_write, transport_data_buffer_size);
     Buffer buffer = {
-        static_cast<const char*>(message->secondary_buffer()) +
+        static_cast<const char*>(message->transport_data()->buffer()) +
             (offset_ - message->main_buffer_size()),
         bytes_to_write};
     buffers->push_back(buffer);
     return;
   }
 
   // Write from both buffers.
   DCHECK_EQ(bytes_to_write, message->main_buffer_size() - offset_ +
-                                message->secondary_buffer_size());
+                                transport_data_buffer_size);
   Buffer buffer1 = {
-      static_cast<const char*>(message->main_buffer()) + offset_,
-      message->main_buffer_size() - offset_};
+    static_cast<const char*>(message->main_buffer()) + offset_,
+    message->main_buffer_size() - offset_
+  };
   buffers->push_back(buffer1);
   Buffer buffer2 = {
-      static_cast<const char*>(message->secondary_buffer()),
-      message->secondary_buffer_size()};
+    static_cast<const char*>(message->transport_data()->buffer()),
+    transport_data_buffer_size
+  };
   buffers->push_back(buffer2);
 }
 
 size_t RawChannel::WriteBuffer::GetTotalBytesToWrite() const {
   if (message_queue_.empty())
     return 0;
 
   MessageInTransit* message = message_queue_.front();
   DCHECK_LT(offset_, message->total_size());
   return message->total_size() - offset_;
@@ skipping 60 matching lines @@
   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);
 
   // TODO(vtl)
-  if (message->has_platform_handles()) {
+  if (message->transport_data() &&
+      message->transport_data()->has_platform_handles()) {
     NOTIMPLEMENTED();
     return false;
   }
 
   base::AutoLock locker(write_lock_);
   if (write_stopped_)
     return false;
 
   if (!write_buffer_->message_queue_.empty()) {
     write_buffer_->message_queue_.push_back(message.release());
@@ skipping 193 matching lines @@
   }
 
   write_stopped_ = true;
   STLDeleteElements(&write_buffer_->message_queue_);
   write_buffer_->offset_ = 0;
   return false;
 }
 
 }  // namespace system
 }  // namespace mojo