Hide the proxy socket address from the clients of ProxyResolvingClientSocket.

content/renderer/p2p/ipc_socket_factory.cc

 // Copyright (c) 2012 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/ipc_socket_factory.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/compiler_specific.h"
@@ skipping 380 matching lines @@
     }
 
     error_ = EWOULDBLOCK;
     IncrementDiscardCounters(data_size);
     return -1;
   } else {
     current_discard_bytes_sequence_ = 0;
   }
 
   net::IPEndPoint address_chrome;
-  if (!jingle_glue::SocketAddressToIPEndPoint(address, &address_chrome)) {
-    LOG(WARNING) << "Failed to convert remote address to IPEndPoint: address = "
-                 << address.ipaddr().ToSensitiveString()
-                 << ", remote_address_ = "
-                 << remote_address_.ipaddr().ToSensitiveString();
-    NOTREACHED();
-    error_ = EINVAL;
-    return -1;
+  if (address.IsUnresolvedIP()) {
+    address_chrome = net::IPEndPoint(net::IPAddressNumber(), address.port());
+  } else {
+    if (!jingle_glue::SocketAddressToIPEndPoint(address, &address_chrome)) {
+      LOG(WARNING) << "Failed to convert remote address to IPEndPoint: address="
+                   << address.ipaddr().ToSensitiveString()
+                   << ", remote_address_="
+                   << remote_address_.ipaddr().ToSensitiveString();
+      NOTREACHED();
+      error_ = EINVAL;
+      return -1;
+    }
   }
 
   send_bytes_available_ -= data_size;
   in_flight_packet_sizes_.push_back(data_size);
   TraceSendThrottlingState();
 
   const char* data_char = reinterpret_cast<const char*>(data);
   std::vector<char> data_vector(data_char, data_char + data_size);
   client_->SendWithDscp(address_chrome, data_vector, options);
 
@@ skipping 104 matching lines @@
       DoSetOption(static_cast<P2PSocketOption> (i), options_[i]);
   }
 
   SignalAddressReady(this, local_address_);
   if (IsTcpClientSocket(type_)) {
     // If remote address is unresolved, set resolved remote IP address received
     // in the callback. This address will be used while sending the packets
     // over the network.
     if (remote_address_.IsUnresolvedIP()) {
       rtc::SocketAddress jingle_socket_address;
-      if (!jingle_glue::IPEndPointToSocketAddress(
-            remote_address, &jingle_socket_address)) {
-        LOG(WARNING) << "Failed to convert remote IPEndPoint to SocketAddress: "
-                     << remote_address.ToString();
-        NOTREACHED();
+      // |remote_address| could be unresolved if the connection is behind a
+      // proxy.
+      if (!remote_address.address().empty() &&
+          jingle_glue::IPEndPointToSocketAddress(
+              remote_address, &jingle_socket_address)) {
+        // Set only the IP address.
+        remote_address_.SetResolvedIP(jingle_socket_address.ipaddr());
       }
-      // Set only the IP address.
-      remote_address_.SetResolvedIP(jingle_socket_address.ipaddr());
     }
 
     // SignalConnect after updating the |remote_address_| so that the listener
     // can get the resolved remote address.
     SignalConnect(this);
   }
 }
 
 void IpcPacketSocket::OnIncomingTcpConnection(
     const net::IPEndPoint& address,
@@ skipping 41 matching lines @@
     SignalClose(this, 0);
   }
 }
 
 void IpcPacketSocket::OnDataReceived(const net::IPEndPoint& address,
                                      const std::vector<char>& data,
                                      const base::TimeTicks& timestamp) {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   rtc::SocketAddress address_lj;
-  if (!jingle_glue::IPEndPointToSocketAddress(address, &address_lj)) {
-    // We should always be able to convert address here because we
-    // don't expect IPv6 address on IPv4 connections.
-    NOTREACHED();
-    return;
+
+  if (address.address().empty()) {
+    DCHECK(IsTcpClientSocket(type_));
+    // |address| could be empty for TCP connections behind a proxy.
+    address_lj = remote_address_;
+  } else {
+    if (!jingle_glue::IPEndPointToSocketAddress(address, &address_lj)) {
+      // We should always be able to convert address here because we
+      // don't expect IPv6 address on IPv4 connections.
+      NOTREACHED();
+      return;
+    }
   }
 
   rtc::PacketTime packet_time(timestamp.ToInternalValue(), 0);
   SignalReadPacket(this, &data[0], data.size(), address_lj,
                    packet_time);
 }
 
 AsyncAddressResolverImpl::AsyncAddressResolverImpl(
     P2PSocketDispatcher* dispatcher)
     : resolver_(new P2PAsyncAddressResolver(dispatcher)) {
@@ skipping 126 matching lines @@
 }
 
 rtc::AsyncResolverInterface*
 IpcPacketSocketFactory::CreateAsyncResolver() {
   scoped_ptr<AsyncAddressResolverImpl> resolver(
     new AsyncAddressResolverImpl(socket_dispatcher_));
   return resolver.release();
 }
 
 }  // namespace content