Mojo: Make MessageInTransit more opaque.

mojo/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/system/raw_channel.h"
 
 #include <errno.h>
 #include <string.h>
 #include <unistd.h>
 
@@ skipping 240 matching lines @@
     read_buffer_num_valid_bytes_ += static_cast<size_t>(bytes_read);
 
     // Dispatch all the messages that we can.
     while (read_buffer_num_valid_bytes_ >= sizeof(MessageInTransit)) {
       const MessageInTransit* message =
           reinterpret_cast<const MessageInTransit*>(
               &read_buffer_[read_buffer_start]);
       DCHECK_EQ(reinterpret_cast<size_t>(message) %
                     MessageInTransit::kMessageAlignment, 0u);
       // If we have the header, not the whole message....
-      if (read_buffer_num_valid_bytes_ <
-              message->size_with_header_and_padding())
+      if (read_buffer_num_valid_bytes_ < message->main_buffer_size())
         break;
 
       // Dispatch the message.
       delegate()->OnReadMessage(*message);
       if (!read_watcher_.get()) {
         // |Shutdown()| was called in |OnReadMessage()|.
         // TODO(vtl): Add test for this case.
         return;
       }
       did_dispatch_message = true;
 
       // Update our state.
-      read_buffer_start += message->size_with_header_and_padding();
-      read_buffer_num_valid_bytes_ -= message->size_with_header_and_padding();
+      read_buffer_start += message->main_buffer_size();
+      read_buffer_num_valid_bytes_ -= message->main_buffer_size();
     }
 
     // If we dispatched any messages, stop reading for now (and let the message
     // loop do its thing for another round).
     // TODO(vtl): Is this the behavior we want? (Alternatives: i. Dispatch only
     // a single message. Risks: slower, more complex if we want to avoid lots of
     // copying. ii. Keep reading until there's no more data and dispatch all the
     // messages we can. Risks: starvation of other users of the message loop.)
     if (did_dispatch_message)
       break;
@@ skipping 59 matching lines @@
   delegate()->OnFatalError(fatal_error);
 }
 
 bool RawChannelPosix::WriteFrontMessageNoLock() {
   write_lock_.AssertAcquired();
 
   DCHECK(!write_stopped_);
   DCHECK(!write_message_queue_.empty());
 
   MessageInTransit* message = write_message_queue_.front();
-  DCHECK_LT(write_message_offset_, message->size_with_header_and_padding());
-  size_t bytes_to_write =
-      message->size_with_header_and_padding() - write_message_offset_;
+  DCHECK_LT(write_message_offset_, message->main_buffer_size());
+  size_t bytes_to_write = message->main_buffer_size() - write_message_offset_;
   ssize_t bytes_written = HANDLE_EINTR(
       write(fd_.get().fd,
-            reinterpret_cast<char*>(message) + write_message_offset_,
+            static_cast<const char*>(message->main_buffer()) +
+                write_message_offset_,
             bytes_to_write));
   if (bytes_written < 0) {
     if (errno != EAGAIN && errno != EWOULDBLOCK) {
       PLOG(ERROR) << "write of size " << bytes_to_write;
       CancelPendingWritesNoLock();
       return false;
     }
 
     // We simply failed to write since we'd block. The logic is the same as if
     // we got a partial write.
@@ skipping 35 matching lines @@
 // Static factory method declared in raw_channel.h.
 // static
 RawChannel* RawChannel::Create(embedder::ScopedPlatformHandle handle,
                                Delegate* delegate,
                                base::MessageLoop* message_loop) {
   return new RawChannelPosix(handle.Pass(), delegate, message_loop);
 }
 
 }  // namespace system
 }  // namespace mojo