Adding PortAllocator option to support cases where sockets can't be bound.

webrtc/base/natsocketfactory.cc

 /*
  *  Copyright 2004 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 79 matching lines @@
 
   SocketAddress GetRemoteAddress() const override {
     return remote_addr_;  // will be NIL if not connected
   }
 
   int Bind(const SocketAddress& addr) override {
     if (socket_) {  // already bound, bubble up error
       return -1;
     }
 
-    int result;
-    socket_ = sf_->CreateInternalSocket(family_, type_, addr, &server_addr_);
-    result = (socket_) ? socket_->Bind(addr) : -1;
-    if (result >= 0) {
-      socket_->SignalConnectEvent.connect(this, &NATSocket::OnConnectEvent);
-      socket_->SignalReadEvent.connect(this, &NATSocket::OnReadEvent);
-      socket_->SignalWriteEvent.connect(this, &NATSocket::OnWriteEvent);
-      socket_->SignalCloseEvent.connect(this, &NATSocket::OnCloseEvent);
-    } else {
-      server_addr_.Clear();
-      delete socket_;
-      socket_ = nullptr;
-    }
-
-    return result;
+    return BindInternal(addr);
   }
 
   int Connect(const SocketAddress& addr) override {
-    if (!socket_) {  // socket must be bound, for now
-      return -1;
+    int result = 0;
+    // If we're not already bound (meaning |socket_| is null), bind to ANY
+    // address.
+    if (!socket_) {
+      result = BindInternal(SocketAddress(GetAnyIP(family_), 0));

[Taylor Brandstetter, 2017/06/13 03:41:30]

This is done by other socket factory classes, it just wasn't necessary in this
one until now.

+      if (result < 0) {
+        return result;
+      }
     }
 
-    int result = 0;
     if (type_ == SOCK_STREAM) {
       result = socket_->Connect(server_addr_.IsNil() ? addr : server_addr_);
     } else {
       connected_ = true;
     }
 
     if (result >= 0) {
       remote_addr_ = addr;
     }
 
@@ skipping 85 matching lines @@
         socket_ = nullptr;
       }
     }
     return result;
   }
 
   int Listen(int backlog) override { return socket_->Listen(backlog); }
   AsyncSocket* Accept(SocketAddress* paddr) override {
     return socket_->Accept(paddr);
   }
-  int GetError() const override { return socket_->GetError(); }
-  void SetError(int error) override { socket_->SetError(error); }
+  int GetError() const override {
+    return socket_ ? socket_->GetError() : error_;
+  }
+  void SetError(int error) override {
+    if (socket_) {
+      socket_->SetError(error);
+    } else {
+      error_ = error;
+    }
+  }
   ConnState GetState() const override {
     return connected_ ? CS_CONNECTED : CS_CLOSED;
   }
   int GetOption(Option opt, int* value) override {
     return socket_->GetOption(opt, value);
   }
   int SetOption(Option opt, int value) override {
     return socket_->SetOption(opt, value);
   }
 
@@ skipping 19 matching lines @@
   void OnWriteEvent(AsyncSocket* socket) {
     RTC_DCHECK(socket == socket_);
     SignalWriteEvent(this);
   }
   void OnCloseEvent(AsyncSocket* socket, int error) {
     RTC_DCHECK(socket == socket_);
     SignalCloseEvent(this, error);
   }
 
  private:
+  int BindInternal(const SocketAddress& addr) {
+    RTC_DCHECK(!socket_);
+
+    int result;
+    socket_ = sf_->CreateInternalSocket(family_, type_, addr, &server_addr_);
+    result = (socket_) ? socket_->Bind(addr) : -1;
+    if (result >= 0) {
+      socket_->SignalConnectEvent.connect(this, &NATSocket::OnConnectEvent);
+      socket_->SignalReadEvent.connect(this, &NATSocket::OnReadEvent);
+      socket_->SignalWriteEvent.connect(this, &NATSocket::OnWriteEvent);
+      socket_->SignalCloseEvent.connect(this, &NATSocket::OnCloseEvent);
+    } else {
+      server_addr_.Clear();
+      delete socket_;
+      socket_ = nullptr;
+    }
+
+    return result;
+  }
+
   // Makes sure the buffer is at least the given size.
   void Grow(size_t new_size) {
     if (size_ < new_size) {
       delete[] buf_;
       size_ = new_size;
       buf_ = new char[size_];
     }
   }
 
   // Sends the destination address to the server to tell it to connect.
@@ skipping 16 matching lines @@
     }
   }
 
   NATInternalSocketFactory* sf_;
   int family_;
   int type_;
   bool connected_;
   SocketAddress remote_addr_;
   SocketAddress server_addr_;  // address of the NAT server
   AsyncSocket* socket_;
+  // Need to hold error in case it occurs before the socket is created.
+  int error_ = 0;
   char* buf_;
   size_t size_;
 };
 
 // NATSocketFactory
 NATSocketFactory::NATSocketFactory(SocketFactory* factory,
                                    const SocketAddress& nat_udp_addr,
                                    const SocketAddress& nat_tcp_addr)
     : factory_(factory), nat_udp_addr_(nat_udp_addr),
       nat_tcp_addr_(nat_tcp_addr) {
@@ skipping 185 matching lines @@
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
     const SocketAddress& int_ip) {
   Translator* nat = nullptr;
   for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
     nat = it->second->FindClient(int_ip);
   }
   return nat;
 }
 
 }  // namespace rtc