Revert "Update webrtc&libjingle 6774:6799."

This reverts commit bf45dff0ca703e5ad3bb6c6754ebdcb0c1b1296a.
(https://codereview.chromium.org/429253003)

Broke sizes on Linux

http://build.chromium.org/p/chromium/builders/Linux/builds/51786

https://code.google.com/p/webrtc/source/browse/trunk/webrtc/base/linux.cc
defines static std::string lsb_release_string; among other things

It's guarded in WEBRTC_CHROMIUM_BUILDs. Maybe it should be
WEBRTC_CHROMIUM_BUILD.


BUG=NONE
TBR=darin@chromium.org, hclam@chromium.org, jochen@chromium.org, palmer@chromium.org, sergeyu@chromium.org, wez@chromium.org, ronghuawu@chromium.org
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/435823002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@286914 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 105 insertions, 106 deletions

diff --git a/remoting/protocol/DEPS b/remoting/protocol/DEPS
index d0a8fc9..7848a62 100644
--- a/remoting/protocol/DEPS
+++ b/remoting/protocol/DEPS
@@ -8,6 +8,5 @@ include_rules = [
   "+remoting/codec",
   "+remoting/signaling",
   "+third_party/libjingle",
-  "+third_party/webrtc",
   "+third_party/protobuf/src",
 ]
diff --git a/remoting/protocol/chromium_port_allocator.cc b/remoting/protocol/chromium_port_allocator.cc
index df9c09c..cfa261f 100644
--- a/remoting/protocol/chromium_port_allocator.cc
+++ b/remoting/protocol/chromium_port_allocator.cc
@@ -30,7 +30,7 @@ class ChromiumPortAllocatorSession
       int component,
       const std::string& ice_username_fragment,
       const std::string& ice_password,
-      const std::vector<rtc::SocketAddress>& stun_hosts,
+      const std::vector<talk_base::SocketAddress>& stun_hosts,
       const std::vector<std::string>& relay_hosts,
       const std::string& relay,
       const scoped_refptr<net::URLRequestContextGetter>& url_context);
@@ -56,7 +56,7 @@ ChromiumPortAllocatorSession::ChromiumPortAllocatorSession(
     int component,
     const std::string& ice_username_fragment,
     const std::string& ice_password,
-    const std::vector<rtc::SocketAddress>& stun_hosts,
+    const std::vector<talk_base::SocketAddress>& stun_hosts,
     const std::vector<std::string>& relay_hosts,
     const std::string& relay,
     const scoped_refptr<net::URLRequestContextGetter>& url_context)
@@ -133,9 +133,9 @@ void ChromiumPortAllocatorSession::OnURLFetchComplete(
 scoped_ptr<ChromiumPortAllocator> ChromiumPortAllocator::Create(
     const scoped_refptr<net::URLRequestContextGetter>& url_context,
     const NetworkSettings& network_settings) {
-  scoped_ptr<rtc::NetworkManager> network_manager(
-      new rtc::BasicNetworkManager());
-  scoped_ptr<rtc::PacketSocketFactory> socket_factory(
+  scoped_ptr<talk_base::NetworkManager> network_manager(
+      new talk_base::BasicNetworkManager());
+  scoped_ptr<talk_base::PacketSocketFactory> socket_factory(
       new ChromiumPacketSocketFactory());
   scoped_ptr<ChromiumPortAllocator> result(
       new ChromiumPortAllocator(url_context, network_manager.Pass(),
@@ -164,8 +164,8 @@ scoped_ptr<ChromiumPortAllocator> ChromiumPortAllocator::Create(
 
 ChromiumPortAllocator::ChromiumPortAllocator(
     const scoped_refptr<net::URLRequestContextGetter>& url_context,
-    scoped_ptr<rtc::NetworkManager> network_manager,
-    scoped_ptr<rtc::PacketSocketFactory> socket_factory)
+    scoped_ptr<talk_base::NetworkManager> network_manager,
+    scoped_ptr<talk_base::PacketSocketFactory> socket_factory)
     : HttpPortAllocatorBase(network_manager.get(),
                             socket_factory.get(),
                             std::string()),
diff --git a/remoting/protocol/chromium_port_allocator.h b/remoting/protocol/chromium_port_allocator.h
index 576f41c..00aedc1 100644
--- a/remoting/protocol/chromium_port_allocator.h
+++ b/remoting/protocol/chromium_port_allocator.h
@@ -41,12 +41,12 @@ class ChromiumPortAllocator : public cricket::HttpPortAllocatorBase {
  private:
   ChromiumPortAllocator(
       const scoped_refptr<net::URLRequestContextGetter>& url_context,
-      scoped_ptr<rtc::NetworkManager> network_manager,
-      scoped_ptr<rtc::PacketSocketFactory> socket_factory);
+      scoped_ptr<talk_base::NetworkManager> network_manager,
+      scoped_ptr<talk_base::PacketSocketFactory> socket_factory);
 
   scoped_refptr<net::URLRequestContextGetter> url_context_;
-  scoped_ptr<rtc::NetworkManager> network_manager_;
-  scoped_ptr<rtc::PacketSocketFactory> socket_factory_;
+  scoped_ptr<talk_base::NetworkManager> network_manager_;
+  scoped_ptr<talk_base::PacketSocketFactory> socket_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromiumPortAllocator);
 };
diff --git a/remoting/protocol/chromium_socket_factory.cc b/remoting/protocol/chromium_socket_factory.cc
index 57fb33b..a424adf 100644
--- a/remoting/protocol/chromium_socket_factory.cc
+++ b/remoting/protocol/chromium_socket_factory.cc
@@ -13,8 +13,8 @@
 #include "net/base/net_errors.h"
 #include "net/udp/udp_server_socket.h"
 #include "remoting/protocol/socket_util.h"
-#include "third_party/webrtc/base/asyncpacketsocket.h"
-#include "third_party/webrtc/base/nethelpers.h"
+#include "third_party/libjingle/source/talk/base/asyncpacketsocket.h"
+#include "third_party/libjingle/source/talk/base/nethelpers.h"
 
 namespace remoting {
 namespace protocol {
@@ -30,26 +30,26 @@ const int kReceiveBufferSize = 65536;
 // reached under normal conditions.
 const int kMaxSendBufferSize = 256 * 1024;
 
-class UdpPacketSocket : public rtc::AsyncPacketSocket {
+class UdpPacketSocket : public talk_base::AsyncPacketSocket {
  public:
   UdpPacketSocket();
   virtual ~UdpPacketSocket();
 
-  bool Init(const rtc::SocketAddress& local_address,
+  bool Init(const talk_base::SocketAddress& local_address,
             int min_port, int max_port);
 
-  // rtc::AsyncPacketSocket interface.
-  virtual rtc::SocketAddress GetLocalAddress() const OVERRIDE;
-  virtual rtc::SocketAddress GetRemoteAddress() const OVERRIDE;
+  // talk_base::AsyncPacketSocket interface.
+  virtual talk_base::SocketAddress GetLocalAddress() const OVERRIDE;
+  virtual talk_base::SocketAddress GetRemoteAddress() const OVERRIDE;
   virtual int Send(const void* data, size_t data_size,
-                   const rtc::PacketOptions& options) OVERRIDE;
+                   const talk_base::PacketOptions& options) OVERRIDE;
   virtual int SendTo(const void* data, size_t data_size,
-                     const rtc::SocketAddress& address,
-                     const rtc::PacketOptions& options) OVERRIDE;
+                     const talk_base::SocketAddress& address,
+                     const talk_base::PacketOptions& options) OVERRIDE;
   virtual int Close() OVERRIDE;
   virtual State GetState() const OVERRIDE;
-  virtual int GetOption(rtc::Socket::Option option, int* value) OVERRIDE;
-  virtual int SetOption(rtc::Socket::Option option, int value) OVERRIDE;
+  virtual int GetOption(talk_base::Socket::Option option, int* value) OVERRIDE;
+  virtual int SetOption(talk_base::Socket::Option option, int value) OVERRIDE;
   virtual int GetError() const OVERRIDE;
   virtual void SetError(int error) OVERRIDE;
 
@@ -78,7 +78,7 @@ class UdpPacketSocket : public rtc::AsyncPacketSocket {
   State state_;
   int error_;
 
-  rtc::SocketAddress local_address_;
+  talk_base::SocketAddress local_address_;
 
   // Receive buffer and address are populated by asynchronous reads.
   scoped_refptr<net::IOBuffer> receive_buffer_;
@@ -112,7 +112,7 @@ UdpPacketSocket::~UdpPacketSocket() {
   Close();
 }
 
-bool UdpPacketSocket::Init(const rtc::SocketAddress& local_address,
+bool UdpPacketSocket::Init(const talk_base::SocketAddress& local_address,
                            int min_port, int max_port) {
   net::IPEndPoint local_endpoint;
   if (!jingle_glue::SocketAddressToIPEndPoint(
@@ -148,27 +148,27 @@ bool UdpPacketSocket::Init(const rtc::SocketAddress& local_address,
   return true;
 }
 
-rtc::SocketAddress UdpPacketSocket::GetLocalAddress() const {
+talk_base::SocketAddress UdpPacketSocket::GetLocalAddress() const {
   DCHECK_EQ(state_, STATE_BOUND);
   return local_address_;
 }
 
-rtc::SocketAddress UdpPacketSocket::GetRemoteAddress() const {
+talk_base::SocketAddress UdpPacketSocket::GetRemoteAddress() const {
   // UDP sockets are not connected - this method should never be called.
   NOTREACHED();
-  return rtc::SocketAddress();
+  return talk_base::SocketAddress();
 }
 
 int UdpPacketSocket::Send(const void* data, size_t data_size,
-                          const rtc::PacketOptions& options) {
+                          const talk_base::PacketOptions& options) {
   // UDP sockets are not connected - this method should never be called.
   NOTREACHED();
   return EWOULDBLOCK;
 }
 
 int UdpPacketSocket::SendTo(const void* data, size_t data_size,
-                            const rtc::SocketAddress& address,
-                            const rtc::PacketOptions& options) {
+                            const talk_base::SocketAddress& address,
+                            const talk_base::PacketOptions& options) {
   if (state_ != STATE_BOUND) {
     NOTREACHED();
     return EINVAL;
@@ -200,51 +200,51 @@ int UdpPacketSocket::Close() {
   return 0;
 }
 
-rtc::AsyncPacketSocket::State UdpPacketSocket::GetState() const {
+talk_base::AsyncPacketSocket::State UdpPacketSocket::GetState() const {
   return state_;
 }
 
-int UdpPacketSocket::GetOption(rtc::Socket::Option option, int* value) {
+int UdpPacketSocket::GetOption(talk_base::Socket::Option option, int* value) {
   // This method is never called by libjingle.
   NOTIMPLEMENTED();
   return -1;
 }
 
-int UdpPacketSocket::SetOption(rtc::Socket::Option option, int value) {
+int UdpPacketSocket::SetOption(talk_base::Socket::Option option, int value) {
   if (state_ != STATE_BOUND) {
     NOTREACHED();
     return EINVAL;
   }
 
   switch (option) {
-    case rtc::Socket::OPT_DONTFRAGMENT:
+    case talk_base::Socket::OPT_DONTFRAGMENT:
       NOTIMPLEMENTED();
       return -1;
 
-    case rtc::Socket::OPT_RCVBUF: {
+    case talk_base::Socket::OPT_RCVBUF: {
       int net_error = socket_->SetReceiveBufferSize(value);
       return (net_error == net::OK) ? 0 : -1;
     }
 
-    case rtc::Socket::OPT_SNDBUF: {
+    case talk_base::Socket::OPT_SNDBUF: {
       int net_error = socket_->SetSendBufferSize(value);
       return (net_error == net::OK) ? 0 : -1;
     }
 
-    case rtc::Socket::OPT_NODELAY:
+    case talk_base::Socket::OPT_NODELAY:
       // OPT_NODELAY is only for TCP sockets.
       NOTREACHED();
       return -1;
 
-    case rtc::Socket::OPT_IPV6_V6ONLY:
+    case talk_base::Socket::OPT_IPV6_V6ONLY:
       NOTIMPLEMENTED();
       return -1;
 
-    case rtc::Socket::OPT_DSCP:
+    case talk_base::Socket::OPT_DSCP:
       NOTIMPLEMENTED();
       return -1;
 
-    case rtc::Socket::OPT_RTP_SENDTIME_EXTN_ID:
+    case talk_base::Socket::OPT_RTP_SENDTIME_EXTN_ID:
       NOTIMPLEMENTED();
       return -1;
   }
@@ -336,14 +336,14 @@ void UdpPacketSocket::HandleReadResult(int result) {
   }
 
   if (result > 0) {
-    rtc::SocketAddress address;
+    talk_base::SocketAddress address;
     if (!jingle_glue::IPEndPointToSocketAddress(receive_address_, &address)) {
       NOTREACHED();
       LOG(ERROR) << "Failed to convert address received from RecvFrom().";
       return;
     }
     SignalReadPacket(this, receive_buffer_->data(), result, address,
-                     rtc::CreatePacketTime(0));
+                     talk_base::CreatePacketTime(0));
   } else {
     LOG(ERROR) << "Received error when reading from UDP socket: " << result;
   }
@@ -357,8 +357,8 @@ ChromiumPacketSocketFactory::ChromiumPacketSocketFactory() {
 ChromiumPacketSocketFactory::~ChromiumPacketSocketFactory() {
 }
 
-rtc::AsyncPacketSocket* ChromiumPacketSocketFactory::CreateUdpSocket(
-      const rtc::SocketAddress& local_address,
+talk_base::AsyncPacketSocket* ChromiumPacketSocketFactory::CreateUdpSocket(
+      const talk_base::SocketAddress& local_address,
       int min_port, int max_port) {
   scoped_ptr<UdpPacketSocket> result(new UdpPacketSocket());
   if (!result->Init(local_address, min_port, max_port))
@@ -366,9 +366,9 @@ rtc::AsyncPacketSocket* ChromiumPacketSocketFactory::CreateUdpSocket(
   return result.release();
 }
 
-rtc::AsyncPacketSocket*
+talk_base::AsyncPacketSocket*
 ChromiumPacketSocketFactory::CreateServerTcpSocket(
-    const rtc::SocketAddress& local_address,
+    const talk_base::SocketAddress& local_address,
     int min_port, int max_port,
     int opts) {
   // We don't use TCP sockets for remoting connections.
@@ -376,11 +376,11 @@ ChromiumPacketSocketFactory::CreateServerTcpSocket(
   return NULL;
 }
 
-rtc::AsyncPacketSocket*
+talk_base::AsyncPacketSocket*
 ChromiumPacketSocketFactory::CreateClientTcpSocket(
-      const rtc::SocketAddress& local_address,
-      const rtc::SocketAddress& remote_address,
-      const rtc::ProxyInfo& proxy_info,
+      const talk_base::SocketAddress& local_address,
+      const talk_base::SocketAddress& remote_address,
+      const talk_base::ProxyInfo& proxy_info,
       const std::string& user_agent,
       int opts) {
   // We don't use TCP sockets for remoting connections.
@@ -388,9 +388,9 @@ ChromiumPacketSocketFactory::CreateClientTcpSocket(
   return NULL;
 }
 
-rtc::AsyncResolverInterface*
+talk_base::AsyncResolverInterface*
 ChromiumPacketSocketFactory::CreateAsyncResolver() {
-  return new rtc::AsyncResolver();
+  return new talk_base::AsyncResolver();
 }
 
 }  // namespace protocol
diff --git a/remoting/protocol/chromium_socket_factory.h b/remoting/protocol/chromium_socket_factory.h
index b07b03c..5a886a5 100644
--- a/remoting/protocol/chromium_socket_factory.h
+++ b/remoting/protocol/chromium_socket_factory.h
@@ -11,25 +11,25 @@
 namespace remoting {
 namespace protocol {
 
-class ChromiumPacketSocketFactory : public rtc::PacketSocketFactory {
+class ChromiumPacketSocketFactory : public talk_base::PacketSocketFactory {
  public:
   explicit ChromiumPacketSocketFactory();
   virtual ~ChromiumPacketSocketFactory();
 
-  virtual rtc::AsyncPacketSocket* CreateUdpSocket(
-      const rtc::SocketAddress& local_address,
+  virtual talk_base::AsyncPacketSocket* CreateUdpSocket(
+      const talk_base::SocketAddress& local_address,
       int min_port, int max_port) OVERRIDE;
-  virtual rtc::AsyncPacketSocket* CreateServerTcpSocket(
-      const rtc::SocketAddress& local_address,
+  virtual talk_base::AsyncPacketSocket* CreateServerTcpSocket(
+      const talk_base::SocketAddress& local_address,
       int min_port, int max_port,
       int opts) OVERRIDE;
-  virtual rtc::AsyncPacketSocket* CreateClientTcpSocket(
-      const rtc::SocketAddress& local_address,
-      const rtc::SocketAddress& remote_address,
-      const rtc::ProxyInfo& proxy_info,
+  virtual talk_base::AsyncPacketSocket* CreateClientTcpSocket(
+      const talk_base::SocketAddress& local_address,
+      const talk_base::SocketAddress& remote_address,
+      const talk_base::ProxyInfo& proxy_info,
       const std::string& user_agent,
       int opts) OVERRIDE;
-  virtual rtc::AsyncResolverInterface* CreateAsyncResolver() OVERRIDE;
+  virtual talk_base::AsyncResolverInterface* CreateAsyncResolver() OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromiumPacketSocketFactory);
diff --git a/remoting/protocol/chromium_socket_factory_unittest.cc b/remoting/protocol/chromium_socket_factory_unittest.cc
index 9a0a4dc..8755d66 100644
--- a/remoting/protocol/chromium_socket_factory_unittest.cc
+++ b/remoting/protocol/chromium_socket_factory_unittest.cc
@@ -8,8 +8,8 @@
 #include "base/run_loop.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/webrtc/base/asyncpacketsocket.h"
-#include "third_party/webrtc/base/socketaddress.h"
+#include "third_party/libjingle/source/talk/base/asyncpacketsocket.h"
+#include "third_party/libjingle/source/talk/base/socketaddress.h"
 
 namespace remoting {
 namespace protocol {
@@ -21,30 +21,30 @@ class ChromiumSocketFactoryTest : public testing::Test,
     socket_factory_.reset(new ChromiumPacketSocketFactory());
 
     socket_.reset(socket_factory_->CreateUdpSocket(
-        rtc::SocketAddress("127.0.0.1", 0), 0, 0));
+        talk_base::SocketAddress("127.0.0.1", 0), 0, 0));
     ASSERT_TRUE(socket_.get() != NULL);
-    EXPECT_EQ(socket_->GetState(), rtc::AsyncPacketSocket::STATE_BOUND);
+    EXPECT_EQ(socket_->GetState(), talk_base::AsyncPacketSocket::STATE_BOUND);
     socket_->SignalReadPacket.connect(
         this, &ChromiumSocketFactoryTest::OnPacket);
   }
 
-  void OnPacket(rtc::AsyncPacketSocket* socket,
+  void OnPacket(talk_base::AsyncPacketSocket* socket,
                 const char* data, size_t size,
-                const rtc::SocketAddress& address,
-                const rtc::PacketTime& packet_time) {
+                const talk_base::SocketAddress& address,
+                const talk_base::PacketTime& packet_time) {
     EXPECT_EQ(socket, socket_.get());
     last_packet_.assign(data, data + size);
     last_address_ = address;
     run_loop_.Quit();
   }
 
-  void VerifyCanSendAndReceive(rtc::AsyncPacketSocket* sender) {
+  void VerifyCanSendAndReceive(talk_base::AsyncPacketSocket* sender) {
     // UDP packets may be lost, so we have to retry sending it more than once.
     const int kMaxAttempts = 3;
     const base::TimeDelta kAttemptPeriod = base::TimeDelta::FromSeconds(1);
     std::string test_packet("TEST PACKET");
     int attempts = 0;
-    rtc::PacketOptions options;
+    talk_base::PacketOptions options;
     while (last_packet_.empty() && attempts++ < kMaxAttempts) {
       sender->SendTo(test_packet.data(), test_packet.size(),
                      socket_->GetLocalAddress(), options);
@@ -60,52 +60,52 @@ class ChromiumSocketFactoryTest : public testing::Test,
   base::MessageLoopForIO message_loop_;
   base::RunLoop run_loop_;
 
-  scoped_ptr<rtc::PacketSocketFactory> socket_factory_;
-  scoped_ptr<rtc::AsyncPacketSocket> socket_;
+  scoped_ptr<talk_base::PacketSocketFactory> socket_factory_;
+  scoped_ptr<talk_base::AsyncPacketSocket> socket_;
 
   std::string last_packet_;
-  rtc::SocketAddress last_address_;
+  talk_base::SocketAddress last_address_;
 };
 
 TEST_F(ChromiumSocketFactoryTest, SendAndReceive) {
-  scoped_ptr<rtc::AsyncPacketSocket> sending_socket(
+  scoped_ptr<talk_base::AsyncPacketSocket> sending_socket(
       socket_factory_->CreateUdpSocket(
-          rtc::SocketAddress("127.0.0.1", 0), 0, 0));
+          talk_base::SocketAddress("127.0.0.1", 0), 0, 0));
   ASSERT_TRUE(sending_socket.get() != NULL);
   EXPECT_EQ(sending_socket->GetState(),
-            rtc::AsyncPacketSocket::STATE_BOUND);
+            talk_base::AsyncPacketSocket::STATE_BOUND);
 
   VerifyCanSendAndReceive(sending_socket.get());
 }
 
 TEST_F(ChromiumSocketFactoryTest, SetOptions) {
-  EXPECT_EQ(0, socket_->SetOption(rtc::Socket::OPT_SNDBUF, 4096));
-  EXPECT_EQ(0, socket_->SetOption(rtc::Socket::OPT_RCVBUF, 4096));
+  EXPECT_EQ(0, socket_->SetOption(talk_base::Socket::OPT_SNDBUF, 4096));
+  EXPECT_EQ(0, socket_->SetOption(talk_base::Socket::OPT_RCVBUF, 4096));
 }
 
 TEST_F(ChromiumSocketFactoryTest, PortRange) {
   const int kMinPort = 12400;
   const int kMaxPort = 12410;
   socket_.reset(socket_factory_->CreateUdpSocket(
-      rtc::SocketAddress("127.0.0.1", 0), kMaxPort, kMaxPort));
+      talk_base::SocketAddress("127.0.0.1", 0), kMaxPort, kMaxPort));
   ASSERT_TRUE(socket_.get() != NULL);
-  EXPECT_EQ(socket_->GetState(), rtc::AsyncPacketSocket::STATE_BOUND);
+  EXPECT_EQ(socket_->GetState(), talk_base::AsyncPacketSocket::STATE_BOUND);
   EXPECT_GE(socket_->GetLocalAddress().port(), kMinPort);
   EXPECT_LE(socket_->GetLocalAddress().port(), kMaxPort);
 }
 
 TEST_F(ChromiumSocketFactoryTest, TransientError) {
-  scoped_ptr<rtc::AsyncPacketSocket> sending_socket(
+  scoped_ptr<talk_base::AsyncPacketSocket> sending_socket(
       socket_factory_->CreateUdpSocket(
-          rtc::SocketAddress("127.0.0.1", 0), 0, 0));
+          talk_base::SocketAddress("127.0.0.1", 0), 0, 0));
   std::string test_packet("TEST");
 
   // Try sending a packet to an IPv6 address from a socket that's bound to an
   // IPv4 address. This send is expected to fail, but the socket should still be
   // functional.
   sending_socket->SendTo(test_packet.data(), test_packet.size(),
-                         rtc::SocketAddress("::1", 0),
-                         rtc::PacketOptions());
+                         talk_base::SocketAddress("::1", 0),
+                         talk_base::PacketOptions());
 
   // Verify that socket is still usable.
   VerifyCanSendAndReceive(sending_socket.get());
diff --git a/remoting/protocol/jingle_messages.cc b/remoting/protocol/jingle_messages.cc
index f378600..2a5b2f0 100644
--- a/remoting/protocol/jingle_messages.cc
+++ b/remoting/protocol/jingle_messages.cc
@@ -77,7 +77,7 @@ bool ParseCandidate(const buzz::XmlElement* element,
 
   candidate->name = name;
 
-  candidate->candidate.set_address(rtc::SocketAddress(address, port));
+  candidate->candidate.set_address(talk_base::SocketAddress(address, port));
   candidate->candidate.set_type(type);
   candidate->candidate.set_protocol(protocol);
   candidate->candidate.set_username(username);
diff --git a/remoting/protocol/jingle_session_manager.cc b/remoting/protocol/jingle_session_manager.cc
index beef15c..0c2f26e 100644
--- a/remoting/protocol/jingle_session_manager.cc
+++ b/remoting/protocol/jingle_session_manager.cc
@@ -12,8 +12,8 @@
 #include "remoting/protocol/transport.h"
 #include "remoting/signaling/iq_sender.h"
 #include "remoting/signaling/signal_strategy.h"
+#include "third_party/libjingle/source/talk/base/socketaddress.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
-#include "third_party/webrtc/base/socketaddress.h"
 
 using buzz::QName;
 
diff --git a/remoting/protocol/jingle_session_manager.h b/remoting/protocol/jingle_session_manager.h
index 89df613..0193523 100644
--- a/remoting/protocol/jingle_session_manager.h
+++ b/remoting/protocol/jingle_session_manager.h
@@ -23,9 +23,9 @@ namespace buzz {
 class XmlElement;
 }  // namespace buzz
 
-namespace rtc {
+namespace talk_base {
 class SocketAddress;
-}  // namespace rtc
+}  // namespace talk_base
 
 namespace remoting {
 
@@ -71,7 +71,7 @@ class JingleSessionManager : public SessionManager,
   void OnJingleInfo(
       const std::string& relay_token,
       const std::vector<std::string>& relay_hosts,
-      const std::vector<rtc::SocketAddress>& stun_hosts);
+      const std::vector<talk_base::SocketAddress>& stun_hosts);
 
   IqSender* iq_sender() { return iq_sender_.get(); }
   void SendReply(const buzz::XmlElement* original_stanza,
diff --git a/remoting/protocol/libjingle_transport_factory.cc b/remoting/protocol/libjingle_transport_factory.cc
index cc31440..d2bddc3 100644
--- a/remoting/protocol/libjingle_transport_factory.cc
+++ b/remoting/protocol/libjingle_transport_factory.cc
@@ -16,12 +16,12 @@
 #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 {
@@ -127,8 +127,8 @@ LibjingleStreamTransport::LibjingleStreamTransport(
       network_settings_(network_settings),
       event_handler_(NULL),
       ice_username_fragment_(
-          rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
-      ice_password_(rtc::CreateRandomString(cricket::ICE_PWD_LENGTH)),
+          talk_base::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
+      ice_password_(talk_base::CreateRandomString(cricket::ICE_PWD_LENGTH)),
       can_start_(false),
       channel_was_writable_(false),
       connect_attempts_left_(kMaxReconnectAttempts) {
@@ -379,7 +379,7 @@ void LibjingleStreamTransport::TryReconnect() {
   --connect_attempts_left_;
 
   // Restart ICE by resetting ICE password.
-  ice_password_ = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
+  ice_password_ = talk_base::CreateRandomString(cricket::ICE_PWD_LENGTH);
   channel_->SetIceCredentials(ice_username_fragment_, ice_password_);
 }
 
@@ -475,7 +475,7 @@ void LibjingleTransportFactory::EnsureFreshJingleInfo() {
 void LibjingleTransportFactory::OnJingleInfo(
     const std::string& relay_token,
     const std::vector<std::string>& relay_hosts,
-    const std::vector<rtc::SocketAddress>& stun_hosts) {
+    const std::vector<talk_base::SocketAddress>& stun_hosts) {
   if (!relay_token.empty() && !relay_hosts.empty()) {
     port_allocator_->SetRelayHosts(relay_hosts);
     port_allocator_->SetRelayToken(relay_token);
diff --git a/remoting/protocol/libjingle_transport_factory.h b/remoting/protocol/libjingle_transport_factory.h
index 08661df..1c00731 100644
--- a/remoting/protocol/libjingle_transport_factory.h
+++ b/remoting/protocol/libjingle_transport_factory.h
@@ -20,11 +20,11 @@ namespace net {
 class URLRequestContextGetter;
 }  // namespace net
 
-namespace rtc {
+namespace talk_base {
 class NetworkManager;
 class PacketSocketFactory;
 class SocketAddress;
-}  // namespace rtc
+}  // namespace talk_base
 
 namespace remoting {
 
@@ -54,7 +54,7 @@ class LibjingleTransportFactory : public TransportFactory {
   void EnsureFreshJingleInfo();
   void OnJingleInfo(const std::string& relay_token,
                     const std::vector<std::string>& relay_hosts,
-                    const std::vector<rtc::SocketAddress>& stun_hosts);
+                    const std::vector<talk_base::SocketAddress>& stun_hosts);
 
   SignalStrategy* signal_strategy_;
   scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator_;
diff --git a/remoting/protocol/message_decoder.cc b/remoting/protocol/message_decoder.cc
index 59e78b7..14ee9a3 100644
--- a/remoting/protocol/message_decoder.cc
+++ b/remoting/protocol/message_decoder.cc
@@ -8,7 +8,7 @@
 #include "net/base/io_buffer.h"
 #include "remoting/base/compound_buffer.h"
 #include "remoting/proto/internal.pb.h"
-#include "third_party/webrtc/base/byteorder.h"
+#include "third_party/libjingle/source/talk/base/byteorder.h"
 
 namespace remoting {
 namespace protocol {
@@ -61,7 +61,7 @@ bool MessageDecoder::GetPayloadSize(int* size) {
   char header[kHeaderSize];
   header_buffer.CopyFrom(buffer_, 0, kHeaderSize);
   header_buffer.CopyTo(header, kHeaderSize);
-  *size = rtc::GetBE32(header);
+  *size = talk_base::GetBE32(header);
   buffer_.CropFront(kHeaderSize);
   return true;
 }
diff --git a/remoting/protocol/message_reader_unittest.cc b/remoting/protocol/message_reader_unittest.cc
index 1ea2412..497e7a5 100644
--- a/remoting/protocol/message_reader_unittest.cc
+++ b/remoting/protocol/message_reader_unittest.cc
@@ -17,7 +17,7 @@
 #include "remoting/protocol/message_reader.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/webrtc/base/byteorder.h"
+#include "third_party/libjingle/source/talk/base/byteorder.h"
 
 using testing::_;
 using testing::DoAll;
@@ -82,7 +82,7 @@ class MessageReaderTest : public testing::Test {
 
   void AddMessage(const std::string& message) {
     std::string data = std::string(4, ' ') + message;
-    rtc::SetBE32(const_cast<char*>(data.data()), message.size());
+    talk_base::SetBE32(const_cast<char*>(data.data()), message.size());
 
     socket_.AppendInputData(std::vector<char>(data.begin(), data.end()));
   }
diff --git a/remoting/protocol/message_serialization.cc b/remoting/protocol/message_serialization.cc
index 435baf9..2a22209 100644
--- a/remoting/protocol/message_serialization.cc
+++ b/remoting/protocol/message_serialization.cc
@@ -8,7 +8,7 @@
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
-#include "third_party/webrtc/base/byteorder.h"
+#include "third_party/libjingle/source/talk/base/byteorder.h"
 
 namespace remoting {
 namespace protocol {
@@ -20,7 +20,7 @@ scoped_refptr<net::IOBufferWithSize> SerializeAndFrameMessage(
   const int kExtraBytes = sizeof(int32);
   int size = msg.ByteSize() + kExtraBytes;
   scoped_refptr<net::IOBufferWithSize> buffer(new net::IOBufferWithSize(size));
-  rtc::SetBE32(buffer->data(), msg.GetCachedSize());
+  talk_base::SetBE32(buffer->data(), msg.GetCachedSize());
   msg.SerializeWithCachedSizesToArray(
       reinterpret_cast<uint8*>(buffer->data()) + kExtraBytes);
   return buffer;