Rewrite rtc::Bind using variadic templates.

webrtc/pc/ortcfactory.cc

 /*
  *  Copyright 2017 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 10 matching lines @@
 namespace webrtc {
 
 // static
 std::unique_ptr<OrtcFactoryInterface> OrtcFactoryInterface::Create(
     rtc::Thread* network_thread,
     rtc::Thread* signaling_thread,
     rtc::NetworkManager* network_manager,
     rtc::PacketSocketFactory* socket_factory) {
   // Hop to signaling thread if needed.
   if (signaling_thread && !signaling_thread->IsCurrent()) {
+    // The template parameters are necessary because there are two
+    // OrtcFactoryInterface::Create methods, so the types can't be derived from
+    // just the function pointer.
     return signaling_thread->Invoke<std::unique_ptr<OrtcFactoryInterface>>(
         RTC_FROM_HERE,
-        rtc::Bind(&OrtcFactoryInterface::Create, network_thread,
-                  signaling_thread, network_manager, socket_factory));
+        rtc::Bind<std::unique_ptr<OrtcFactoryInterface>, rtc::Thread*,
+                  rtc::Thread*, rtc::NetworkManager*,
+                  rtc::PacketSocketFactory*>(&OrtcFactoryInterface::Create,
+                                             network_thread, signaling_thread,
+                                             network_manager, socket_factory));
   }
   OrtcFactory* new_factory =
       new OrtcFactory(network_thread, signaling_thread,
                       network_manager, socket_factory);
   // Return a proxy so that any calls on the returned object (including
   // destructor) happen on the signaling thread.
   return OrtcFactoryProxy::Create(new_factory->signaling_thread(),
                                   new_factory->network_thread(), new_factory);
 }
 
@@ skipping 65 matching lines @@
   LOG(LS_INFO) << "Created UDP socket with address "
                << socket->GetLocalAddress().ToSensitiveString() << ".";
   // Use proxy so that calls to the returned object are invoked on the network
   // thread.
   return UdpTransportProxy::Create(
       signaling_thread_, network_thread_,
       new cricket::UdpTransport(std::string(), std::move(socket)));
 }
 
 }  // namespace webrtc