Add SocketFactoryInterface::Prepare and fix how symmetric NAT is determined

webrtc/p2p/stunprober/stunprober.cc

 /*
  *  Copyright 2015 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.
  */
 
@@ skipping 56 matching lines @@
   rtc::scoped_ptr<rtc::ByteBuffer> request_packet(
       new rtc::ByteBuffer(nullptr, kMaxUdpBufferSize));
   if (!message.Write(request_packet.get())) {
     prober_->End(WRITE_FAILED, 0);
     return;
   }
 
   auto addr = server_ips_[num_request_sent_];
   request.server_addr = addr.ipaddr();
 
-  int rv = 0;
-
-  // Only bind to the interface at the first request.
-  if (num_request_sent_ == 0) {
-    rtc::IPAddress local_addr;
-    rv = prober_->GetLocalAddress(&local_addr);
-    if (rv != 0) {
-      prober_->End(GENERIC_FAILURE, rv);
-      return;
-    }
-    rv = socket_->Bind(rtc::SocketAddress(local_addr, 0));
-    if (rv < 0) {
-      prober_->End(GENERIC_FAILURE, rv);
-      return;
-    }
-  }
-
   // The write must succeed immediately. Otherwise, the calculating of the STUN
   // request timing could become too complicated. Callback is ignored by passing
   // empty AsyncCallback.
-  rv = socket_->SendTo(addr, const_cast<char*>(request_packet->Data()),
-                       request_packet->Length(), AsyncCallback());
+  int rv = socket_->SendTo(addr, const_cast<char*>(request_packet->Data()),
+                           request_packet->Length(), AsyncCallback());
   if (rv < 0) {
     prober_->End(WRITE_FAILED, rv);
     return;
   }
 
   request.sent_time_ms = rtc::Time();
 
   // Post a read waiting for response. For share mode, the subsequent read will
   // be posted inside OnStunResponseReceived.
   if (num_request_sent_ == 0) {
@@ skipping 163 matching lines @@
   std::set<rtc::SocketAddress> addrs(all_servers_ips_.begin(),
                                      all_servers_ips_.end());
   all_servers_ips_.assign(addrs.begin(), addrs.end());
 
   rtc::IPAddress addr;
   if (GetLocalAddress(&addr) != 0) {
     End(GENERIC_FAILURE, result);
     return;
   }
 
-  MaybeScheduleStunRequests();
+  socket_factory_->Prepare(GetTotalClientSockets(), GetTotalServerSockets(),
+                           [this](int result) {
+                             if (result == 0) {
+                               this->MaybeScheduleStunRequests();
+                             }
+                           });
 }
 
 int StunProber::GetLocalAddress(rtc::IPAddress* addr) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (local_addr_.family() == AF_UNSPEC) {
     rtc::SocketAddress sock_addr;
     rtc::scoped_ptr<ClientSocketInterface> socket(
         socket_factory_->CreateClientSocket());
     int rv = socket->Connect(all_servers_ips_[0]);
     if (rv != SUCCESS) {
@@ skipping 140 matching lines @@
 
   // Shared mode is only true if we use the shared socket and there are more
   // than 1 responding servers.
   stats.shared_socket_mode =
       shared_socket_mode_ && (num_server_ip_with_response > 1);
 
   stats.host_ip = local_addr_.ToString();
   stats.num_request_sent = num_sent;
   stats.num_response_received = num_received;
   stats.target_request_interval_ns = interval_ms_ * 1000;
+  stats.symmetric_nat =
+      stats.srflx_addrs.size() > static_cast<size_t>(GetTotalServerSockets());
 
   if (num_sent) {
     stats.success_percent = static_cast<int>(100 * num_received / num_sent);
   }
 
   if (num_sent > 1) {
     stats.actual_request_interval_ns =
         (1000 * (last_sent_time - first_sent_time)) / (num_sent - 1);
   }
 
@@ skipping 10 matching lines @@
   if (!finished_callback_.empty()) {
     AsyncCallback callback = finished_callback_;
     finished_callback_ = AsyncCallback();
 
     // Callback at the last since the prober might be deleted in the callback.
     callback(status);
   }
 }
 
 }  // namespace stunprober