Allow data pipe producer/consumer handles to be re-sent.

mojo/edk/system/remote_consumer_data_pipe_impl.cc

 // Copyright 2015 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/remote_consumer_data_pipe_impl.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/data_pipe.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/remote_data_pipe_ack.h"
 
 namespace mojo {
 namespace system {
 
 namespace {
@@ skipping 225 matching lines @@
     rv.satisfied_signals |= MOJO_HANDLE_SIGNAL_PEER_CLOSED;
   }
   rv.satisfiable_signals |= MOJO_HANDLE_SIGNAL_PEER_CLOSED;
   return rv;
 }
 
 void RemoteConsumerDataPipeImpl::ProducerStartSerialize(
     Channel* channel,
     size_t* max_size,
     size_t* max_platform_handles) {
-  // TODO(vtl): Support serializing producer data pipe handles.
-  NOTIMPLEMENTED();  // FIXME
-  *max_size = 0;
+  *max_size = sizeof(SerializedDataPipeProducerDispatcher) +
+              channel->GetSerializedEndpointSize();
   *max_platform_handles = 0;
 }
 
 bool RemoteConsumerDataPipeImpl::ProducerEndSerialize(
     Channel* channel,
     void* destination,
     size_t* actual_size,
     embedder::PlatformHandleVector* platform_handles) {
-  // TODO(vtl): Support serializing producer data pipe handles.
-  NOTIMPLEMENTED();  // FIXME
-  owner()->ProducerCloseNoLock();
-  return false;
+  SerializedDataPipeProducerDispatcher* s =
+      static_cast<SerializedDataPipeProducerDispatcher*>(destination);
+  s->validated_options = validated_options();
+  void* destination_for_endpoint = static_cast<char*>(destination) +
+                                   sizeof(SerializedDataPipeProducerDispatcher);
+
+  if (!consumer_open()) {
+    // Case 1: The consumer is closed.
+    s->consumer_num_bytes = static_cast<size_t>(-1);
+    *actual_size = sizeof(SerializedDataPipeProducerDispatcher);
+    return true;
+  }
+
+  // Case 2: The consumer isn't closed. We pass |channel_endpoint| back to the
+  // |Channel|. There's no reason for us to continue to exist afterwards.
+
+  s->consumer_num_bytes = consumer_num_bytes_;
+  // Note: We don't use |port|.
+  scoped_refptr<ChannelEndpoint> channel_endpoint;
+  channel_endpoint.swap(channel_endpoint_);
+  channel->SerializeEndpointWithRemotePeer(destination_for_endpoint, nullptr,
+                                           channel_endpoint);
+  owner()->SetConsumerClosedNoLock();

[Hajime Morrita, 2015/03/03 03:00:38]

This isn't directly related to this CL, but it'd be nice if the naming indicates
that consumer_open() and SetConsumeClosedNoLock() refers the same flag, or even
there is no flag and it just sees channel_endpoint_ to decide open-ness. The
flag seems a bit too delicate.

[viettrungluu, 2015/03/03 05:17:45]

Yeah, things aren't factored quite right (partly a consequence of my moving the
implementation of DataPipe into the ...DataPipeImpl subclasses). :-/

I kind of want to just make the the impls are in charge of this information
(rather than having flags in DataPipe) ... but I'd have to do this carefully
since impls can be swapped (and sometimes there may not be an impl, even if
momentarily, which would complicate various DCHECKs and such).

+
+  *actual_size = sizeof(SerializedDataPipeProducerDispatcher) +
+                 channel->GetSerializedEndpointSize();
+  return true;
 }
 
 void RemoteConsumerDataPipeImpl::ConsumerClose() {
   NOTREACHED();
 }
 
 MojoResult RemoteConsumerDataPipeImpl::ConsumerReadData(
     UserPointer<void> /*elements*/,
     UserPointer<uint32_t> /*num_bytes*/,
     uint32_t /*max_num_bytes_to_read*/,
@@ skipping 103 matching lines @@
   DCHECK(consumer_open());
   DCHECK(channel_endpoint_);
   owner()->SetConsumerClosedNoLock();
   channel_endpoint_->DetachFromClient();
   channel_endpoint_ = nullptr;
   DestroyBuffer();
 }
 
 }  // namespace system
 }  // namespace mojo