Update webrtc&libjingle 6774:6825.

remoting/protocol/chromium_port_allocator.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/protocol/chromium_port_allocator.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/http/http_status_code.h"
@@ skipping 12 matching lines @@
 class ChromiumPortAllocatorSession
     : public cricket::HttpPortAllocatorSessionBase,
       public net::URLFetcherDelegate {
  public:
   ChromiumPortAllocatorSession(
       cricket::HttpPortAllocatorBase* allocator,
       const std::string& content_name,
       int component,
       const std::string& ice_username_fragment,
       const std::string& ice_password,
-      const std::vector<talk_base::SocketAddress>& stun_hosts,
+      const std::vector<rtc::SocketAddress>& stun_hosts,
       const std::vector<std::string>& relay_hosts,
       const std::string& relay,
       const scoped_refptr<net::URLRequestContextGetter>& url_context);
   virtual ~ChromiumPortAllocatorSession();
 
   // cricket::HttpPortAllocatorBase overrides.
   virtual void ConfigReady(cricket::PortConfiguration* config) OVERRIDE;
   virtual void SendSessionRequest(const std::string& host, int port) OVERRIDE;
 
   // net::URLFetcherDelegate interface.
   virtual void OnURLFetchComplete(const net::URLFetcher* url_fetcher) OVERRIDE;
 
  private:
   scoped_refptr<net::URLRequestContextGetter> url_context_;
   std::set<const net::URLFetcher*> url_fetchers_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromiumPortAllocatorSession);
 };
 
 ChromiumPortAllocatorSession::ChromiumPortAllocatorSession(
     cricket::HttpPortAllocatorBase* allocator,
     const std::string& content_name,
     int component,
     const std::string& ice_username_fragment,
     const std::string& ice_password,
-    const std::vector<talk_base::SocketAddress>& stun_hosts,
+    const std::vector<rtc::SocketAddress>& stun_hosts,
     const std::vector<std::string>& relay_hosts,
     const std::string& relay,
     const scoped_refptr<net::URLRequestContextGetter>& url_context)
     : HttpPortAllocatorSessionBase(allocator,
                                    content_name,
                                    component,
                                    ice_username_fragment,
                                    ice_password,
                                    stun_hosts,
                                    relay_hosts,
@@ skipping 56 matching lines @@
 
   ReceiveSessionResponse(response);
 }
 
 }  // namespace
 
 // static
 scoped_ptr<ChromiumPortAllocator> ChromiumPortAllocator::Create(
     const scoped_refptr<net::URLRequestContextGetter>& url_context,
     const NetworkSettings& network_settings) {
-  scoped_ptr<talk_base::NetworkManager> network_manager(
-      new talk_base::BasicNetworkManager());
-  scoped_ptr<talk_base::PacketSocketFactory> socket_factory(
+  scoped_ptr<rtc::NetworkManager> network_manager(
+      new rtc::BasicNetworkManager());
+  scoped_ptr<rtc::PacketSocketFactory> socket_factory(
       new ChromiumPacketSocketFactory());
   scoped_ptr<ChromiumPortAllocator> result(
       new ChromiumPortAllocator(url_context, network_manager.Pass(),
                             socket_factory.Pass()));
 
   // We always use PseudoTcp to provide a reliable channel. It provides poor
   // performance when combined with TCP-based transport, so we have to disable
   // TCP ports. ENABLE_SHARED_UFRAG flag is specified so that the same username
   // fragment is shared between all candidates for this channel.
   int flags = cricket::PORTALLOCATOR_DISABLE_TCP |
               cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
               cricket::PORTALLOCATOR_ENABLE_IPV6;
 
   if (!(network_settings.flags & NetworkSettings::NAT_TRAVERSAL_STUN))
     flags |= cricket::PORTALLOCATOR_DISABLE_STUN;
 
   if (!(network_settings.flags & NetworkSettings::NAT_TRAVERSAL_RELAY))
     flags |= cricket::PORTALLOCATOR_DISABLE_RELAY;
 
   result->set_flags(flags);
   result->SetPortRange(network_settings.min_port,
                        network_settings.max_port);
 
   return result.Pass();
 }
 
 ChromiumPortAllocator::ChromiumPortAllocator(
     const scoped_refptr<net::URLRequestContextGetter>& url_context,
-    scoped_ptr<talk_base::NetworkManager> network_manager,
-    scoped_ptr<talk_base::PacketSocketFactory> socket_factory)
+    scoped_ptr<rtc::NetworkManager> network_manager,
+    scoped_ptr<rtc::PacketSocketFactory> socket_factory)
     : HttpPortAllocatorBase(network_manager.get(),
                             socket_factory.get(),
                             std::string()),
       url_context_(url_context),
       network_manager_(network_manager.Pass()),
       socket_factory_(socket_factory.Pass()) {}
 
 ChromiumPortAllocator::~ChromiumPortAllocator() {
 }
 
 cricket::PortAllocatorSession* ChromiumPortAllocator::CreateSessionInternal(
     const std::string& content_name,
     int component,
     const std::string& ice_username_fragment,
     const std::string& ice_password) {
   return new ChromiumPortAllocatorSession(
       this, content_name, component, ice_username_fragment, ice_password,
       stun_hosts(), relay_hosts(), relay_token(), url_context_);
 }
 
 }  // namespace protocol
 }  // namespace remoting