Mojo: (Theoretically) implement the read side of platform handle passing.

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 293 matching lines @@
     // TODO(vtl): Validate that |message_size| is sane.
     while (remaining_bytes > 0 &&
            MessageInTransit::GetNextMessageSize(
                &read_buffer_->buffer_[read_buffer_start], remaining_bytes,
                &message_size) &&
            remaining_bytes >= message_size) {
       MessageInTransit::View
           message_view(message_size, &read_buffer_->buffer_[read_buffer_start]);
       DCHECK_EQ(message_view.total_size(), message_size);
 
+      const char* error_message = NULL;
+      if (!message_view.IsValid(GetSerializedPlatformHandleSize(),
+                                &error_message)) {
+        DCHECK(error_message);
+        LOG(WARNING) << "Received invalid message: " << error_message;
+        read_stopped_ = true;
+        CallOnFatalError(Delegate::FATAL_ERROR_FAILED_READ);
+        return;
+      }
+
+      scoped_ptr<embedder::PlatformHandleVector> platform_handles;
+      if (message_view.transport_data_buffer()) {
+        size_t num_platform_handles;
+        const void* platform_handle_table;
+        TransportData::GetPlatformHandleTable(
+            message_view.transport_data_buffer(),
+            &num_platform_handles,
+            &platform_handle_table);
+
+        if (num_platform_handles > 0) {
+          platform_handles =
+              GetReadPlatformHandles(num_platform_handles,
+                                     platform_handle_table).Pass();
+          if (!platform_handles) {
+            LOG(WARNING) << "Invalid number of platform handles received";
+            read_stopped_ = true;
+            CallOnFatalError(Delegate::FATAL_ERROR_FAILED_READ);
+            return;
+          }
+        }
+      }
+
+      // TODO(vtl): In the case that we aren't expecting any platform handles,
+      // for the POSIX implementation, we should confirm that none are stored.
+
       // Dispatch the message.
       DCHECK(delegate_);
       delegate_->OnReadMessage(message_view);
       if (read_stopped_) {
         // |Shutdown()| was called in |OnReadMessage()|.
         // TODO(vtl): Add test for this case.
         return;
       }
       did_dispatch_message = true;
 
@@ skipping 105 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