Mojo: Remove Channel::AttachMessagePipeEndpoint().

mojo/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/system/channel.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 87 matching lines @@
 // directly to this function, which wouldn't be sufficient for safety.
 MessageInTransit::EndpointId Channel::AttachEndpoint(
     scoped_refptr<ChannelEndpoint> endpoint) {
   DCHECK(endpoint.get());
 
   MessageInTransit::EndpointId local_id;
   {
     base::AutoLock locker(lock_);
 
     DLOG_IF(WARNING, is_shutting_down_)
-        << "AttachMessagePipeEndpoint() while shutting down";
+        << "AttachEndpoint() while shutting down";
 
     while (next_local_id_ == MessageInTransit::kInvalidEndpointId ||
            local_id_to_endpoint_map_.find(next_local_id_) !=
                local_id_to_endpoint_map_.end())
       next_local_id_++;
 
     local_id = next_local_id_;
     next_local_id_++;
     local_id_to_endpoint_map_[local_id] = endpoint;
   }
 
   endpoint->AttachToChannel(this, local_id);
   // This might fail if that port got an |OnPeerClose()| before attaching.
   if (endpoint->message_pipe_->Attach(endpoint->port_, endpoint.get()))
     return local_id;
 
   // Note: If it failed, quite possibly the endpoint info was removed from that
   // map (there's a race between us adding it to the map above and calling
   // |Attach()|). And even if an entry exists for |local_id|, we need to check
   // that it's the one we added (and not some other one that was added since).
   {
     base::AutoLock locker(lock_);
     IdToEndpointMap::iterator it = local_id_to_endpoint_map_.find(local_id);
     if (it != local_id_to_endpoint_map_.end() &&
         it->second->message_pipe_.get() == endpoint->message_pipe_.get() &&
         it->second->port_ == endpoint->port_) {
       DCHECK_EQ(it->second->state_, ChannelEndpoint::STATE_NORMAL);
       // TODO(vtl): FIXME -- This is wrong. We need to specify (to
-      // |AttachMessagePipeEndpoint()| who's going to be responsible for calling
+      // |AttachEndpoint()| who's going to be responsible for calling
       // |RunMessagePipeEndpoint()| ("us", or the remote by sending us a
       // |kSubtypeChannelRunMessagePipeEndpoint|). If the remote is going to
       // run, then we'll get messages to an "invalid" local ID (for running, for
       // removal).
       local_id_to_endpoint_map_.erase(it);
     }
   }
   endpoint->DetachFromChannel();
   return MessageInTransit::kInvalidEndpointId;
 }
 
-MessageInTransit::EndpointId Channel::AttachMessagePipeEndpoint(
-    scoped_refptr<MessagePipe> message_pipe,
-    unsigned port) {
-  DCHECK(message_pipe.get());
-  DCHECK(port == 0 || port == 1);
-
-  return AttachEndpoint(
-      make_scoped_refptr(new ChannelEndpoint(message_pipe.get(), port)));
-}
-
 bool Channel::RunMessagePipeEndpoint(MessageInTransit::EndpointId local_id,
                                      MessageInTransit::EndpointId remote_id) {
   scoped_refptr<ChannelEndpoint> endpoint;
   ChannelEndpoint::State state;
   scoped_refptr<MessagePipe> message_pipe;
   unsigned port;
   {
     base::AutoLock locker(lock_);
 
     DLOG_IF(WARNING, is_shutting_down_)
@@ skipping 392 matching lines @@
   // TODO(vtl): Is this how we really want to handle this?
   // Sometimes we'll want to propagate the error back to the message pipe
   // (endpoint), and notify it that the remote is (effectively) closed.
   // Sometimes we'll want to kill the channel (and notify all the endpoints that
   // their remotes are dead.
   LOG(WARNING) << error_message;
 }
 
 }  // namespace system
 }  // namespace mojo