Mojo: Make MessageInTransit more opaque still.

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 233 matching lines @@
         CallOnFatalError(Delegate::FATAL_ERROR_FAILED_READ);
         return;
       }
 
       break;
     }
 
     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)) {
+    size_t message_size;
+    // Note that we rely on short-circuit evaluation here:
+    //   - |read_buffer_start| may be an invalid index into |read_buffer_| if
+    //     |read_buffer_num_valid_bytes_| is zero.
+    //   - |message_size| is only valid if |GetNextMessageSize()| returns true.
+    // TODO(vtl): Use |message_size| more intelligently (e.g., to request the
+    // next read).
+    while (read_buffer_num_valid_bytes_ > 0 &&
+           MessageInTransit::GetNextMessageSize(
+               &read_buffer_[read_buffer_start], read_buffer_num_valid_bytes_,
+               &message_size) &&
+           read_buffer_num_valid_bytes_ >= message_size) {
       const MessageInTransit* message =
-          reinterpret_cast<const MessageInTransit*>(
+          MessageInTransit::CreateReadOnlyFromBuffer(
               &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->main_buffer_size())
-        break;
+      DCHECK_EQ(message->main_buffer_size(), message_size);
 
       // 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->main_buffer_size();
-      read_buffer_num_valid_bytes_ -= message->main_buffer_size();
+      read_buffer_start += message_size;
+      read_buffer_num_valid_bytes_ -= message_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 120 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