Bind a socket to a network if the network handle is set.

webrtc/p2p/base/basicpacketsocketfactory.cc

 /*
  *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/p2p/base/basicpacketsocketfactory.h"
 
 #include "webrtc/p2p/base/asyncstuntcpsocket.h"
 #include "webrtc/p2p/base/stun.h"
 #include "webrtc/base/asynctcpsocket.h"
 #include "webrtc/base/asyncudpsocket.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/nethelpers.h"
+#include "webrtc/base/network.h"
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/socketadapters.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
 
 BasicPacketSocketFactory::BasicPacketSocketFactory()
     : thread_(Thread::Current()),
@@ skipping 11 matching lines @@
       socket_factory_(socket_factory) {
 }
 
 BasicPacketSocketFactory::~BasicPacketSocketFactory() {
 }
 
 AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocket(
     const SocketAddress& address,
     uint16_t min_port,
     uint16_t max_port) {
+  return CreateUdpSocketOnNetwork(address, min_port, max_port, nullptr);
+}
+
+AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocketOnNetwork(
+    const SocketAddress& address,
+    uint16_t min_port,
+    uint16_t max_port,
+    const Network* network) {
   // UDP sockets are simple.
   rtc::AsyncSocket* socket =
       socket_factory()->CreateAsyncSocket(
           address.family(), SOCK_DGRAM);
   if (!socket) {
     return NULL;
   }
+  if (network && network->IsHandleValid()) {
+    int res = socket->BindToNetwork(network->handle());
+    if (res < 0) {
+      LOG(LS_WARNING) << "Network bind failed with error " << res;
+    }
+  }
   if (BindSocket(socket, address, min_port, max_port) < 0) {
     LOG(LS_ERROR) << "UDP bind failed with error "
                     << socket->GetError();
     delete socket;
     return NULL;
   }
   return new rtc::AsyncUDPSocket(socket);
 }
 
 AsyncPacketSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
@@ skipping 120 matching lines @@
   if (min_port == 0 && max_port == 0) {
     // If there's no port range, let the OS pick a port for us.
     ret = socket->Bind(local_address);
   } else {
     // Otherwise, try to find a port in the provided range.
     for (int port = min_port; ret < 0 && port <= max_port; ++port) {
       ret = socket->Bind(rtc::SocketAddress(local_address.ipaddr(),
                                                   port));
     }
   }
   return ret;

[pthatcher1, 2016/01/06 21:58:46]

So, I think we can do something here to avoid needing to have two bind methods
on a socket and a NetworkHandle on Network.  

Here's how:

1.  Define a SocketBinderInterface which has own method:  BindSocket(int fd,
const SocketAddress& local_address);

2.  Inside of PhysicalSocket::Bind, call socket_binder_->BindSocket(s_,
local_address).  If no socket_binder_ is set, it can call ::bind.

3.  Inject an AndroidSocketBinder into the PhysicalSocket as the socket_binder_,
and the AndroidSocketBinder will do all the Android-specific stuff.  The
AndroidSocketBinder can have access to an AndroidNetworkEnumerator or be an
AndroidNetworkEnumerator.

4.  Add SocketServer::SetSocketBinder(SocketBinderInterface* binder) and call it
with the AndroidNetworkEnumerator.  


5.  Maybe inside of PeerConnectionFactory::Initialize(), do something like this:

default_network_manager_.reset(new rtc::BasicNetworkManager());
default_socket_factory_.reset(new
rtc::BasicPacketSocketFactory(worker_thread_));
if (default_network_manager_.socket_binder()) {
 
default_socket_factory_.SetSocketBinder(default_network_manager_.socket_binder());
}

And then SocketPacketFactory::SetSocketBinder calls
SocketServer::SetSocketBinder.

Something like that :).

[honghaiz3, 2016/01/12 20:36:42]

Step 2: I think ::bind should be called anyway, not?
Step 3: I implemented the NetworkBinderInterface in NetworkMonitor. 
I called it NetworkBinderInterface since it provides more information (binding
to network). 
Step 4,5, I just used the global access to the network monitor. 

 }
 
 SocketFactory* BasicPacketSocketFactory::socket_factory() {
   if (thread_) {
     ASSERT(thread_ == Thread::Current());
     return thread_->socketserver();
   } else {
     return socket_factory_;
   }
 }
 
 }  // namespace rtc