Push remote hostname to P2P socket host.

content/renderer/p2p/socket_client_impl.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 "content/renderer/p2p/socket_client_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/common/p2p_messages.h"
 #include "content/renderer/p2p/socket_client_delegate.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "content/renderer/render_thread_impl.h"
 #include "crypto/random.h"
 
 namespace {
 
 uint64 GetUniqueId(uint32 random_socket_id, uint32 packet_id) {
   uint64 uid = random_socket_id;
   uid <<= 32;
   uid |= packet_id;
   return uid;
 }
 
 }  // namespace
 
 namespace content {
 
-scoped_refptr<P2PSocketClient> P2PSocketClient::Create(
-    P2PSocketType type,
-    const net::IPEndPoint& local_address,
-    const net::IPEndPoint& remote_address,
-    P2PSocketClientDelegate* delegate) {
-  P2PSocketClientImpl* impl = new P2PSocketClientImpl(
-      RenderThreadImpl::current()->p2p_socket_dispatcher());
-  impl->Init(type, local_address, remote_address, delegate);
-  return impl;
-}
-
 P2PSocketClientImpl::P2PSocketClientImpl(P2PSocketDispatcher* dispatcher)
     : dispatcher_(dispatcher),
       ipc_message_loop_(dispatcher->message_loop()),
       delegate_message_loop_(base::MessageLoopProxy::current()),
       socket_id_(0), delegate_(NULL),
       state_(STATE_UNINITIALIZED),
       random_socket_id_(0),
       next_packet_id_(0) {
   crypto::RandBytes(&random_socket_id_, sizeof(random_socket_id_));
 }
 
 P2PSocketClientImpl::~P2PSocketClientImpl() {
   CHECK(state_ == STATE_CLOSED || state_ == STATE_UNINITIALIZED);
 }
 
 void P2PSocketClientImpl::Init(
     P2PSocketType type,
     const net::IPEndPoint& local_address,
-    const net::IPEndPoint& remote_address,
+    const P2PHostAndIPEndPoint& remote_address,
     P2PSocketClientDelegate* delegate) {
   DCHECK(delegate_message_loop_->BelongsToCurrentThread());
   // |delegate_| is only accessesed on |delegate_message_loop_|.
   delegate_ = delegate;
 
   ipc_message_loop_->PostTask(
       FROM_HERE, base::Bind(&P2PSocketClientImpl::DoInit,
                             this,
                             type,
                             local_address,
                             remote_address));
 }
 
 void P2PSocketClientImpl::DoInit(P2PSocketType type,
                                  const net::IPEndPoint& local_address,
-                                 const net::IPEndPoint& remote_address) {
+                                 const P2PHostAndIPEndPoint& remote_address) {
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   DCHECK(delegate_);
   state_ = STATE_OPENING;
   socket_id_ = dispatcher_->RegisterClient(this);
   dispatcher_->SendP2PMessage(new P2PHostMsg_CreateSocket(
       type, socket_id_, local_address, remote_address));
 }
 
 void P2PSocketClientImpl::SendWithDscp(
     const net::IPEndPoint& address,
@@ skipping 167 matching lines @@
     delegate_->OnDataReceived(address, data, timestamp);
 }
 
 void P2PSocketClientImpl::Detach() {
   DCHECK(ipc_message_loop_->BelongsToCurrentThread());
   dispatcher_ = NULL;
   OnError();
 }
 
 }  // namespace content