Mojo: Make some attempts towards fixing remote message pipe closure.

mojo/system/message_pipe_dispatcher.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_pipe_dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/system/channel.h"
 #include "mojo/system/constants.h"
 #include "mojo/system/local_message_pipe_endpoint.h"
@@ skipping 55 matching lines @@
   if (size != sizeof(SerializedMessagePipeDispatcher)) {
     LOG(ERROR) << "Invalid serialized message pipe dispatcher";
     return scoped_refptr<MessagePipeDispatcher>();
   }
 
   std::pair<scoped_refptr<MessagePipeDispatcher>, scoped_refptr<MessagePipe> >
       remote_message_pipe = CreateRemoteMessagePipe();
 
   MessageInTransit::EndpointId remote_id =
       static_cast<const SerializedMessagePipeDispatcher*>(source)->endpoint_id;
+  if (remote_id == MessageInTransit::kInvalidEndpointId) {
+    // This means that the other end was closed, and there were no messages
+    // enqueued for us.
+    // TODO(vtl): This is wrong. We should produce a "dead" message pipe
+    // dispatcher.
+    NOTIMPLEMENTED();
+    return scoped_refptr<MessagePipeDispatcher>();
+  }
   MessageInTransit::EndpointId local_id =
       channel->AttachMessagePipeEndpoint(remote_message_pipe.second, 1);
+  if (local_id == MessageInTransit::kInvalidEndpointId) {
+    LOG(ERROR) << "Failed to deserialize message pipe dispatcher (failed to "
+                  "attach; remote ID = " << remote_id << ")";
+    return scoped_refptr<MessagePipeDispatcher>();
+  }
   DVLOG(2) << "Deserializing message pipe dispatcher (remote ID = "
            << remote_id << ", new local ID = " << local_id << ")";
 
   if (!channel->RunMessagePipeEndpoint(local_id, remote_id)) {
     // In general, this shouldn't fail, since we generated |local_id| locally.
     NOTREACHED();
     return scoped_refptr<MessagePipeDispatcher>();
   }
 
   // TODO(vtl): FIXME -- Need some error handling here.
@@ skipping 104 matching lines @@
     size_t* actual_size,
     std::vector<embedder::PlatformHandle>* platform_handles) {
   DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
 
   // Convert the local endpoint to a proxy endpoint (moving the message queue).
   message_pipe_->ConvertLocalToProxy(port_);
 
   // Attach the new proxy endpoint to the channel.
   MessageInTransit::EndpointId endpoint_id =
       channel->AttachMessagePipeEndpoint(message_pipe_, port_);
-  DCHECK_NE(endpoint_id, MessageInTransit::kInvalidEndpointId);
-
+  // Note: It's okay to get an endpoint ID of |kInvalidEndpointId|. (It's
+  // possible that the other endpoint -- the one that we're not sending -- was
+  // closed in the intervening time.) In that case, we need to deserialize a
+  // "dead" message pipe dispatcher on the other end. (Note that this is
+  // different from just producing |MOJO_HANDLE_INVALID|.)
   DVLOG(2) << "Serializing message pipe dispatcher (local ID = " << endpoint_id
            << ")";
 
   // We now have a local ID. Before we can run the proxy endpoint, we need to
   // get an ack back from the other side with the remote ID.
   static_cast<SerializedMessagePipeDispatcher*>(destination)->endpoint_id =
       endpoint_id;
 
   message_pipe_ = NULL;
   port_ = kInvalidPort;
 
   *actual_size = sizeof(SerializedMessagePipeDispatcher);
   return true;
 }
 
 // MessagePipeDispatcherTransport ----------------------------------------------
 
 MessagePipeDispatcherTransport::MessagePipeDispatcherTransport(
     DispatcherTransport transport) : DispatcherTransport(transport) {
   DCHECK_EQ(message_pipe_dispatcher()->GetType(), Dispatcher::kTypeMessagePipe);
 }
 
 }  // namespace system
 }  // namespace mojo