Add a Mojo EDK for Chrome that uses one OS pipe per message pipe.

mojo/edk/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 "third_party/mojo/src/mojo/edk/system/message_in_transit.h"
+#include "mojo/edk/system/message_in_transit.h"
 
 #include <string.h>
 
 #include <ostream>
 
 #include "base/logging.h"
-#include "third_party/mojo/src/mojo/edk/system/configuration.h"
-#include "third_party/mojo/src/mojo/edk/system/transport_data.h"
+#include "mojo/edk/system/configuration.h"
+#include "mojo/edk/system/transport_data.h"
 
 namespace mojo {
-namespace system {
+namespace edk {
 
 MOJO_STATIC_CONST_MEMBER_DEFINITION const size_t
     MessageInTransit::kMessageAlignment;
 
 struct MessageInTransit::PrivateStructForCompileAsserts {
   // The size of |Header| must be a multiple of the alignment.
   static_assert(sizeof(Header) % kMessageAlignment == 0,
                 "sizeof(MessageInTransit::Header) invalid");
 };
 
@@ skipping 35 matching lines @@
     if (e) {
       *error_message = e;
       return false;
     }
   }
 
   return true;
 }
 
 MessageInTransit::MessageInTransit(Type type,
-                                   Subtype subtype,
                                    uint32_t num_bytes,
                                    const void* bytes)
     : main_buffer_size_(RoundUpMessageAlignment(sizeof(Header) + num_bytes)),
       main_buffer_(static_cast<char*>(
           base::AlignedAlloc(main_buffer_size_, kMessageAlignment))) {
-  ConstructorHelper(type, subtype, num_bytes);
+  ConstructorHelper(type, num_bytes);
   if (bytes) {
     memcpy(MessageInTransit::bytes(), bytes, num_bytes);
     memset(static_cast<char*>(MessageInTransit::bytes()) + num_bytes, 0,
            main_buffer_size_ - sizeof(Header) - num_bytes);
   } else {
     memset(MessageInTransit::bytes(), 0, main_buffer_size_ - sizeof(Header));
   }
 }
 
-MessageInTransit::MessageInTransit(Type type,
-                                   Subtype subtype,
-                                   uint32_t num_bytes,
-                                   UserPointer<const void> bytes)
-    : main_buffer_size_(RoundUpMessageAlignment(sizeof(Header) + num_bytes)),
-      main_buffer_(static_cast<char*>(
-          base::AlignedAlloc(main_buffer_size_, kMessageAlignment))) {
-  ConstructorHelper(type, subtype, num_bytes);
-  bytes.GetArray(MessageInTransit::bytes(), num_bytes);
-  memset(static_cast<char*>(MessageInTransit::bytes()) + num_bytes, 0,
-         main_buffer_size_ - sizeof(Header) - num_bytes);
-}
-
 MessageInTransit::MessageInTransit(const View& message_view)
     : main_buffer_size_(message_view.main_buffer_size()),
       main_buffer_(static_cast<char*>(
           base::AlignedAlloc(main_buffer_size_, kMessageAlignment))) {
   DCHECK_GE(main_buffer_size_, sizeof(Header));
   DCHECK_EQ(main_buffer_size_ % kMessageAlignment, 0u);
 
   memcpy(main_buffer_.get(), message_view.main_buffer(), main_buffer_size_);
   DCHECK_EQ(main_buffer_size_,
             RoundUpMessageAlignment(sizeof(Header) + num_bytes()));
 }
 
 MessageInTransit::~MessageInTransit() {
   if (dispatchers_) {
     for (size_t i = 0; i < dispatchers_->size(); i++) {
       if (!(*dispatchers_)[i])
         continue;
-
-      DCHECK((*dispatchers_)[i]->HasOneRef());
       (*dispatchers_)[i]->Close();
     }
   }
 }
 
 // static
 bool MessageInTransit::GetNextMessageSize(const void* buffer,
                                           size_t buffer_size,
                                           size_t* next_message_size) {
   DCHECK(next_message_size);
@@ skipping 13 matching lines @@
   return true;
 }
 
 void MessageInTransit::SetDispatchers(
     scoped_ptr<DispatcherVector> dispatchers) {
   DCHECK(dispatchers);
   DCHECK(!dispatchers_);
   DCHECK(!transport_data_);
 
   dispatchers_ = dispatchers.Pass();
-#ifndef NDEBUG
-  for (size_t i = 0; i < dispatchers_->size(); i++)
-    DCHECK(!(*dispatchers_)[i] || (*dispatchers_)[i]->HasOneRef());
-#endif
 }
 
 void MessageInTransit::SetTransportData(
     scoped_ptr<TransportData> transport_data) {
   DCHECK(transport_data);
   DCHECK(!transport_data_);
   DCHECK(!dispatchers_);
 
   transport_data_ = transport_data.Pass();
   UpdateTotalSize();
 }
 
-void MessageInTransit::SerializeAndCloseDispatchers(Channel* channel) {
-  DCHECK(channel);
+void MessageInTransit::SerializeAndCloseDispatchers() {
   DCHECK(!transport_data_);
 
   if (!dispatchers_ || !dispatchers_->size())
     return;
 
-  transport_data_.reset(new TransportData(dispatchers_.Pass(), channel));
+  transport_data_.reset(new TransportData(dispatchers_.Pass()));
 
   // Update the sizes in the message header.
   UpdateTotalSize();
 }
 
 void MessageInTransit::ConstructorHelper(Type type,
-                                         Subtype subtype,
                                          uint32_t num_bytes) {
   DCHECK_LE(num_bytes, GetConfiguration().max_message_num_bytes);
 
   // |total_size| is updated below, from the other values.
   header()->type = type;
-  header()->subtype = subtype;
-  header()->source_id = ChannelEndpointId();
-  header()->destination_id = ChannelEndpointId();
   header()->num_bytes = num_bytes;
   header()->unused = 0;
   // Note: If dispatchers are subsequently attached, then |total_size| will have
   // to be adjusted.
   UpdateTotalSize();
 }
 
 void MessageInTransit::UpdateTotalSize() {
   DCHECK_EQ(main_buffer_size_ % kMessageAlignment, 0u);
   header()->total_size = static_cast<uint32_t>(main_buffer_size_);
   if (transport_data_) {
     header()->total_size +=
         static_cast<uint32_t>(transport_data_->buffer_size());
   }
 }
 
-}  // namespace system
+}  // namespace edk
 }  // namespace mojo