Mojo: Add the ability to attach PlatformHandles to MessageInTransits.

mojo/system/message_in_transit.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/message_in_transit.h"
 
 #include <string.h>
 
 #include <new>
 
@@ skipping 130 matching lines @@
   memcpy(secondary_buffer_, message_view.secondary_buffer(),
          secondary_buffer_size_);
 
   DCHECK_EQ(main_buffer_size_,
             RoundUpMessageAlignment(sizeof(Header) + num_bytes()));
 }
 
 MessageInTransit::~MessageInTransit() {
   base::AlignedFree(main_buffer_);
   base::AlignedFree(secondary_buffer_);  // Okay if null.
-#ifndef NDEBUG
-  main_buffer_size_ = 0;
-  main_buffer_ = NULL;
-  secondary_buffer_size_ = 0;
-  secondary_buffer_ = NULL;
-#endif
 
-  if (dispatchers_.get()) {
+  if (dispatchers_) {
     for (size_t i = 0; i < dispatchers_->size(); i++) {
       if (!(*dispatchers_)[i])
         continue;
 
       DCHECK((*dispatchers_)[i]->HasOneRef());
       (*dispatchers_)[i]->Close();
     }
-    dispatchers_.reset();
   }
+
+  if (platform_handles_) {
+    for (size_t i = 0; i < platform_handles_->size(); i++)
+      (*platform_handles_)[i].CloseIfNecessary();
+  }
+
+#ifndef NDEBUG
+  main_buffer_size_ = 0;
+  main_buffer_ = NULL;
+  secondary_buffer_size_ = 0;
+  secondary_buffer_ = NULL;
+  dispatchers_.reset();
+  platform_handles_.reset();
+#endif
 }
 
 // static
 bool MessageInTransit::GetNextMessageSize(const void* buffer,
                                           size_t buffer_size,
                                           size_t* next_message_size) {
   DCHECK(next_message_size);
   if (!buffer_size)
     return false;
   DCHECK(buffer);
   DCHECK_EQ(reinterpret_cast<uintptr_t>(buffer) %
                 MessageInTransit::kMessageAlignment, 0u);
 
   if (buffer_size < sizeof(Header))
     return false;
 
   const Header* header = static_cast<const Header*>(buffer);
   *next_message_size = header->total_size;
   DCHECK_EQ(*next_message_size % kMessageAlignment, 0u);
   return true;
 }
 
 void MessageInTransit::SetDispatchers(
     scoped_ptr<std::vector<scoped_refptr<Dispatcher> > > dispatchers) {
-  DCHECK(dispatchers.get());
-  DCHECK(!dispatchers_.get());
+  DCHECK(dispatchers);
+  DCHECK(!dispatchers_);
 
   dispatchers_ = dispatchers.Pass();
 #ifndef NDEBUG
   for (size_t i = 0; i < dispatchers_->size(); i++)
     DCHECK(!(*dispatchers_)[i] || (*dispatchers_)[i]->HasOneRef());
 #endif
 }
 
 void MessageInTransit::SerializeAndCloseDispatchers(Channel* channel) {
   DCHECK(channel);
   DCHECK(!secondary_buffer_);
   CHECK_EQ(num_handles(),
-           dispatchers_.get() ? dispatchers_->size() : static_cast<size_t>(0));
+           dispatchers_ ? dispatchers_->size() : static_cast<size_t>(0));
 
   if (!num_handles())
     return;
 
   size_t handle_table_size = num_handles() * sizeof(HandleTableEntry);
   // The size of the secondary buffer. We'll start with the size of the handle
   // table, and add to it as we go along.
   size_t size = handle_table_size;
   for (size_t i = 0; i < dispatchers_->size(); i++) {
     if (Dispatcher* dispatcher = (*dispatchers_)[i].get()) {
@@ skipping 39 matching lines @@
     }
 
     current_offset += RoundUpMessageAlignment(actual_size);
     DCHECK_LE(current_offset, size);
   }
 
   UpdateTotalSize();
 }
 
 void MessageInTransit::DeserializeDispatchers(Channel* channel) {
-  DCHECK(!dispatchers_.get());
+  DCHECK(!dispatchers_);
 
   // This should have been checked by calling |IsValid()| on the |View| first.
   DCHECK_LE(num_handles(), kMaxMessageNumHandles);
 
   if (!num_handles())
     return;
 
   dispatchers_.reset(
       new std::vector<scoped_refptr<Dispatcher> >(num_handles()));
 
@@ skipping 69 matching lines @@
 
 void MessageInTransit::UpdateTotalSize() {
   DCHECK_EQ(main_buffer_size_ % kMessageAlignment, 0u);
   DCHECK_EQ(secondary_buffer_size_ % kMessageAlignment, 0u);
   header()->total_size =
       static_cast<uint32_t>(main_buffer_size_ + secondary_buffer_size_);
 }
 
 }  // namespace system
 }  // namespace mojo