Mojo: More work towards sending message pipe handles over remote message pipes.

mojo/system/proxy_message_pipe_endpoint.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/proxy_message_pipe_endpoint.h"
 
 #include <string.h>
 
+#include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "mojo/system/channel.h"
+#include "mojo/system/message_pipe_dispatcher.h"
 
 namespace mojo {
 namespace system {
 
 ProxyMessagePipeEndpoint::ProxyMessagePipeEndpoint()
     : local_id_(MessageInTransit::kInvalidEndpointId),
       remote_id_(MessageInTransit::kInvalidEndpointId),
       is_open_(true),
       is_peer_open_(true) {
 }
@@ skipping 34 matching lines @@
                                MessageInTransit::kSubtypeMessagePipePeerClosed,
                                NULL, 0);
   EnqueueMessageInternal(message, NULL);
 }
 
 MojoResult ProxyMessagePipeEndpoint::EnqueueMessage(
     MessageInTransit* message,
     const std::vector<Dispatcher*>* dispatchers) {
   DCHECK(!dispatchers || !dispatchers->empty());
 
-  MojoResult result = CanEnqueueDispatchers(dispatchers);
+  // No need to preflight if there are no dispatchers.
+  if (!dispatchers) {
+    EnqueueMessageInternal(message, NULL);
+    return MOJO_RESULT_OK;
+  }
+
+  std::vector<PreflightDispatcherInfo> preflight_dispatcher_infos;
+  MojoResult result = PreflightDispatchers(dispatchers,
+                                           &preflight_dispatcher_infos);
   if (result != MOJO_RESULT_OK) {
     message->Destroy();
     return result;
   }
 
   EnqueueMessageInternal(message, dispatchers);
   return MOJO_RESULT_OK;
 }
 
 void ProxyMessagePipeEndpoint::Attach(scoped_refptr<Channel> channel,
@@ skipping 21 matching lines @@
   remote_id_ = remote_id;
   AssertConsistentState();
 
   for (std::deque<MessageInTransit*>::iterator it =
            paused_message_queue_.begin(); it != paused_message_queue_.end();
        ++it)
     EnqueueMessageInternal(*it, NULL);
   paused_message_queue_.clear();
 }
 
-MojoResult ProxyMessagePipeEndpoint::CanEnqueueDispatchers(
-    const std::vector<Dispatcher*>* dispatchers) {
+MojoResult ProxyMessagePipeEndpoint::PreflightDispatchers(
+    const std::vector<Dispatcher*>* dispatchers,
+    std::vector<PreflightDispatcherInfo>* preflight_dispatcher_infos) {
+  DCHECK(!dispatchers || !dispatchers->empty());
+  DCHECK(preflight_dispatcher_infos);
+  DCHECK(preflight_dispatcher_infos->empty());
+
+  // Size it to fit everything.
+  preflight_dispatcher_infos->resize(dispatchers->size());
+
+  // TODO(vtl): We'll begin with limited support for sending message pipe
+  // handles. We won't support:
+  //  - sending both handles (the |hash_set| below is to detect this case and
+  //    fail gracefully);
+  //  - sending a handle whose peer is remote.
+  base::hash_set<intptr_t> message_pipes;
+
+  for (size_t i = 0; i < dispatchers->size(); i++) {
+    Dispatcher* dispatcher = (*dispatchers)[i];
+    switch (dispatcher->GetType()) {
+      case Dispatcher::kTypeUnknown:
+        LOG(ERROR) << "Unknown dispatcher type";
+        return MOJO_RESULT_INTERNAL;
+
+      case Dispatcher::kTypeMessagePipe: {
+        MessagePipeDispatcher* mp_dispatcher =
+            static_cast<MessagePipeDispatcher*>(dispatcher);
+        (*preflight_dispatcher_infos)[i].message_pipe =
+            mp_dispatcher->GetMessagePipeNoLock();
+        DCHECK((*preflight_dispatcher_infos)[i].message_pipe);
+        (*preflight_dispatcher_infos)[i].port = mp_dispatcher->GetPortNoLock();
+
+        // Check for unsupported cases (see TODO above).
+        bool is_new_element = message_pipes.insert(reinterpret_cast<intptr_t>(
+            (*preflight_dispatcher_infos)[i].message_pipe)).second;
+        if (!is_new_element) {
+          NOTIMPLEMENTED()
+              << "Sending both sides of a message pipe not yet supported";
+          return MOJO_RESULT_UNIMPLEMENTED;
+        }
+        // TODO(vtl): Check that peer isn't remote (per above TODO).
+
+        break;
+      }
+
+      case Dispatcher::kTypeDataPipeProducer:
+        NOTIMPLEMENTED() << "Sending data pipe producers not yet supported";
+        return MOJO_RESULT_UNIMPLEMENTED;
+
+      case Dispatcher::kTypeDataPipeConsumer:
+        NOTIMPLEMENTED() << "Sending data pipe consumers not yet supported";
+        return MOJO_RESULT_UNIMPLEMENTED;
+
+      default:
+        LOG(ERROR) << "Invalid or unsupported dispatcher type";
+        return MOJO_RESULT_UNIMPLEMENTED;
+    }
+  }
+
   // TODO(vtl): Support sending handles over OS pipes.
-  if (dispatchers) {
-    NOTIMPLEMENTED();
-    return MOJO_RESULT_UNIMPLEMENTED;
-  }
-  return MOJO_RESULT_OK;
+  NOTIMPLEMENTED();
+  return MOJO_RESULT_UNIMPLEMENTED;
 }
 
 // Note: We may have to enqueue messages even when our (local) peer isn't open
 // -- it may have been written to and closed immediately, before we were ready.
 // This case is handled in |Run()| (which will call us).
 void ProxyMessagePipeEndpoint::EnqueueMessageInternal(
     MessageInTransit* message,
     const std::vector<Dispatcher*>* dispatchers) {
   DCHECK(is_open_);
 
@@ skipping 21 matching lines @@
     DCHECK_NE(local_id_, MessageInTransit::kInvalidEndpointId);
   } else {  // Not attached.
     DCHECK_EQ(local_id_, MessageInTransit::kInvalidEndpointId);
     DCHECK_EQ(remote_id_, MessageInTransit::kInvalidEndpointId);
   }
 }
 #endif
 
 }  // namespace system
 }  // namespace mojo