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

webrtc/p2p/stunprober/stunprober.h

 /*
  *  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 37 matching lines @@
 
 // Chrome has client and server socket. Client socket supports Connect but not
 // Bind. Server is opposite.
 class SocketInterface {
  public:
   enum {
     IO_PENDING = -1,
     FAILED = -2,
   };
   SocketInterface() {}
-  virtual int GetLocalAddress(rtc::SocketAddress* local_address) = 0;
   virtual void Close() = 0;
   virtual ~SocketInterface() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SocketInterface);
 };
 
 class ClientSocketInterface : public SocketInterface {
  public:
   ClientSocketInterface() {}
   // Even though we have SendTo and RecvFrom, if Connect is not called first,
   // getsockname will only return 0.0.0.0.
   virtual int Connect(const rtc::SocketAddress& addr) = 0;
 
+  virtual int GetLocalAddress(rtc::SocketAddress* local_address) = 0;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ClientSocketInterface);
 };
 
 class ServerSocketInterface : public SocketInterface {
  public:
   ServerSocketInterface() {}
-  virtual int Bind(const rtc::SocketAddress& addr) = 0;
 
   virtual int SendTo(const rtc::SocketAddress& addr,
                      char* buf,
                      size_t buf_len,
                      AsyncCallback callback) = 0;
 
   // If the returned value is positive, it means that buf has been
   // sent. Otherwise, it should return IO_PENDING. Callback will be invoked
   // after the data is successfully read into buf.
   virtual int RecvFrom(char* buf,
                        size_t buf_len,
                        rtc::SocketAddress* addr,
                        AsyncCallback callback) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServerSocketInterface);
 };
 
 class SocketFactoryInterface {
  public:
   SocketFactoryInterface() {}
+  // To provide a chance to prepare the sockets that we need. This is
+  // implemented for chrome renderer process as the socket needs to be ready to
+  // use in browser process.
+  virtual void Prepare(size_t total_client_socket,
+                       size_t total_server_socket,
+                       AsyncCallback callback) {
+    callback(0);
+  }
   virtual ClientSocketInterface* CreateClientSocket() = 0;
   virtual ServerSocketInterface* CreateServerSocket(
       size_t send_buffer_size,
       size_t receive_buffer_size) = 0;
   virtual ~SocketFactoryInterface() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SocketFactoryInterface);
 };
 
@@ skipping 15 matching lines @@
     RESOLVE_FAILED,   // Host resolution failed.
     WRITE_FAILED,     // Sending a message to the server failed.
     READ_FAILED,      // Reading the reply from the server failed.
   };
 
   struct Stats {
     Stats() {}
     int num_request_sent = 0;
     int num_response_received = 0;
     bool behind_nat = false;
+    bool symmetric_nat = false;
     int average_rtt_ms = -1;
     int success_percent = 0;
     int target_request_interval_ns = 0;
     int actual_request_interval_ns = 0;
 
     // Also report whether this trial can't be considered truly as shared
     // mode. Share mode only makes sense when we have multiple IP resolved and
     // successfully probed.
     bool shared_socket_mode = false;
 
     std::string host_ip;
 
     // If the srflx_addrs has more than 1 element, the NAT is symmetric.
     std::set<std::string> srflx_addrs;
-
-    bool symmetric_nat() { return srflx_addrs.size() > 1; }
   };
 
   // StunProber is not thread safe. It's task_runner's responsibility to ensure
   // all calls happen sequentially.
   StunProber(HostNameResolverInterface* host_name_resolver,
              SocketFactoryInterface* socket_factory,
              TaskRunnerInterface* task_runner);
   virtual ~StunProber();
 
   // Begin performing the probe test against the |servers|. If
@@ skipping 95 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(Requester);
   };
 
  private:
   void OnServerResolved(int index, int result);
 
   bool Done() {
     return num_request_sent_ >= requests_per_ip_ * all_servers_ips_.size();
   }
 
+  int GetTotalClientSockets() { return 1; }
+  int GetTotalServerSockets() {
+    return (shared_socket_mode_ ? 1 : all_servers_ips_.size()) *
+           requests_per_ip_;
+  }
+
   bool SendNextRequest();
 
   // Will be invoked in 1ms intervals and schedule the next request from the
   // |current_requester_| if the time has passed for another request.
   void MaybeScheduleStunRequests();
 
   // End the probe with the given |status|.  Invokes |fininsh_callback|, which
   // may destroy the class.
   void End(StunProber::Status status, int result);
 
@@ skipping 50 matching lines @@
   std::vector<Requester*> requesters_;
 
   rtc::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(StunProber);
 };
 
 }  // namespace stunprober
 
 #endif  // WEBRTC_P2P_STUNPROBER_STUNPROBER_H_