Update mojo sdk to rev cc531b32182099a5a034a99daff35ed5d38a61c8

mojo/edk/system/channel.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/edk/system/channel.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
+#include "mojo/edk/system/endpoint_relayer.h"
 #include "mojo/edk/system/transport_data.h"
 
 namespace mojo {
 namespace system {
 
 namespace {
 
 struct SerializedEndpoint {
   // This is the endpoint ID on the receiving side, and should be a "remote ID".
   // (The receiving side should already have had an endpoint attached and been
@@ skipping 154 matching lines @@
         "ID %u)",
         static_cast<unsigned>(local_id.value()),
         static_cast<unsigned>(remote_id.value())));
   }
 }
 
 size_t Channel::GetSerializedEndpointSize() const {
   return sizeof(SerializedEndpoint);
 }
 
-void Channel::SerializeEndpoint(scoped_refptr<ChannelEndpoint> endpoint,
-                                void* destination) {
+void Channel::SerializeEndpointWithClosedPeer(
+    void* destination,
+    MessageInTransitQueue* message_queue) {
+  // We can actually just pass no client to |SerializeEndpointWithLocalPeer()|.
+  SerializeEndpointWithLocalPeer(destination, message_queue, nullptr, 0);
+}
+
+scoped_refptr<ChannelEndpoint> Channel::SerializeEndpointWithLocalPeer(
+    void* destination,
+    MessageInTransitQueue* message_queue,
+    ChannelEndpointClient* endpoint_client,
+    unsigned endpoint_client_port) {
+  DCHECK(destination);
+  // Allow |endpoint_client| to be null, for use by
+  // |SerializeEndpointWithClosedPeer()|.
+
+  scoped_refptr<ChannelEndpoint> endpoint(new ChannelEndpoint(
+      endpoint_client, endpoint_client_port, message_queue));
+
   SerializedEndpoint* s = static_cast<SerializedEndpoint*>(destination);
   s->receiver_endpoint_id = AttachAndRunEndpoint(endpoint);
-  DVLOG(2) << "Serializing endpoint (remote ID = " << s->receiver_endpoint_id
-           << ")";
+  DVLOG(2) << "Serializing endpoint with local or closed peer (remote ID = "
+           << s->receiver_endpoint_id << ")";
+
+  return endpoint;
+}
+
+void Channel::SerializeEndpointWithRemotePeer(
+    void* destination,
+    MessageInTransitQueue* message_queue,
+    scoped_refptr<ChannelEndpoint> peer_endpoint) {
+  DCHECK(destination);
+  DCHECK(peer_endpoint);
+
+  DLOG(WARNING) << "Direct message pipe passing across multiple channels not "
+                   "yet implemented; will proxy";
+  // Create and set up an |EndpointRelayer| to proxy.
+  // TODO(vtl): If we were to own/track the relayer directly (rather than owning
+  // it via its |ChannelEndpoint|s), then we might be able to make
+  // |ChannelEndpoint|'s |client_| pointer a raw pointer.
+  scoped_refptr<EndpointRelayer> relayer(new EndpointRelayer());
+  scoped_refptr<ChannelEndpoint> endpoint(
+      new ChannelEndpoint(relayer.get(), 0, message_queue));
+  relayer->Init(endpoint.get(), peer_endpoint.get());
+  peer_endpoint->ReplaceClient(relayer.get(), 1);
+
+  SerializedEndpoint* s = static_cast<SerializedEndpoint*>(destination);
+  s->receiver_endpoint_id = AttachAndRunEndpoint(endpoint);
+  DVLOG(2) << "Serializing endpoint with remote peer (remote ID = "
+           << s->receiver_endpoint_id << ")";
 }
 
 scoped_refptr<IncomingEndpoint> Channel::DeserializeEndpoint(
     const void* source) {
   const SerializedEndpoint* s = static_cast<const SerializedEndpoint*>(source);
   ChannelEndpointId local_id = s->receiver_endpoint_id;
   // No need to check the validity of |local_id| -- if it's not valid, it simply
   // won't be in |incoming_endpoints_|.
   DVLOG_IF(2, !local_id.is_valid() || !local_id.is_remote())
       << "Attempt to get incoming endpoint for invalid ID " << local_id;
@@ skipping 352 matching lines @@
            << ", local ID " << local_id << ", remote ID " << remote_id;
   scoped_ptr<MessageInTransit> message(new MessageInTransit(
       MessageInTransit::kTypeChannel, subtype, 0, nullptr));
   message->set_source_id(local_id);
   message->set_destination_id(remote_id);
   return WriteMessage(message.Pass());
 }
 
 }  // namespace system
 }  // namespace mojo