Webrtc deps roll.

remoting/protocol/libjingle_transport_factory.cc

 // Copyright (c) 2012 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/libjingle_transport_factory.h"
 
 #include "base/callback.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "jingle/glue/channel_socket_adapter.h"
 #include "jingle/glue/pseudotcp_adapter.h"
 #include "jingle/glue/utils.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/network_settings.h"
 #include "remoting/signaling/jingle_info_request.h"
-#include "third_party/libjingle/source/talk/base/network.h"
 #include "third_party/libjingle/source/talk/p2p/base/constants.h"
 #include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h"
 #include "third_party/libjingle/source/talk/p2p/base/port.h"
 #include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h"
 #include "third_party/libjingle/source/talk/p2p/client/httpportallocator.h"
+#include "third_party/webrtc/base/network.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 // Value is chosen to balance the extra latency against the reduced
 // load due to ACK traffic.
 const int kTcpAckDelayMilliseconds = 10;
 
@@ skipping 85 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LibjingleStreamTransport);
 };
 
 LibjingleStreamTransport::LibjingleStreamTransport(
     cricket::PortAllocator* port_allocator,
     const NetworkSettings& network_settings)
     : port_allocator_(port_allocator),
       network_settings_(network_settings),
       event_handler_(NULL),
       ice_username_fragment_(
-          talk_base::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
-      ice_password_(talk_base::CreateRandomString(cricket::ICE_PWD_LENGTH)),
+          rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
+      ice_password_(rtc::CreateRandomString(cricket::ICE_PWD_LENGTH)),
       can_start_(false),
       channel_was_writable_(false),
       connect_attempts_left_(kMaxReconnectAttempts) {
   DCHECK(!ice_username_fragment_.empty());
   DCHECK(!ice_password_.empty());
 }
 
 LibjingleStreamTransport::~LibjingleStreamTransport() {
   DCHECK(event_handler_);
   event_handler_->OnTransportDeleted(this);
@@ skipping 230 matching lines @@
     reconnect_timer_.Stop();
 
     // Notify the caller that ICE connection has failed - normally that will
     // terminate Jingle connection (i.e. the transport will be destroyed).
     event_handler_->OnTransportFailed(this);
     return;
   }
   --connect_attempts_left_;
 
   // Restart ICE by resetting ICE password.
-  ice_password_ = talk_base::CreateRandomString(cricket::ICE_PWD_LENGTH);
+  ice_password_ = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
   channel_->SetIceCredentials(ice_username_fragment_, ice_password_);
 }
 
 void LibjingleStreamTransport::NotifyConnected(
     scoped_ptr<net::StreamSocket> socket) {
   DCHECK(!is_connected());
   StreamTransport::ConnectedCallback callback = callback_;
   callback_.Reset();
   callback.Run(socket.Pass());
 }
@@ skipping 75 matching lines @@
       base::TimeDelta::FromSeconds(kJingleInfoUpdatePeriodSeconds)) {
     jingle_info_request_.reset(new JingleInfoRequest(signal_strategy_));
     jingle_info_request_->Send(base::Bind(
         &LibjingleTransportFactory::OnJingleInfo, base::Unretained(this)));
   }
 }
 
 void LibjingleTransportFactory::OnJingleInfo(
     const std::string& relay_token,
     const std::vector<std::string>& relay_hosts,
-    const std::vector<talk_base::SocketAddress>& stun_hosts) {
+    const std::vector<rtc::SocketAddress>& stun_hosts) {
   if (!relay_token.empty() && !relay_hosts.empty()) {
     port_allocator_->SetRelayHosts(relay_hosts);
     port_allocator_->SetRelayToken(relay_token);
   }
   if (!stun_hosts.empty()) {
     port_allocator_->SetStunHosts(stun_hosts);
   }
 
   jingle_info_request_.reset();
   if ((!relay_token.empty() && !relay_hosts.empty()) || !stun_hosts.empty())
     last_jingle_info_update_time_ = base::TimeTicks::Now();
 
   while (!on_jingle_info_callbacks_.empty()) {
     on_jingle_info_callbacks_.begin()->Run();
     on_jingle_info_callbacks_.pop_front();
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting