(Auto)update libjingle 72097588-> 72159069

git-svn-id: http://webrtc.googlecode.com/svn/trunk/talk@6799 4adac7df-926f-26a2-2b94-8c16560cd09d

98 files changed, 2696 insertions, 2696 deletions

diff --git a/p2p/base/asyncstuntcpsocket.cc b/p2p/base/asyncstuntcpsocket.cc
index 8bcfa3a..74288f8 100644
--- a/p2p/base/asyncstuntcpsocket.cc
+++ b/p2p/base/asyncstuntcpsocket.cc
@@ -29,8 +29,8 @@
 
 #include <string.h>
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
 #include "talk/p2p/base/stun.h"
 
 namespace cricket {
@@ -53,20 +53,20 @@ inline bool IsStunMessage(uint16 msg_type) {
 // it. Takes ownership of |socket|. Returns NULL if bind() or
 // connect() fail (|socket| is destroyed in that case).
 AsyncStunTCPSocket* AsyncStunTCPSocket::Create(
-    talk_base::AsyncSocket* socket,
-    const talk_base::SocketAddress& bind_address,
-    const talk_base::SocketAddress& remote_address) {
+    rtc::AsyncSocket* socket,
+    const rtc::SocketAddress& bind_address,
+    const rtc::SocketAddress& remote_address) {
   return new AsyncStunTCPSocket(AsyncTCPSocketBase::ConnectSocket(
       socket, bind_address, remote_address), false);
 }
 
 AsyncStunTCPSocket::AsyncStunTCPSocket(
-    talk_base::AsyncSocket* socket, bool listen)
-    : talk_base::AsyncTCPSocketBase(socket, listen, kBufSize) {
+    rtc::AsyncSocket* socket, bool listen)
+    : rtc::AsyncTCPSocketBase(socket, listen, kBufSize) {
 }
 
 int AsyncStunTCPSocket::Send(const void *pv, size_t cb,
-                             const talk_base::PacketOptions& options) {
+                             const rtc::PacketOptions& options) {
   if (cb > kBufSize || cb < kPacketLenSize + kPacketLenOffset) {
     SetError(EMSGSIZE);
     return -1;
@@ -101,7 +101,7 @@ int AsyncStunTCPSocket::Send(const void *pv, size_t cb,
 }
 
 void AsyncStunTCPSocket::ProcessInput(char* data, size_t* len) {
-  talk_base::SocketAddress remote_addr(GetRemoteAddress());
+  rtc::SocketAddress remote_addr(GetRemoteAddress());
   // STUN packet - First 4 bytes. Total header size is 20 bytes.
   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   // |0 0|     STUN Message Type     |         Message Length        |
@@ -126,7 +126,7 @@ void AsyncStunTCPSocket::ProcessInput(char* data, size_t* len) {
     }
 
     SignalReadPacket(this, data, expected_pkt_len, remote_addr,
-                     talk_base::CreatePacketTime(0));
+                     rtc::CreatePacketTime(0));
 
     *len -= actual_length;
     if (*len > 0) {
@@ -136,7 +136,7 @@ void AsyncStunTCPSocket::ProcessInput(char* data, size_t* len) {
 }
 
 void AsyncStunTCPSocket::HandleIncomingConnection(
-    talk_base::AsyncSocket* socket) {
+    rtc::AsyncSocket* socket) {
   SignalNewConnection(this, new AsyncStunTCPSocket(socket, false));
 }
 
@@ -144,9 +144,9 @@ size_t AsyncStunTCPSocket::GetExpectedLength(const void* data, size_t len,
                                              int* pad_bytes) {
   *pad_bytes = 0;
   PacketLength pkt_len =
-      talk_base::GetBE16(static_cast<const char*>(data) + kPacketLenOffset);
+      rtc::GetBE16(static_cast<const char*>(data) + kPacketLenOffset);
   size_t expected_pkt_len;
-  uint16 msg_type = talk_base::GetBE16(data);
+  uint16 msg_type = rtc::GetBE16(data);
   if (IsStunMessage(msg_type)) {
     // STUN message.
     expected_pkt_len = kStunHeaderSize + pkt_len;
diff --git a/p2p/base/asyncstuntcpsocket.h b/p2p/base/asyncstuntcpsocket.h
index bef8e98..b63c0b5 100644
--- a/p2p/base/asyncstuntcpsocket.h
+++ b/p2p/base/asyncstuntcpsocket.h
@@ -28,29 +28,29 @@
 #ifndef TALK_BASE_ASYNCSTUNTCPSOCKET_H_
 #define TALK_BASE_ASYNCSTUNTCPSOCKET_H_
 
-#include "talk/base/asynctcpsocket.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketfactory.h"
+#include "webrtc/base/asynctcpsocket.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socketfactory.h"
 
 namespace cricket {
 
-class AsyncStunTCPSocket : public talk_base::AsyncTCPSocketBase {
+class AsyncStunTCPSocket : public rtc::AsyncTCPSocketBase {
  public:
   // Binds and connects |socket| and creates AsyncTCPSocket for
   // it. Takes ownership of |socket|. Returns NULL if bind() or
   // connect() fail (|socket| is destroyed in that case).
   static AsyncStunTCPSocket* Create(
-      talk_base::AsyncSocket* socket,
-      const talk_base::SocketAddress& bind_address,
-      const talk_base::SocketAddress& remote_address);
+      rtc::AsyncSocket* socket,
+      const rtc::SocketAddress& bind_address,
+      const rtc::SocketAddress& remote_address);
 
-  AsyncStunTCPSocket(talk_base::AsyncSocket* socket, bool listen);
+  AsyncStunTCPSocket(rtc::AsyncSocket* socket, bool listen);
   virtual ~AsyncStunTCPSocket() {}
 
   virtual int Send(const void* pv, size_t cb,
-                   const talk_base::PacketOptions& options);
+                   const rtc::PacketOptions& options);
   virtual void ProcessInput(char* data, size_t* len);
-  virtual void HandleIncomingConnection(talk_base::AsyncSocket* socket);
+  virtual void HandleIncomingConnection(rtc::AsyncSocket* socket);
 
  private:
   // This method returns the message hdr + length written in the header.
diff --git a/p2p/base/asyncstuntcpsocket_unittest.cc b/p2p/base/asyncstuntcpsocket_unittest.cc
index f3261df..3796c51 100644
--- a/p2p/base/asyncstuntcpsocket_unittest.cc
+++ b/p2p/base/asyncstuntcpsocket_unittest.cc
@@ -25,10 +25,10 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/asyncsocket.h"
-#include "talk/base/gunit.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/virtualsocketserver.h"
+#include "webrtc/base/asyncsocket.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/virtualsocketserver.h"
 #include "talk/p2p/base/asyncstuntcpsocket.h"
 
 namespace cricket {
@@ -77,14 +77,14 @@ static unsigned char kTurnChannelDataMessageWithOddLength[] = {
 };
 
 
-static const talk_base::SocketAddress kClientAddr("11.11.11.11", 0);
-static const talk_base::SocketAddress kServerAddr("22.22.22.22", 0);
+static const rtc::SocketAddress kClientAddr("11.11.11.11", 0);
+static const rtc::SocketAddress kServerAddr("22.22.22.22", 0);
 
 class AsyncStunTCPSocketTest : public testing::Test,
                                public sigslot::has_slots<> {
  protected:
   AsyncStunTCPSocketTest()
-      : vss_(new talk_base::VirtualSocketServer(NULL)),
+      : vss_(new rtc::VirtualSocketServer(NULL)),
         ss_scope_(vss_.get()) {
   }
 
@@ -93,14 +93,14 @@ class AsyncStunTCPSocketTest : public testing::Test,
   }
 
   void CreateSockets() {
-    talk_base::AsyncSocket* server = vss_->CreateAsyncSocket(
+    rtc::AsyncSocket* server = vss_->CreateAsyncSocket(
         kServerAddr.family(), SOCK_STREAM);
     server->Bind(kServerAddr);
     recv_socket_.reset(new AsyncStunTCPSocket(server, true));
     recv_socket_->SignalNewConnection.connect(
         this, &AsyncStunTCPSocketTest::OnNewConnection);
 
-    talk_base::AsyncSocket* client = vss_->CreateAsyncSocket(
+    rtc::AsyncSocket* client = vss_->CreateAsyncSocket(
         kClientAddr.family(), SOCK_STREAM);
     send_socket_.reset(AsyncStunTCPSocket::Create(
         client, kClientAddr, recv_socket_->GetLocalAddress()));
@@ -108,21 +108,21 @@ class AsyncStunTCPSocketTest : public testing::Test,
     vss_->ProcessMessagesUntilIdle();
   }
 
-  void OnReadPacket(talk_base::AsyncPacketSocket* socket, const char* data,
-                    size_t len, const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time) {
+  void OnReadPacket(rtc::AsyncPacketSocket* socket, const char* data,
+                    size_t len, const rtc::SocketAddress& remote_addr,
+                    const rtc::PacketTime& packet_time) {
     recv_packets_.push_back(std::string(data, len));
   }
 
-  void OnNewConnection(talk_base::AsyncPacketSocket* server,
-                       talk_base::AsyncPacketSocket* new_socket) {
+  void OnNewConnection(rtc::AsyncPacketSocket* server,
+                       rtc::AsyncPacketSocket* new_socket) {
     listen_socket_.reset(new_socket);
     new_socket->SignalReadPacket.connect(
         this, &AsyncStunTCPSocketTest::OnReadPacket);
   }
 
   bool Send(const void* data, size_t len) {
-    talk_base::PacketOptions options;
+    rtc::PacketOptions options;
     size_t ret = send_socket_->Send(
         reinterpret_cast<const char*>(data), len, options);
     vss_->ProcessMessagesUntilIdle();
@@ -139,11 +139,11 @@ class AsyncStunTCPSocketTest : public testing::Test,
     return ret;
   }
 
-  talk_base::scoped_ptr<talk_base::VirtualSocketServer> vss_;
-  talk_base::SocketServerScope ss_scope_;
-  talk_base::scoped_ptr<AsyncStunTCPSocket> send_socket_;
-  talk_base::scoped_ptr<AsyncStunTCPSocket> recv_socket_;
-  talk_base::scoped_ptr<talk_base::AsyncPacketSocket> listen_socket_;
+  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
+  rtc::SocketServerScope ss_scope_;
+  rtc::scoped_ptr<AsyncStunTCPSocket> send_socket_;
+  rtc::scoped_ptr<AsyncStunTCPSocket> recv_socket_;
+  rtc::scoped_ptr<rtc::AsyncPacketSocket> listen_socket_;
   std::list<std::string> recv_packets_;
 };
 
diff --git a/p2p/base/basicpacketsocketfactory.cc b/p2p/base/basicpacketsocketfactory.cc
index 758d492..75a7055 100644
--- a/p2p/base/basicpacketsocketfactory.cc
+++ b/p2p/base/basicpacketsocketfactory.cc
@@ -27,18 +27,18 @@
 
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 
-#include "talk/base/asyncudpsocket.h"
-#include "talk/base/asynctcpsocket.h"
-#include "talk/base/logging.h"
-#include "talk/base/nethelpers.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketadapters.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/asyncudpsocket.h"
+#include "webrtc/base/asynctcpsocket.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/nethelpers.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socketadapters.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/asyncstuntcpsocket.h"
 #include "talk/p2p/base/stun.h"
 
-namespace talk_base {
+namespace rtc {
 
 BasicPacketSocketFactory::BasicPacketSocketFactory()
     : thread_(Thread::Current()),
@@ -62,7 +62,7 @@ BasicPacketSocketFactory::~BasicPacketSocketFactory() {
 AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocket(
     const SocketAddress& address, int min_port, int max_port) {
   // UDP sockets are simple.
-  talk_base::AsyncSocket* socket =
+  rtc::AsyncSocket* socket =
       socket_factory()->CreateAsyncSocket(
           address.family(), SOCK_DGRAM);
   if (!socket) {
@@ -74,7 +74,7 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocket(
     delete socket;
     return NULL;
   }
-  return new talk_base::AsyncUDPSocket(socket);
+  return new rtc::AsyncUDPSocket(socket);
 }
 
 AsyncPacketSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
@@ -86,7 +86,7 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
     return NULL;
   }
 
-  talk_base::AsyncSocket* socket =
+  rtc::AsyncSocket* socket =
       socket_factory()->CreateAsyncSocket(local_address.family(),
                                           SOCK_STREAM);
   if (!socket) {
@@ -103,17 +103,17 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
   // If using SSLTCP, wrap the TCP socket in a pseudo-SSL socket.
   if (opts & PacketSocketFactory::OPT_SSLTCP) {
     ASSERT(!(opts & PacketSocketFactory::OPT_TLS));
-    socket = new talk_base::AsyncSSLSocket(socket);
+    socket = new rtc::AsyncSSLSocket(socket);
   }
 
   // Set TCP_NODELAY (via OPT_NODELAY) for improved performance.
   // See http://go/gtalktcpnodelayexperiment
-  socket->SetOption(talk_base::Socket::OPT_NODELAY, 1);
+  socket->SetOption(rtc::Socket::OPT_NODELAY, 1);
 
   if (opts & PacketSocketFactory::OPT_STUN)
     return new cricket::AsyncStunTCPSocket(socket, true);
 
-  return new talk_base::AsyncTCPSocket(socket, true);
+  return new rtc::AsyncTCPSocket(socket, true);
 }
 
 AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
@@ -126,7 +126,7 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
     return NULL;
   }
 
-  talk_base::AsyncSocket* socket =
+  rtc::AsyncSocket* socket =
       socket_factory()->CreateAsyncSocket(local_address.family(), SOCK_STREAM);
   if (!socket) {
     return NULL;
@@ -140,11 +140,11 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
   }
 
   // If using a proxy, wrap the socket in a proxy socket.
-  if (proxy_info.type == talk_base::PROXY_SOCKS5) {
-    socket = new talk_base::AsyncSocksProxySocket(
+  if (proxy_info.type == rtc::PROXY_SOCKS5) {
+    socket = new rtc::AsyncSocksProxySocket(
         socket, proxy_info.address, proxy_info.username, proxy_info.password);
-  } else if (proxy_info.type == talk_base::PROXY_HTTPS) {
-    socket = new talk_base::AsyncHttpsProxySocket(
+  } else if (proxy_info.type == rtc::PROXY_HTTPS) {
+    socket = new rtc::AsyncHttpsProxySocket(
         socket, user_agent, proxy_info.address,
         proxy_info.username, proxy_info.password);
   }
@@ -152,7 +152,7 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
   // If using SSLTCP, wrap the TCP socket in a pseudo-SSL socket.
   if (opts & PacketSocketFactory::OPT_SSLTCP) {
     ASSERT(!(opts & PacketSocketFactory::OPT_TLS));
-    socket = new talk_base::AsyncSSLSocket(socket);
+    socket = new rtc::AsyncSSLSocket(socket);
   }
 
   if (socket->Connect(remote_address) < 0) {
@@ -167,18 +167,18 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
   if (opts & PacketSocketFactory::OPT_STUN) {
     tcp_socket = new cricket::AsyncStunTCPSocket(socket, false);
   } else {
-    tcp_socket = new talk_base::AsyncTCPSocket(socket, false);
+    tcp_socket = new rtc::AsyncTCPSocket(socket, false);
   }
 
   // Set TCP_NODELAY (via OPT_NODELAY) for improved performance.
   // See http://go/gtalktcpnodelayexperiment
-  tcp_socket->SetOption(talk_base::Socket::OPT_NODELAY, 1);
+  tcp_socket->SetOption(rtc::Socket::OPT_NODELAY, 1);
 
   return tcp_socket;
 }
 
 AsyncResolverInterface* BasicPacketSocketFactory::CreateAsyncResolver() {
-  return new talk_base::AsyncResolver();
+  return new rtc::AsyncResolver();
 }
 
 int BasicPacketSocketFactory::BindSocket(
@@ -191,7 +191,7 @@ int BasicPacketSocketFactory::BindSocket(
   } else {
     // Otherwise, try to find a port in the provided range.
     for (int port = min_port; ret < 0 && port <= max_port; ++port) {
-      ret = socket->Bind(talk_base::SocketAddress(local_address.ipaddr(),
+      ret = socket->Bind(rtc::SocketAddress(local_address.ipaddr(),
                                                   port));
     }
   }
@@ -207,4 +207,4 @@ SocketFactory* BasicPacketSocketFactory::socket_factory() {
   }
 }
 
-}  // namespace talk_base
+}  // namespace rtc
diff --git a/p2p/base/basicpacketsocketfactory.h b/p2p/base/basicpacketsocketfactory.h
index 27963c9..b1bae35 100644
--- a/p2p/base/basicpacketsocketfactory.h
+++ b/p2p/base/basicpacketsocketfactory.h
@@ -30,7 +30,7 @@
 
 #include "talk/p2p/base/packetsocketfactory.h"
 
-namespace talk_base {
+namespace rtc {
 
 class AsyncSocket;
 class SocketFactory;
@@ -63,6 +63,6 @@ class BasicPacketSocketFactory : public PacketSocketFactory {
   SocketFactory* socket_factory_;
 };
 
-}  // namespace talk_base
+}  // namespace rtc
 
 #endif  // TALK_BASE_BASICPACKETSOCKETFACTORY_H_
diff --git a/p2p/base/candidate.h b/p2p/base/candidate.h
index d6abdb0..56174bd 100644
--- a/p2p/base/candidate.h
+++ b/p2p/base/candidate.h
@@ -35,8 +35,8 @@
 #include <sstream>
 #include <iomanip>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/socketaddress.h"
 #include "talk/p2p/base/constants.h"
 
 namespace cricket {
@@ -49,7 +49,7 @@ class Candidate {
   // candidate-attribute syntax. http://tools.ietf.org/html/rfc5245#section-15.1
   Candidate() : component_(0), priority_(0), generation_(0) {}
   Candidate(const std::string& id, int component, const std::string& protocol,
-            const talk_base::SocketAddress& address, uint32 priority,
+            const rtc::SocketAddress& address, uint32 priority,
             const std::string& username, const std::string& password,
             const std::string& type, const std::string& network_name,
             uint32 generation, const std::string& foundation)
@@ -68,8 +68,8 @@ class Candidate {
   const std::string & protocol() const { return protocol_; }
   void set_protocol(const std::string & protocol) { protocol_ = protocol; }
 
-  const talk_base::SocketAddress & address() const { return address_; }
-  void set_address(const talk_base::SocketAddress & address) {
+  const rtc::SocketAddress & address() const { return address_; }
+  void set_address(const rtc::SocketAddress & address) {
     address_ = address;
   }
 
@@ -94,7 +94,7 @@ class Candidate {
     // This can happen for e.g. when preference = 3.
     uint64 prio_val = static_cast<uint64>(preference * 127) << 24;
     priority_ = static_cast<uint32>(
-      talk_base::_min(prio_val, static_cast<uint64>(UINT_MAX)));
+      rtc::_min(prio_val, static_cast<uint64>(UINT_MAX)));
   }
 
   const std::string & username() const { return username_; }
@@ -132,11 +132,11 @@ class Candidate {
     foundation_ = foundation;
   }
 
-  const talk_base::SocketAddress & related_address() const {
+  const rtc::SocketAddress & related_address() const {
     return related_address_;
   }
   void set_related_address(
-      const talk_base::SocketAddress & related_address) {
+      const rtc::SocketAddress & related_address) {
     related_address_ = related_address;
   }
 
@@ -208,7 +208,7 @@ class Candidate {
   std::string id_;
   int component_;
   std::string protocol_;
-  talk_base::SocketAddress address_;
+  rtc::SocketAddress address_;
   uint32 priority_;
   std::string username_;
   std::string password_;
@@ -216,7 +216,7 @@ class Candidate {
   std::string network_name_;
   uint32 generation_;
   std::string foundation_;
-  talk_base::SocketAddress related_address_;
+  rtc::SocketAddress related_address_;
 };
 
 }  // namespace cricket
diff --git a/p2p/base/common.h b/p2p/base/common.h
index 5a38180..a33e9e0 100644
--- a/p2p/base/common.h
+++ b/p2p/base/common.h
@@ -28,7 +28,7 @@
 #ifndef TALK_P2P_BASE_COMMON_H_
 #define TALK_P2P_BASE_COMMON_H_
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 
 // Common log description format for jingle messages
 #define LOG_J(sev, obj) LOG(sev) << "Jingle:" << obj->ToString() << ": "
diff --git a/p2p/base/dtlstransport.h b/p2p/base/dtlstransport.h
index 641f572..318c14a 100644
--- a/p2p/base/dtlstransport.h
+++ b/p2p/base/dtlstransport.h
@@ -31,7 +31,7 @@
 #include "talk/p2p/base/dtlstransportchannel.h"
 #include "talk/p2p/base/transport.h"
 
-namespace talk_base {
+namespace rtc {
 class SSLIdentity;
 }
 
@@ -43,23 +43,23 @@ class PortAllocator;
 template<class Base>
 class DtlsTransport : public Base {
  public:
-  DtlsTransport(talk_base::Thread* signaling_thread,
-                talk_base::Thread* worker_thread,
+  DtlsTransport(rtc::Thread* signaling_thread,
+                rtc::Thread* worker_thread,
                 const std::string& content_name,
                 PortAllocator* allocator,
-                talk_base::SSLIdentity* identity)
+                rtc::SSLIdentity* identity)
       : Base(signaling_thread, worker_thread, content_name, allocator),
         identity_(identity),
-        secure_role_(talk_base::SSL_CLIENT) {
+        secure_role_(rtc::SSL_CLIENT) {
   }
 
   ~DtlsTransport() {
     Base::DestroyAllChannels();
   }
-  virtual void SetIdentity_w(talk_base::SSLIdentity* identity) {
+  virtual void SetIdentity_w(rtc::SSLIdentity* identity) {
     identity_ = identity;
   }
-  virtual bool GetIdentity_w(talk_base::SSLIdentity** identity) {
+  virtual bool GetIdentity_w(rtc::SSLIdentity** identity) {
     if (!identity_)
       return false;
 
@@ -69,14 +69,14 @@ class DtlsTransport : public Base {
 
   virtual bool ApplyLocalTransportDescription_w(TransportChannelImpl* channel,
                                                 std::string* error_desc) {
-    talk_base::SSLFingerprint* local_fp =
+    rtc::SSLFingerprint* local_fp =
         Base::local_description()->identity_fingerprint.get();
 
     if (local_fp) {
       // Sanity check local fingerprint.
       if (identity_) {
-        talk_base::scoped_ptr<talk_base::SSLFingerprint> local_fp_tmp(
-            talk_base::SSLFingerprint::Create(local_fp->algorithm,
+        rtc::scoped_ptr<rtc::SSLFingerprint> local_fp_tmp(
+            rtc::SSLFingerprint::Create(local_fp->algorithm,
                                               identity_));
         ASSERT(local_fp_tmp.get() != NULL);
         if (!(*local_fp_tmp == *local_fp)) {
@@ -112,13 +112,13 @@ class DtlsTransport : public Base {
       return BadTransportDescription(msg, error_desc);
     }
 
-    talk_base::SSLFingerprint* local_fp =
+    rtc::SSLFingerprint* local_fp =
         Base::local_description()->identity_fingerprint.get();
-    talk_base::SSLFingerprint* remote_fp =
+    rtc::SSLFingerprint* remote_fp =
         Base::remote_description()->identity_fingerprint.get();
 
     if (remote_fp && local_fp) {
-      remote_fingerprint_.reset(new talk_base::SSLFingerprint(*remote_fp));
+      remote_fingerprint_.reset(new rtc::SSLFingerprint(*remote_fp));
 
       // From RFC 4145, section-4.1, The following are the values that the
       // 'setup' attribute can take in an offer/answer exchange:
@@ -188,8 +188,8 @@ class DtlsTransport : public Base {
         // If local is passive, local will act as server.
       }
 
-      secure_role_ = is_remote_server ? talk_base::SSL_CLIENT :
-                                        talk_base::SSL_SERVER;
+      secure_role_ = is_remote_server ? rtc::SSL_CLIENT :
+                                        rtc::SSL_SERVER;
 
     } else if (local_fp && (local_role == CA_ANSWER)) {
       return BadTransportDescription(
@@ -197,7 +197,7 @@ class DtlsTransport : public Base {
           error_desc);
     } else {
       // We are not doing DTLS
-      remote_fingerprint_.reset(new talk_base::SSLFingerprint(
+      remote_fingerprint_.reset(new rtc::SSLFingerprint(
           "", NULL, 0));
     }
 
@@ -219,7 +219,7 @@ class DtlsTransport : public Base {
     Base::DestroyTransportChannel(base_channel);
   }
 
-  virtual bool GetSslRole_w(talk_base::SSLRole* ssl_role) const {
+  virtual bool GetSslRole_w(rtc::SSLRole* ssl_role) const {
     ASSERT(ssl_role != NULL);
     *ssl_role = secure_role_;
     return true;
@@ -247,9 +247,9 @@ class DtlsTransport : public Base {
     return Base::ApplyNegotiatedTransportDescription_w(channel, error_desc);
   }
 
-  talk_base::SSLIdentity* identity_;
-  talk_base::SSLRole secure_role_;
-  talk_base::scoped_ptr<talk_base::SSLFingerprint> remote_fingerprint_;
+  rtc::SSLIdentity* identity_;
+  rtc::SSLRole secure_role_;
+  rtc::scoped_ptr<rtc::SSLFingerprint> remote_fingerprint_;
 };
 
 }  // namespace cricket
diff --git a/p2p/base/dtlstransportchannel.cc b/p2p/base/dtlstransportchannel.cc
index 416e6e9..85da4a9 100644
--- a/p2p/base/dtlstransportchannel.cc
+++ b/p2p/base/dtlstransportchannel.cc
@@ -28,12 +28,12 @@
 
 #include "talk/p2p/base/dtlstransportchannel.h"
 
-#include "talk/base/buffer.h"
-#include "talk/base/dscp.h"
-#include "talk/base/messagequeue.h"
-#include "talk/base/stream.h"
-#include "talk/base/sslstreamadapter.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/dscp.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/common.h"
 
 namespace cricket {
@@ -52,45 +52,45 @@ static bool IsRtpPacket(const char* data, size_t len) {
   return (len >= kMinRtpPacketLen && (u[0] & 0xC0) == 0x80);
 }
 
-talk_base::StreamResult StreamInterfaceChannel::Read(void* buffer,
+rtc::StreamResult StreamInterfaceChannel::Read(void* buffer,
                                                      size_t buffer_len,
                                                      size_t* read,
                                                      int* error) {
-  if (state_ == talk_base::SS_CLOSED)
-    return talk_base::SR_EOS;
-  if (state_ == talk_base::SS_OPENING)
-    return talk_base::SR_BLOCK;
+  if (state_ == rtc::SS_CLOSED)
+    return rtc::SR_EOS;
+  if (state_ == rtc::SS_OPENING)
+    return rtc::SR_BLOCK;
 
   return fifo_.Read(buffer, buffer_len, read, error);
 }
 
-talk_base::StreamResult StreamInterfaceChannel::Write(const void* data,
+rtc::StreamResult StreamInterfaceChannel::Write(const void* data,
                                                       size_t data_len,
                                                       size_t* written,
                                                       int* error) {
   // Always succeeds, since this is an unreliable transport anyway.
   // TODO: Should this block if channel_'s temporarily unwritable?
-  talk_base::PacketOptions packet_options;
+  rtc::PacketOptions packet_options;
   channel_->SendPacket(static_cast<const char*>(data), data_len,
                        packet_options);
   if (written) {
     *written = data_len;
   }
-  return talk_base::SR_SUCCESS;
+  return rtc::SR_SUCCESS;
 }
 
 bool StreamInterfaceChannel::OnPacketReceived(const char* data, size_t size) {
   // We force a read event here to ensure that we don't overflow our FIFO.
   // Under high packet rate this can occur if we wait for the FIFO to post its
   // own SE_READ.
-  bool ret = (fifo_.WriteAll(data, size, NULL, NULL) == talk_base::SR_SUCCESS);
+  bool ret = (fifo_.WriteAll(data, size, NULL, NULL) == rtc::SR_SUCCESS);
   if (ret) {
-    SignalEvent(this, talk_base::SE_READ, 0);
+    SignalEvent(this, rtc::SE_READ, 0);
   }
   return ret;
 }
 
-void StreamInterfaceChannel::OnEvent(talk_base::StreamInterface* stream,
+void StreamInterfaceChannel::OnEvent(rtc::StreamInterface* stream,
                                      int sig, int err) {
   SignalEvent(this, sig, err);
 }
@@ -100,12 +100,12 @@ DtlsTransportChannelWrapper::DtlsTransportChannelWrapper(
                                            TransportChannelImpl* channel)
     : TransportChannelImpl(channel->content_name(), channel->component()),
       transport_(transport),
-      worker_thread_(talk_base::Thread::Current()),
+      worker_thread_(rtc::Thread::Current()),
       channel_(channel),
       downward_(NULL),
       dtls_state_(STATE_NONE),
       local_identity_(NULL),
-      ssl_role_(talk_base::SSL_CLIENT) {
+      ssl_role_(rtc::SSL_CLIENT) {
   channel_->SignalReadableState.connect(this,
       &DtlsTransportChannelWrapper::OnReadableState);
   channel_->SignalWritableState.connect(this,
@@ -155,7 +155,7 @@ void DtlsTransportChannelWrapper::Reset() {
 }
 
 bool DtlsTransportChannelWrapper::SetLocalIdentity(
-    talk_base::SSLIdentity* identity) {
+    rtc::SSLIdentity* identity) {
   if (dtls_state_ != STATE_NONE) {
     if (identity == local_identity_) {
       // This may happen during renegotiation.
@@ -178,7 +178,7 @@ bool DtlsTransportChannelWrapper::SetLocalIdentity(
 }
 
 bool DtlsTransportChannelWrapper::GetLocalIdentity(
-    talk_base::SSLIdentity** identity) const {
+    rtc::SSLIdentity** identity) const {
   if (!local_identity_)
     return false;
 
@@ -186,7 +186,7 @@ bool DtlsTransportChannelWrapper::GetLocalIdentity(
   return true;
 }
 
-bool DtlsTransportChannelWrapper::SetSslRole(talk_base::SSLRole role) {
+bool DtlsTransportChannelWrapper::SetSslRole(rtc::SSLRole role) {
   if (dtls_state_ == STATE_OPEN) {
     if (ssl_role_ != role) {
       LOG(LS_ERROR) << "SSL Role can't be reversed after the session is setup.";
@@ -199,7 +199,7 @@ bool DtlsTransportChannelWrapper::SetSslRole(talk_base::SSLRole role) {
   return true;
 }
 
-bool DtlsTransportChannelWrapper::GetSslRole(talk_base::SSLRole* role) const {
+bool DtlsTransportChannelWrapper::GetSslRole(rtc::SSLRole* role) const {
   *role = ssl_role_;
   return true;
 }
@@ -209,7 +209,7 @@ bool DtlsTransportChannelWrapper::SetRemoteFingerprint(
     const uint8* digest,
     size_t digest_len) {
 
-  talk_base::Buffer remote_fingerprint_value(digest, digest_len);
+  rtc::Buffer remote_fingerprint_value(digest, digest_len);
 
   if (dtls_state_ != STATE_NONE &&
       remote_fingerprint_value_ == remote_fingerprint_value &&
@@ -247,7 +247,7 @@ bool DtlsTransportChannelWrapper::SetRemoteFingerprint(
 }
 
 bool DtlsTransportChannelWrapper::GetRemoteCertificate(
-    talk_base::SSLCertificate** cert) const {
+    rtc::SSLCertificate** cert) const {
   if (!dtls_)
     return false;
 
@@ -258,7 +258,7 @@ bool DtlsTransportChannelWrapper::SetupDtls() {
   StreamInterfaceChannel* downward =
       new StreamInterfaceChannel(worker_thread_, channel_);
 
-  dtls_.reset(talk_base::SSLStreamAdapter::Create(downward));
+  dtls_.reset(rtc::SSLStreamAdapter::Create(downward));
   if (!dtls_) {
     LOG_J(LS_ERROR, this) << "Failed to create DTLS adapter.";
     delete downward;
@@ -268,7 +268,7 @@ bool DtlsTransportChannelWrapper::SetupDtls() {
   downward_ = downward;
 
   dtls_->SetIdentity(local_identity_->GetReference());
-  dtls_->SetMode(talk_base::SSL_MODE_DTLS);
+  dtls_->SetMode(rtc::SSL_MODE_DTLS);
   dtls_->SetServerRole(ssl_role_);
   dtls_->SignalEvent.connect(this, &DtlsTransportChannelWrapper::OnDtlsEvent);
   if (!dtls_->SetPeerCertificateDigest(
@@ -347,7 +347,7 @@ bool DtlsTransportChannelWrapper::GetSrtpCipher(std::string* cipher) {
 // Called from upper layers to send a media packet.
 int DtlsTransportChannelWrapper::SendPacket(
     const char* data, size_t size,
-    const talk_base::PacketOptions& options, int flags) {
+    const rtc::PacketOptions& options, int flags) {
   int result = -1;
 
   switch (dtls_state_) {
@@ -374,7 +374,7 @@ int DtlsTransportChannelWrapper::SendPacket(
         result = channel_->SendPacket(data, size, options);
       } else {
         result = (dtls_->WriteAll(data, size, NULL, NULL) ==
-          talk_base::SR_SUCCESS) ? static_cast<int>(size) : -1;
+          rtc::SR_SUCCESS) ? static_cast<int>(size) : -1;
       }
       break;
       // Not doing DTLS.
@@ -400,7 +400,7 @@ int DtlsTransportChannelWrapper::SendPacket(
 //     - Once the DTLS handshake completes, the state is that of the
 //       impl again
 void DtlsTransportChannelWrapper::OnReadableState(TransportChannel* channel) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == channel_);
   LOG_J(LS_VERBOSE, this)
       << "DTLSTransportChannelWrapper: channel readable state changed.";
@@ -412,7 +412,7 @@ void DtlsTransportChannelWrapper::OnReadableState(TransportChannel* channel) {
 }
 
 void DtlsTransportChannelWrapper::OnWritableState(TransportChannel* channel) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == channel_);
   LOG_J(LS_VERBOSE, this)
       << "DTLSTransportChannelWrapper: channel writable state changed.";
@@ -454,8 +454,8 @@ void DtlsTransportChannelWrapper::OnWritableState(TransportChannel* channel) {
 
 void DtlsTransportChannelWrapper::OnReadPacket(
     TransportChannel* channel, const char* data, size_t size,
-    const talk_base::PacketTime& packet_time, int flags) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+    const rtc::PacketTime& packet_time, int flags) {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == channel_);
   ASSERT(flags == 0);
 
@@ -521,14 +521,14 @@ void DtlsTransportChannelWrapper::OnReadyToSend(TransportChannel* channel) {
   }
 }
 
-void DtlsTransportChannelWrapper::OnDtlsEvent(talk_base::StreamInterface* dtls,
+void DtlsTransportChannelWrapper::OnDtlsEvent(rtc::StreamInterface* dtls,
                                               int sig, int err) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(dtls == dtls_.get());
-  if (sig & talk_base::SE_OPEN) {
+  if (sig & rtc::SE_OPEN) {
     // This is the first time.
     LOG_J(LS_INFO, this) << "DTLS handshake complete.";
-    if (dtls_->GetState() == talk_base::SS_OPEN) {
+    if (dtls_->GetState() == rtc::SS_OPEN) {
       // The check for OPEN shouldn't be necessary but let's make
       // sure we don't accidentally frob the state if it's closed.
       dtls_state_ = STATE_OPEN;
@@ -537,15 +537,15 @@ void DtlsTransportChannelWrapper::OnDtlsEvent(talk_base::StreamInterface* dtls,
       set_writable(true);
     }
   }
-  if (sig & talk_base::SE_READ) {
+  if (sig & rtc::SE_READ) {
     char buf[kMaxDtlsPacketLen];
     size_t read;
-    if (dtls_->Read(buf, sizeof(buf), &read, NULL) == talk_base::SR_SUCCESS) {
-      SignalReadPacket(this, buf, read, talk_base::CreatePacketTime(0), 0);
+    if (dtls_->Read(buf, sizeof(buf), &read, NULL) == rtc::SR_SUCCESS) {
+      SignalReadPacket(this, buf, read, rtc::CreatePacketTime(0), 0);
     }
   }
-  if (sig & talk_base::SE_CLOSE) {
-    ASSERT(sig == talk_base::SE_CLOSE);  // SE_CLOSE should be by itself.
+  if (sig & rtc::SE_CLOSE) {
+    ASSERT(sig == rtc::SE_CLOSE);  // SE_CLOSE should be by itself.
     if (!err) {
       LOG_J(LS_INFO, this) << "DTLS channel closed";
     } else {
diff --git a/p2p/base/dtlstransportchannel.h b/p2p/base/dtlstransportchannel.h
index 232d400..c4082d3 100644
--- a/p2p/base/dtlstransportchannel.h
+++ b/p2p/base/dtlstransportchannel.h
@@ -32,22 +32,22 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/buffer.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sslstreamadapter.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/base/stream.h"
 #include "talk/p2p/base/transportchannelimpl.h"
 
 namespace cricket {
 
 // A bridge between a packet-oriented/channel-type interface on
 // the bottom and a StreamInterface on the top.
-class StreamInterfaceChannel : public talk_base::StreamInterface,
+class StreamInterfaceChannel : public rtc::StreamInterface,
                                public sigslot::has_slots<> {
  public:
-  StreamInterfaceChannel(talk_base::Thread* owner, TransportChannel* channel)
+  StreamInterfaceChannel(rtc::Thread* owner, TransportChannel* channel)
       : channel_(channel),
-        state_(talk_base::SS_OPEN),
+        state_(rtc::SS_OPEN),
         fifo_(kFifoSize, owner) {
     fifo_.SignalEvent.connect(this, &StreamInterfaceChannel::OnEvent);
   }
@@ -56,22 +56,22 @@ class StreamInterfaceChannel : public talk_base::StreamInterface,
   bool OnPacketReceived(const char* data, size_t size);
 
   // Implementations of StreamInterface
-  virtual talk_base::StreamState GetState() const { return state_; }
-  virtual void Close() { state_ = talk_base::SS_CLOSED; }
-  virtual talk_base::StreamResult Read(void* buffer, size_t buffer_len,
+  virtual rtc::StreamState GetState() const { return state_; }
+  virtual void Close() { state_ = rtc::SS_CLOSED; }
+  virtual rtc::StreamResult Read(void* buffer, size_t buffer_len,
                                        size_t* read, int* error);
-  virtual talk_base::StreamResult Write(const void* data, size_t data_len,
+  virtual rtc::StreamResult Write(const void* data, size_t data_len,
                                         size_t* written, int* error);
 
  private:
   static const size_t kFifoSize = 8192;
 
   // Forward events
-  virtual void OnEvent(talk_base::StreamInterface* stream, int sig, int err);
+  virtual void OnEvent(rtc::StreamInterface* stream, int sig, int err);
 
   TransportChannel* channel_;  // owned by DtlsTransportChannelWrapper
-  talk_base::StreamState state_;
-  talk_base::FifoBuffer fifo_;
+  rtc::StreamState state_;
+  rtc::FifoBuffer fifo_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamInterfaceChannel);
 };
@@ -130,8 +130,8 @@ class DtlsTransportChannelWrapper : public TransportChannelImpl {
   virtual size_t GetConnectionCount() const {
     return channel_->GetConnectionCount();
   }
-  virtual bool SetLocalIdentity(talk_base::SSLIdentity *identity);
-  virtual bool GetLocalIdentity(talk_base::SSLIdentity** identity) const;
+  virtual bool SetLocalIdentity(rtc::SSLIdentity *identity);
+  virtual bool GetLocalIdentity(rtc::SSLIdentity** identity) const;
 
   virtual bool SetRemoteFingerprint(const std::string& digest_alg,
                                     const uint8* digest,
@@ -140,11 +140,11 @@ class DtlsTransportChannelWrapper : public TransportChannelImpl {
 
   // Called to send a packet (via DTLS, if turned on).
   virtual int SendPacket(const char* data, size_t size,
-                         const talk_base::PacketOptions& options,
+                         const rtc::PacketOptions& options,
                          int flags);
 
   // TransportChannel calls that we forward to the wrapped transport.
-  virtual int SetOption(talk_base::Socket::Option opt, int value) {
+  virtual int SetOption(rtc::Socket::Option opt, int value) {
     return channel_->SetOption(opt, value);
   }
   virtual int GetError() {
@@ -165,12 +165,12 @@ class DtlsTransportChannelWrapper : public TransportChannelImpl {
   // Find out which DTLS-SRTP cipher was negotiated
   virtual bool GetSrtpCipher(std::string* cipher);
 
-  virtual bool GetSslRole(talk_base::SSLRole* role) const;
-  virtual bool SetSslRole(talk_base::SSLRole role);
+  virtual bool GetSslRole(rtc::SSLRole* role) const;
+  virtual bool SetSslRole(rtc::SSLRole role);
 
   // Once DTLS has been established, this method retrieves the certificate in
   // use by the remote peer, for use in external identity verification.
-  virtual bool GetRemoteCertificate(talk_base::SSLCertificate** cert) const;
+  virtual bool GetRemoteCertificate(rtc::SSLCertificate** cert) const;
 
   // Once DTLS has established (i.e., this channel is writable), this method
   // extracts the keys negotiated during the DTLS handshake, for use in external
@@ -231,9 +231,9 @@ class DtlsTransportChannelWrapper : public TransportChannelImpl {
   void OnReadableState(TransportChannel* channel);
   void OnWritableState(TransportChannel* channel);
   void OnReadPacket(TransportChannel* channel, const char* data, size_t size,
-                    const talk_base::PacketTime& packet_time, int flags);
+                    const rtc::PacketTime& packet_time, int flags);
   void OnReadyToSend(TransportChannel* channel);
-  void OnDtlsEvent(talk_base::StreamInterface* stream_, int sig, int err);
+  void OnDtlsEvent(rtc::StreamInterface* stream_, int sig, int err);
   bool SetupDtls();
   bool MaybeStartDtls();
   bool HandleDtlsPacket(const char* data, size_t size);
@@ -245,15 +245,15 @@ class DtlsTransportChannelWrapper : public TransportChannelImpl {
   void OnConnectionRemoved(TransportChannelImpl* channel);
 
   Transport* transport_;  // The transport_ that created us.
-  talk_base::Thread* worker_thread_;  // Everything should occur on this thread.
+  rtc::Thread* worker_thread_;  // Everything should occur on this thread.
   TransportChannelImpl* channel_;  // Underlying channel, owned by transport_.
-  talk_base::scoped_ptr<talk_base::SSLStreamAdapter> dtls_;  // The DTLS stream
+  rtc::scoped_ptr<rtc::SSLStreamAdapter> dtls_;  // The DTLS stream
   StreamInterfaceChannel* downward_;  // Wrapper for channel_, owned by dtls_.
   std::vector<std::string> srtp_ciphers_;  // SRTP ciphers to use with DTLS.
   State dtls_state_;
-  talk_base::SSLIdentity* local_identity_;
-  talk_base::SSLRole ssl_role_;
-  talk_base::Buffer remote_fingerprint_value_;
+  rtc::SSLIdentity* local_identity_;
+  rtc::SSLRole ssl_role_;
+  rtc::Buffer remote_fingerprint_value_;
   std::string remote_fingerprint_algorithm_;
 
   DISALLOW_COPY_AND_ASSIGN(DtlsTransportChannelWrapper);
diff --git a/p2p/base/dtlstransportchannel_unittest.cc b/p2p/base/dtlstransportchannel_unittest.cc
index 5727ac4..ce4951a 100644
--- a/p2p/base/dtlstransportchannel_unittest.cc
+++ b/p2p/base/dtlstransportchannel_unittest.cc
@@ -28,21 +28,21 @@
 
 #include <set>
 
-#include "talk/base/common.h"
-#include "talk/base/dscp.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/dscp.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/fakesession.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/sslidentity.h"
-#include "talk/base/sslstreamadapter.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/sslidentity.h"
+#include "webrtc/base/sslstreamadapter.h"
 #include "talk/p2p/base/dtlstransport.h"
 
 #define MAYBE_SKIP_TEST(feature)                    \
-  if (!(talk_base::SSLStreamAdapter::feature())) {  \
+  if (!(rtc::SSLStreamAdapter::feature())) {  \
     LOG(LS_INFO) << "Feature disabled... skipping"; \
     return;                                         \
   }
@@ -64,8 +64,8 @@ enum Flags { NF_REOFFER = 0x1, NF_EXPECT_FAILURE = 0x2 };
 class DtlsTestClient : public sigslot::has_slots<> {
  public:
   DtlsTestClient(const std::string& name,
-                 talk_base::Thread* signaling_thread,
-                 talk_base::Thread* worker_thread) :
+                 rtc::Thread* signaling_thread,
+                 rtc::Thread* worker_thread) :
       name_(name),
       signaling_thread_(signaling_thread),
       worker_thread_(worker_thread),
@@ -80,9 +80,9 @@ class DtlsTestClient : public sigslot::has_slots<> {
     protocol_ = proto;
   }
   void CreateIdentity() {
-    identity_.reset(talk_base::SSLIdentity::Generate(name_));
+    identity_.reset(rtc::SSLIdentity::Generate(name_));
   }
-  talk_base::SSLIdentity* identity() { return identity_.get(); }
+  rtc::SSLIdentity* identity() { return identity_.get(); }
   void SetupSrtp() {
     ASSERT(identity_.get() != NULL);
     use_dtls_srtp_ = true;
@@ -135,22 +135,22 @@ class DtlsTestClient : public sigslot::has_slots<> {
   }
 
   // Allow any DTLS configuration to be specified (including invalid ones).
-  void Negotiate(talk_base::SSLIdentity* local_identity,
-                 talk_base::SSLIdentity* remote_identity,
+  void Negotiate(rtc::SSLIdentity* local_identity,
+                 rtc::SSLIdentity* remote_identity,
                  cricket::ContentAction action,
                  ConnectionRole local_role,
                  ConnectionRole remote_role,
                  int flags) {
-    talk_base::scoped_ptr<talk_base::SSLFingerprint> local_fingerprint;
-    talk_base::scoped_ptr<talk_base::SSLFingerprint> remote_fingerprint;
+    rtc::scoped_ptr<rtc::SSLFingerprint> local_fingerprint;
+    rtc::scoped_ptr<rtc::SSLFingerprint> remote_fingerprint;
     if (local_identity) {
-      local_fingerprint.reset(talk_base::SSLFingerprint::Create(
-          talk_base::DIGEST_SHA_1, local_identity));
+      local_fingerprint.reset(rtc::SSLFingerprint::Create(
+          rtc::DIGEST_SHA_1, local_identity));
       ASSERT_TRUE(local_fingerprint.get() != NULL);
     }
     if (remote_identity) {
-      remote_fingerprint.reset(talk_base::SSLFingerprint::Create(
-          talk_base::DIGEST_SHA_1, remote_identity));
+      remote_fingerprint.reset(rtc::SSLFingerprint::Create(
+          rtc::DIGEST_SHA_1, remote_identity));
       ASSERT_TRUE(remote_fingerprint.get() != NULL);
     }
 
@@ -205,8 +205,8 @@ class DtlsTestClient : public sigslot::has_slots<> {
 
   bool writable() const { return transport_->writable(); }
 
-  void CheckRole(talk_base::SSLRole role) {
-    if (role == talk_base::SSL_CLIENT) {
+  void CheckRole(rtc::SSLRole role) {
+    if (role == rtc::SSL_CLIENT) {
       ASSERT_FALSE(received_dtls_client_hello_);
       ASSERT_TRUE(received_dtls_server_hello_);
     } else {
@@ -233,19 +233,19 @@ class DtlsTestClient : public sigslot::has_slots<> {
 
   void SendPackets(size_t channel, size_t size, size_t count, bool srtp) {
     ASSERT(channel < channels_.size());
-    talk_base::scoped_ptr<char[]> packet(new char[size]);
+    rtc::scoped_ptr<char[]> packet(new char[size]);
     size_t sent = 0;
     do {
       // Fill the packet with a known value and a sequence number to check
       // against, and make sure that it doesn't look like DTLS.
       memset(packet.get(), sent & 0xff, size);
       packet[0] = (srtp) ? 0x80 : 0x00;
-      talk_base::SetBE32(packet.get() + kPacketNumOffset,
+      rtc::SetBE32(packet.get() + kPacketNumOffset,
                          static_cast<uint32>(sent));
 
       // Only set the bypass flag if we've activated DTLS.
       int flags = (identity_.get() && srtp) ? cricket::PF_SRTP_BYPASS : 0;
-      talk_base::PacketOptions packet_options;
+      rtc::PacketOptions packet_options;
       int rv = channels_[channel]->SendPacket(
           packet.get(), size, packet_options, flags);
       ASSERT_GT(rv, 0);
@@ -256,11 +256,11 @@ class DtlsTestClient : public sigslot::has_slots<> {
 
   int SendInvalidSrtpPacket(size_t channel, size_t size) {
     ASSERT(channel < channels_.size());
-    talk_base::scoped_ptr<char[]> packet(new char[size]);
+    rtc::scoped_ptr<char[]> packet(new char[size]);
     // Fill the packet with 0 to form an invalid SRTP packet.
     memset(packet.get(), 0, size);
 
-    talk_base::PacketOptions packet_options;
+    rtc::PacketOptions packet_options;
     return channels_[channel]->SendPacket(
         packet.get(), size, packet_options, cricket::PF_SRTP_BYPASS);
   }
@@ -279,7 +279,7 @@ class DtlsTestClient : public sigslot::has_slots<> {
         (data[0] != 0 && static_cast<uint8>(data[0]) != 0x80)) {
       return false;
     }
-    uint32 packet_num = talk_base::GetBE32(data + kPacketNumOffset);
+    uint32 packet_num = rtc::GetBE32(data + kPacketNumOffset);
     for (size_t i = kPacketHeaderLen; i < size; ++i) {
       if (static_cast<uint8>(data[i]) != (packet_num & 0xff)) {
         return false;
@@ -296,7 +296,7 @@ class DtlsTestClient : public sigslot::has_slots<> {
     if (size <= packet_size_) {
       return false;
     }
-    uint32 packet_num = talk_base::GetBE32(data + kPacketNumOffset);
+    uint32 packet_num = rtc::GetBE32(data + kPacketNumOffset);
     int num_matches = 0;
     for (size_t i = kPacketNumOffset; i < size; ++i) {
       if (static_cast<uint8>(data[i]) == (packet_num & 0xff)) {
@@ -319,7 +319,7 @@ class DtlsTestClient : public sigslot::has_slots<> {
 
   void OnTransportChannelReadPacket(cricket::TransportChannel* channel,
                                     const char* data, size_t size,
-                                    const talk_base::PacketTime& packet_time,
+                                    const rtc::PacketTime& packet_time,
                                     int flags) {
     uint32 packet_num = 0;
     ASSERT_TRUE(VerifyPacket(data, size, &packet_num));
@@ -333,7 +333,7 @@ class DtlsTestClient : public sigslot::has_slots<> {
   // Hook into the raw packet stream to make sure DTLS packets are encrypted.
   void OnFakeTransportChannelReadPacket(cricket::TransportChannel* channel,
                                         const char* data, size_t size,
-                                        const talk_base::PacketTime& time,
+                                        const rtc::PacketTime& time,
                                         int flags) {
     // Flags shouldn't be set on the underlying TransportChannel packets.
     ASSERT_EQ(0, flags);
@@ -360,11 +360,11 @@ class DtlsTestClient : public sigslot::has_slots<> {
 
  private:
   std::string name_;
-  talk_base::Thread* signaling_thread_;
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* signaling_thread_;
+  rtc::Thread* worker_thread_;
   cricket::TransportProtocol protocol_;
-  talk_base::scoped_ptr<talk_base::SSLIdentity> identity_;
-  talk_base::scoped_ptr<cricket::FakeTransport> transport_;
+  rtc::scoped_ptr<rtc::SSLIdentity> identity_;
+  rtc::scoped_ptr<cricket::FakeTransport> transport_;
   std::vector<cricket::DtlsTransportChannelWrapper*> channels_;
   size_t packet_size_;
   std::set<int> received_;
@@ -378,18 +378,18 @@ class DtlsTestClient : public sigslot::has_slots<> {
 class DtlsTransportChannelTest : public testing::Test {
  public:
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   DtlsTransportChannelTest() :
-      client1_("P1", talk_base::Thread::Current(),
-               talk_base::Thread::Current()),
-      client2_("P2", talk_base::Thread::Current(),
-               talk_base::Thread::Current()),
+      client1_("P1", rtc::Thread::Current(),
+               rtc::Thread::Current()),
+      client2_("P2", rtc::Thread::Current(),
+               rtc::Thread::Current()),
       channel_ct_(1),
       use_dtls_(false),
       use_dtls_srtp_(false) {
@@ -435,17 +435,17 @@ class DtlsTransportChannelTest : public testing::Test {
 
     // Check that we used the right roles.
     if (use_dtls_) {
-      talk_base::SSLRole client1_ssl_role =
+      rtc::SSLRole client1_ssl_role =
           (client1_role == cricket::CONNECTIONROLE_ACTIVE ||
            (client2_role == cricket::CONNECTIONROLE_PASSIVE &&
             client1_role == cricket::CONNECTIONROLE_ACTPASS)) ?
-              talk_base::SSL_CLIENT : talk_base::SSL_SERVER;
+              rtc::SSL_CLIENT : rtc::SSL_SERVER;
 
-      talk_base::SSLRole client2_ssl_role =
+      rtc::SSLRole client2_ssl_role =
           (client2_role == cricket::CONNECTIONROLE_ACTIVE ||
            (client1_role == cricket::CONNECTIONROLE_PASSIVE &&
             client2_role == cricket::CONNECTIONROLE_ACTPASS)) ?
-              talk_base::SSL_CLIENT : talk_base::SSL_SERVER;
+              rtc::SSL_CLIENT : rtc::SSL_SERVER;
 
       client1_.CheckRole(client1_ssl_role);
       client2_.CheckRole(client2_ssl_role);
@@ -701,12 +701,12 @@ TEST_F(DtlsTransportChannelTest, TestDtlsSetupWithLegacyAsAnswerer) {
   MAYBE_SKIP_TEST(HaveDtlsSrtp);
   PrepareDtls(true, true);
   NegotiateWithLegacy();
-  talk_base::SSLRole channel1_role;
-  talk_base::SSLRole channel2_role;
+  rtc::SSLRole channel1_role;
+  rtc::SSLRole channel2_role;
   EXPECT_TRUE(client1_.transport()->GetSslRole(&channel1_role));
   EXPECT_TRUE(client2_.transport()->GetSslRole(&channel2_role));
-  EXPECT_EQ(talk_base::SSL_SERVER, channel1_role);
-  EXPECT_EQ(talk_base::SSL_CLIENT, channel2_role);
+  EXPECT_EQ(rtc::SSL_SERVER, channel1_role);
+  EXPECT_EQ(rtc::SSL_CLIENT, channel2_role);
 }
 
 // Testing re offer/answer after the session is estbalished. Roles will be
@@ -801,10 +801,10 @@ TEST_F(DtlsTransportChannelTest, TestCertificatesBeforeConnect) {
   PrepareDtls(true, true);
   Negotiate();
 
-  talk_base::scoped_ptr<talk_base::SSLIdentity> identity1;
-  talk_base::scoped_ptr<talk_base::SSLIdentity> identity2;
-  talk_base::scoped_ptr<talk_base::SSLCertificate> remote_cert1;
-  talk_base::scoped_ptr<talk_base::SSLCertificate> remote_cert2;
+  rtc::scoped_ptr<rtc::SSLIdentity> identity1;
+  rtc::scoped_ptr<rtc::SSLIdentity> identity2;
+  rtc::scoped_ptr<rtc::SSLCertificate> remote_cert1;
+  rtc::scoped_ptr<rtc::SSLCertificate> remote_cert2;
 
   // After negotiation, each side has a distinct local certificate, but still no
   // remote certificate, because connection has not yet occurred.
@@ -826,10 +826,10 @@ TEST_F(DtlsTransportChannelTest, TestCertificatesAfterConnect) {
   PrepareDtls(true, true);
   ASSERT_TRUE(Connect());
 
-  talk_base::scoped_ptr<talk_base::SSLIdentity> identity1;
-  talk_base::scoped_ptr<talk_base::SSLIdentity> identity2;
-  talk_base::scoped_ptr<talk_base::SSLCertificate> remote_cert1;
-  talk_base::scoped_ptr<talk_base::SSLCertificate> remote_cert2;
+  rtc::scoped_ptr<rtc::SSLIdentity> identity1;
+  rtc::scoped_ptr<rtc::SSLIdentity> identity2;
+  rtc::scoped_ptr<rtc::SSLCertificate> remote_cert1;
+  rtc::scoped_ptr<rtc::SSLCertificate> remote_cert2;
 
   // After connection, each side has a distinct local certificate.
   ASSERT_TRUE(client1_.transport()->GetIdentity(identity1.accept()));
diff --git a/p2p/base/fakesession.h b/p2p/base/fakesession.h
index f2c5b84..67b4cd9 100644
--- a/p2p/base/fakesession.h
+++ b/p2p/base/fakesession.h
@@ -32,11 +32,11 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/buffer.h"
-#include "talk/base/fakesslidentity.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/sslfingerprint.h"
-#include "talk/base/messagequeue.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/fakesslidentity.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/sslfingerprint.h"
+#include "webrtc/base/messagequeue.h"
 #include "talk/p2p/base/session.h"
 #include "talk/p2p/base/transport.h"
 #include "talk/p2p/base/transportchannel.h"
@@ -46,17 +46,17 @@ namespace cricket {
 
 class FakeTransport;
 
-struct PacketMessageData : public talk_base::MessageData {
+struct PacketMessageData : public rtc::MessageData {
   PacketMessageData(const char* data, size_t len) : packet(data, len) {
   }
-  talk_base::Buffer packet;
+  rtc::Buffer packet;
 };
 
 // Fake transport channel class, which can be passed to anything that needs a
 // transport channel. Can be informed of another FakeTransportChannel via
 // SetDestination.
 class FakeTransportChannel : public TransportChannelImpl,
-                             public talk_base::MessageHandler {
+                             public rtc::MessageHandler {
  public:
   explicit FakeTransportChannel(Transport* transport,
                                 const std::string& content_name,
@@ -73,7 +73,7 @@ class FakeTransportChannel : public TransportChannelImpl,
         ice_proto_(ICEPROTO_HYBRID),
         remote_ice_mode_(ICEMODE_FULL),
         dtls_fingerprint_("", NULL, 0),
-        ssl_role_(talk_base::SSL_CLIENT),
+        ssl_role_(rtc::SSL_CLIENT),
         connection_count_(0) {
   }
   ~FakeTransportChannel() {
@@ -87,7 +87,7 @@ class FakeTransportChannel : public TransportChannelImpl,
   const std::string& ice_pwd() const { return ice_pwd_; }
   const std::string& remote_ice_ufrag() const { return remote_ice_ufrag_; }
   const std::string& remote_ice_pwd() const { return remote_ice_pwd_; }
-  const talk_base::SSLFingerprint& dtls_fingerprint() const {
+  const rtc::SSLFingerprint& dtls_fingerprint() const {
     return dtls_fingerprint_;
   }
 
@@ -122,14 +122,14 @@ class FakeTransportChannel : public TransportChannelImpl,
   virtual void SetRemoteIceMode(IceMode mode) { remote_ice_mode_ = mode; }
   virtual bool SetRemoteFingerprint(const std::string& alg, const uint8* digest,
                                     size_t digest_len) {
-    dtls_fingerprint_ = talk_base::SSLFingerprint(alg, digest, digest_len);
+    dtls_fingerprint_ = rtc::SSLFingerprint(alg, digest, digest_len);
     return true;
   }
-  virtual bool SetSslRole(talk_base::SSLRole role) {
+  virtual bool SetSslRole(rtc::SSLRole role) {
     ssl_role_ = role;
     return true;
   }
-  virtual bool GetSslRole(talk_base::SSLRole* role) const {
+  virtual bool GetSslRole(rtc::SSLRole* role) const {
     *role = ssl_role_;
     return true;
   }
@@ -184,7 +184,7 @@ class FakeTransportChannel : public TransportChannelImpl,
   }
 
   virtual int SendPacket(const char* data, size_t len,
-                         const talk_base::PacketOptions& options, int flags) {
+                         const rtc::PacketOptions& options, int flags) {
     if (state_ != STATE_CONNECTED) {
       return -1;
     }
@@ -195,13 +195,13 @@ class FakeTransportChannel : public TransportChannelImpl,
 
     PacketMessageData* packet = new PacketMessageData(data, len);
     if (async_) {
-      talk_base::Thread::Current()->Post(this, 0, packet);
+      rtc::Thread::Current()->Post(this, 0, packet);
     } else {
-      talk_base::Thread::Current()->Send(this, 0, packet);
+      rtc::Thread::Current()->Send(this, 0, packet);
     }
     return static_cast<int>(len);
   }
-  virtual int SetOption(talk_base::Socket::Option opt, int value) {
+  virtual int SetOption(rtc::Socket::Option opt, int value) {
     return true;
   }
   virtual int GetError() {
@@ -213,22 +213,22 @@ class FakeTransportChannel : public TransportChannelImpl,
   virtual void OnCandidate(const Candidate& candidate) {
   }
 
-  virtual void OnMessage(talk_base::Message* msg) {
+  virtual void OnMessage(rtc::Message* msg) {
     PacketMessageData* data = static_cast<PacketMessageData*>(
         msg->pdata);
     dest_->SignalReadPacket(dest_, data->packet.data(),
                             data->packet.length(),
-                            talk_base::CreatePacketTime(0), 0);
+                            rtc::CreatePacketTime(0), 0);
     delete data;
   }
 
-  bool SetLocalIdentity(talk_base::SSLIdentity* identity) {
+  bool SetLocalIdentity(rtc::SSLIdentity* identity) {
     identity_ = identity;
     return true;
   }
 
 
-  void SetRemoteCertificate(talk_base::FakeSSLCertificate* cert) {
+  void SetRemoteCertificate(rtc::FakeSSLCertificate* cert) {
     remote_cert_ = cert;
   }
 
@@ -249,7 +249,7 @@ class FakeTransportChannel : public TransportChannelImpl,
     return false;
   }
 
-  virtual bool GetLocalIdentity(talk_base::SSLIdentity** identity) const {
+  virtual bool GetLocalIdentity(rtc::SSLIdentity** identity) const {
     if (!identity_)
       return false;
 
@@ -257,7 +257,7 @@ class FakeTransportChannel : public TransportChannelImpl,
     return true;
   }
 
-  virtual bool GetRemoteCertificate(talk_base::SSLCertificate** cert) const {
+  virtual bool GetRemoteCertificate(rtc::SSLCertificate** cert) const {
     if (!remote_cert_)
       return false;
 
@@ -307,8 +307,8 @@ class FakeTransportChannel : public TransportChannelImpl,
   FakeTransportChannel* dest_;
   State state_;
   bool async_;
-  talk_base::SSLIdentity* identity_;
-  talk_base::FakeSSLCertificate* remote_cert_;
+  rtc::SSLIdentity* identity_;
+  rtc::FakeSSLCertificate* remote_cert_;
   bool do_dtls_;
   std::vector<std::string> srtp_ciphers_;
   std::string chosen_srtp_cipher_;
@@ -320,8 +320,8 @@ class FakeTransportChannel : public TransportChannelImpl,
   std::string remote_ice_ufrag_;
   std::string remote_ice_pwd_;
   IceMode remote_ice_mode_;
-  talk_base::SSLFingerprint dtls_fingerprint_;
-  talk_base::SSLRole ssl_role_;
+  rtc::SSLFingerprint dtls_fingerprint_;
+  rtc::SSLRole ssl_role_;
   size_t connection_count_;
 };
 
@@ -331,8 +331,8 @@ class FakeTransportChannel : public TransportChannelImpl,
 class FakeTransport : public Transport {
  public:
   typedef std::map<int, FakeTransportChannel*> ChannelMap;
-  FakeTransport(talk_base::Thread* signaling_thread,
-                talk_base::Thread* worker_thread,
+  FakeTransport(rtc::Thread* signaling_thread,
+                rtc::Thread* worker_thread,
                 const std::string& content_name,
                 PortAllocator* alllocator = NULL)
       : Transport(signaling_thread, worker_thread,
@@ -364,7 +364,7 @@ class FakeTransport : public Transport {
     }
   }
 
-  void set_identity(talk_base::SSLIdentity* identity) {
+  void set_identity(rtc::SSLIdentity* identity) {
     identity_ = identity;
   }
 
@@ -387,10 +387,10 @@ class FakeTransport : public Transport {
     channels_.erase(channel->component());
     delete channel;
   }
-  virtual void SetIdentity_w(talk_base::SSLIdentity* identity) {
+  virtual void SetIdentity_w(rtc::SSLIdentity* identity) {
     identity_ = identity;
   }
-  virtual bool GetIdentity_w(talk_base::SSLIdentity** identity) {
+  virtual bool GetIdentity_w(rtc::SSLIdentity** identity) {
     if (!identity_)
       return false;
 
@@ -420,7 +420,7 @@ class FakeTransport : public Transport {
   ChannelMap channels_;
   FakeTransport* dest_;
   bool async_;
-  talk_base::SSLIdentity* identity_;
+  rtc::SSLIdentity* identity_;
 };
 
 // Fake session class, which can be passed into a BaseChannel object for
@@ -428,19 +428,19 @@ class FakeTransport : public Transport {
 class FakeSession : public BaseSession {
  public:
   explicit FakeSession()
-      : BaseSession(talk_base::Thread::Current(),
-                    talk_base::Thread::Current(),
+      : BaseSession(rtc::Thread::Current(),
+                    rtc::Thread::Current(),
                     NULL, "", "", true),
       fail_create_channel_(false) {
   }
   explicit FakeSession(bool initiator)
-      : BaseSession(talk_base::Thread::Current(),
-                    talk_base::Thread::Current(),
+      : BaseSession(rtc::Thread::Current(),
+                    rtc::Thread::Current(),
                     NULL, "", "", initiator),
       fail_create_channel_(false) {
   }
-  FakeSession(talk_base::Thread* worker_thread, bool initiator)
-      : BaseSession(talk_base::Thread::Current(),
+  FakeSession(rtc::Thread* worker_thread, bool initiator)
+      : BaseSession(rtc::Thread::Current(),
                     worker_thread,
                     NULL, "", "", initiator),
       fail_create_channel_(false) {
@@ -477,7 +477,7 @@ class FakeSession : public BaseSession {
   }
 
   // TODO: Hoist this into Session when we re-work the Session code.
-  void set_ssl_identity(talk_base::SSLIdentity* identity) {
+  void set_ssl_identity(rtc::SSLIdentity* identity) {
     for (TransportMap::const_iterator it = transport_proxies().begin();
         it != transport_proxies().end(); ++it) {
       // We know that we have a FakeTransport*
diff --git a/p2p/base/p2ptransport.cc b/p2p/base/p2ptransport.cc
index 7f53cff..89d2564 100644
--- a/p2p/base/p2ptransport.cc
+++ b/p2p/base/p2ptransport.cc
@@ -30,10 +30,10 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/base64.h"
-#include "talk/base/common.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/base64.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/p2ptransportchannel.h"
 #include "talk/p2p/base/parsing.h"
@@ -57,8 +57,8 @@ static buzz::XmlElement* NewTransportElement(const std::string& name) {
   return new buzz::XmlElement(buzz::QName(name, LN_TRANSPORT), true);
 }
 
-P2PTransport::P2PTransport(talk_base::Thread* signaling_thread,
-                           talk_base::Thread* worker_thread,
+P2PTransport::P2PTransport(rtc::Thread* signaling_thread,
+                           rtc::Thread* worker_thread,
                            const std::string& content_name,
                            PortAllocator* allocator)
     : Transport(signaling_thread, worker_thread,
@@ -112,7 +112,7 @@ bool P2PTransportParser::WriteTransportDescription(
     buzz::XmlElement** out_elem,
     WriteError* error) {
   TransportProtocol proto = TransportProtocolFromDescription(&desc);
-  talk_base::scoped_ptr<buzz::XmlElement> trans_elem(
+  rtc::scoped_ptr<buzz::XmlElement> trans_elem(
       NewTransportElement(desc.transport_type));
 
   // Fail if we get HYBRID or ICE right now.
@@ -124,7 +124,7 @@ bool P2PTransportParser::WriteTransportDescription(
 
   for (std::vector<Candidate>::const_iterator iter = desc.candidates.begin();
        iter != desc.candidates.end(); ++iter) {
-    talk_base::scoped_ptr<buzz::XmlElement> cand_elem(
+    rtc::scoped_ptr<buzz::XmlElement> cand_elem(
         new buzz::XmlElement(QN_GINGLE_P2P_CANDIDATE));
     if (!WriteCandidate(proto, *iter, translator, cand_elem.get(), error)) {
       return false;
@@ -149,7 +149,7 @@ bool P2PTransportParser::WriteGingleCandidate(
     const CandidateTranslator* translator,
     buzz::XmlElement** out_elem,
     WriteError* error) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem(
+  rtc::scoped_ptr<buzz::XmlElement> elem(
       new buzz::XmlElement(QN_GINGLE_CANDIDATE));                                     
   bool ret = WriteCandidate(ICEPROTO_GOOGLE, candidate, translator, elem.get(),
                             error);
@@ -165,7 +165,7 @@ bool P2PTransportParser::VerifyUsernameFormat(TransportProtocol proto,
   if (proto == ICEPROTO_GOOGLE || proto == ICEPROTO_HYBRID) {
     if (username.size() > kMaxGiceUsernameSize)
       return BadParse("candidate username is too long", error);
-    if (!talk_base::Base64::IsBase64Encoded(username))
+    if (!rtc::Base64::IsBase64Encoded(username))
       return BadParse("candidate username has non-base64 encoded characters",
                       error);
   } else if (proto == ICEPROTO_RFC5245) {
@@ -192,7 +192,7 @@ bool P2PTransportParser::ParseCandidate(TransportProtocol proto,
     return BadParse("candidate missing required attribute", error);
   }
 
-  talk_base::SocketAddress address;
+  rtc::SocketAddress address;
   if (!ParseAddress(elem, QN_ADDRESS, QN_PORT, &address, error))
     return false;
 
diff --git a/p2p/base/p2ptransport.h b/p2p/base/p2ptransport.h
index f2b10f8..500bb9b 100644
--- a/p2p/base/p2ptransport.h
+++ b/p2p/base/p2ptransport.h
@@ -36,8 +36,8 @@ namespace cricket {
 
 class P2PTransport : public Transport {
  public:
-  P2PTransport(talk_base::Thread* signaling_thread,
-               talk_base::Thread* worker_thread,
+  P2PTransport(rtc::Thread* signaling_thread,
+               rtc::Thread* worker_thread,
                const std::string& content_name,
                PortAllocator* allocator);
   virtual ~P2PTransport();
diff --git a/p2p/base/p2ptransportchannel.cc b/p2p/base/p2ptransportchannel.cc
index 2e1160f..8e56f15 100644
--- a/p2p/base/p2ptransportchannel.cc
+++ b/p2p/base/p2ptransportchannel.cc
@@ -28,10 +28,10 @@
 #include "talk/p2p/base/p2ptransportchannel.h"
 
 #include <set>
-#include "talk/base/common.h"
-#include "talk/base/crc32.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/crc32.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/p2p/base/common.h"
 #include "talk/p2p/base/relayport.h"  // For RELAY_PORT_TYPE.
 #include "talk/p2p/base/stunport.h"  // For STUN_PORT_TYPE.
@@ -159,7 +159,7 @@ P2PTransportChannel::P2PTransportChannel(const std::string& content_name,
     TransportChannelImpl(content_name, component),
     transport_(transport),
     allocator_(allocator),
-    worker_thread_(talk_base::Thread::Current()),
+    worker_thread_(rtc::Thread::Current()),
     incoming_only_(false),
     waiting_for_signaling_(false),
     error_(0),
@@ -175,7 +175,7 @@ P2PTransportChannel::P2PTransportChannel(const std::string& content_name,
 }
 
 P2PTransportChannel::~P2PTransportChannel() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   for (uint32 i = 0; i < allocator_sessions_.size(); ++i)
     delete allocator_sessions_[i];
@@ -216,7 +216,7 @@ void P2PTransportChannel::AddConnection(Connection* connection) {
 }
 
 void P2PTransportChannel::SetIceRole(IceRole ice_role) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (ice_role_ != ice_role) {
     ice_role_ = ice_role;
     for (std::vector<PortInterface *>::iterator it = ports_.begin();
@@ -227,7 +227,7 @@ void P2PTransportChannel::SetIceRole(IceRole ice_role) {
 }
 
 void P2PTransportChannel::SetIceTiebreaker(uint64 tiebreaker) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (!ports_.empty()) {
     LOG(LS_ERROR)
         << "Attempt to change tiebreaker after Port has been allocated.";
@@ -243,7 +243,7 @@ bool P2PTransportChannel::GetIceProtocolType(IceProtocolType* type) const {
 }
 
 void P2PTransportChannel::SetIceProtocolType(IceProtocolType type) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   protocol_type_ = type;
   for (std::vector<PortInterface *>::iterator it = ports_.begin();
@@ -254,7 +254,7 @@ void P2PTransportChannel::SetIceProtocolType(IceProtocolType type) {
 
 void P2PTransportChannel::SetIceCredentials(const std::string& ice_ufrag,
                                             const std::string& ice_pwd) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   bool ice_restart = false;
   if (!ice_ufrag_.empty() && !ice_pwd_.empty()) {
     // Restart candidate allocation if there is any change in either
@@ -274,7 +274,7 @@ void P2PTransportChannel::SetIceCredentials(const std::string& ice_ufrag,
 
 void P2PTransportChannel::SetRemoteIceCredentials(const std::string& ice_ufrag,
                                                   const std::string& ice_pwd) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   bool ice_restart = false;
   if (!remote_ice_ufrag_.empty() && !remote_ice_pwd_.empty()) {
     ice_restart = (remote_ice_ufrag_ != ice_ufrag) ||
@@ -298,7 +298,7 @@ void P2PTransportChannel::SetRemoteIceMode(IceMode mode) {
 
 // Go into the state of processing candidates, and running in general
 void P2PTransportChannel::Connect() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (ice_ufrag_.empty() || ice_pwd_.empty()) {
     ASSERT(false);
     LOG(LS_ERROR) << "P2PTransportChannel::Connect: The ice_ufrag_ and the "
@@ -315,7 +315,7 @@ void P2PTransportChannel::Connect() {
 
 // Reset the socket, clear up any previous allocations and start over
 void P2PTransportChannel::Reset() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Get rid of all the old allocators.  This should clean up everything.
   for (uint32 i = 0; i < allocator_sessions_.size(); ++i)
@@ -349,7 +349,7 @@ void P2PTransportChannel::Reset() {
 // A new port is available, attempt to make connections for it
 void P2PTransportChannel::OnPortReady(PortAllocatorSession *session,
                                       PortInterface* port) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Set in-effect options on the new port
   for (OptionMap::const_iterator it = options_.begin();
@@ -392,7 +392,7 @@ void P2PTransportChannel::OnPortReady(PortAllocatorSession *session,
 // A new candidate is available, let listeners know
 void P2PTransportChannel::OnCandidatesReady(
     PortAllocatorSession *session, const std::vector<Candidate>& candidates) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   for (size_t i = 0; i < candidates.size(); ++i) {
     SignalCandidateReady(this, candidates[i]);
   }
@@ -400,17 +400,17 @@ void P2PTransportChannel::OnCandidatesReady(
 
 void P2PTransportChannel::OnCandidatesAllocationDone(
     PortAllocatorSession* session) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   SignalCandidatesAllocationDone(this);
 }
 
 // Handle stun packets
 void P2PTransportChannel::OnUnknownAddress(
     PortInterface* port,
-    const talk_base::SocketAddress& address, ProtocolType proto,
+    const rtc::SocketAddress& address, ProtocolType proto,
     IceMessage* stun_msg, const std::string &remote_username,
     bool port_muxed) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Port has received a valid stun packet from an address that no Connection
   // is currently available for. See if we already have a candidate with the
@@ -486,12 +486,12 @@ void P2PTransportChannel::OnUnknownAddress(
       }
     }
 
-    std::string id = talk_base::CreateRandomString(8);
+    std::string id = rtc::CreateRandomString(8);
     new_remote_candidate = Candidate(
         id, component(), ProtoToString(proto), address,
         0, remote_username, remote_password, type,
         port->Network()->name(), 0U,
-        talk_base::ToString<uint32>(talk_base::ComputeCrc32(id)));
+        rtc::ToString<uint32>(rtc::ComputeCrc32(id)));
     new_remote_candidate.set_priority(
         new_remote_candidate.GetPriority(ICE_TYPE_PREFERENCE_SRFLX,
                                          port->Network()->preference(), 0));
@@ -591,7 +591,7 @@ void P2PTransportChannel::OnRoleConflict(PortInterface* port) {
 
 // When the signalling channel is ready, we can really kick off the allocator
 void P2PTransportChannel::OnSignalingReady() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (waiting_for_signaling_) {
     waiting_for_signaling_ = false;
     AddAllocatorSession(allocator_->CreateSession(
@@ -600,7 +600,7 @@ void P2PTransportChannel::OnSignalingReady() {
 }
 
 void P2PTransportChannel::OnUseCandidate(Connection* conn) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(ice_role_ == ICEROLE_CONTROLLED);
   ASSERT(protocol_type_ == ICEPROTO_RFC5245);
   if (conn->write_state() == Connection::STATE_WRITABLE) {
@@ -617,7 +617,7 @@ void P2PTransportChannel::OnUseCandidate(Connection* conn) {
 }
 
 void P2PTransportChannel::OnCandidate(const Candidate& candidate) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Create connections to this remote candidate.
   CreateConnections(candidate, NULL, false);
@@ -632,7 +632,7 @@ void P2PTransportChannel::OnCandidate(const Candidate& candidate) {
 bool P2PTransportChannel::CreateConnections(const Candidate& remote_candidate,
                                             PortInterface* origin_port,
                                             bool readable) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   Candidate new_remote_candidate(remote_candidate);
   new_remote_candidate.set_generation(
@@ -794,7 +794,7 @@ void P2PTransportChannel::RememberRemoteCandidate(
 
 // Set options on ourselves is simply setting options on all of our available
 // port objects.
-int P2PTransportChannel::SetOption(talk_base::Socket::Option opt, int value) {
+int P2PTransportChannel::SetOption(rtc::Socket::Option opt, int value) {
   OptionMap::iterator it = options_.find(opt);
   if (it == options_.end()) {
     options_.insert(std::make_pair(opt, value));
@@ -818,9 +818,9 @@ int P2PTransportChannel::SetOption(talk_base::Socket::Option opt, int value) {
 
 // Send data to the other side, using our best connection.
 int P2PTransportChannel::SendPacket(const char *data, size_t len,
-                                    const talk_base::PacketOptions& options,
+                                    const rtc::PacketOptions& options,
                                     int flags) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (flags != 0) {
     error_ = EINVAL;
     return -1;
@@ -839,7 +839,7 @@ int P2PTransportChannel::SendPacket(const char *data, size_t len,
 }
 
 bool P2PTransportChannel::GetStats(ConnectionInfos *infos) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   // Gather connection infos.
   infos->clear();
 
@@ -870,12 +870,12 @@ bool P2PTransportChannel::GetStats(ConnectionInfos *infos) {
   return true;
 }
 
-talk_base::DiffServCodePoint P2PTransportChannel::DefaultDscpValue() const {
-  OptionMap::const_iterator it = options_.find(talk_base::Socket::OPT_DSCP);
+rtc::DiffServCodePoint P2PTransportChannel::DefaultDscpValue() const {
+  OptionMap::const_iterator it = options_.find(rtc::Socket::OPT_DSCP);
   if (it == options_.end()) {
-    return talk_base::DSCP_NO_CHANGE;
+    return rtc::DSCP_NO_CHANGE;
   }
-  return static_cast<talk_base::DiffServCodePoint> (it->second);
+  return static_cast<rtc::DiffServCodePoint> (it->second);
 }
 
 // Begin allocate (or immediately re-allocate, if MSG_ALLOCATE pending)
@@ -888,7 +888,7 @@ void P2PTransportChannel::Allocate() {
 
 // Monitor connection states.
 void P2PTransportChannel::UpdateConnectionStates() {
-  uint32 now = talk_base::Time();
+  uint32 now = rtc::Time();
 
   // We need to copy the list of connections since some may delete themselves
   // when we call UpdateState.
@@ -907,7 +907,7 @@ void P2PTransportChannel::RequestSort() {
 // Sort the available connections to find the best one.  We also monitor
 // the number of available connections and the current state.
 void P2PTransportChannel::SortConnections() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Make sure the connection states are up-to-date since this affects how they
   // will be sorted.
@@ -926,7 +926,7 @@ void P2PTransportChannel::SortConnections() {
   sort_dirty_ = false;
 
   // Get a list of the networks that we are using.
-  std::set<talk_base::Network*> networks;
+  std::set<rtc::Network*> networks;
   for (uint32 i = 0; i < connections_.size(); ++i)
     networks.insert(connections_[i]->port()->Network());
 
@@ -962,7 +962,7 @@ void P2PTransportChannel::SortConnections() {
   // we would prune out the current best connection).  We leave connections on
   // other networks because they may not be using the same resources and they
   // may represent very distinct paths over which we can switch.
-  std::set<talk_base::Network*>::iterator network;
+  std::set<rtc::Network*>::iterator network;
   for (network = networks.begin(); network != networks.end(); ++network) {
     Connection* primier = GetBestConnectionOnNetwork(*network);
     if (!primier || (primier->write_state() != Connection::STATE_WRITABLE))
@@ -1044,7 +1044,7 @@ void P2PTransportChannel::UpdateChannelState() {
 // We checked the status of our connections and we had at least one that
 // was writable, go into the writable state.
 void P2PTransportChannel::HandleWritable() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (!writable()) {
     for (uint32 i = 0; i < allocator_sessions_.size(); ++i) {
       if (allocator_sessions_[i]->IsGettingPorts()) {
@@ -1059,7 +1059,7 @@ void P2PTransportChannel::HandleWritable() {
 
 // Notify upper layer about channel not writable state, if it was before.
 void P2PTransportChannel::HandleNotWritable() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (was_writable_) {
     was_writable_ = false;
     set_writable(false);
@@ -1074,7 +1074,7 @@ void P2PTransportChannel::HandleAllTimedOut() {
 // If we have a best connection, return it, otherwise return top one in the
 // list (later we will mark it best).
 Connection* P2PTransportChannel::GetBestConnectionOnNetwork(
-    talk_base::Network* network) {
+    rtc::Network* network) {
   // If the best connection is on this network, then it wins.
   if (best_connection_ && (best_connection_->port()->Network() == network))
     return best_connection_;
@@ -1089,7 +1089,7 @@ Connection* P2PTransportChannel::GetBestConnectionOnNetwork(
 }
 
 // Handle any queued up requests
-void P2PTransportChannel::OnMessage(talk_base::Message *pmsg) {
+void P2PTransportChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_SORT:
       OnSort();
@@ -1151,7 +1151,7 @@ bool P2PTransportChannel::IsPingable(Connection* conn) {
 // pingable connection unless we have a writable connection that is past the
 // maximum acceptable ping delay.
 Connection* P2PTransportChannel::FindNextPingableConnection() {
-  uint32 now = talk_base::Time();
+  uint32 now = rtc::Time();
   if (best_connection_ &&
       (best_connection_->write_state() == Connection::STATE_WRITABLE) &&
       (best_connection_->last_ping_sent()
@@ -1197,13 +1197,13 @@ void P2PTransportChannel::PingConnection(Connection* conn) {
     }
   }
   conn->set_use_candidate_attr(use_candidate);
-  conn->Ping(talk_base::Time());
+  conn->Ping(rtc::Time());
 }
 
 // When a connection's state changes, we need to figure out who to use as
 // the best connection again.  It could have become usable, or become unusable.
 void P2PTransportChannel::OnConnectionStateChange(Connection* connection) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Update the best connection if the state change is from pending best
   // connection and role is controlled.
@@ -1222,7 +1222,7 @@ void P2PTransportChannel::OnConnectionStateChange(Connection* connection) {
 // When a connection is removed, edit it out, and then update our best
 // connection.
 void P2PTransportChannel::OnConnectionDestroyed(Connection* connection) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Note: the previous best_connection_ may be destroyed by now, so don't
   // use it.
@@ -1256,7 +1256,7 @@ void P2PTransportChannel::OnConnectionDestroyed(Connection* connection) {
 // When a port is destroyed remove it from our list of ports to use for
 // connection attempts.
 void P2PTransportChannel::OnPortDestroyed(PortInterface* port) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Remove this port from the list (if we didn't drop it already).
   std::vector<PortInterface*>::iterator iter =
@@ -1271,8 +1271,8 @@ void P2PTransportChannel::OnPortDestroyed(PortInterface* port) {
 // We data is available, let listeners know
 void P2PTransportChannel::OnReadPacket(
     Connection *connection, const char *data, size_t len,
-    const talk_base::PacketTime& packet_time) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+    const rtc::PacketTime& packet_time) {
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Do not deliver, if packet doesn't belong to the correct transport channel.
   if (!FindConnection(connection))
diff --git a/p2p/base/p2ptransportchannel.h b/p2p/base/p2ptransportchannel.h
index 09dabd5..b1c1607 100644
--- a/p2p/base/p2ptransportchannel.h
+++ b/p2p/base/p2ptransportchannel.h
@@ -40,8 +40,8 @@
 #include <map>
 #include <vector>
 #include <string>
-#include "talk/base/asyncpacketsocket.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/asyncpacketsocket.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/portinterface.h"
 #include "talk/p2p/base/portallocator.h"
@@ -66,7 +66,7 @@ class RemoteCandidate : public Candidate {
 // P2PTransportChannel manages the candidates and connection process to keep
 // two P2P clients connected to each other.
 class P2PTransportChannel : public TransportChannelImpl,
-                            public talk_base::MessageHandler {
+                            public rtc::MessageHandler {
  public:
   P2PTransportChannel(const std::string& content_name,
                       int component,
@@ -94,8 +94,8 @@ class P2PTransportChannel : public TransportChannelImpl,
 
   // From TransportChannel:
   virtual int SendPacket(const char *data, size_t len,
-                         const talk_base::PacketOptions& options, int flags);
-  virtual int SetOption(talk_base::Socket::Option opt, int value);
+                         const rtc::PacketOptions& options, int flags);
+  virtual int SetOption(rtc::Socket::Option opt, int value);
   virtual int GetError() { return error_; }
   virtual bool GetStats(std::vector<ConnectionInfo>* stats);
 
@@ -112,11 +112,11 @@ class P2PTransportChannel : public TransportChannelImpl,
   virtual bool IsDtlsActive() const { return false; }
 
   // Default implementation.
-  virtual bool GetSslRole(talk_base::SSLRole* role) const {
+  virtual bool GetSslRole(rtc::SSLRole* role) const {
     return false;
   }
 
-  virtual bool SetSslRole(talk_base::SSLRole role) {
+  virtual bool SetSslRole(rtc::SSLRole role) {
     return false;
   }
 
@@ -131,11 +131,11 @@ class P2PTransportChannel : public TransportChannelImpl,
   }
 
   // Returns false because the channel is not encrypted by default.
-  virtual bool GetLocalIdentity(talk_base::SSLIdentity** identity) const {
+  virtual bool GetLocalIdentity(rtc::SSLIdentity** identity) const {
     return false;
   }
 
-  virtual bool GetRemoteCertificate(talk_base::SSLCertificate** cert) const {
+  virtual bool GetRemoteCertificate(rtc::SSLCertificate** cert) const {
     return false;
   }
 
@@ -150,7 +150,7 @@ class P2PTransportChannel : public TransportChannelImpl,
     return false;
   }
 
-  virtual bool SetLocalIdentity(talk_base::SSLIdentity* identity) {
+  virtual bool SetLocalIdentity(rtc::SSLIdentity* identity) {
     return false;
   }
 
@@ -163,10 +163,10 @@ class P2PTransportChannel : public TransportChannelImpl,
   }
 
   // Helper method used only in unittest.
-  talk_base::DiffServCodePoint DefaultDscpValue() const;
+  rtc::DiffServCodePoint DefaultDscpValue() const;
 
  private:
-  talk_base::Thread* thread() { return worker_thread_; }
+  rtc::Thread* thread() { return worker_thread_; }
   PortAllocatorSession* allocator_session() {
     return allocator_sessions_.back();
   }
@@ -181,7 +181,7 @@ class P2PTransportChannel : public TransportChannelImpl,
   void HandleNotWritable();
   void HandleAllTimedOut();
 
-  Connection* GetBestConnectionOnNetwork(talk_base::Network* network);
+  Connection* GetBestConnectionOnNetwork(rtc::Network* network);
   bool CreateConnections(const Candidate &remote_candidate,
                          PortInterface* origin_port, bool readable);
   bool CreateConnection(PortInterface* port, const Candidate& remote_candidate,
@@ -203,7 +203,7 @@ class P2PTransportChannel : public TransportChannelImpl,
                          const std::vector<Candidate>& candidates);
   void OnCandidatesAllocationDone(PortAllocatorSession* session);
   void OnUnknownAddress(PortInterface* port,
-                        const talk_base::SocketAddress& addr,
+                        const rtc::SocketAddress& addr,
                         ProtocolType proto,
                         IceMessage* stun_msg,
                         const std::string& remote_username,
@@ -213,19 +213,19 @@ class P2PTransportChannel : public TransportChannelImpl,
 
   void OnConnectionStateChange(Connection* connection);
   void OnReadPacket(Connection *connection, const char *data, size_t len,
-                    const talk_base::PacketTime& packet_time);
+                    const rtc::PacketTime& packet_time);
   void OnReadyToSend(Connection* connection);
   void OnConnectionDestroyed(Connection *connection);
 
   void OnUseCandidate(Connection* conn);
 
-  virtual void OnMessage(talk_base::Message *pmsg);
+  virtual void OnMessage(rtc::Message *pmsg);
   void OnSort();
   void OnPing();
 
   P2PTransport* transport_;
   PortAllocator *allocator_;
-  talk_base::Thread *worker_thread_;
+  rtc::Thread *worker_thread_;
   bool incoming_only_;
   bool waiting_for_signaling_;
   int error_;
@@ -239,7 +239,7 @@ class P2PTransportChannel : public TransportChannelImpl,
   std::vector<RemoteCandidate> remote_candidates_;
   bool sort_dirty_;  // indicates whether another sort is needed right now
   bool was_writable_;
-  typedef std::map<talk_base::Socket::Option, int> OptionMap;
+  typedef std::map<rtc::Socket::Option, int> OptionMap;
   OptionMap options_;
   std::string ice_ufrag_;
   std::string ice_pwd_;
diff --git a/p2p/base/p2ptransportchannel_unittest.cc b/p2p/base/p2ptransportchannel_unittest.cc
index f65f502..79796cf 100644
--- a/p2p/base/p2ptransportchannel_unittest.cc
+++ b/p2p/base/p2ptransportchannel_unittest.cc
@@ -25,20 +25,20 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/dscp.h"
-#include "talk/base/fakenetwork.h"
-#include "talk/base/firewallsocketserver.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/natserver.h"
-#include "talk/base/natsocketfactory.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/proxyserver.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/thread.h"
-#include "talk/base/virtualsocketserver.h"
+#include "webrtc/base/dscp.h"
+#include "webrtc/base/fakenetwork.h"
+#include "webrtc/base/firewallsocketserver.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/natserver.h"
+#include "webrtc/base/natsocketfactory.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/proxyserver.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/virtualsocketserver.h"
 #include "talk/p2p/base/p2ptransportchannel.h"
 #include "talk/p2p/base/testrelayserver.h"
 #include "talk/p2p/base/teststunserver.h"
@@ -51,7 +51,7 @@ using cricket::kDefaultStepDelay;
 using cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG;
 using cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET;
 using cricket::ServerAddresses;
-using talk_base::SocketAddress;
+using rtc::SocketAddress;
 
 static const int kDefaultTimeout = 1000;
 static const int kOnlyLocalPorts = cricket::PORTALLOCATOR_DISABLE_STUN |
@@ -129,15 +129,15 @@ static const uint64 kTiebreaker2 = 22222;
 // Note that this class is a base class for use by other tests, who will provide
 // specialized test behavior.
 class P2PTransportChannelTestBase : public testing::Test,
-                                    public talk_base::MessageHandler,
+                                    public rtc::MessageHandler,
                                     public sigslot::has_slots<> {
  public:
   P2PTransportChannelTestBase()
-      : main_(talk_base::Thread::Current()),
-        pss_(new talk_base::PhysicalSocketServer),
-        vss_(new talk_base::VirtualSocketServer(pss_.get())),
-        nss_(new talk_base::NATSocketServer(vss_.get())),
-        ss_(new talk_base::FirewallSocketServer(nss_.get())),
+      : main_(rtc::Thread::Current()),
+        pss_(new rtc::PhysicalSocketServer),
+        vss_(new rtc::VirtualSocketServer(pss_.get())),
+        nss_(new rtc::NATSocketServer(vss_.get())),
+        ss_(new rtc::FirewallSocketServer(nss_.get())),
         ss_scope_(ss_.get()),
         stun_server_(main_, kStunAddr),
         turn_server_(main_, kTurnUdpIntAddr, kTurnUdpExtAddr),
@@ -213,7 +213,7 @@ class P2PTransportChannelTestBase : public testing::Test,
 
     std::string name_;  // TODO - Currently not used.
     std::list<std::string> ch_packets_;
-    talk_base::scoped_ptr<cricket::P2PTransportChannel> ch_;
+    rtc::scoped_ptr<cricket::P2PTransportChannel> ch_;
   };
 
   struct Endpoint {
@@ -249,8 +249,8 @@ class P2PTransportChannelTestBase : public testing::Test,
       allocator_->set_allow_tcp_listen(allow_tcp_listen);
     }
 
-    talk_base::FakeNetworkManager network_manager_;
-    talk_base::scoped_ptr<cricket::BasicPortAllocator> allocator_;
+    rtc::FakeNetworkManager network_manager_;
+    rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
     ChannelData cd1_;
     ChannelData cd2_;
     int signaling_delay_;
@@ -260,7 +260,7 @@ class P2PTransportChannelTestBase : public testing::Test,
     cricket::IceProtocolType protocol_type_;
   };
 
-  struct CandidateData : public talk_base::MessageData {
+  struct CandidateData : public rtc::MessageData {
     CandidateData(cricket::TransportChannel* ch, const cricket::Candidate& c)
         : channel(ch), candidate(c) {
     }
@@ -367,15 +367,15 @@ class P2PTransportChannelTestBase : public testing::Test,
   static const Result kPrflxTcpToLocalTcp;
 
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
-  talk_base::NATSocketServer* nat() { return nss_.get(); }
-  talk_base::FirewallSocketServer* fw() { return ss_.get(); }
+  rtc::NATSocketServer* nat() { return nss_.get(); }
+  rtc::FirewallSocketServer* fw() { return ss_.get(); }
 
   Endpoint* GetEndpoint(int endpoint) {
     if (endpoint == 0) {
@@ -395,10 +395,10 @@ class P2PTransportChannelTestBase : public testing::Test,
   void RemoveAddress(int endpoint, const SocketAddress& addr) {
     GetEndpoint(endpoint)->network_manager_.RemoveInterface(addr);
   }
-  void SetProxy(int endpoint, talk_base::ProxyType type) {
-    talk_base::ProxyInfo info;
+  void SetProxy(int endpoint, rtc::ProxyType type) {
+    rtc::ProxyInfo info;
     info.type = type;
-    info.address = (type == talk_base::PROXY_HTTPS) ?
+    info.address = (type == rtc::PROXY_HTTPS) ?
         kHttpsProxyAddrs[endpoint] : kSocksProxyAddrs[endpoint];
     GetAllocator(endpoint)->set_proxy("unittest/1.0", info);
   }
@@ -428,7 +428,7 @@ class P2PTransportChannelTestBase : public testing::Test,
   }
 
   void Test(const Result& expected) {
-    int32 connect_start = talk_base::Time(), connect_time;
+    int32 connect_start = rtc::Time(), connect_time;
 
     // Create the channels and wait for them to connect.
     CreateChannels(1);
@@ -440,7 +440,7 @@ class P2PTransportChannelTestBase : public testing::Test,
                             ep2_ch1()->writable(),
                             expected.connect_wait,
                             1000);
-    connect_time = talk_base::TimeSince(connect_start);
+    connect_time = rtc::TimeSince(connect_start);
     if (connect_time < expected.connect_wait) {
       LOG(LS_INFO) << "Connect time: " << connect_time << " ms";
     } else {
@@ -452,7 +452,7 @@ class P2PTransportChannelTestBase : public testing::Test,
     // This may take up to 2 seconds.
     if (ep1_ch1()->best_connection() &&
         ep2_ch1()->best_connection()) {
-      int32 converge_start = talk_base::Time(), converge_time;
+      int32 converge_start = rtc::Time(), converge_time;
       int converge_wait = 2000;
       EXPECT_TRUE_WAIT_MARGIN(
           LocalCandidate(ep1_ch1())->type() == expected.local_type &&
@@ -504,7 +504,7 @@ class P2PTransportChannelTestBase : public testing::Test,
         }
       }
 
-      converge_time = talk_base::TimeSince(converge_start);
+      converge_time = rtc::TimeSince(converge_start);
       if (converge_time < converge_wait) {
         LOG(LS_INFO) << "Converge time: " << converge_time << " ms";
       } else {
@@ -657,8 +657,8 @@ class P2PTransportChannelTestBase : public testing::Test,
     main_->PostDelayed(GetEndpoint(ch)->signaling_delay_, this, 0,
                        new CandidateData(ch, c));
   }
-  void OnMessage(talk_base::Message* msg) {
-    talk_base::scoped_ptr<CandidateData> data(
+  void OnMessage(rtc::Message* msg) {
+    rtc::scoped_ptr<CandidateData> data(
         static_cast<CandidateData*>(msg->pdata));
     cricket::P2PTransportChannel* rch = GetRemoteChannel(data->channel);
     cricket::Candidate c = data->candidate;
@@ -673,7 +673,7 @@ class P2PTransportChannelTestBase : public testing::Test,
     rch->OnCandidate(c);
   }
   void OnReadPacket(cricket::TransportChannel* channel, const char* data,
-                    size_t len, const talk_base::PacketTime& packet_time,
+                    size_t len, const rtc::PacketTime& packet_time,
                     int flags) {
     std::list<std::string>& packets = GetPacketList(channel);
     packets.push_front(std::string(data, len));
@@ -687,7 +687,7 @@ class P2PTransportChannelTestBase : public testing::Test,
   }
   int SendData(cricket::TransportChannel* channel,
                const char* data, size_t len) {
-    talk_base::PacketOptions options;
+    rtc::PacketOptions options;
     return channel->SendPacket(data, len, options, 0);
   }
   bool CheckDataOnChannel(cricket::TransportChannel* channel,
@@ -739,17 +739,17 @@ class P2PTransportChannelTestBase : public testing::Test,
   }
 
  private:
-  talk_base::Thread* main_;
-  talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
-  talk_base::scoped_ptr<talk_base::VirtualSocketServer> vss_;
-  talk_base::scoped_ptr<talk_base::NATSocketServer> nss_;
-  talk_base::scoped_ptr<talk_base::FirewallSocketServer> ss_;
-  talk_base::SocketServerScope ss_scope_;
+  rtc::Thread* main_;
+  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
+  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
+  rtc::scoped_ptr<rtc::NATSocketServer> nss_;
+  rtc::scoped_ptr<rtc::FirewallSocketServer> ss_;
+  rtc::SocketServerScope ss_scope_;
   cricket::TestStunServer stun_server_;
   cricket::TestTurnServer turn_server_;
   cricket::TestRelayServer relay_server_;
-  talk_base::SocksProxyServer socks_server1_;
-  talk_base::SocksProxyServer socks_server2_;
+  rtc::SocksProxyServer socks_server1_;
+  rtc::SocksProxyServer socks_server2_;
   Endpoint ep1_;
   Endpoint ep2_;
   bool clear_remote_candidates_ufrag_pwd_;
@@ -814,13 +814,13 @@ class P2PTransportChannelTest : public P2PTransportChannelTestBase {
     GetEndpoint(0)->allocator_.reset(
         new cricket::BasicPortAllocator(&(GetEndpoint(0)->network_manager_),
         stun_servers,
-        talk_base::SocketAddress(), talk_base::SocketAddress(),
-        talk_base::SocketAddress()));
+        rtc::SocketAddress(), rtc::SocketAddress(),
+        rtc::SocketAddress()));
     GetEndpoint(1)->allocator_.reset(
         new cricket::BasicPortAllocator(&(GetEndpoint(1)->network_manager_),
         stun_servers,
-        talk_base::SocketAddress(), talk_base::SocketAddress(),
-        talk_base::SocketAddress()));
+        rtc::SocketAddress(), rtc::SocketAddress(),
+        rtc::SocketAddress()));
 
     cricket::RelayServerConfig relay_server(cricket::RELAY_GTURN);
     if (type == cricket::ICEPROTO_RFC5245) {
@@ -860,7 +860,7 @@ class P2PTransportChannelTest : public P2PTransportChannelTestBase {
         AddAddress(endpoint, kPrivateAddrs[endpoint]);
         // Add a single NAT of the desired type
         nat()->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
-            static_cast<talk_base::NATType>(config - NAT_FULL_CONE))->
+            static_cast<rtc::NATType>(config - NAT_FULL_CONE))->
             AddClient(kPrivateAddrs[endpoint]);
         break;
       case NAT_DOUBLE_CONE:
@@ -869,9 +869,9 @@ class P2PTransportChannelTest : public P2PTransportChannelTestBase {
         // Add a two cascaded NATs of the desired types
         nat()->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
             (config == NAT_DOUBLE_CONE) ?
-                talk_base::NAT_OPEN_CONE : talk_base::NAT_SYMMETRIC)->
+                rtc::NAT_OPEN_CONE : rtc::NAT_SYMMETRIC)->
             AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
-                talk_base::NAT_OPEN_CONE)->
+                rtc::NAT_OPEN_CONE)->
                 AddClient(kCascadedPrivateAddrs[endpoint]);
         break;
       case BLOCK_UDP:
@@ -881,34 +881,34 @@ class P2PTransportChannelTest : public P2PTransportChannelTestBase {
       case PROXY_SOCKS:
         AddAddress(endpoint, kPublicAddrs[endpoint]);
         // Block all UDP
-        fw()->AddRule(false, talk_base::FP_UDP, talk_base::FD_ANY,
+        fw()->AddRule(false, rtc::FP_UDP, rtc::FD_ANY,
                       kPublicAddrs[endpoint]);
         if (config == BLOCK_UDP_AND_INCOMING_TCP) {
           // Block TCP inbound to the endpoint
-          fw()->AddRule(false, talk_base::FP_TCP, SocketAddress(),
+          fw()->AddRule(false, rtc::FP_TCP, SocketAddress(),
                         kPublicAddrs[endpoint]);
         } else if (config == BLOCK_ALL_BUT_OUTGOING_HTTP) {
           // Block all TCP to/from the endpoint except 80/443 out
-          fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
-                        SocketAddress(talk_base::IPAddress(INADDR_ANY), 80));
-          fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
-                        SocketAddress(talk_base::IPAddress(INADDR_ANY), 443));
-          fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
+          fw()->AddRule(true, rtc::FP_TCP, kPublicAddrs[endpoint],
+                        SocketAddress(rtc::IPAddress(INADDR_ANY), 80));
+          fw()->AddRule(true, rtc::FP_TCP, kPublicAddrs[endpoint],
+                        SocketAddress(rtc::IPAddress(INADDR_ANY), 443));
+          fw()->AddRule(false, rtc::FP_TCP, rtc::FD_ANY,
                         kPublicAddrs[endpoint]);
         } else if (config == PROXY_HTTPS) {
           // Block all TCP to/from the endpoint except to the proxy server
-          fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
+          fw()->AddRule(true, rtc::FP_TCP, kPublicAddrs[endpoint],
                         kHttpsProxyAddrs[endpoint]);
-          fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
+          fw()->AddRule(false, rtc::FP_TCP, rtc::FD_ANY,
                         kPublicAddrs[endpoint]);
-          SetProxy(endpoint, talk_base::PROXY_HTTPS);
+          SetProxy(endpoint, rtc::PROXY_HTTPS);
         } else if (config == PROXY_SOCKS) {
           // Block all TCP to/from the endpoint except to the proxy server
-          fw()->AddRule(true, talk_base::FP_TCP, kPublicAddrs[endpoint],
+          fw()->AddRule(true, rtc::FP_TCP, kPublicAddrs[endpoint],
                         kSocksProxyAddrs[endpoint]);
-          fw()->AddRule(false, talk_base::FP_TCP, talk_base::FD_ANY,
+          fw()->AddRule(false, rtc::FP_TCP, rtc::FD_ANY,
                         kPublicAddrs[endpoint]);
-          SetProxy(endpoint, talk_base::PROXY_SOCKS5);
+          SetProxy(endpoint, rtc::PROXY_SOCKS5);
         }
         break;
       default:
@@ -1310,7 +1310,7 @@ TEST_F(P2PTransportChannelTest, IncomingOnlyBlocked) {
   ep1_ch1()->set_incoming_only(true);
 
   // Pump for 1 second and verify that the channels are not connected.
-  talk_base::Thread::Current()->ProcessMessages(1000);
+  rtc::Thread::Current()->ProcessMessages(1000);
 
   EXPECT_FALSE(ep1_ch1()->readable());
   EXPECT_FALSE(ep1_ch1()->writable());
@@ -1514,25 +1514,25 @@ TEST_F(P2PTransportChannelTest, TestDefaultDscpValue) {
   AddAddress(1, kPublicAddrs[1]);
 
   CreateChannels(1);
-  EXPECT_EQ(talk_base::DSCP_NO_CHANGE,
+  EXPECT_EQ(rtc::DSCP_NO_CHANGE,
             GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
-  EXPECT_EQ(talk_base::DSCP_NO_CHANGE,
+  EXPECT_EQ(rtc::DSCP_NO_CHANGE,
             GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
   GetEndpoint(0)->cd1_.ch_->SetOption(
-      talk_base::Socket::OPT_DSCP, talk_base::DSCP_CS6);
+      rtc::Socket::OPT_DSCP, rtc::DSCP_CS6);
   GetEndpoint(1)->cd1_.ch_->SetOption(
-      talk_base::Socket::OPT_DSCP, talk_base::DSCP_CS6);
-  EXPECT_EQ(talk_base::DSCP_CS6,
+      rtc::Socket::OPT_DSCP, rtc::DSCP_CS6);
+  EXPECT_EQ(rtc::DSCP_CS6,
             GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
-  EXPECT_EQ(talk_base::DSCP_CS6,
+  EXPECT_EQ(rtc::DSCP_CS6,
             GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
   GetEndpoint(0)->cd1_.ch_->SetOption(
-      talk_base::Socket::OPT_DSCP, talk_base::DSCP_AF41);
+      rtc::Socket::OPT_DSCP, rtc::DSCP_AF41);
   GetEndpoint(1)->cd1_.ch_->SetOption(
-      talk_base::Socket::OPT_DSCP, talk_base::DSCP_AF41);
-  EXPECT_EQ(talk_base::DSCP_AF41,
+      rtc::Socket::OPT_DSCP, rtc::DSCP_AF41);
+  EXPECT_EQ(rtc::DSCP_AF41,
             GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
-  EXPECT_EQ(talk_base::DSCP_AF41,
+  EXPECT_EQ(rtc::DSCP_AF41,
             GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
 }
 
@@ -1608,13 +1608,13 @@ class P2PTransportChannelSameNatTest : public P2PTransportChannelTestBase {
  protected:
   void ConfigureEndpoints(Config nat_type, Config config1, Config config2) {
     ASSERT(nat_type >= NAT_FULL_CONE && nat_type <= NAT_SYMMETRIC);
-    talk_base::NATSocketServer::Translator* outer_nat =
+    rtc::NATSocketServer::Translator* outer_nat =
         nat()->AddTranslator(kPublicAddrs[0], kNatAddrs[0],
-            static_cast<talk_base::NATType>(nat_type - NAT_FULL_CONE));
+            static_cast<rtc::NATType>(nat_type - NAT_FULL_CONE));
     ConfigureEndpoint(outer_nat, 0, config1);
     ConfigureEndpoint(outer_nat, 1, config2);
   }
-  void ConfigureEndpoint(talk_base::NATSocketServer::Translator* nat,
+  void ConfigureEndpoint(rtc::NATSocketServer::Translator* nat,
                          int endpoint, Config config) {
     ASSERT(config <= NAT_SYMMETRIC);
     if (config == OPEN) {
@@ -1623,7 +1623,7 @@ class P2PTransportChannelSameNatTest : public P2PTransportChannelTestBase {
     } else {
       AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]);
       nat->AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
-          static_cast<talk_base::NATType>(config - NAT_FULL_CONE))->AddClient(
+          static_cast<rtc::NATType>(config - NAT_FULL_CONE))->AddClient(
               kCascadedPrivateAddrs[endpoint]);
     }
   }
@@ -1673,7 +1673,7 @@ TEST_F(P2PTransportChannelMultihomedTest, TestFailover) {
 
   // Blackhole any traffic to or from the public addrs.
   LOG(LS_INFO) << "Failing over...";
-  fw()->AddRule(false, talk_base::FP_ANY, talk_base::FD_ANY,
+  fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY,
                 kPublicAddrs[1]);
 
   // We should detect loss of connectivity within 5 seconds or so.
diff --git a/p2p/base/packetsocketfactory.h b/p2p/base/packetsocketfactory.h
index e985b37..6b82682 100644
--- a/p2p/base/packetsocketfactory.h
+++ b/p2p/base/packetsocketfactory.h
@@ -28,9 +28,9 @@
 #ifndef TALK_BASE_PACKETSOCKETFACTORY_H_
 #define TALK_BASE_PACKETSOCKETFACTORY_H_
 
-#include "talk/base/proxyinfo.h"
+#include "webrtc/base/proxyinfo.h"
 
-namespace talk_base {
+namespace rtc {
 
 class AsyncPacketSocket;
 class AsyncResolverInterface;
@@ -64,6 +64,6 @@ class PacketSocketFactory {
   DISALLOW_EVIL_CONSTRUCTORS(PacketSocketFactory);
 };
 
-}  // namespace talk_base
+}  // namespace rtc
 
 #endif  // TALK_BASE_PACKETSOCKETFACTORY_H_
diff --git a/p2p/base/parsing.cc b/p2p/base/parsing.cc
index ebe0596..1d7bf3e 100644
--- a/p2p/base/parsing.cc
+++ b/p2p/base/parsing.cc
@@ -29,7 +29,7 @@
 
 #include <algorithm>
 #include <stdlib.h>
-#include "talk/base/stringutils.h"
+#include "webrtc/base/stringutils.h"
 
 namespace {
 static const char kTrue[] = "true";
diff --git a/p2p/base/parsing.h b/p2p/base/parsing.h
index c820056..fc6862d 100644
--- a/p2p/base/parsing.h
+++ b/p2p/base/parsing.h
@@ -30,8 +30,8 @@
 
 #include <string>
 #include <vector>
-#include "talk/base/basictypes.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/xmllite/xmlelement.h"  // Needed to delete ParseError.extra.
 
 namespace cricket {
@@ -97,7 +97,7 @@ bool GetXmlAttr(const buzz::XmlElement* elem,
     return false;
   }
   std::string unparsed = elem->Attr(name);
-  return talk_base::FromString(unparsed, val_out);
+  return rtc::FromString(unparsed, val_out);
 }
 
 template <class T>
@@ -116,7 +116,7 @@ template <class T>
 bool AddXmlAttr(buzz::XmlElement* elem,
                 const buzz::QName& name, const T& val) {
   std::string buf;
-  if (!talk_base::ToString(val, &buf)) {
+  if (!rtc::ToString(val, &buf)) {
     return false;
   }
   elem->AddAttr(name, buf);
@@ -126,7 +126,7 @@ bool AddXmlAttr(buzz::XmlElement* elem,
 template <class T>
 bool SetXmlBody(buzz::XmlElement* elem, const T& val) {
   std::string buf;
-  if (!talk_base::ToString(val, &buf)) {
+  if (!rtc::ToString(val, &buf)) {
     return false;
   }
   elem->SetBodyText(buf);
diff --git a/p2p/base/port.cc b/p2p/base/port.cc
index cf0f203..0d3a5cd 100644
--- a/p2p/base/port.cc
+++ b/p2p/base/port.cc
@@ -30,14 +30,14 @@
 #include <algorithm>
 #include <vector>
 
-#include "talk/base/base64.h"
-#include "talk/base/crc32.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/messagedigest.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/base64.h"
+#include "webrtc/base/crc32.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/messagedigest.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/p2p/base/common.h"
 
 namespace {
@@ -81,7 +81,7 @@ std::string GetRtcpUfragFromRtpUfrag(const std::string& rtp_ufrag) {
   }
   // Change the last character to the one next to it in the base64 table.
   char new_last_char;
-  if (!talk_base::Base64::GetNextBase64Char(rtp_ufrag[rtp_ufrag.size() - 1],
+  if (!rtc::Base64::GetNextBase64Char(rtp_ufrag[rtp_ufrag.size() - 1],
                                             &new_last_char)) {
     // Should not be here.
     ASSERT(false);
@@ -103,7 +103,7 @@ const uint32 DEFAULT_RTT = MAXIMUM_RTT;
 
 // Computes our estimate of the RTT given the current estimate.
 inline uint32 ConservativeRTTEstimate(uint32 rtt) {
-  return talk_base::_max(MINIMUM_RTT, talk_base::_min(MAXIMUM_RTT, 2 * rtt));
+  return rtc::_max(MINIMUM_RTT, rtc::_min(MAXIMUM_RTT, 2 * rtt));
 }
 
 // Weighting of the old rtt value to new data.
@@ -156,14 +156,14 @@ bool StringToProto(const char* value, ProtocolType* proto) {
 static std::string ComputeFoundation(
     const std::string& type,
     const std::string& protocol,
-    const talk_base::SocketAddress& base_address) {
+    const rtc::SocketAddress& base_address) {
   std::ostringstream ost;
   ost << type << base_address.ipaddr().ToString() << protocol;
-  return talk_base::ToString<uint32>(talk_base::ComputeCrc32(ost.str()));
+  return rtc::ToString<uint32>(rtc::ComputeCrc32(ost.str()));
 }
 
-Port::Port(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
-           talk_base::Network* network, const talk_base::IPAddress& ip,
+Port::Port(rtc::Thread* thread, rtc::PacketSocketFactory* factory,
+           rtc::Network* network, const rtc::IPAddress& ip,
            const std::string& username_fragment, const std::string& password)
     : thread_(thread),
       factory_(factory),
@@ -185,9 +185,9 @@ Port::Port(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
   Construct();
 }
 
-Port::Port(talk_base::Thread* thread, const std::string& type,
-           talk_base::PacketSocketFactory* factory,
-           talk_base::Network* network, const talk_base::IPAddress& ip,
+Port::Port(rtc::Thread* thread, const std::string& type,
+           rtc::PacketSocketFactory* factory,
+           rtc::Network* network, const rtc::IPAddress& ip,
            int min_port, int max_port, const std::string& username_fragment,
            const std::string& password)
     : thread_(thread),
@@ -216,8 +216,8 @@ void Port::Construct() {
   // If the username_fragment and password are empty, we should just create one.
   if (ice_username_fragment_.empty()) {
     ASSERT(password_.empty());
-    ice_username_fragment_ = talk_base::CreateRandomString(ICE_UFRAG_LENGTH);
-    password_ = talk_base::CreateRandomString(ICE_PWD_LENGTH);
+    ice_username_fragment_ = rtc::CreateRandomString(ICE_UFRAG_LENGTH);
+    password_ = rtc::CreateRandomString(ICE_PWD_LENGTH);
   }
   LOG_J(LS_INFO, this) << "Port created";
 }
@@ -238,7 +238,7 @@ Port::~Port() {
     delete list[i];
 }
 
-Connection* Port::GetConnection(const talk_base::SocketAddress& remote_addr) {
+Connection* Port::GetConnection(const rtc::SocketAddress& remote_addr) {
   AddressMap::const_iterator iter = connections_.find(remote_addr);
   if (iter != connections_.end())
     return iter->second;
@@ -246,9 +246,9 @@ Connection* Port::GetConnection(const talk_base::SocketAddress& remote_addr) {
     return NULL;
 }
 
-void Port::AddAddress(const talk_base::SocketAddress& address,
-                      const talk_base::SocketAddress& base_address,
-                      const talk_base::SocketAddress& related_address,
+void Port::AddAddress(const rtc::SocketAddress& address,
+                      const rtc::SocketAddress& base_address,
+                      const rtc::SocketAddress& related_address,
                       const std::string& protocol,
                       const std::string& type,
                       uint32 type_preference,
@@ -257,16 +257,16 @@ void Port::AddAddress(const talk_base::SocketAddress& address,
              type, type_preference, 0, final);
 }
 
-void Port::AddAddress(const talk_base::SocketAddress& address,
-                      const talk_base::SocketAddress& base_address,
-                      const talk_base::SocketAddress& related_address,
+void Port::AddAddress(const rtc::SocketAddress& address,
+                      const rtc::SocketAddress& base_address,
+                      const rtc::SocketAddress& related_address,
                       const std::string& protocol,
                       const std::string& type,
                       uint32 type_preference,
                       uint32 relay_preference,
                       bool final) {
   Candidate c;
-  c.set_id(talk_base::CreateRandomString(8));
+  c.set_id(rtc::CreateRandomString(8));
   c.set_component(component_);
   c.set_type(type);
   c.set_protocol(protocol);
@@ -294,7 +294,7 @@ void Port::AddConnection(Connection* conn) {
 }
 
 void Port::OnReadPacket(
-    const char* data, size_t size, const talk_base::SocketAddress& addr,
+    const char* data, size_t size, const rtc::SocketAddress& addr,
     ProtocolType proto) {
   // If the user has enabled port packets, just hand this over.
   if (enable_port_packets_) {
@@ -304,7 +304,7 @@ void Port::OnReadPacket(
 
   // If this is an authenticated STUN request, then signal unknown address and
   // send back a proper binding response.
-  talk_base::scoped_ptr<IceMessage> msg;
+  rtc::scoped_ptr<IceMessage> msg;
   std::string remote_username;
   if (!GetStunMessage(data, size, addr, msg.accept(), &remote_username)) {
     LOG_J(LS_ERROR, this) << "Received non-STUN packet from unknown address ("
@@ -358,7 +358,7 @@ bool Port::IsHybridIce() const {
 }
 
 bool Port::GetStunMessage(const char* data, size_t size,
-                          const talk_base::SocketAddress& addr,
+                          const rtc::SocketAddress& addr,
                           IceMessage** out_msg, std::string* out_username) {
   // NOTE: This could clearly be optimized to avoid allocating any memory.
   //       However, at the data rates we'll be looking at on the client side,
@@ -376,8 +376,8 @@ bool Port::GetStunMessage(const char* data, size_t size,
 
   // Parse the request message.  If the packet is not a complete and correct
   // STUN message, then ignore it.
-  talk_base::scoped_ptr<IceMessage> stun_msg(new IceMessage());
-  talk_base::ByteBuffer buf(data, size);
+  rtc::scoped_ptr<IceMessage> stun_msg(new IceMessage());
+  rtc::ByteBuffer buf(data, size);
   if (!stun_msg->Read(&buf) || (buf.Length() > 0)) {
     return false;
   }
@@ -465,7 +465,7 @@ bool Port::GetStunMessage(const char* data, size_t size,
   return true;
 }
 
-bool Port::IsCompatibleAddress(const talk_base::SocketAddress& addr) {
+bool Port::IsCompatibleAddress(const rtc::SocketAddress& addr) {
   int family = ip().family();
   // We use single-stack sockets, so families must match.
   if (addr.family() != family) {
@@ -524,7 +524,7 @@ bool Port::ParseStunUsername(const StunMessage* stun_msg,
 }
 
 bool Port::MaybeIceRoleConflict(
-    const talk_base::SocketAddress& addr, IceMessage* stun_msg,
+    const rtc::SocketAddress& addr, IceMessage* stun_msg,
     const std::string& remote_ufrag) {
   // Validate ICE_CONTROLLING or ICE_CONTROLLED attributes.
   bool ret = true;
@@ -596,7 +596,7 @@ void Port::CreateStunUsername(const std::string& remote_username,
 }
 
 void Port::SendBindingResponse(StunMessage* request,
-                               const talk_base::SocketAddress& addr) {
+                               const rtc::SocketAddress& addr) {
   ASSERT(request->type() == STUN_BINDING_REQUEST);
 
   // Retrieve the username from the request.
@@ -642,9 +642,9 @@ void Port::SendBindingResponse(StunMessage* request,
   }
 
   // Send the response message.
-  talk_base::ByteBuffer buf;
+  rtc::ByteBuffer buf;
   response.Write(&buf);
-  talk_base::PacketOptions options(DefaultDscpValue());
+  rtc::PacketOptions options(DefaultDscpValue());
   if (SendTo(buf.Data(), buf.Length(), addr, options, false) < 0) {
     LOG_J(LS_ERROR, this) << "Failed to send STUN ping response to "
                           << addr.ToSensitiveString();
@@ -659,7 +659,7 @@ void Port::SendBindingResponse(StunMessage* request,
 }
 
 void Port::SendBindingErrorResponse(StunMessage* request,
-                                    const talk_base::SocketAddress& addr,
+                                    const rtc::SocketAddress& addr,
                                     int error_code, const std::string& reason) {
   ASSERT(request->type() == STUN_BINDING_REQUEST);
 
@@ -697,15 +697,15 @@ void Port::SendBindingErrorResponse(StunMessage* request,
   }
 
   // Send the response message.
-  talk_base::ByteBuffer buf;
+  rtc::ByteBuffer buf;
   response.Write(&buf);
-  talk_base::PacketOptions options(DefaultDscpValue());
+  rtc::PacketOptions options(DefaultDscpValue());
   SendTo(buf.Data(), buf.Length(), addr, options, false);
   LOG_J(LS_INFO, this) << "Sending STUN binding error: reason=" << reason
                        << " to " << addr.ToSensitiveString();
 }
 
-void Port::OnMessage(talk_base::Message *pmsg) {
+void Port::OnMessage(rtc::Message *pmsg) {
   ASSERT(pmsg->message_id == MSG_CHECKTIMEOUT);
   CheckTimeout();
 }
@@ -899,9 +899,9 @@ uint64 Connection::priority() const {
       g = remote_candidate_.priority();
       d = local_candidate().priority();
     }
-    priority = talk_base::_min(g, d);
+    priority = rtc::_min(g, d);
     priority = priority << 32;
-    priority += 2 * talk_base::_max(g, d) + (g > d ? 1 : 0);
+    priority += 2 * rtc::_max(g, d) + (g > d ? 1 : 0);
   }
   return priority;
 }
@@ -948,7 +948,7 @@ void Connection::set_use_candidate_attr(bool enable) {
 
 void Connection::OnSendStunPacket(const void* data, size_t size,
                                   StunRequest* req) {
-  talk_base::PacketOptions options(port_->DefaultDscpValue());
+  rtc::PacketOptions options(port_->DefaultDscpValue());
   if (port_->SendTo(data, size, remote_candidate_.address(),
                     options, false) < 0) {
     LOG_J(LS_WARNING, this) << "Failed to send STUN ping " << req->id();
@@ -956,10 +956,10 @@ void Connection::OnSendStunPacket(const void* data, size_t size,
 }
 
 void Connection::OnReadPacket(
-  const char* data, size_t size, const talk_base::PacketTime& packet_time) {
-  talk_base::scoped_ptr<IceMessage> msg;
+  const char* data, size_t size, const rtc::PacketTime& packet_time) {
+  rtc::scoped_ptr<IceMessage> msg;
   std::string remote_ufrag;
-  const talk_base::SocketAddress& addr(remote_candidate_.address());
+  const rtc::SocketAddress& addr(remote_candidate_.address());
   if (!port_->GetStunMessage(data, size, addr, msg.accept(), &remote_ufrag)) {
     // The packet did not parse as a valid STUN message
 
@@ -968,7 +968,7 @@ void Connection::OnReadPacket(
       // readable means data from this address is acceptable
       // Send it on!
 
-      last_data_received_ = talk_base::Time();
+      last_data_received_ = rtc::Time();
       recv_rate_tracker_.Update(size);
       SignalReadPacket(this, data, size, packet_time);
 
@@ -1091,7 +1091,7 @@ void Connection::UpdateState(uint32 now) {
   std::string pings;
   for (size_t i = 0; i < pings_since_last_response_.size(); ++i) {
     char buf[32];
-    talk_base::sprintfn(buf, sizeof(buf), "%u",
+    rtc::sprintfn(buf, sizeof(buf), "%u",
         pings_since_last_response_[i]);
     pings.append(buf).append(" ");
   }
@@ -1176,7 +1176,7 @@ void Connection::Ping(uint32 now) {
 }
 
 void Connection::ReceivedPing() {
-  last_ping_received_ = talk_base::Time();
+  last_ping_received_ = rtc::Time();
   set_read_state(STATE_READABLE);
 }
 
@@ -1251,21 +1251,21 @@ void Connection::OnConnectionRequestResponse(ConnectionRequest* request,
   std::string pings;
   for (size_t i = 0; i < pings_since_last_response_.size(); ++i) {
     char buf[32];
-    talk_base::sprintfn(buf, sizeof(buf), "%u",
+    rtc::sprintfn(buf, sizeof(buf), "%u",
         pings_since_last_response_[i]);
     pings.append(buf).append(" ");
   }
 
-  talk_base::LoggingSeverity level =
+  rtc::LoggingSeverity level =
       (pings_since_last_response_.size() > CONNECTION_WRITE_CONNECT_FAILURES) ?
-          talk_base::LS_INFO : talk_base::LS_VERBOSE;
+          rtc::LS_INFO : rtc::LS_VERBOSE;
 
   LOG_JV(level, this) << "Received STUN ping response " << request->id()
                       << ", pings_since_last_response_=" << pings
                       << ", rtt=" << rtt;
 
   pings_since_last_response_.clear();
-  last_ping_response_received_ = talk_base::Time();
+  last_ping_response_received_ = rtc::Time();
   rtt_ = (RTT_RATIO * rtt_ + rtt) / (RTT_RATIO + 1);
 
   // Peer reflexive candidate is only for RFC 5245 ICE.
@@ -1307,8 +1307,8 @@ void Connection::OnConnectionRequestErrorResponse(ConnectionRequest* request,
 
 void Connection::OnConnectionRequestTimeout(ConnectionRequest* request) {
   // Log at LS_INFO if we miss a ping on a writable connection.
-  talk_base::LoggingSeverity sev = (write_state_ == STATE_WRITABLE) ?
-      talk_base::LS_INFO : talk_base::LS_VERBOSE;
+  rtc::LoggingSeverity sev = (write_state_ == STATE_WRITABLE) ?
+      rtc::LS_INFO : rtc::LS_VERBOSE;
   LOG_JV(sev, this) << "Timing-out STUN ping " << request->id()
                     << " after " << request->Elapsed() << " ms";
 }
@@ -1330,7 +1330,7 @@ void Connection::HandleRoleConflictFromPeer() {
   port_->SignalRoleConflict(port_);
 }
 
-void Connection::OnMessage(talk_base::Message *pmsg) {
+void Connection::OnMessage(rtc::Message *pmsg) {
   ASSERT(pmsg->message_id == MSG_DELETE);
 
   LOG_J(LS_INFO, this) << "Connection deleted";
@@ -1393,7 +1393,7 @@ void Connection::MaybeAddPrflxCandidate(ConnectionRequest* request,
     return;
   }
   const uint32 priority = priority_attr->value();
-  std::string id = talk_base::CreateRandomString(8);
+  std::string id = rtc::CreateRandomString(8);
 
   Candidate new_local_candidate;
   new_local_candidate.set_id(id);
@@ -1424,7 +1424,7 @@ ProxyConnection::ProxyConnection(Port* port, size_t index,
 }
 
 int ProxyConnection::Send(const void* data, size_t size,
-                          const talk_base::PacketOptions& options) {
+                          const rtc::PacketOptions& options) {
   if (write_state_ == STATE_WRITE_INIT || write_state_ == STATE_WRITE_TIMEOUT) {
     error_ = EWOULDBLOCK;
     return SOCKET_ERROR;
diff --git a/p2p/base/port.h b/p2p/base/port.h
index 9613264..0071a03 100644
--- a/p2p/base/port.h
+++ b/p2p/base/port.h
@@ -33,13 +33,13 @@
 #include <map>
 #include <set>
 
-#include "talk/base/asyncpacketsocket.h"
-#include "talk/base/network.h"
-#include "talk/base/proxyinfo.h"
-#include "talk/base/ratetracker.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/asyncpacketsocket.h"
+#include "webrtc/base/network.h"
+#include "webrtc/base/proxyinfo.h"
+#include "webrtc/base/ratetracker.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/packetsocketfactory.h"
 #include "talk/p2p/base/portinterface.h"
@@ -100,36 +100,36 @@ const char* ProtoToString(ProtocolType proto);
 bool StringToProto(const char* value, ProtocolType* proto);
 
 struct ProtocolAddress {
-  talk_base::SocketAddress address;
+  rtc::SocketAddress address;
   ProtocolType proto;
   bool secure;
 
-  ProtocolAddress(const talk_base::SocketAddress& a, ProtocolType p)
+  ProtocolAddress(const rtc::SocketAddress& a, ProtocolType p)
       : address(a), proto(p), secure(false) { }
-  ProtocolAddress(const talk_base::SocketAddress& a, ProtocolType p, bool sec)
+  ProtocolAddress(const rtc::SocketAddress& a, ProtocolType p, bool sec)
       : address(a), proto(p), secure(sec) { }
 };
 
-typedef std::set<talk_base::SocketAddress> ServerAddresses;
+typedef std::set<rtc::SocketAddress> ServerAddresses;
 
 // Represents a local communication mechanism that can be used to create
 // connections to similar mechanisms of the other client.  Subclasses of this
 // one add support for specific mechanisms like local UDP ports.
-class Port : public PortInterface, public talk_base::MessageHandler,
+class Port : public PortInterface, public rtc::MessageHandler,
              public sigslot::has_slots<> {
  public:
-  Port(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
-       talk_base::Network* network, const talk_base::IPAddress& ip,
+  Port(rtc::Thread* thread, rtc::PacketSocketFactory* factory,
+       rtc::Network* network, const rtc::IPAddress& ip,
        const std::string& username_fragment, const std::string& password);
-  Port(talk_base::Thread* thread, const std::string& type,
-       talk_base::PacketSocketFactory* factory,
-       talk_base::Network* network, const talk_base::IPAddress& ip,
+  Port(rtc::Thread* thread, const std::string& type,
+       rtc::PacketSocketFactory* factory,
+       rtc::Network* network, const rtc::IPAddress& ip,
        int min_port, int max_port, const std::string& username_fragment,
        const std::string& password);
   virtual ~Port();
 
   virtual const std::string& Type() const { return type_; }
-  virtual talk_base::Network* Network() const { return network_; }
+  virtual rtc::Network* Network() const { return network_; }
 
   // This method will set the flag which enables standard ICE/STUN procedures
   // in STUN connectivity checks. Currently this method does
@@ -151,11 +151,11 @@ class Port : public PortInterface, public talk_base::MessageHandler,
   virtual bool SharedSocket() const { return shared_socket_; }
 
   // The thread on which this port performs its I/O.
-  talk_base::Thread* thread() { return thread_; }
+  rtc::Thread* thread() { return thread_; }
 
   // The factory used to create the sockets of this port.
-  talk_base::PacketSocketFactory* socket_factory() const { return factory_; }
-  void set_socket_factory(talk_base::PacketSocketFactory* factory) {
+  rtc::PacketSocketFactory* socket_factory() const { return factory_; }
+  void set_socket_factory(rtc::PacketSocketFactory* factory) {
     factory_ = factory;
   }
 
@@ -217,12 +217,12 @@ class Port : public PortInterface, public talk_base::MessageHandler,
 
   // Returns a map containing all of the connections of this port, keyed by the
   // remote address.
-  typedef std::map<talk_base::SocketAddress, Connection*> AddressMap;
+  typedef std::map<rtc::SocketAddress, Connection*> AddressMap;
   const AddressMap& connections() { return connections_; }
 
   // Returns the connection to the given address or NULL if none exists.
   virtual Connection* GetConnection(
-      const talk_base::SocketAddress& remote_addr);
+      const rtc::SocketAddress& remote_addr);
 
   // Called each time a connection is created.
   sigslot::signal2<Port*, Connection*> SignalConnectionCreated;
@@ -232,9 +232,9 @@ class Port : public PortInterface, public talk_base::MessageHandler,
   // port implemented this method.
   // TODO(mallinath) - Make it pure virtual.
   virtual bool HandleIncomingPacket(
-      talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      const talk_base::PacketTime& packet_time) {
+      rtc::AsyncPacketSocket* socket, const char* data, size_t size,
+      const rtc::SocketAddress& remote_addr,
+      const rtc::PacketTime& packet_time) {
     ASSERT(false);
     return false;
   }
@@ -243,29 +243,29 @@ class Port : public PortInterface, public talk_base::MessageHandler,
   // these methods should be called as a response to SignalUnknownAddress.
   // NOTE: You MUST call CreateConnection BEFORE SendBindingResponse.
   virtual void SendBindingResponse(StunMessage* request,
-                                   const talk_base::SocketAddress& addr);
+                                   const rtc::SocketAddress& addr);
   virtual void SendBindingErrorResponse(
-      StunMessage* request, const talk_base::SocketAddress& addr,
+      StunMessage* request, const rtc::SocketAddress& addr,
       int error_code, const std::string& reason);
 
   void set_proxy(const std::string& user_agent,
-                 const talk_base::ProxyInfo& proxy) {
+                 const rtc::ProxyInfo& proxy) {
     user_agent_ = user_agent;
     proxy_ = proxy;
   }
   const std::string& user_agent() { return user_agent_; }
-  const talk_base::ProxyInfo& proxy() { return proxy_; }
+  const rtc::ProxyInfo& proxy() { return proxy_; }
 
   virtual void EnablePortPackets();
 
   // Called if the port has no connections and is no longer useful.
   void Destroy();
 
-  virtual void OnMessage(talk_base::Message *pmsg);
+  virtual void OnMessage(rtc::Message *pmsg);
 
   // Debugging description of this port
   virtual std::string ToString() const;
-  talk_base::IPAddress& ip() { return ip_; }
+  rtc::IPAddress& ip() { return ip_; }
   int min_port() { return min_port_; }
   int max_port() { return max_port_; }
 
@@ -281,7 +281,7 @@ class Port : public PortInterface, public talk_base::MessageHandler,
   void CreateStunUsername(const std::string& remote_username,
                           std::string* stun_username_attr_str) const;
 
-  bool MaybeIceRoleConflict(const talk_base::SocketAddress& addr,
+  bool MaybeIceRoleConflict(const rtc::SocketAddress& addr,
                             IceMessage* stun_msg,
                             const std::string& remote_ufrag);
 
@@ -309,15 +309,15 @@ class Port : public PortInterface, public talk_base::MessageHandler,
 
   void set_type(const std::string& type) { type_ = type; }
   // Fills in the local address of the port.
-  void AddAddress(const talk_base::SocketAddress& address,
-                  const talk_base::SocketAddress& base_address,
-                  const talk_base::SocketAddress& related_address,
+  void AddAddress(const rtc::SocketAddress& address,
+                  const rtc::SocketAddress& base_address,
+                  const rtc::SocketAddress& related_address,
                   const std::string& protocol, const std::string& type,
                   uint32 type_preference, bool final);
 
-  void AddAddress(const talk_base::SocketAddress& address,
-                  const talk_base::SocketAddress& base_address,
-                  const talk_base::SocketAddress& related_address,
+  void AddAddress(const rtc::SocketAddress& address,
+                  const rtc::SocketAddress& base_address,
+                  const rtc::SocketAddress& related_address,
                   const std::string& protocol, const std::string& type,
                   uint32 type_preference, uint32 relay_preference, bool final);
 
@@ -328,7 +328,7 @@ class Port : public PortInterface, public talk_base::MessageHandler,
   // currently a connection.  If this is an authenticated STUN binding request,
   // then we will signal the client.
   void OnReadPacket(const char* data, size_t size,
-                    const talk_base::SocketAddress& addr,
+                    const rtc::SocketAddress& addr,
                     ProtocolType proto);
 
   // If the given data comprises a complete and correct STUN message then the
@@ -337,16 +337,16 @@ class Port : public PortInterface, public talk_base::MessageHandler,
   // message.  Otherwise, the function may send a STUN response internally.
   // remote_username contains the remote fragment of the STUN username.
   bool GetStunMessage(const char* data, size_t size,
-                      const talk_base::SocketAddress& addr,
+                      const rtc::SocketAddress& addr,
                       IceMessage** out_msg, std::string* out_username);
 
   // Checks if the address in addr is compatible with the port's ip.
-  bool IsCompatibleAddress(const talk_base::SocketAddress& addr);
+  bool IsCompatibleAddress(const rtc::SocketAddress& addr);
 
   // Returns default DSCP value.
-  talk_base::DiffServCodePoint DefaultDscpValue() const {
+  rtc::DiffServCodePoint DefaultDscpValue() const {
     // No change from what MediaChannel set.
-    return talk_base::DSCP_NO_CHANGE;
+    return rtc::DSCP_NO_CHANGE;
   }
 
  private:
@@ -357,12 +357,12 @@ class Port : public PortInterface, public talk_base::MessageHandler,
   // Checks if this port is useless, and hence, should be destroyed.
   void CheckTimeout();
 
-  talk_base::Thread* thread_;
-  talk_base::PacketSocketFactory* factory_;
+  rtc::Thread* thread_;
+  rtc::PacketSocketFactory* factory_;
   std::string type_;
   bool send_retransmit_count_attribute_;
-  talk_base::Network* network_;
-  talk_base::IPAddress ip_;
+  rtc::Network* network_;
+  rtc::IPAddress ip_;
   int min_port_;
   int max_port_;
   std::string content_name_;
@@ -388,14 +388,14 @@ class Port : public PortInterface, public talk_base::MessageHandler,
   bool shared_socket_;
   // Information to use when going through a proxy.
   std::string user_agent_;
-  talk_base::ProxyInfo proxy_;
+  rtc::ProxyInfo proxy_;
 
   friend class Connection;
 };
 
 // Represents a communication link between a port on the local client and a
 // port on the remote client.
-class Connection : public talk_base::MessageHandler,
+class Connection : public rtc::MessageHandler,
     public sigslot::has_slots<> {
  public:
   // States are from RFC 5245. http://tools.ietf.org/html/rfc5245#section-5.7.4
@@ -461,19 +461,19 @@ class Connection : public talk_base::MessageHandler,
   // the interface of AsyncPacketSocket, which may use UDP or TCP under the
   // covers.
   virtual int Send(const void* data, size_t size,
-                   const talk_base::PacketOptions& options) = 0;
+                   const rtc::PacketOptions& options) = 0;
 
   // Error if Send() returns < 0
   virtual int GetError() = 0;
 
   sigslot::signal4<Connection*, const char*, size_t,
-                   const talk_base::PacketTime&> SignalReadPacket;
+                   const rtc::PacketTime&> SignalReadPacket;
 
   sigslot::signal1<Connection*> SignalReadyToSend;
 
   // Called when a packet is received on this connection.
   void OnReadPacket(const char* data, size_t size,
-                    const talk_base::PacketTime& packet_time);
+                    const rtc::PacketTime& packet_time);
 
   // Called when the socket is currently able to send.
   void OnReadyToSend();
@@ -549,7 +549,7 @@ class Connection : public talk_base::MessageHandler,
   // Checks if this connection is useless, and hence, should be destroyed.
   void CheckTimeout();
 
-  void OnMessage(talk_base::Message *pmsg);
+  void OnMessage(rtc::Message *pmsg);
 
   Port* port_;
   size_t local_candidate_index_;
@@ -573,8 +573,8 @@ class Connection : public talk_base::MessageHandler,
   uint32 last_ping_response_received_;
   std::vector<uint32> pings_since_last_response_;
 
-  talk_base::RateTracker recv_rate_tracker_;
-  talk_base::RateTracker send_rate_tracker_;
+  rtc::RateTracker recv_rate_tracker_;
+  rtc::RateTracker send_rate_tracker_;
 
  private:
   void MaybeAddPrflxCandidate(ConnectionRequest* request,
@@ -593,7 +593,7 @@ class ProxyConnection : public Connection {
   ProxyConnection(Port* port, size_t index, const Candidate& candidate);
 
   virtual int Send(const void* data, size_t size,
-                   const talk_base::PacketOptions& options);
+                   const rtc::PacketOptions& options);
   virtual int GetError() { return error_; }
 
  private:
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index f4f9935..e4f37a9 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -25,19 +25,19 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/crc32.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/natserver.h"
-#include "talk/base/natsocketfactory.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
-#include "talk/base/virtualsocketserver.h"
+#include "webrtc/base/crc32.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/natserver.h"
+#include "webrtc/base/natsocketfactory.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/virtualsocketserver.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/portproxy.h"
 #include "talk/p2p/base/relayport.h"
@@ -49,24 +49,24 @@
 #include "talk/p2p/base/transport.h"
 #include "talk/p2p/base/turnport.h"
 
-using talk_base::AsyncPacketSocket;
-using talk_base::ByteBuffer;
-using talk_base::NATType;
-using talk_base::NAT_OPEN_CONE;
-using talk_base::NAT_ADDR_RESTRICTED;
-using talk_base::NAT_PORT_RESTRICTED;
-using talk_base::NAT_SYMMETRIC;
-using talk_base::PacketSocketFactory;
-using talk_base::scoped_ptr;
-using talk_base::Socket;
-using talk_base::SocketAddress;
+using rtc::AsyncPacketSocket;
+using rtc::ByteBuffer;
+using rtc::NATType;
+using rtc::NAT_OPEN_CONE;
+using rtc::NAT_ADDR_RESTRICTED;
+using rtc::NAT_PORT_RESTRICTED;
+using rtc::NAT_SYMMETRIC;
+using rtc::PacketSocketFactory;
+using rtc::scoped_ptr;
+using rtc::Socket;
+using rtc::SocketAddress;
 using namespace cricket;
 
 static const int kTimeout = 1000;
 static const SocketAddress kLocalAddr1("192.168.1.2", 0);
 static const SocketAddress kLocalAddr2("192.168.1.3", 0);
-static const SocketAddress kNatAddr1("77.77.77.77", talk_base::NAT_SERVER_PORT);
-static const SocketAddress kNatAddr2("88.88.88.88", talk_base::NAT_SERVER_PORT);
+static const SocketAddress kNatAddr1("77.77.77.77", rtc::NAT_SERVER_PORT);
+static const SocketAddress kNatAddr2("88.88.88.88", rtc::NAT_SERVER_PORT);
 static const SocketAddress kStunAddr("99.99.99.1", STUN_SERVER_PORT);
 static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000);
 static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001);
@@ -117,9 +117,9 @@ static bool WriteStunMessage(const StunMessage* msg, ByteBuffer* buf) {
 // Stub port class for testing STUN generation and processing.
 class TestPort : public Port {
  public:
-  TestPort(talk_base::Thread* thread, const std::string& type,
-           talk_base::PacketSocketFactory* factory, talk_base::Network* network,
-           const talk_base::IPAddress& ip, int min_port, int max_port,
+  TestPort(rtc::Thread* thread, const std::string& type,
+           rtc::PacketSocketFactory* factory, rtc::Network* network,
+           const rtc::IPAddress& ip, int min_port, int max_port,
            const std::string& username_fragment, const std::string& password)
       : Port(thread, type, factory, network, ip,
              min_port, max_port, username_fragment, password) {
@@ -145,22 +145,22 @@ class TestPort : public Port {
   }
 
   virtual void PrepareAddress() {
-    talk_base::SocketAddress addr(ip(), min_port());
-    AddAddress(addr, addr, talk_base::SocketAddress(), "udp", Type(),
+    rtc::SocketAddress addr(ip(), min_port());
+    AddAddress(addr, addr, rtc::SocketAddress(), "udp", Type(),
                ICE_TYPE_PREFERENCE_HOST, true);
   }
 
   // Exposed for testing candidate building.
-  void AddCandidateAddress(const talk_base::SocketAddress& addr) {
-    AddAddress(addr, addr, talk_base::SocketAddress(), "udp", Type(),
+  void AddCandidateAddress(const rtc::SocketAddress& addr) {
+    AddAddress(addr, addr, rtc::SocketAddress(), "udp", Type(),
                type_preference_, false);
   }
-  void AddCandidateAddress(const talk_base::SocketAddress& addr,
-                           const talk_base::SocketAddress& base_address,
+  void AddCandidateAddress(const rtc::SocketAddress& addr,
+                           const rtc::SocketAddress& base_address,
                            const std::string& type,
                            int type_preference,
                            bool final) {
-    AddAddress(addr, base_address, talk_base::SocketAddress(), "udp", type,
+    AddAddress(addr, base_address, rtc::SocketAddress(), "udp", type,
                type_preference, final);
   }
 
@@ -174,8 +174,8 @@ class TestPort : public Port {
     return conn;
   }
   virtual int SendTo(
-      const void* data, size_t size, const talk_base::SocketAddress& addr,
-      const talk_base::PacketOptions& options, bool payload) {
+      const void* data, size_t size, const rtc::SocketAddress& addr,
+      const rtc::PacketOptions& options, bool payload) {
     if (!payload) {
       IceMessage* msg = new IceMessage;
       ByteBuffer* buf = new ByteBuffer(static_cast<const char*>(data), size);
@@ -191,10 +191,10 @@ class TestPort : public Port {
     }
     return static_cast<int>(size);
   }
-  virtual int SetOption(talk_base::Socket::Option opt, int value) {
+  virtual int SetOption(rtc::Socket::Option opt, int value) {
     return 0;
   }
-  virtual int GetOption(talk_base::Socket::Option opt, int* value) {
+  virtual int GetOption(rtc::Socket::Option opt, int* value) {
     return -1;
   }
   virtual int GetError() {
@@ -209,8 +209,8 @@ class TestPort : public Port {
   }
 
  private:
-  talk_base::scoped_ptr<ByteBuffer> last_stun_buf_;
-  talk_base::scoped_ptr<IceMessage> last_stun_msg_;
+  rtc::scoped_ptr<ByteBuffer> last_stun_buf_;
+  rtc::scoped_ptr<IceMessage> last_stun_msg_;
   int type_preference_;
 };
 
@@ -319,13 +319,13 @@ class TestChannel : public sigslot::has_slots<> {
 
  private:
   IceMode ice_mode_;
-  talk_base::scoped_ptr<Port> src_;
+  rtc::scoped_ptr<Port> src_;
   Port* dst_;
 
   int complete_count_;
   Connection* conn_;
   SocketAddress remote_address_;
-  talk_base::scoped_ptr<StunMessage> remote_request_;
+  rtc::scoped_ptr<StunMessage> remote_request_;
   std::string remote_frag_;
   bool nominated_;
 };
@@ -333,12 +333,12 @@ class TestChannel : public sigslot::has_slots<> {
 class PortTest : public testing::Test, public sigslot::has_slots<> {
  public:
   PortTest()
-      : main_(talk_base::Thread::Current()),
-        pss_(new talk_base::PhysicalSocketServer),
-        ss_(new talk_base::VirtualSocketServer(pss_.get())),
+      : main_(rtc::Thread::Current()),
+        pss_(new rtc::PhysicalSocketServer),
+        ss_(new rtc::VirtualSocketServer(pss_.get())),
         ss_scope_(ss_.get()),
-        network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY), 32),
-        socket_factory_(talk_base::Thread::Current()),
+        network_("unittest", "unittest", rtc::IPAddress(INADDR_ANY), 32),
+        socket_factory_(rtc::Thread::Current()),
         nat_factory1_(ss_.get(), kNatAddr1),
         nat_factory2_(ss_.get(), kNatAddr2),
         nat_socket_factory1_(&nat_factory1_),
@@ -348,21 +348,21 @@ class PortTest : public testing::Test, public sigslot::has_slots<> {
         relay_server_(main_, kRelayUdpIntAddr, kRelayUdpExtAddr,
                       kRelayTcpIntAddr, kRelayTcpExtAddr,
                       kRelaySslTcpIntAddr, kRelaySslTcpExtAddr),
-        username_(talk_base::CreateRandomString(ICE_UFRAG_LENGTH)),
-        password_(talk_base::CreateRandomString(ICE_PWD_LENGTH)),
+        username_(rtc::CreateRandomString(ICE_UFRAG_LENGTH)),
+        password_(rtc::CreateRandomString(ICE_PWD_LENGTH)),
         ice_protocol_(cricket::ICEPROTO_GOOGLE),
         role_conflict_(false),
         destroyed_(false) {
-    network_.AddIP(talk_base::IPAddress(INADDR_ANY));
+    network_.AddIP(rtc::IPAddress(INADDR_ANY));
   }
 
  protected:
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
 
@@ -452,7 +452,7 @@ class PortTest : public testing::Test, public sigslot::has_slots<> {
     return port;
   }
   StunPort* CreateStunPort(const SocketAddress& addr,
-                           talk_base::PacketSocketFactory* factory) {
+                           rtc::PacketSocketFactory* factory) {
     ServerAddresses stun_servers;
     stun_servers.insert(kStunAddr);
     StunPort* port = StunPort::Create(main_, factory, &network_,
@@ -478,7 +478,7 @@ class PortTest : public testing::Test, public sigslot::has_slots<> {
   TurnPort* CreateTurnPort(const SocketAddress& addr,
                            PacketSocketFactory* socket_factory,
                            ProtocolType int_proto, ProtocolType ext_proto,
-                           const talk_base::SocketAddress& server_addr) {
+                           const rtc::SocketAddress& server_addr) {
     TurnPort* port = TurnPort::Create(main_, socket_factory, &network_,
                                       addr.ipaddr(), 0, 0,
                                       username_, password_, ProtocolAddress(
@@ -504,9 +504,9 @@ class PortTest : public testing::Test, public sigslot::has_slots<> {
     port->SetIceProtocolType(ice_protocol_);
     return port;
   }
-  talk_base::NATServer* CreateNatServer(const SocketAddress& addr,
-                                        talk_base::NATType type) {
-    return new talk_base::NATServer(type, ss_.get(), addr, ss_.get(), addr);
+  rtc::NATServer* CreateNatServer(const SocketAddress& addr,
+                                        rtc::NATType type) {
+    return new rtc::NATServer(type, ss_.get(), addr, ss_.get(), addr);
   }
   static const char* StunName(NATType type) {
     switch (type) {
@@ -565,7 +565,7 @@ class PortTest : public testing::Test, public sigslot::has_slots<> {
         new StunByteStringAttribute(STUN_ATTR_USERNAME, username));
     return msg;
   }
-  TestPort* CreateTestPort(const talk_base::SocketAddress& addr,
+  TestPort* CreateTestPort(const rtc::SocketAddress& addr,
                            const std::string& username,
                            const std::string& password) {
     TestPort* port =  new TestPort(main_, "test", &socket_factory_, &network_,
@@ -573,7 +573,7 @@ class PortTest : public testing::Test, public sigslot::has_slots<> {
     port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
     return port;
   }
-  TestPort* CreateTestPort(const talk_base::SocketAddress& addr,
+  TestPort* CreateTestPort(const rtc::SocketAddress& addr,
                            const std::string& username,
                            const std::string& password,
                            cricket::IceProtocolType type,
@@ -600,23 +600,23 @@ class PortTest : public testing::Test, public sigslot::has_slots<> {
   }
   bool destroyed() const { return destroyed_; }
 
-  talk_base::BasicPacketSocketFactory* nat_socket_factory1() {
+  rtc::BasicPacketSocketFactory* nat_socket_factory1() {
     return &nat_socket_factory1_;
   }
 
  private:
-  talk_base::Thread* main_;
-  talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
-  talk_base::scoped_ptr<talk_base::VirtualSocketServer> ss_;
-  talk_base::SocketServerScope ss_scope_;
-  talk_base::Network network_;
-  talk_base::BasicPacketSocketFactory socket_factory_;
-  talk_base::scoped_ptr<talk_base::NATServer> nat_server1_;
-  talk_base::scoped_ptr<talk_base::NATServer> nat_server2_;
-  talk_base::NATSocketFactory nat_factory1_;
-  talk_base::NATSocketFactory nat_factory2_;
-  talk_base::BasicPacketSocketFactory nat_socket_factory1_;
-  talk_base::BasicPacketSocketFactory nat_socket_factory2_;
+  rtc::Thread* main_;
+  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
+  rtc::scoped_ptr<rtc::VirtualSocketServer> ss_;
+  rtc::SocketServerScope ss_scope_;
+  rtc::Network network_;
+  rtc::BasicPacketSocketFactory socket_factory_;
+  rtc::scoped_ptr<rtc::NATServer> nat_server1_;
+  rtc::scoped_ptr<rtc::NATServer> nat_server2_;
+  rtc::NATSocketFactory nat_factory1_;
+  rtc::NATSocketFactory nat_factory2_;
+  rtc::BasicPacketSocketFactory nat_socket_factory1_;
+  rtc::BasicPacketSocketFactory nat_socket_factory2_;
   TestStunServer stun_server_;
   TestTurnServer turn_server_;
   TestRelayServer relay_server_;
@@ -781,7 +781,7 @@ void PortTest::ConnectAndDisconnectChannels(TestChannel* ch1,
   ch2->Stop();
 }
 
-class FakePacketSocketFactory : public talk_base::PacketSocketFactory {
+class FakePacketSocketFactory : public rtc::PacketSocketFactory {
  public:
   FakePacketSocketFactory()
       : next_udp_socket_(NULL),
@@ -811,7 +811,7 @@ class FakePacketSocketFactory : public talk_base::PacketSocketFactory {
   // per-factory and not when socket is created.
   virtual AsyncPacketSocket* CreateClientTcpSocket(
       const SocketAddress& local_address, const SocketAddress& remote_address,
-      const talk_base::ProxyInfo& proxy_info,
+      const rtc::ProxyInfo& proxy_info,
       const std::string& user_agent, int opts) {
     EXPECT_TRUE(next_client_tcp_socket_ != NULL);
     AsyncPacketSocket* result = next_client_tcp_socket_;
@@ -828,7 +828,7 @@ class FakePacketSocketFactory : public talk_base::PacketSocketFactory {
   void set_next_client_tcp_socket(AsyncPacketSocket* next_client_tcp_socket) {
     next_client_tcp_socket_ = next_client_tcp_socket;
   }
-  talk_base::AsyncResolverInterface* CreateAsyncResolver() {
+  rtc::AsyncResolverInterface* CreateAsyncResolver() {
     return NULL;
   }
 
@@ -853,11 +853,11 @@ class FakeAsyncPacketSocket : public AsyncPacketSocket {
 
   // Send a packet.
   virtual int Send(const void *pv, size_t cb,
-                   const talk_base::PacketOptions& options) {
+                   const rtc::PacketOptions& options) {
     return static_cast<int>(cb);
   }
   virtual int SendTo(const void *pv, size_t cb, const SocketAddress& addr,
-                     const talk_base::PacketOptions& options) {
+                     const rtc::PacketOptions& options) {
     return static_cast<int>(cb);
   }
   virtual int Close() {
@@ -1097,7 +1097,7 @@ TEST_F(PortTest, TestLocalToLocalAsIce) {
 // should remain equal to the request generated by the port and role of port
 // must be in controlling.
 TEST_F(PortTest, TestLoopbackCallAsIce) {
-  talk_base::scoped_ptr<TestPort> lport(
+  rtc::scoped_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->SetIceProtocolType(ICEPROTO_RFC5245);
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
@@ -1113,7 +1113,7 @@ TEST_F(PortTest, TestLoopbackCallAsIce) {
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   conn->OnReadPacket(lport->last_stun_buf()->Data(),
                      lport->last_stun_buf()->Length(),
-                     talk_base::PacketTime());
+                     rtc::PacketTime());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
@@ -1130,7 +1130,7 @@ TEST_F(PortTest, TestLoopbackCallAsIce) {
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
-  talk_base::scoped_ptr<IceMessage> modified_req(
+  rtc::scoped_ptr<IceMessage> modified_req(
       CreateStunMessage(STUN_BINDING_REQUEST));
   const StunByteStringAttribute* username_attr = msg->GetByteString(
       STUN_ATTR_USERNAME);
@@ -1144,9 +1144,9 @@ TEST_F(PortTest, TestLoopbackCallAsIce) {
   modified_req->AddFingerprint();
 
   lport->Reset();
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
   WriteStunMessage(modified_req.get(), buf.get());
-  conn1->OnReadPacket(buf->Data(), buf->Length(), talk_base::PacketTime());
+  conn1->OnReadPacket(buf->Data(), buf->Length(), rtc::PacketTime());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
@@ -1158,12 +1158,12 @@ TEST_F(PortTest, TestLoopbackCallAsIce) {
 // value of tiebreaker, when it receives ping request from |rport| it will
 // send role conflict signal.
 TEST_F(PortTest, TestIceRoleConflict) {
-  talk_base::scoped_ptr<TestPort> lport(
+  rtc::scoped_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->SetIceProtocolType(ICEPROTO_RFC5245);
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
-  talk_base::scoped_ptr<TestPort> rport(
+  rtc::scoped_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->SetIceProtocolType(ICEPROTO_RFC5245);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLING);
@@ -1185,7 +1185,7 @@ TEST_F(PortTest, TestIceRoleConflict) {
   // Send rport binding request to lport.
   lconn->OnReadPacket(rport->last_stun_buf()->Data(),
                       rport->last_stun_buf()->Length(),
-                      talk_base::PacketTime());
+                      rtc::PacketTime());
 
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
@@ -1195,7 +1195,7 @@ TEST_F(PortTest, TestIceRoleConflict) {
 TEST_F(PortTest, TestTcpNoDelay) {
   TCPPort* port1 = CreateTcpPort(kLocalAddr1);
   int option_value = -1;
-  int success = port1->GetOption(talk_base::Socket::OPT_NODELAY,
+  int success = port1->GetOption(rtc::Socket::OPT_NODELAY,
                                  &option_value);
   ASSERT_EQ(0, success);  // GetOption() should complete successfully w/ 0
   ASSERT_EQ(1, option_value);
@@ -1298,43 +1298,43 @@ TEST_F(PortTest, TestSkipCrossFamilyUdp) {
 // get through DefaultDscpValue.
 TEST_F(PortTest, TestDefaultDscpValue) {
   int dscp;
-  talk_base::scoped_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1));
-  EXPECT_EQ(0, udpport->SetOption(talk_base::Socket::OPT_DSCP,
-                                  talk_base::DSCP_CS6));
-  EXPECT_EQ(0, udpport->GetOption(talk_base::Socket::OPT_DSCP, &dscp));
-  talk_base::scoped_ptr<TCPPort> tcpport(CreateTcpPort(kLocalAddr1));
-  EXPECT_EQ(0, tcpport->SetOption(talk_base::Socket::OPT_DSCP,
-                                 talk_base::DSCP_AF31));
-  EXPECT_EQ(0, tcpport->GetOption(talk_base::Socket::OPT_DSCP, &dscp));
-  EXPECT_EQ(talk_base::DSCP_AF31, dscp);
-  talk_base::scoped_ptr<StunPort> stunport(
+  rtc::scoped_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1));
+  EXPECT_EQ(0, udpport->SetOption(rtc::Socket::OPT_DSCP,
+                                  rtc::DSCP_CS6));
+  EXPECT_EQ(0, udpport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+  rtc::scoped_ptr<TCPPort> tcpport(CreateTcpPort(kLocalAddr1));
+  EXPECT_EQ(0, tcpport->SetOption(rtc::Socket::OPT_DSCP,
+                                 rtc::DSCP_AF31));
+  EXPECT_EQ(0, tcpport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+  EXPECT_EQ(rtc::DSCP_AF31, dscp);
+  rtc::scoped_ptr<StunPort> stunport(
       CreateStunPort(kLocalAddr1, nat_socket_factory1()));
-  EXPECT_EQ(0, stunport->SetOption(talk_base::Socket::OPT_DSCP,
-                                  talk_base::DSCP_AF41));
-  EXPECT_EQ(0, stunport->GetOption(talk_base::Socket::OPT_DSCP, &dscp));
-  EXPECT_EQ(talk_base::DSCP_AF41, dscp);
-  talk_base::scoped_ptr<TurnPort> turnport1(CreateTurnPort(
+  EXPECT_EQ(0, stunport->SetOption(rtc::Socket::OPT_DSCP,
+                                  rtc::DSCP_AF41));
+  EXPECT_EQ(0, stunport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+  EXPECT_EQ(rtc::DSCP_AF41, dscp);
+  rtc::scoped_ptr<TurnPort> turnport1(CreateTurnPort(
       kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   // Socket is created in PrepareAddress.
   turnport1->PrepareAddress();
-  EXPECT_EQ(0, turnport1->SetOption(talk_base::Socket::OPT_DSCP,
-                                  talk_base::DSCP_CS7));
-  EXPECT_EQ(0, turnport1->GetOption(talk_base::Socket::OPT_DSCP, &dscp));
-  EXPECT_EQ(talk_base::DSCP_CS7, dscp);
+  EXPECT_EQ(0, turnport1->SetOption(rtc::Socket::OPT_DSCP,
+                                  rtc::DSCP_CS7));
+  EXPECT_EQ(0, turnport1->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+  EXPECT_EQ(rtc::DSCP_CS7, dscp);
   // This will verify correct value returned without the socket.
-  talk_base::scoped_ptr<TurnPort> turnport2(CreateTurnPort(
+  rtc::scoped_ptr<TurnPort> turnport2(CreateTurnPort(
       kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
-  EXPECT_EQ(0, turnport2->SetOption(talk_base::Socket::OPT_DSCP,
-                                  talk_base::DSCP_CS6));
-  EXPECT_EQ(0, turnport2->GetOption(talk_base::Socket::OPT_DSCP, &dscp));
-  EXPECT_EQ(talk_base::DSCP_CS6, dscp);
+  EXPECT_EQ(0, turnport2->SetOption(rtc::Socket::OPT_DSCP,
+                                  rtc::DSCP_CS6));
+  EXPECT_EQ(0, turnport2->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+  EXPECT_EQ(rtc::DSCP_CS6, dscp);
 }
 
 // Test sending STUN messages in GICE format.
 TEST_F(PortTest, TestSendStunMessageAsGice) {
-  talk_base::scoped_ptr<TestPort> lport(
+  rtc::scoped_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
-  talk_base::scoped_ptr<TestPort> rport(
+  rtc::scoped_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   lport->SetIceProtocolType(ICEPROTO_GOOGLE);
   rport->SetIceProtocolType(ICEPROTO_GOOGLE);
@@ -1362,7 +1362,7 @@ TEST_F(PortTest, TestSendStunMessageAsGice) {
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_FINGERPRINT) == NULL);
 
   // Save a copy of the BINDING-REQUEST for use below.
-  talk_base::scoped_ptr<IceMessage> request(CopyStunMessage(msg));
+  rtc::scoped_ptr<IceMessage> request(CopyStunMessage(msg));
 
   // Respond with a BINDING-RESPONSE.
   rport->SendBindingResponse(request.get(), lport->Candidates()[0].address());
@@ -1409,9 +1409,9 @@ TEST_F(PortTest, TestSendStunMessageAsGice) {
 
 // Test sending STUN messages in ICE format.
 TEST_F(PortTest, TestSendStunMessageAsIce) {
-  talk_base::scoped_ptr<TestPort> lport(
+  rtc::scoped_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
-  talk_base::scoped_ptr<TestPort> rport(
+  rtc::scoped_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   lport->SetIceProtocolType(ICEPROTO_RFC5245);
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
@@ -1460,7 +1460,7 @@ TEST_F(PortTest, TestSendStunMessageAsIce) {
   ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == NULL);
 
   // Save a copy of the BINDING-REQUEST for use below.
-  talk_base::scoped_ptr<IceMessage> request(CopyStunMessage(msg));
+  rtc::scoped_ptr<IceMessage> request(CopyStunMessage(msg));
 
   // Respond with a BINDING-RESPONSE.
   rport->SendBindingResponse(request.get(), lport->Candidates()[0].address());
@@ -1551,9 +1551,9 @@ TEST_F(PortTest, TestSendStunMessageAsIce) {
 }
 
 TEST_F(PortTest, TestUseCandidateAttribute) {
-  talk_base::scoped_ptr<TestPort> lport(
+  rtc::scoped_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
-  talk_base::scoped_ptr<TestPort> rport(
+  rtc::scoped_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   lport->SetIceProtocolType(ICEPROTO_RFC5245);
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
@@ -1582,13 +1582,13 @@ TEST_F(PortTest, TestUseCandidateAttribute) {
 // Test handling STUN messages in GICE format.
 TEST_F(PortTest, TestHandleStunMessageAsGice) {
   // Our port will act as the "remote" port.
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   port->SetIceProtocolType(ICEPROTO_GOOGLE);
 
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid GICE username and no M-I.
@@ -1649,13 +1649,13 @@ TEST_F(PortTest, TestHandleStunMessageAsGice) {
 // Test handling STUN messages in ICE format.
 TEST_F(PortTest, TestHandleStunMessageAsIce) {
   // Our port will act as the "remote" port.
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   port->SetIceProtocolType(ICEPROTO_RFC5245);
 
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid ICE username,
@@ -1702,13 +1702,13 @@ TEST_F(PortTest, TestHandleStunMessageAsIce) {
 // ICEPROTO_RFC5245 mode after successfully handling the message.
 TEST_F(PortTest, TestHandleStunMessageAsIceInHybridMode) {
   // Our port will act as the "remote" port.
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   port->SetIceProtocolType(ICEPROTO_HYBRID);
 
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid ICE username,
@@ -1729,13 +1729,13 @@ TEST_F(PortTest, TestHandleStunMessageAsIceInHybridMode) {
 // ICEPROTO_GOOGLE mode after successfully handling the message.
 TEST_F(PortTest, TestHandleStunMessageAsGiceInHybridMode) {
   // Our port will act as the "remote" port.
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   port->SetIceProtocolType(ICEPROTO_HYBRID);
 
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid GICE username and no M-I.
@@ -1753,13 +1753,13 @@ TEST_F(PortTest, TestHandleStunMessageAsGiceInHybridMode) {
 // in that mode.
 TEST_F(PortTest, TestHandleStunMessageAsGiceInIceMode) {
   // Our port will act as the "remote" port.
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   port->SetIceProtocolType(ICEPROTO_RFC5245);
 
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid GICE username and no M-I.
@@ -1775,13 +1775,13 @@ TEST_F(PortTest, TestHandleStunMessageAsGiceInIceMode) {
 
 // Tests handling of GICE binding requests with missing or incorrect usernames.
 TEST_F(PortTest, TestHandleStunMessageAsGiceBadUsername) {
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   port->SetIceProtocolType(ICEPROTO_GOOGLE);
 
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST with no username.
@@ -1834,13 +1834,13 @@ TEST_F(PortTest, TestHandleStunMessageAsGiceBadUsername) {
 
 // Tests handling of ICE binding requests with missing or incorrect usernames.
 TEST_F(PortTest, TestHandleStunMessageAsIceBadUsername) {
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   port->SetIceProtocolType(ICEPROTO_RFC5245);
 
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST with no username.
@@ -1904,13 +1904,13 @@ TEST_F(PortTest, TestHandleStunMessageAsIceBadUsername) {
 // Test handling STUN messages (as ICE) with missing or malformed M-I.
 TEST_F(PortTest, TestHandleStunMessageAsIceBadMessageIntegrity) {
   // Our port will act as the "remote" port.
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   port->SetIceProtocolType(ICEPROTO_RFC5245);
 
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid ICE username and
@@ -1946,13 +1946,13 @@ TEST_F(PortTest, TestHandleStunMessageAsIceBadMessageIntegrity) {
 // Test handling STUN messages (as ICE) with missing or malformed FINGERPRINT.
 TEST_F(PortTest, TestHandleStunMessageAsIceBadFingerprint) {
   // Our port will act as the "remote" port.
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   port->SetIceProtocolType(ICEPROTO_RFC5245);
 
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   // BINDING-REQUEST from local to remote with valid ICE username and
@@ -2013,16 +2013,16 @@ TEST_F(PortTest, TestHandleStunMessageAsIceBadFingerprint) {
 // Test handling of STUN binding indication messages (as ICE). STUN binding
 // indications are allowed only to the connection which is in read mode.
 TEST_F(PortTest, TestHandleStunBindingIndication) {
-  talk_base::scoped_ptr<TestPort> lport(
+  rtc::scoped_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr2, "lfrag", "lpass"));
   lport->SetIceProtocolType(ICEPROTO_RFC5245);
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
 
   // Verifying encoding and decoding STUN indication message.
-  talk_base::scoped_ptr<IceMessage> in_msg, out_msg;
-  talk_base::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
-  talk_base::SocketAddress addr(kLocalAddr1);
+  rtc::scoped_ptr<IceMessage> in_msg, out_msg;
+  rtc::scoped_ptr<ByteBuffer> buf(new ByteBuffer());
+  rtc::SocketAddress addr(kLocalAddr1);
   std::string username;
 
   in_msg.reset(CreateStunMessage(STUN_BINDING_INDICATION));
@@ -2036,7 +2036,7 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
 
   // Verify connection can handle STUN indication and updates
   // last_ping_received.
-  talk_base::scoped_ptr<TestPort> rport(
+  rtc::scoped_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->SetIceProtocolType(ICEPROTO_RFC5245);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
@@ -2059,21 +2059,21 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
   // Send rport binding request to lport.
   lconn->OnReadPacket(rport->last_stun_buf()->Data(),
                       rport->last_stun_buf()->Length(),
-                      talk_base::PacketTime());
+                      rtc::PacketTime());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
   uint32 last_ping_received1 = lconn->last_ping_received();
 
   // Adding a delay of 100ms.
-  talk_base::Thread::Current()->ProcessMessages(100);
+  rtc::Thread::Current()->ProcessMessages(100);
   // Pinging lconn using stun indication message.
-  lconn->OnReadPacket(buf->Data(), buf->Length(), talk_base::PacketTime());
+  lconn->OnReadPacket(buf->Data(), buf->Length(), rtc::PacketTime());
   uint32 last_ping_received2 = lconn->last_ping_received();
   EXPECT_GT(last_ping_received2, last_ping_received1);
 }
 
 TEST_F(PortTest, TestComputeCandidatePriority) {
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr1, "name", "pass"));
   port->set_type_preference(90);
   port->set_component(177);
@@ -2109,13 +2109,13 @@ TEST_F(PortTest, TestComputeCandidatePriority) {
 }
 
 TEST_F(PortTest, TestPortProxyProperties) {
-  talk_base::scoped_ptr<TestPort> port(
+  rtc::scoped_ptr<TestPort> port(
       CreateTestPort(kLocalAddr1, "name", "pass"));
   port->SetIceRole(cricket::ICEROLE_CONTROLLING);
   port->SetIceTiebreaker(kTiebreaker1);
 
   // Create a proxy port.
-  talk_base::scoped_ptr<PortProxy> proxy(new PortProxy());
+  rtc::scoped_ptr<PortProxy> proxy(new PortProxy());
   proxy->set_impl(port.get());
   EXPECT_EQ(port->Type(), proxy->Type());
   EXPECT_EQ(port->Network(), proxy->Network());
@@ -2126,7 +2126,7 @@ TEST_F(PortTest, TestPortProxyProperties) {
 // In the case of shared socket, one port may be shared by local and stun.
 // Test that candidates with different types will have different foundation.
 TEST_F(PortTest, TestFoundation) {
-  talk_base::scoped_ptr<TestPort> testport(
+  rtc::scoped_ptr<TestPort> testport(
       CreateTestPort(kLocalAddr1, "name", "pass"));
   testport->AddCandidateAddress(kLocalAddr1, kLocalAddr1,
                                 LOCAL_PORT_TYPE,
@@ -2140,21 +2140,21 @@ TEST_F(PortTest, TestFoundation) {
 
 // This test verifies the foundation of different types of ICE candidates.
 TEST_F(PortTest, TestCandidateFoundation) {
-  talk_base::scoped_ptr<talk_base::NATServer> nat_server(
+  rtc::scoped_ptr<rtc::NATServer> nat_server(
       CreateNatServer(kNatAddr1, NAT_OPEN_CONE));
-  talk_base::scoped_ptr<UDPPort> udpport1(CreateUdpPort(kLocalAddr1));
+  rtc::scoped_ptr<UDPPort> udpport1(CreateUdpPort(kLocalAddr1));
   udpport1->PrepareAddress();
-  talk_base::scoped_ptr<UDPPort> udpport2(CreateUdpPort(kLocalAddr1));
+  rtc::scoped_ptr<UDPPort> udpport2(CreateUdpPort(kLocalAddr1));
   udpport2->PrepareAddress();
   EXPECT_EQ(udpport1->Candidates()[0].foundation(),
             udpport2->Candidates()[0].foundation());
-  talk_base::scoped_ptr<TCPPort> tcpport1(CreateTcpPort(kLocalAddr1));
+  rtc::scoped_ptr<TCPPort> tcpport1(CreateTcpPort(kLocalAddr1));
   tcpport1->PrepareAddress();
-  talk_base::scoped_ptr<TCPPort> tcpport2(CreateTcpPort(kLocalAddr1));
+  rtc::scoped_ptr<TCPPort> tcpport2(CreateTcpPort(kLocalAddr1));
   tcpport2->PrepareAddress();
   EXPECT_EQ(tcpport1->Candidates()[0].foundation(),
             tcpport2->Candidates()[0].foundation());
-  talk_base::scoped_ptr<Port> stunport(
+  rtc::scoped_ptr<Port> stunport(
       CreateStunPort(kLocalAddr1, nat_socket_factory1()));
   stunport->PrepareAddress();
   ASSERT_EQ_WAIT(1U, stunport->Candidates().size(), kTimeout);
@@ -2167,7 +2167,7 @@ TEST_F(PortTest, TestCandidateFoundation) {
   EXPECT_NE(udpport2->Candidates()[0].foundation(),
             stunport->Candidates()[0].foundation());
   // Verify GTURN candidate foundation.
-  talk_base::scoped_ptr<RelayPort> relayport(
+  rtc::scoped_ptr<RelayPort> relayport(
       CreateGturnPort(kLocalAddr1));
   relayport->AddServerAddress(
       cricket::ProtocolAddress(kRelayUdpIntAddr, cricket::PROTO_UDP));
@@ -2178,7 +2178,7 @@ TEST_F(PortTest, TestCandidateFoundation) {
   EXPECT_NE(udpport2->Candidates()[0].foundation(),
             relayport->Candidates()[0].foundation());
   // Verifying TURN candidate foundation.
-  talk_base::scoped_ptr<Port> turnport1(CreateTurnPort(
+  rtc::scoped_ptr<Port> turnport1(CreateTurnPort(
       kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   turnport1->PrepareAddress();
   ASSERT_EQ_WAIT(1U, turnport1->Candidates().size(), kTimeout);
@@ -2188,7 +2188,7 @@ TEST_F(PortTest, TestCandidateFoundation) {
             turnport1->Candidates()[0].foundation());
   EXPECT_NE(stunport->Candidates()[0].foundation(),
             turnport1->Candidates()[0].foundation());
-  talk_base::scoped_ptr<Port> turnport2(CreateTurnPort(
+  rtc::scoped_ptr<Port> turnport2(CreateTurnPort(
       kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   turnport2->PrepareAddress();
   ASSERT_EQ_WAIT(1U, turnport2->Candidates().size(), kTimeout);
@@ -2199,8 +2199,8 @@ TEST_F(PortTest, TestCandidateFoundation) {
   SocketAddress kTurnUdpIntAddr2("99.99.98.4", STUN_SERVER_PORT);
   SocketAddress kTurnUdpExtAddr2("99.99.98.5", 0);
   TestTurnServer turn_server2(
-      talk_base::Thread::Current(), kTurnUdpIntAddr2, kTurnUdpExtAddr2);
-  talk_base::scoped_ptr<Port> turnport3(CreateTurnPort(
+      rtc::Thread::Current(), kTurnUdpIntAddr2, kTurnUdpExtAddr2);
+  rtc::scoped_ptr<Port> turnport3(CreateTurnPort(
       kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP,
       kTurnUdpIntAddr2));
   turnport3->PrepareAddress();
@@ -2212,16 +2212,16 @@ TEST_F(PortTest, TestCandidateFoundation) {
 // This test verifies the related addresses of different types of
 // ICE candiates.
 TEST_F(PortTest, TestCandidateRelatedAddress) {
-  talk_base::scoped_ptr<talk_base::NATServer> nat_server(
+  rtc::scoped_ptr<rtc::NATServer> nat_server(
       CreateNatServer(kNatAddr1, NAT_OPEN_CONE));
-  talk_base::scoped_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1));
+  rtc::scoped_ptr<UDPPort> udpport(CreateUdpPort(kLocalAddr1));
   udpport->PrepareAddress();
   // For UDPPort, related address will be empty.
   EXPECT_TRUE(udpport->Candidates()[0].related_address().IsNil());
   // Testing related address for stun candidates.
   // For stun candidate related address must be equal to the base
   // socket address.
-  talk_base::scoped_ptr<StunPort> stunport(
+  rtc::scoped_ptr<StunPort> stunport(
       CreateStunPort(kLocalAddr1, nat_socket_factory1()));
   stunport->PrepareAddress();
   ASSERT_EQ_WAIT(1U, stunport->Candidates().size(), kTimeout);
@@ -2234,18 +2234,18 @@ TEST_F(PortTest, TestCandidateRelatedAddress) {
   // Verifying the related address for the GTURN candidates.
   // NOTE: In case of GTURN related address will be equal to the mapped
   // address, but address(mapped) will not be XOR.
-  talk_base::scoped_ptr<RelayPort> relayport(
+  rtc::scoped_ptr<RelayPort> relayport(
       CreateGturnPort(kLocalAddr1));
   relayport->AddServerAddress(
       cricket::ProtocolAddress(kRelayUdpIntAddr, cricket::PROTO_UDP));
   relayport->PrepareAddress();
   ASSERT_EQ_WAIT(1U, relayport->Candidates().size(), kTimeout);
   // For Gturn related address is set to "0.0.0.0:0"
-  EXPECT_EQ(talk_base::SocketAddress(),
+  EXPECT_EQ(rtc::SocketAddress(),
             relayport->Candidates()[0].related_address());
   // Verifying the related address for TURN candidate.
   // For TURN related address must be equal to the mapped address.
-  talk_base::scoped_ptr<Port> turnport(CreateTurnPort(
+  rtc::scoped_ptr<Port> turnport(CreateTurnPort(
       kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   turnport->PrepareAddress();
   ASSERT_EQ_WAIT(1U, turnport->Candidates().size(), kTimeout);
@@ -2266,10 +2266,10 @@ TEST_F(PortTest, TestCandidatePreference) {
 
 // Test the Connection priority is calculated correctly.
 TEST_F(PortTest, TestConnectionPriority) {
-  talk_base::scoped_ptr<TestPort> lport(
+  rtc::scoped_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
   lport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_HOST);
-  talk_base::scoped_ptr<TestPort> rport(
+  rtc::scoped_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   rport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_RELAY);
   lport->set_component(123);
@@ -2328,7 +2328,7 @@ TEST_F(PortTest, TestWritableState) {
   // Data should be unsendable until the connection is accepted.
   char data[] = "abcd";
   int data_size = ARRAY_SIZE(data);
-  talk_base::PacketOptions options;
+  rtc::PacketOptions options;
   EXPECT_EQ(SOCKET_ERROR, ch1.conn()->Send(data, data_size, options));
 
   // Accept the connection to return the binding response, transition to
@@ -2405,7 +2405,7 @@ TEST_F(PortTest, TestIceLiteConnectivity) {
       kLocalAddr1, "lfrag", "lpass", cricket::ICEPROTO_RFC5245,
       cricket::ICEROLE_CONTROLLING, kTiebreaker1);
 
-  talk_base::scoped_ptr<TestPort> ice_lite_port(CreateTestPort(
+  rtc::scoped_ptr<TestPort> ice_lite_port(CreateTestPort(
       kLocalAddr2, "rfrag", "rpass", cricket::ICEPROTO_RFC5245,
       cricket::ICEROLE_CONTROLLED, kTiebreaker2));
   // Setup TestChannel. This behaves like FULL mode client.
@@ -2439,14 +2439,14 @@ TEST_F(PortTest, TestIceLiteConnectivity) {
   // But we need a connection to send a response message.
   ice_lite_port->CreateConnection(
       ice_full_port->Candidates()[0], cricket::Port::ORIGIN_MESSAGE);
-  talk_base::scoped_ptr<IceMessage> request(CopyStunMessage(msg));
+  rtc::scoped_ptr<IceMessage> request(CopyStunMessage(msg));
   ice_lite_port->SendBindingResponse(
       request.get(), ice_full_port->Candidates()[0].address());
 
   // Feeding the respone message from litemode to the full mode connection.
   ch1.conn()->OnReadPacket(ice_lite_port->last_stun_buf()->Data(),
                            ice_lite_port->last_stun_buf()->Length(),
-                           talk_base::PacketTime());
+                           rtc::PacketTime());
   // Verifying full mode connection becomes writable from the response.
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                  kTimeout);
@@ -2484,7 +2484,7 @@ TEST_F(PortTest, TestControllingNoTimeout) {
   ConnectAndDisconnectChannels(&ch1, &ch2);
 
   // After the connection is destroyed, the port should not be destroyed.
-  talk_base::Thread::Current()->ProcessMessages(kTimeout);
+  rtc::Thread::Current()->ProcessMessages(kTimeout);
   EXPECT_FALSE(destroyed());
 }
 
diff --git a/p2p/base/portallocator.h b/p2p/base/portallocator.h
index ade9c7a..6bea077 100644
--- a/p2p/base/portallocator.h
+++ b/p2p/base/portallocator.h
@@ -31,9 +31,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/helpers.h"
-#include "talk/base/proxyinfo.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/proxyinfo.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/p2p/base/portinterface.h"
 
 namespace cricket {
@@ -137,8 +137,8 @@ class PortAllocator : public sigslot::has_slots<> {
   void set_flags(uint32 flags) { flags_ = flags; }
 
   const std::string& user_agent() const { return agent_; }
-  const talk_base::ProxyInfo& proxy() const { return proxy_; }
-  void set_proxy(const std::string& agent, const talk_base::ProxyInfo& proxy) {
+  const rtc::ProxyInfo& proxy() const { return proxy_; }
+  void set_proxy(const std::string& agent, const rtc::ProxyInfo& proxy) {
     agent_ = agent;
     proxy_ = proxy;
   }
@@ -178,7 +178,7 @@ class PortAllocator : public sigslot::has_slots<> {
 
   uint32 flags_;
   std::string agent_;
-  talk_base::ProxyInfo proxy_;
+  rtc::ProxyInfo proxy_;
   int min_port_;
   int max_port_;
   uint32 step_delay_;
diff --git a/p2p/base/portallocatorsessionproxy.cc b/p2p/base/portallocatorsessionproxy.cc
index d804bdc..f7e3668 100644
--- a/p2p/base/portallocatorsessionproxy.cc
+++ b/p2p/base/portallocatorsessionproxy.cc
@@ -27,7 +27,7 @@
 
 #include "talk/p2p/base/portallocatorsessionproxy.h"
 
-#include "talk/base/thread.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/portallocator.h"
 #include "talk/p2p/base/portproxy.h"
 
@@ -38,11 +38,11 @@ enum {
   MSG_SEND_ALLOCATED_PORTS,
 };
 
-typedef talk_base::TypedMessageData<PortAllocatorSessionProxy*> ProxyObjData;
+typedef rtc::TypedMessageData<PortAllocatorSessionProxy*> ProxyObjData;
 
 PortAllocatorSessionMuxer::PortAllocatorSessionMuxer(
     PortAllocatorSession* session)
-    : worker_thread_(talk_base::Thread::Current()),
+    : worker_thread_(rtc::Thread::Current()),
       session_(session),
       candidate_done_signal_received_(false) {
   session_->SignalPortReady.connect(
@@ -114,7 +114,7 @@ void PortAllocatorSessionMuxer::OnSessionProxyDestroyed(
   }
 }
 
-void PortAllocatorSessionMuxer::OnMessage(talk_base::Message *pmsg) {
+void PortAllocatorSessionMuxer::OnMessage(rtc::Message *pmsg) {
   ProxyObjData* proxy = static_cast<ProxyObjData*>(pmsg->pdata);
   switch (pmsg->message_id) {
     case MSG_SEND_ALLOCATION_DONE:
diff --git a/p2p/base/portallocatorsessionproxy.h b/p2p/base/portallocatorsessionproxy.h
index 990ea8a..659c730 100644
--- a/p2p/base/portallocatorsessionproxy.h
+++ b/p2p/base/portallocatorsessionproxy.h
@@ -42,7 +42,7 @@ class PortProxy;
 // deleted upon receiving SignalDestroyed signal. This class is used when
 // PORTALLOCATOR_ENABLE_BUNDLE flag is set.
 
-class PortAllocatorSessionMuxer : public talk_base::MessageHandler,
+class PortAllocatorSessionMuxer : public rtc::MessageHandler,
                                   public sigslot::has_slots<> {
  public:
   explicit PortAllocatorSessionMuxer(PortAllocatorSession* session);
@@ -59,16 +59,16 @@ class PortAllocatorSessionMuxer : public talk_base::MessageHandler,
   sigslot::signal1<PortAllocatorSessionMuxer*> SignalDestroyed;
 
  private:
-  virtual void OnMessage(talk_base::Message *pmsg);
+  virtual void OnMessage(rtc::Message *pmsg);
   void OnSessionProxyDestroyed(PortAllocatorSession* proxy);
   void SendAllocationDone_w(PortAllocatorSessionProxy* proxy);
   void SendAllocatedPorts_w(PortAllocatorSessionProxy* proxy);
 
   // Port will be deleted when SignalDestroyed received, otherwise delete
   // happens when PortAllocatorSession dtor is called.
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* worker_thread_;
   std::vector<PortInterface*> ports_;
-  talk_base::scoped_ptr<PortAllocatorSession> session_;
+  rtc::scoped_ptr<PortAllocatorSession> session_;
   std::vector<PortAllocatorSessionProxy*> session_proxies_;
   bool candidate_done_signal_received_;
 };
diff --git a/p2p/base/portallocatorsessionproxy_unittest.cc b/p2p/base/portallocatorsessionproxy_unittest.cc
index 689fb96..95864d4 100644
--- a/p2p/base/portallocatorsessionproxy_unittest.cc
+++ b/p2p/base/portallocatorsessionproxy_unittest.cc
@@ -27,9 +27,9 @@
 
 #include <vector>
 
-#include "talk/base/fakenetwork.h"
-#include "talk/base/gunit.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/fakenetwork.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/portallocatorsessionproxy.h"
 #include "talk/p2p/client/basicportallocator.h"
@@ -102,10 +102,10 @@ class TestSessionChannel : public sigslot::has_slots<> {
 class PortAllocatorSessionProxyTest : public testing::Test {
  public:
   PortAllocatorSessionProxyTest()
-      : socket_factory_(talk_base::Thread::Current()),
-        allocator_(talk_base::Thread::Current(), NULL),
+      : socket_factory_(rtc::Thread::Current()),
+        allocator_(rtc::Thread::Current(), NULL),
         session_(new cricket::FakePortAllocatorSession(
-                     talk_base::Thread::Current(), &socket_factory_,
+                     rtc::Thread::Current(), &socket_factory_,
                      "test content", 1,
                      kIceUfrag0, kIcePwd0)),
         session_muxer_(new PortAllocatorSessionMuxer(session_)) {
@@ -125,7 +125,7 @@ class PortAllocatorSessionProxyTest : public testing::Test {
   }
 
  protected:
-  talk_base::BasicPacketSocketFactory socket_factory_;
+  rtc::BasicPacketSocketFactory socket_factory_;
   cricket::FakePortAllocator allocator_;
   cricket::FakePortAllocatorSession* session_;
   // Muxer object will be delete itself after all registered session proxies
diff --git a/p2p/base/portinterface.h b/p2p/base/portinterface.h
index 5ebf653..a36c2b1 100644
--- a/p2p/base/portinterface.h
+++ b/p2p/base/portinterface.h
@@ -30,10 +30,10 @@
 
 #include <string>
 
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/socketaddress.h"
 #include "talk/p2p/base/transport.h"
 
-namespace talk_base {
+namespace rtc {
 class Network;
 struct PacketOptions;
 }
@@ -58,7 +58,7 @@ class PortInterface {
   virtual ~PortInterface() {}
 
   virtual const std::string& Type() const = 0;
-  virtual talk_base::Network* Network() const = 0;
+  virtual rtc::Network* Network() const = 0;
 
   virtual void SetIceProtocolType(IceProtocolType protocol) = 0;
   virtual IceProtocolType IceProtocol() const = 0;
@@ -81,7 +81,7 @@ class PortInterface {
 
   // Returns the connection to the given address or NULL if none exists.
   virtual Connection* GetConnection(
-      const talk_base::SocketAddress& remote_addr) = 0;
+      const rtc::SocketAddress& remote_addr) = 0;
 
   // Creates a new connection to the given address.
   enum CandidateOrigin { ORIGIN_THIS_PORT, ORIGIN_OTHER_PORT, ORIGIN_MESSAGE };
@@ -89,8 +89,8 @@ class PortInterface {
       const Candidate& remote_candidate, CandidateOrigin origin) = 0;
 
   // Functions on the underlying socket(s).
-  virtual int SetOption(talk_base::Socket::Option opt, int value) = 0;
-  virtual int GetOption(talk_base::Socket::Option opt, int* value) = 0;
+  virtual int SetOption(rtc::Socket::Option opt, int value) = 0;
+  virtual int GetOption(rtc::Socket::Option opt, int* value) = 0;
   virtual int GetError() = 0;
 
   virtual const std::vector<Candidate>& Candidates() const = 0;
@@ -98,13 +98,13 @@ class PortInterface {
   // Sends the given packet to the given address, provided that the address is
   // that of a connection or an address that has sent to us already.
   virtual int SendTo(const void* data, size_t size,
-                     const talk_base::SocketAddress& addr,
-                     const talk_base::PacketOptions& options, bool payload) = 0;
+                     const rtc::SocketAddress& addr,
+                     const rtc::PacketOptions& options, bool payload) = 0;
 
   // Indicates that we received a successful STUN binding request from an
   // address that doesn't correspond to any current connection.  To turn this
   // into a real connection, call CreateConnection.
-  sigslot::signal6<PortInterface*, const talk_base::SocketAddress&,
+  sigslot::signal6<PortInterface*, const rtc::SocketAddress&,
                    ProtocolType, IceMessage*, const std::string&,
                    bool> SignalUnknownAddress;
 
@@ -112,9 +112,9 @@ class PortInterface {
   // these methods should be called as a response to SignalUnknownAddress.
   // NOTE: You MUST call CreateConnection BEFORE SendBindingResponse.
   virtual void SendBindingResponse(StunMessage* request,
-                                   const talk_base::SocketAddress& addr) = 0;
+                                   const rtc::SocketAddress& addr) = 0;
   virtual void SendBindingErrorResponse(
-      StunMessage* request, const talk_base::SocketAddress& addr,
+      StunMessage* request, const rtc::SocketAddress& addr,
       int error_code, const std::string& reason) = 0;
 
   // Signaled when this port decides to delete itself because it no longer has
@@ -130,7 +130,7 @@ class PortInterface {
   // through this port.
   virtual void EnablePortPackets() = 0;
   sigslot::signal4<PortInterface*, const char*, size_t,
-                   const talk_base::SocketAddress&> SignalReadPacket;
+                   const rtc::SocketAddress&> SignalReadPacket;
 
   virtual std::string ToString() const = 0;
 
diff --git a/p2p/base/portproxy.cc b/p2p/base/portproxy.cc
index 43bb747..841cd85 100644
--- a/p2p/base/portproxy.cc
+++ b/p2p/base/portproxy.cc
@@ -42,7 +42,7 @@ const std::string& PortProxy::Type() const {
   return impl_->Type();
 }
 
-talk_base::Network* PortProxy::Network() const {
+rtc::Network* PortProxy::Network() const {
   ASSERT(impl_ != NULL);
   return impl_->Network();
 }
@@ -96,20 +96,20 @@ Connection* PortProxy::CreateConnection(const Candidate& remote_candidate,
 
 int PortProxy::SendTo(const void* data,
                       size_t size,
-                      const talk_base::SocketAddress& addr,
-                      const talk_base::PacketOptions& options,
+                      const rtc::SocketAddress& addr,
+                      const rtc::PacketOptions& options,
                       bool payload) {
   ASSERT(impl_ != NULL);
   return impl_->SendTo(data, size, addr, options, payload);
 }
 
-int PortProxy::SetOption(talk_base::Socket::Option opt,
+int PortProxy::SetOption(rtc::Socket::Option opt,
                          int value) {
   ASSERT(impl_ != NULL);
   return impl_->SetOption(opt, value);
 }
 
-int PortProxy::GetOption(talk_base::Socket::Option opt,
+int PortProxy::GetOption(rtc::Socket::Option opt,
                          int* value) {
   ASSERT(impl_ != NULL);
   return impl_->GetOption(opt, value);
@@ -126,19 +126,19 @@ const std::vector<Candidate>& PortProxy::Candidates() const {
 }
 
 void PortProxy::SendBindingResponse(
-    StunMessage* request, const talk_base::SocketAddress& addr) {
+    StunMessage* request, const rtc::SocketAddress& addr) {
   ASSERT(impl_ != NULL);
   impl_->SendBindingResponse(request, addr);
 }
 
 Connection* PortProxy::GetConnection(
-    const talk_base::SocketAddress& remote_addr) {
+    const rtc::SocketAddress& remote_addr) {
   ASSERT(impl_ != NULL);
   return impl_->GetConnection(remote_addr);
 }
 
 void PortProxy::SendBindingErrorResponse(
-    StunMessage* request, const talk_base::SocketAddress& addr,
+    StunMessage* request, const rtc::SocketAddress& addr,
     int error_code, const std::string& reason) {
   ASSERT(impl_ != NULL);
   impl_->SendBindingErrorResponse(request, addr, error_code, reason);
@@ -156,7 +156,7 @@ std::string PortProxy::ToString() const {
 
 void PortProxy::OnUnknownAddress(
     PortInterface *port,
-    const talk_base::SocketAddress &addr,
+    const rtc::SocketAddress &addr,
     ProtocolType proto,
     IceMessage *stun_msg,
     const std::string &remote_username,
diff --git a/p2p/base/portproxy.h b/p2p/base/portproxy.h
index d138dc3..da555cc 100644
--- a/p2p/base/portproxy.h
+++ b/p2p/base/portproxy.h
@@ -28,10 +28,10 @@
 #ifndef TALK_P2P_BASE_PORTPROXY_H_
 #define TALK_P2P_BASE_PORTPROXY_H_
 
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/p2p/base/portinterface.h"
 
-namespace talk_base {
+namespace rtc {
 class Network;
 }
 
@@ -46,7 +46,7 @@ class PortProxy : public PortInterface, public sigslot::has_slots<> {
   void set_impl(PortInterface* port);
 
   virtual const std::string& Type() const;
-  virtual talk_base::Network* Network() const;
+  virtual rtc::Network* Network() const;
 
   virtual void SetIceProtocolType(IceProtocolType protocol);
   virtual IceProtocolType IceProtocol() const;
@@ -65,22 +65,22 @@ class PortProxy : public PortInterface, public sigslot::has_slots<> {
   virtual Connection* CreateConnection(const Candidate& remote_candidate,
                                        CandidateOrigin origin);
   virtual Connection* GetConnection(
-      const talk_base::SocketAddress& remote_addr);
+      const rtc::SocketAddress& remote_addr);
 
   virtual int SendTo(const void* data, size_t size,
-                     const talk_base::SocketAddress& addr,
-                     const talk_base::PacketOptions& options,
+                     const rtc::SocketAddress& addr,
+                     const rtc::PacketOptions& options,
                      bool payload);
-  virtual int SetOption(talk_base::Socket::Option opt, int value);
-  virtual int GetOption(talk_base::Socket::Option opt, int* value);
+  virtual int SetOption(rtc::Socket::Option opt, int value);
+  virtual int GetOption(rtc::Socket::Option opt, int* value);
   virtual int GetError();
 
   virtual const std::vector<Candidate>& Candidates() const;
 
   virtual void SendBindingResponse(StunMessage* request,
-                                   const talk_base::SocketAddress& addr);
+                                   const rtc::SocketAddress& addr);
   virtual void SendBindingErrorResponse(
-        StunMessage* request, const talk_base::SocketAddress& addr,
+        StunMessage* request, const rtc::SocketAddress& addr,
         int error_code, const std::string& reason);
 
   virtual void EnablePortPackets();
@@ -88,7 +88,7 @@ class PortProxy : public PortInterface, public sigslot::has_slots<> {
 
  private:
   void OnUnknownAddress(PortInterface *port,
-                        const talk_base::SocketAddress &addr,
+                        const rtc::SocketAddress &addr,
                         ProtocolType proto,
                         IceMessage *stun_msg,
                         const std::string &remote_username,
diff --git a/p2p/base/pseudotcp.cc b/p2p/base/pseudotcp.cc
index 3925637..9a944f0 100644
--- a/p2p/base/pseudotcp.cc
+++ b/p2p/base/pseudotcp.cc
@@ -32,15 +32,15 @@
 
 #include <set>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/bytebuffer.h"
-#include "talk/base/byteorder.h"
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socket.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socket.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/timeutils.h"
 
 // The following logging is for detailed (packet-level) analysis only.
 #define _DBG_NONE     0
@@ -151,23 +151,23 @@ const uint32 IDLE_TIMEOUT = 90 * 1000; // 90 seconds;
 //////////////////////////////////////////////////////////////////////
 
 inline void long_to_bytes(uint32 val, void* buf) {
-  *static_cast<uint32*>(buf) = talk_base::HostToNetwork32(val);
+  *static_cast<uint32*>(buf) = rtc::HostToNetwork32(val);
 }
 
 inline void short_to_bytes(uint16 val, void* buf) {
-  *static_cast<uint16*>(buf) = talk_base::HostToNetwork16(val);
+  *static_cast<uint16*>(buf) = rtc::HostToNetwork16(val);
 }
 
 inline uint32 bytes_to_long(const void* buf) {
-  return talk_base::NetworkToHost32(*static_cast<const uint32*>(buf));
+  return rtc::NetworkToHost32(*static_cast<const uint32*>(buf));
 }
 
 inline uint16 bytes_to_short(const void* buf) {
-  return talk_base::NetworkToHost16(*static_cast<const uint16*>(buf));
+  return rtc::NetworkToHost16(*static_cast<const uint16*>(buf));
 }
 
 uint32 bound(uint32 lower, uint32 middle, uint32 upper) {
-  return talk_base::_min(talk_base::_max(lower, middle), upper);
+  return rtc::_min(rtc::_max(lower, middle), upper);
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -199,7 +199,7 @@ void ReportStats() {
   char buffer[256];
   size_t len = 0;
   for (int i = 0; i < S_NUM_STATS; ++i) {
-    len += talk_base::sprintfn(buffer, ARRAY_SIZE(buffer), "%s%s:%d",
+    len += rtc::sprintfn(buffer, ARRAY_SIZE(buffer), "%s%s:%d",
                                (i == 0) ? "" : ",", STAT_NAMES[i], g_stats[i]);
     g_stats[i] = 0;
   }
@@ -214,9 +214,9 @@ void ReportStats() {
 
 uint32 PseudoTcp::Now() {
 #if 0  // Use this to synchronize timers with logging timestamps (easier debug)
-  return talk_base::TimeSince(StartTime());
+  return rtc::TimeSince(StartTime());
 #else
-  return talk_base::Time();
+  return rtc::Time();
 #endif
 }
 
@@ -301,7 +301,7 @@ void PseudoTcp::NotifyClock(uint32 now) {
     return;
 
     // Check if it's time to retransmit a segment
-  if (m_rto_base && (talk_base::TimeDiff(m_rto_base + m_rx_rto, now) <= 0)) {
+  if (m_rto_base && (rtc::TimeDiff(m_rto_base + m_rx_rto, now) <= 0)) {
     if (m_slist.empty()) {
       ASSERT(false);
     } else {
@@ -320,21 +320,21 @@ void PseudoTcp::NotifyClock(uint32 now) {
       }
 
       uint32 nInFlight = m_snd_nxt - m_snd_una;
-      m_ssthresh = talk_base::_max(nInFlight / 2, 2 * m_mss);
+      m_ssthresh = rtc::_max(nInFlight / 2, 2 * m_mss);
       //LOG(LS_INFO) << "m_ssthresh: " << m_ssthresh << "  nInFlight: " << nInFlight << "  m_mss: " << m_mss;
       m_cwnd = m_mss;
 
       // Back off retransmit timer.  Note: the limit is lower when connecting.
       uint32 rto_limit = (m_state < TCP_ESTABLISHED) ? DEF_RTO : MAX_RTO;
-      m_rx_rto = talk_base::_min(rto_limit, m_rx_rto * 2);
+      m_rx_rto = rtc::_min(rto_limit, m_rx_rto * 2);
       m_rto_base = now;
     }
   }
 
   // Check if it's time to probe closed windows
   if ((m_snd_wnd == 0)
-        && (talk_base::TimeDiff(m_lastsend + m_rx_rto, now) <= 0)) {
-    if (talk_base::TimeDiff(now, m_lastrecv) >= 15000) {
+        && (rtc::TimeDiff(m_lastsend + m_rx_rto, now) <= 0)) {
+    if (rtc::TimeDiff(now, m_lastrecv) >= 15000) {
       closedown(ECONNABORTED);
       return;
     }
@@ -344,11 +344,11 @@ void PseudoTcp::NotifyClock(uint32 now) {
     m_lastsend = now;
 
     // back off retransmit timer
-    m_rx_rto = talk_base::_min(MAX_RTO, m_rx_rto * 2);
+    m_rx_rto = rtc::_min(MAX_RTO, m_rx_rto * 2);
   }
 
   // Check if it's time to send delayed acks
-  if (m_t_ack && (talk_base::TimeDiff(m_t_ack + m_ack_delay, now) <= 0)) {
+  if (m_t_ack && (rtc::TimeDiff(m_t_ack + m_ack_delay, now) <= 0)) {
     packet(m_snd_nxt, 0, 0, 0);
   }
 
@@ -436,21 +436,21 @@ int PseudoTcp::Recv(char* buffer, size_t len) {
   }
 
   size_t read = 0;
-  talk_base::StreamResult result = m_rbuf.Read(buffer, len, &read, NULL);
+  rtc::StreamResult result = m_rbuf.Read(buffer, len, &read, NULL);
 
   // If there's no data in |m_rbuf|.
-  if (result == talk_base::SR_BLOCK) {
+  if (result == rtc::SR_BLOCK) {
     m_bReadEnable = true;
     m_error = EWOULDBLOCK;
     return SOCKET_ERROR;
   }
-  ASSERT(result == talk_base::SR_SUCCESS);
+  ASSERT(result == rtc::SR_SUCCESS);
 
   size_t available_space = 0;
   m_rbuf.GetWriteRemaining(&available_space);
 
   if (uint32(available_space) - m_rcv_wnd >=
-      talk_base::_min<uint32>(m_rbuf_len / 2, m_mss)) {
+      rtc::_min<uint32>(m_rbuf_len / 2, m_mss)) {
     // TODO(jbeda): !?! Not sure about this was closed business
     bool bWasClosed = (m_rcv_wnd == 0);
     m_rcv_wnd = static_cast<uint32>(available_space);
@@ -528,7 +528,7 @@ IPseudoTcpNotify::WriteResult PseudoTcp::packet(uint32 seq, uint8 flags,
 
   uint32 now = Now();
 
-  talk_base::scoped_ptr<uint8[]> buffer(new uint8[MAX_PACKET]);
+  rtc::scoped_ptr<uint8[]> buffer(new uint8[MAX_PACKET]);
   long_to_bytes(m_conv, buffer.get());
   long_to_bytes(seq, buffer.get() + 4);
   long_to_bytes(m_rcv_nxt, buffer.get() + 8);
@@ -544,10 +544,10 @@ IPseudoTcpNotify::WriteResult PseudoTcp::packet(uint32 seq, uint8 flags,
 
   if (len) {
     size_t bytes_read = 0;
-    talk_base::StreamResult result = m_sbuf.ReadOffset(
+    rtc::StreamResult result = m_sbuf.ReadOffset(
         buffer.get() + HEADER_SIZE, len, offset, &bytes_read);
-    UNUSED(result);
-    ASSERT(result == talk_base::SR_SUCCESS);
+    RTC_UNUSED(result);
+    ASSERT(result == rtc::SR_SUCCESS);
     ASSERT(static_cast<uint32>(bytes_read) == len);
   }
 
@@ -631,20 +631,20 @@ bool PseudoTcp::clock_check(uint32 now, long& nTimeout) {
   nTimeout = DEFAULT_TIMEOUT;
 
   if (m_t_ack) {
-    nTimeout = talk_base::_min<int32>(nTimeout,
-      talk_base::TimeDiff(m_t_ack + m_ack_delay, now));
+    nTimeout = rtc::_min<int32>(nTimeout,
+      rtc::TimeDiff(m_t_ack + m_ack_delay, now));
   }
   if (m_rto_base) {
-    nTimeout = talk_base::_min<int32>(nTimeout,
-      talk_base::TimeDiff(m_rto_base + m_rx_rto, now));
+    nTimeout = rtc::_min<int32>(nTimeout,
+      rtc::TimeDiff(m_rto_base + m_rx_rto, now));
   }
   if (m_snd_wnd == 0) {
-    nTimeout = talk_base::_min<int32>(nTimeout, talk_base::TimeDiff(m_lastsend + m_rx_rto, now));
+    nTimeout = rtc::_min<int32>(nTimeout, rtc::TimeDiff(m_lastsend + m_rx_rto, now));
   }
 #if PSEUDO_KEEPALIVE
   if (m_state == TCP_ESTABLISHED) {
-    nTimeout = talk_base::_min<int32>(nTimeout,
-      talk_base::TimeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3/2 : IDLE_PING), now));
+    nTimeout = rtc::_min<int32>(nTimeout,
+      rtc::TimeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3/2 : IDLE_PING), now));
   }
 #endif // PSEUDO_KEEPALIVE
   return true;
@@ -717,7 +717,7 @@ bool PseudoTcp::process(Segment& seg) {
   if ((seg.ack > m_snd_una) && (seg.ack <= m_snd_nxt)) {
     // Calculate round-trip time
     if (seg.tsecr) {
-      int32 rtt = talk_base::TimeDiff(now, seg.tsecr);
+      int32 rtt = rtc::TimeDiff(now, seg.tsecr);
       if (rtt >= 0) {
         if (m_rx_srtt == 0) {
           m_rx_srtt = rtt;
@@ -730,7 +730,7 @@ bool PseudoTcp::process(Segment& seg) {
           m_rx_srtt = (7 * m_rx_srtt + rtt) / 8;
         }
         m_rx_rto = bound(MIN_RTO, m_rx_srtt +
-            talk_base::_max<uint32>(1, 4 * m_rx_rttvar), MAX_RTO);
+            rtc::_max<uint32>(1, 4 * m_rx_rttvar), MAX_RTO);
 #if _DEBUGMSG >= _DBG_VERBOSE
         LOG(LS_INFO) << "rtt: " << rtt
                      << "  srtt: " << m_rx_srtt
@@ -767,7 +767,7 @@ bool PseudoTcp::process(Segment& seg) {
     if (m_dup_acks >= 3) {
       if (m_snd_una >= m_recover) { // NewReno
         uint32 nInFlight = m_snd_nxt - m_snd_una;
-        m_cwnd = talk_base::_min(m_ssthresh, nInFlight + m_mss); // (Fast Retransmit)
+        m_cwnd = rtc::_min(m_ssthresh, nInFlight + m_mss); // (Fast Retransmit)
 #if _DEBUGMSG >= _DBG_NORMAL
         LOG(LS_INFO) << "exit recovery";
 #endif // _DEBUGMSG
@@ -780,7 +780,7 @@ bool PseudoTcp::process(Segment& seg) {
           closedown(ECONNABORTED);
           return false;
         }
-        m_cwnd += m_mss - talk_base::_min(nAcked, m_cwnd);
+        m_cwnd += m_mss - rtc::_min(nAcked, m_cwnd);
       }
     } else {
       m_dup_acks = 0;
@@ -788,7 +788,7 @@ bool PseudoTcp::process(Segment& seg) {
       if (m_cwnd < m_ssthresh) {
         m_cwnd += m_mss;
       } else {
-        m_cwnd += talk_base::_max<uint32>(1, m_mss * m_mss / m_cwnd);
+        m_cwnd += rtc::_max<uint32>(1, m_mss * m_mss / m_cwnd);
       }
     }
   } else if (seg.ack == m_snd_una) {
@@ -811,7 +811,7 @@ bool PseudoTcp::process(Segment& seg) {
         }
         m_recover = m_snd_nxt;
         uint32 nInFlight = m_snd_nxt - m_snd_una;
-        m_ssthresh = talk_base::_max(nInFlight / 2, 2 * m_mss);
+        m_ssthresh = rtc::_max(nInFlight / 2, 2 * m_mss);
         //LOG(LS_INFO) << "m_ssthresh: " << m_ssthresh << "  nInFlight: " << nInFlight << "  m_mss: " << m_mss;
         m_cwnd = m_ssthresh + 3 * m_mss;
       } else if (m_dup_acks > 3) {
@@ -908,10 +908,10 @@ bool PseudoTcp::process(Segment& seg) {
     } else {
       uint32 nOffset = seg.seq - m_rcv_nxt;
 
-      talk_base::StreamResult result = m_rbuf.WriteOffset(seg.data, seg.len,
+      rtc::StreamResult result = m_rbuf.WriteOffset(seg.data, seg.len,
                                                           nOffset, NULL);
-      ASSERT(result == talk_base::SR_SUCCESS);
-      UNUSED(result);
+      ASSERT(result == rtc::SR_SUCCESS);
+      RTC_UNUSED(result);
 
       if (seg.seq == m_rcv_nxt) {
         m_rbuf.ConsumeWriteBuffer(seg.len);
@@ -969,7 +969,7 @@ bool PseudoTcp::transmit(const SList::iterator& seg, uint32 now) {
     return false;
   }
 
-  uint32 nTransmit = talk_base::_min(seg->len, m_mss);
+  uint32 nTransmit = rtc::_min(seg->len, m_mss);
 
   while (true) {
     uint32 seq = seg->seq;
@@ -1035,13 +1035,13 @@ bool PseudoTcp::transmit(const SList::iterator& seg, uint32 now) {
 void PseudoTcp::attemptSend(SendFlags sflags) {
   uint32 now = Now();
 
-  if (talk_base::TimeDiff(now, m_lastsend) > static_cast<long>(m_rx_rto)) {
+  if (rtc::TimeDiff(now, m_lastsend) > static_cast<long>(m_rx_rto)) {
     m_cwnd = m_mss;
   }
 
 #if _DEBUGMSG
   bool bFirst = true;
-  UNUSED(bFirst);
+  RTC_UNUSED(bFirst);
 #endif // _DEBUGMSG
 
   while (true) {
@@ -1049,14 +1049,14 @@ void PseudoTcp::attemptSend(SendFlags sflags) {
     if ((m_dup_acks == 1) || (m_dup_acks == 2)) { // Limited Transmit
       cwnd += m_dup_acks * m_mss;
     }
-    uint32 nWindow = talk_base::_min(m_snd_wnd, cwnd);
+    uint32 nWindow = rtc::_min(m_snd_wnd, cwnd);
     uint32 nInFlight = m_snd_nxt - m_snd_una;
     uint32 nUseable = (nInFlight < nWindow) ? (nWindow - nInFlight) : 0;
 
     size_t snd_buffered = 0;
     m_sbuf.GetBuffered(&snd_buffered);
     uint32 nAvailable =
-        talk_base::_min(static_cast<uint32>(snd_buffered) - nInFlight, m_mss);
+        rtc::_min(static_cast<uint32>(snd_buffered) - nInFlight, m_mss);
 
     if (nAvailable > nUseable) {
       if (nUseable * 4 < nWindow) {
@@ -1153,8 +1153,8 @@ PseudoTcp::adjustMTU() {
   LOG(LS_INFO) << "Adjusting mss to " << m_mss << " bytes";
 #endif // _DEBUGMSG
   // Enforce minimums on ssthresh and cwnd
-  m_ssthresh = talk_base::_max(m_ssthresh, 2 * m_mss);
-  m_cwnd = talk_base::_max(m_cwnd, m_mss);
+  m_ssthresh = rtc::_max(m_ssthresh, 2 * m_mss);
+  m_cwnd = rtc::_max(m_cwnd, m_mss);
 }
 
 bool
@@ -1171,7 +1171,7 @@ PseudoTcp::disableWindowScale() {
 
 void
 PseudoTcp::queueConnectMessage() {
-  talk_base::ByteBuffer buf(talk_base::ByteBuffer::ORDER_NETWORK);
+  rtc::ByteBuffer buf(rtc::ByteBuffer::ORDER_NETWORK);
 
   buf.WriteUInt8(CTL_CONNECT);
   if (m_support_wnd_scale) {
@@ -1189,7 +1189,7 @@ PseudoTcp::parseOptions(const char* data, uint32 len) {
 
   // See http://www.freesoft.org/CIE/Course/Section4/8.htm for
   // parsing the options list.
-  talk_base::ByteBuffer buf(data, len);
+  rtc::ByteBuffer buf(data, len);
   while (buf.Length()) {
     uint8 kind = TCP_OPT_EOL;
     buf.ReadUInt8(&kind);
@@ -1204,7 +1204,7 @@ PseudoTcp::parseOptions(const char* data, uint32 len) {
 
     // Length of this option.
     ASSERT(len != 0);
-    UNUSED(len);
+    RTC_UNUSED(len);
     uint8 opt_len = 0;
     buf.ReadUInt8(&opt_len);
 
@@ -1278,7 +1278,7 @@ PseudoTcp::resizeReceiveBuffer(uint32 new_size) {
   // before connection is established or when peers are exchanging connect
   // messages.
   ASSERT(result);
-  UNUSED(result);
+  RTC_UNUSED(result);
   m_rbuf_len = new_size;
   m_rwnd_scale = scale_factor;
   m_ssthresh = new_size;
diff --git a/p2p/base/pseudotcp.h b/p2p/base/pseudotcp.h
index edd861b..46e9d3b 100644
--- a/p2p/base/pseudotcp.h
+++ b/p2p/base/pseudotcp.h
@@ -30,8 +30,8 @@
 
 #include <list>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/stream.h"
 
 namespace cricket {
 
@@ -219,13 +219,13 @@ class PseudoTcp {
   RList m_rlist;
   uint32 m_rbuf_len, m_rcv_nxt, m_rcv_wnd, m_lastrecv;
   uint8 m_rwnd_scale;  // Window scale factor.
-  talk_base::FifoBuffer m_rbuf;
+  rtc::FifoBuffer m_rbuf;
 
   // Outgoing data
   SList m_slist;
   uint32 m_sbuf_len, m_snd_nxt, m_snd_wnd, m_lastsend, m_snd_una;
   uint8 m_swnd_scale;  // Window scale factor.
-  talk_base::FifoBuffer m_sbuf;
+  rtc::FifoBuffer m_sbuf;
 
   // Maximum segment size, estimated protocol level, largest segment sent
   uint32 m_mss, m_msslevel, m_largest, m_mtu_advise;
diff --git a/p2p/base/pseudotcp_unittest.cc b/p2p/base/pseudotcp_unittest.cc
index e18159e..8ca3ce1 100644
--- a/p2p/base/pseudotcp_unittest.cc
+++ b/p2p/base/pseudotcp_unittest.cc
@@ -27,12 +27,12 @@
 
 #include <vector>
 
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/messagehandler.h"
-#include "talk/base/stream.h"
-#include "talk/base/thread.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/p2p/base/pseudotcp.h"
 
 using cricket::PseudoTcp;
@@ -57,7 +57,7 @@ class PseudoTcpForTest : public cricket::PseudoTcp {
 };
 
 class PseudoTcpTestBase : public testing::Test,
-                      public talk_base::MessageHandler,
+                      public rtc::MessageHandler,
                       public cricket::IPseudoTcpNotify {
  public:
   PseudoTcpTestBase()
@@ -70,11 +70,11 @@ class PseudoTcpTestBase : public testing::Test,
         delay_(0),
         loss_(0) {
     // Set use of the test RNG to get predictable loss patterns.
-    talk_base::SetRandomTestMode(true);
+    rtc::SetRandomTestMode(true);
   }
   ~PseudoTcpTestBase() {
     // Put it back for the next test.
-    talk_base::SetRandomTestMode(false);
+    rtc::SetRandomTestMode(false);
   }
   void SetLocalMtu(int mtu) {
     local_.NotifyMTU(mtu);
@@ -157,16 +157,16 @@ class PseudoTcpTestBase : public testing::Test,
                                      const char* buffer, size_t len) {
     // Randomly drop the desired percentage of packets.
     // Also drop packets that are larger than the configured MTU.
-    if (talk_base::CreateRandomId() % 100 < static_cast<uint32>(loss_)) {
+    if (rtc::CreateRandomId() % 100 < static_cast<uint32>(loss_)) {
       LOG(LS_VERBOSE) << "Randomly dropping packet, size=" << len;
     } else if (len > static_cast<size_t>(
-        talk_base::_min(local_mtu_, remote_mtu_))) {
+        rtc::_min(local_mtu_, remote_mtu_))) {
       LOG(LS_VERBOSE) << "Dropping packet that exceeds path MTU, size=" << len;
     } else {
       int id = (tcp == &local_) ? MSG_RPACKET : MSG_LPACKET;
       std::string packet(buffer, len);
-      talk_base::Thread::Current()->PostDelayed(delay_, this, id,
-          talk_base::WrapMessageData(packet));
+      rtc::Thread::Current()->PostDelayed(delay_, this, id,
+          rtc::WrapMessageData(packet));
     }
     return WR_SUCCESS;
   }
@@ -176,23 +176,23 @@ class PseudoTcpTestBase : public testing::Test,
   void UpdateClock(PseudoTcp* tcp, uint32 message) {
     long interval = 0;  // NOLINT
     tcp->GetNextClock(PseudoTcp::Now(), interval);
-    interval = talk_base::_max<int>(interval, 0L);  // sometimes interval is < 0
-    talk_base::Thread::Current()->Clear(this, message);
-    talk_base::Thread::Current()->PostDelayed(interval, this, message);
+    interval = rtc::_max<int>(interval, 0L);  // sometimes interval is < 0
+    rtc::Thread::Current()->Clear(this, message);
+    rtc::Thread::Current()->PostDelayed(interval, this, message);
   }
 
-  virtual void OnMessage(talk_base::Message* message) {
+  virtual void OnMessage(rtc::Message* message) {
     switch (message->message_id) {
       case MSG_LPACKET: {
         const std::string& s(
-            talk_base::UseMessageData<std::string>(message->pdata));
+            rtc::UseMessageData<std::string>(message->pdata));
         local_.NotifyPacket(s.c_str(), s.size());
         UpdateLocalClock();
         break;
       }
       case MSG_RPACKET: {
         const std::string& s(
-            talk_base::UseMessageData<std::string>(message->pdata));
+            rtc::UseMessageData<std::string>(message->pdata));
         remote_.NotifyPacket(s.c_str(), s.size());
         UpdateRemoteClock();
         break;
@@ -213,8 +213,8 @@ class PseudoTcpTestBase : public testing::Test,
 
   PseudoTcpForTest local_;
   PseudoTcpForTest remote_;
-  talk_base::MemoryStream send_stream_;
-  talk_base::MemoryStream recv_stream_;
+  rtc::MemoryStream send_stream_;
+  rtc::MemoryStream recv_stream_;
   bool have_connected_;
   bool have_disconnected_;
   int local_mtu_;
@@ -238,13 +238,13 @@ class PseudoTcpTest : public PseudoTcpTestBase {
     // Prepare the receive stream.
     recv_stream_.ReserveSize(size);
     // Connect and wait until connected.
-    start = talk_base::Time();
+    start = rtc::Time();
     EXPECT_EQ(0, Connect());
     EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
     // Sending will start from OnTcpWriteable and complete when all data has
     // been received.
     EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
-    elapsed = talk_base::TimeSince(start);
+    elapsed = rtc::TimeSince(start);
     recv_stream_.GetSize(&received);
     // Ensure we closed down OK and we got the right data.
     // TODO: Ensure the errors are cleared properly.
@@ -308,7 +308,7 @@ class PseudoTcpTest : public PseudoTcpTestBase {
     do {
       send_stream_.GetPosition(&position);
       if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
-          talk_base::SR_EOS) {
+          rtc::SR_EOS) {
         sent = local_.Send(block, tosend);
         UpdateLocalClock();
         if (sent != -1) {
@@ -326,8 +326,8 @@ class PseudoTcpTest : public PseudoTcpTestBase {
   }
 
  private:
-  talk_base::MemoryStream send_stream_;
-  talk_base::MemoryStream recv_stream_;
+  rtc::MemoryStream send_stream_;
+  rtc::MemoryStream recv_stream_;
 };
 
 
@@ -357,13 +357,13 @@ class PseudoTcpTestPingPong : public PseudoTcpTestBase {
     // Prepare the receive stream.
     recv_stream_.ReserveSize(size);
     // Connect and wait until connected.
-    start = talk_base::Time();
+    start = rtc::Time();
     EXPECT_EQ(0, Connect());
     EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
     // Sending will start from OnTcpWriteable and stop when the required
     // number of iterations have completed.
     EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
-    elapsed = talk_base::TimeSince(start);
+    elapsed = rtc::TimeSince(start);
     LOG(LS_INFO) << "Performed " << iterations << " pings in "
                  << elapsed << " ms";
   }
@@ -428,7 +428,7 @@ class PseudoTcpTestPingPong : public PseudoTcpTestBase {
       send_stream_.GetPosition(&position);
       tosend = bytes_per_send_ ? bytes_per_send_ : sizeof(block);
       if (send_stream_.Read(block, tosend, &tosend, NULL) !=
-          talk_base::SR_EOS) {
+          rtc::SR_EOS) {
         sent = sender_->Send(block, tosend);
         UpdateLocalClock();
         if (sent != -1) {
@@ -474,7 +474,7 @@ class PseudoTcpTestReceiveWindow : public PseudoTcpTestBase {
     EXPECT_EQ(0, Connect());
     EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
 
-    talk_base::Thread::Current()->Post(this, MSG_WRITE);
+    rtc::Thread::Current()->Post(this, MSG_WRITE);
     EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
 
     ASSERT_EQ(2u, send_position_.size());
@@ -492,7 +492,7 @@ class PseudoTcpTestReceiveWindow : public PseudoTcpTestBase {
     EXPECT_EQ(2 * estimated_recv_window, recv_position_[1]);
   }
 
-  virtual void OnMessage(talk_base::Message* message) {
+  virtual void OnMessage(rtc::Message* message) {
     int message_id = message->message_id;
     PseudoTcpTestBase::OnMessage(message);
 
@@ -555,7 +555,7 @@ class PseudoTcpTestReceiveWindow : public PseudoTcpTestBase {
     do {
       send_stream_.GetPosition(&position);
       if (send_stream_.Read(block, sizeof(block), &tosend, NULL) !=
-          talk_base::SR_EOS) {
+          rtc::SR_EOS) {
         sent = local_.Send(block, tosend);
         UpdateLocalClock();
         if (sent != -1) {
@@ -572,7 +572,7 @@ class PseudoTcpTestReceiveWindow : public PseudoTcpTestBase {
     // At this point, we've filled up the available space in the send queue.
 
     int message_queue_size =
-        static_cast<int>(talk_base::Thread::Current()->size());
+        static_cast<int>(rtc::Thread::Current()->size());
     // The message queue will always have at least 2 messages, an RCLOCK and
     // an LCLOCK, since they are added back on the delay queue at the same time
     // they are pulled off and therefore are never really removed.
@@ -580,7 +580,7 @@ class PseudoTcpTestReceiveWindow : public PseudoTcpTestBase {
       // If there are non-clock messages remaining, attempt to continue sending
       // after giving those messages time to process, which should free up the
       // send buffer.
-      talk_base::Thread::Current()->PostDelayed(10, this, MSG_WRITE);
+      rtc::Thread::Current()->PostDelayed(10, this, MSG_WRITE);
     } else {
       if (!remote_.isReceiveBufferFull()) {
         LOG(LS_ERROR) << "This shouldn't happen - the send buffer is full, "
@@ -596,8 +596,8 @@ class PseudoTcpTestReceiveWindow : public PseudoTcpTestBase {
   }
 
  private:
-  talk_base::MemoryStream send_stream_;
-  talk_base::MemoryStream recv_stream_;
+  rtc::MemoryStream send_stream_;
+  rtc::MemoryStream recv_stream_;
 
   std::vector<size_t> send_position_;
   std::vector<size_t> recv_position_;
diff --git a/p2p/base/rawtransport.cc b/p2p/base/rawtransport.cc
index fe4f3a2..60f8879 100644
--- a/p2p/base/rawtransport.cc
+++ b/p2p/base/rawtransport.cc
@@ -28,7 +28,7 @@
 #include <string>
 #include <vector>
 #include "talk/p2p/base/rawtransport.h"
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/parsing.h"
 #include "talk/p2p/base/sessionmanager.h"
@@ -40,8 +40,8 @@
 #if defined(FEATURE_ENABLE_PSTN)
 namespace cricket {
 
-RawTransport::RawTransport(talk_base::Thread* signaling_thread,
-                           talk_base::Thread* worker_thread,
+RawTransport::RawTransport(rtc::Thread* signaling_thread,
+                           rtc::Thread* worker_thread,
                            const std::string& content_name,
                            PortAllocator* allocator)
     : Transport(signaling_thread, worker_thread,
@@ -67,7 +67,7 @@ bool RawTransport::ParseCandidates(SignalingProtocol protocol,
       if (type() != cand_elem->Attr(buzz::QN_NAME)) {
         return BadParse("channel named does not exist", error);
       }
-      talk_base::SocketAddress addr;
+      rtc::SocketAddress addr;
       if (!ParseRawAddress(cand_elem, &addr, error))
         return false;
 
@@ -91,7 +91,7 @@ bool RawTransport::WriteCandidates(SignalingProtocol protocol,
        ++cand) {
     ASSERT(cand->component() == 1);
     ASSERT(cand->protocol() == "udp");
-    talk_base::SocketAddress addr = cand->address();
+    rtc::SocketAddress addr = cand->address();
 
     buzz::XmlElement* elem = new buzz::XmlElement(QN_GINGLE_RAW_CHANNEL);
     elem->SetAttr(buzz::QN_NAME, type());
@@ -103,7 +103,7 @@ bool RawTransport::WriteCandidates(SignalingProtocol protocol,
 }
 
 bool RawTransport::ParseRawAddress(const buzz::XmlElement* elem,
-                                   talk_base::SocketAddress* addr,
+                                   rtc::SocketAddress* addr,
                                    ParseError* error) {
   // Make sure the required attributes exist
   if (!elem->HasAttr(QN_ADDRESS) ||
diff --git a/p2p/base/rawtransport.h b/p2p/base/rawtransport.h
index 6bb04fe..3a20ef5 100644
--- a/p2p/base/rawtransport.h
+++ b/p2p/base/rawtransport.h
@@ -39,8 +39,8 @@ namespace cricket {
 // that it thinks will work.
 class RawTransport : public Transport, public TransportParser {
  public:
-  RawTransport(talk_base::Thread* signaling_thread,
-               talk_base::Thread* worker_thread,
+  RawTransport(rtc::Thread* signaling_thread,
+               rtc::Thread* worker_thread,
                const std::string& content_name,
                PortAllocator* allocator);
   virtual ~RawTransport();
@@ -66,7 +66,7 @@ class RawTransport : public Transport, public TransportParser {
   // given channel.  This will return false and signal an error if the address
   // or channel name is bad.
   bool ParseRawAddress(const buzz::XmlElement* elem,
-                       talk_base::SocketAddress* addr,
+                       rtc::SocketAddress* addr,
                        ParseError* error);
 
   friend class RawTransportChannel;  // For ParseAddress.
diff --git a/p2p/base/rawtransportchannel.cc b/p2p/base/rawtransportchannel.cc
index 37478ca..4df0692 100644
--- a/p2p/base/rawtransportchannel.cc
+++ b/p2p/base/rawtransportchannel.cc
@@ -29,7 +29,7 @@
 
 #include <string>
 #include <vector>
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/portallocator.h"
 #include "talk/p2p/base/portinterface.h"
@@ -45,7 +45,7 @@
 
 namespace {
 
-const uint32 MSG_DESTROY_UNUSED_PORTS = 1;
+const uint32 MSG_DESTROY_RTC_UNUSED_PORTS = 1;
 
 }  // namespace
 
@@ -54,7 +54,7 @@ namespace cricket {
 RawTransportChannel::RawTransportChannel(const std::string& content_name,
                                          int component,
                                          RawTransport* transport,
-                                         talk_base::Thread *worker_thread,
+                                         rtc::Thread *worker_thread,
                                          PortAllocator *allocator)
   : TransportChannelImpl(content_name, component),
     raw_transport_(transport),
@@ -75,7 +75,7 @@ RawTransportChannel::~RawTransportChannel() {
 }
 
 int RawTransportChannel::SendPacket(const char *data, size_t size,
-                                    const talk_base::PacketOptions& options,
+                                    const rtc::PacketOptions& options,
                                     int flags) {
   if (port_ == NULL)
     return -1;
@@ -86,7 +86,7 @@ int RawTransportChannel::SendPacket(const char *data, size_t size,
   return port_->SendTo(data, size, remote_address_, options, true);
 }
 
-int RawTransportChannel::SetOption(talk_base::Socket::Option opt, int value) {
+int RawTransportChannel::SetOption(rtc::Socket::Option opt, int value) {
   // TODO: allow these to be set before we have a port
   if (port_ == NULL)
     return -1;
@@ -130,7 +130,7 @@ void RawTransportChannel::Reset() {
   stun_port_ = NULL;
   relay_port_ = NULL;
   port_ = NULL;
-  remote_address_ = talk_base::SocketAddress();
+  remote_address_ = rtc::SocketAddress();
 }
 
 void RawTransportChannel::OnCandidate(const Candidate& candidate) {
@@ -144,7 +144,7 @@ void RawTransportChannel::OnCandidate(const Candidate& candidate) {
 }
 
 void RawTransportChannel::OnRemoteAddress(
-    const talk_base::SocketAddress& remote_address) {
+    const rtc::SocketAddress& remote_address) {
   remote_address_ = remote_address;
   set_readable(true);
 
@@ -225,7 +225,7 @@ void RawTransportChannel::SetPort(PortInterface* port) {
   // We don't need any ports other than the one we picked.
   allocator_session_->StopGettingPorts();
   worker_thread_->Post(
-      this, MSG_DESTROY_UNUSED_PORTS, NULL);
+      this, MSG_DESTROY_RTC_UNUSED_PORTS, NULL);
 
   // Send a message to the other client containing our address.
 
@@ -255,13 +255,13 @@ void RawTransportChannel::SetWritable() {
 
 void RawTransportChannel::OnReadPacket(
     PortInterface* port, const char* data, size_t size,
-    const talk_base::SocketAddress& addr) {
+    const rtc::SocketAddress& addr) {
   ASSERT(port_ == port);
-  SignalReadPacket(this, data, size, talk_base::CreatePacketTime(0), 0);
+  SignalReadPacket(this, data, size, rtc::CreatePacketTime(0), 0);
 }
 
-void RawTransportChannel::OnMessage(talk_base::Message* msg) {
-  ASSERT(msg->message_id == MSG_DESTROY_UNUSED_PORTS);
+void RawTransportChannel::OnMessage(rtc::Message* msg) {
+  ASSERT(msg->message_id == MSG_DESTROY_RTC_UNUSED_PORTS);
   ASSERT(port_ != NULL);
   if (port_ != stun_port_) {
     stun_port_->Destroy();
diff --git a/p2p/base/rawtransportchannel.h b/p2p/base/rawtransportchannel.h
index 52085c0..43c25e5 100644
--- a/p2p/base/rawtransportchannel.h
+++ b/p2p/base/rawtransportchannel.h
@@ -30,14 +30,14 @@
 
 #include <string>
 #include <vector>
-#include "talk/base/messagequeue.h"
+#include "webrtc/base/messagequeue.h"
 #include "talk/p2p/base/transportchannelimpl.h"
 #include "talk/p2p/base/rawtransport.h"
 #include "talk/p2p/base/candidate.h"
 
 #if defined(FEATURE_ENABLE_PSTN)
 
-namespace talk_base {
+namespace rtc {
 class Thread;
 }
 
@@ -54,19 +54,19 @@ class StunPort;
 // address of the other side.  We pick a single address to send them based on
 // a simple investigation of NAT type.
 class RawTransportChannel : public TransportChannelImpl,
-    public talk_base::MessageHandler {
+    public rtc::MessageHandler {
  public:
   RawTransportChannel(const std::string& content_name,
                       int component,
                       RawTransport* transport,
-                      talk_base::Thread *worker_thread,
+                      rtc::Thread *worker_thread,
                       PortAllocator *allocator);
   virtual ~RawTransportChannel();
 
   // Implementation of normal channel packet sending.
   virtual int SendPacket(const char *data, size_t len,
-                         const talk_base::PacketOptions& options, int flags);
-  virtual int SetOption(talk_base::Socket::Option opt, int value);
+                         const rtc::PacketOptions& options, int flags);
+  virtual int SetOption(rtc::Socket::Option opt, int value);
   virtual int GetError();
 
   // Implements TransportChannelImpl.
@@ -91,7 +91,7 @@ class RawTransportChannel : public TransportChannelImpl,
   // have this since we now know where to send.
   virtual void OnCandidate(const Candidate& candidate);
 
-  void OnRemoteAddress(const talk_base::SocketAddress& remote_address);
+  void OnRemoteAddress(const rtc::SocketAddress& remote_address);
 
   // Below ICE specific virtual methods not implemented.
   virtual IceRole GetIceRole() const { return ICEROLE_UNKNOWN; }
@@ -114,11 +114,11 @@ class RawTransportChannel : public TransportChannelImpl,
   virtual bool IsDtlsActive() const { return false; }
 
   // Default implementation.
-  virtual bool GetSslRole(talk_base::SSLRole* role) const {
+  virtual bool GetSslRole(rtc::SSLRole* role) const {
     return false;
   }
 
-  virtual bool SetSslRole(talk_base::SSLRole role) {
+  virtual bool SetSslRole(rtc::SSLRole role) {
     return false;
   }
 
@@ -133,11 +133,11 @@ class RawTransportChannel : public TransportChannelImpl,
   }
 
   // Returns false because the channel is not DTLS.
-  virtual bool GetLocalIdentity(talk_base::SSLIdentity** identity) const {
+  virtual bool GetLocalIdentity(rtc::SSLIdentity** identity) const {
     return false;
   }
 
-  virtual bool GetRemoteCertificate(talk_base::SSLCertificate** cert) const {
+  virtual bool GetRemoteCertificate(rtc::SSLCertificate** cert) const {
     return false;
   }
 
@@ -152,7 +152,7 @@ class RawTransportChannel : public TransportChannelImpl,
     return false;
   }
 
-  virtual bool SetLocalIdentity(talk_base::SSLIdentity* identity) {
+  virtual bool SetLocalIdentity(rtc::SSLIdentity* identity) {
     return false;
   }
 
@@ -166,14 +166,14 @@ class RawTransportChannel : public TransportChannelImpl,
 
  private:
   RawTransport* raw_transport_;
-  talk_base::Thread *worker_thread_;
+  rtc::Thread *worker_thread_;
   PortAllocator* allocator_;
   PortAllocatorSession* allocator_session_;
   StunPort* stun_port_;
   RelayPort* relay_port_;
   PortInterface* port_;
   bool use_relay_;
-  talk_base::SocketAddress remote_address_;
+  rtc::SocketAddress remote_address_;
 
   // Called when the allocator creates another port.
   void OnPortReady(PortAllocatorSession* session, PortInterface* port);
@@ -192,10 +192,10 @@ class RawTransportChannel : public TransportChannelImpl,
 
   // Called when we receive a packet from the other client.
   void OnReadPacket(PortInterface* port, const char* data, size_t size,
-                    const talk_base::SocketAddress& addr);
+                    const rtc::SocketAddress& addr);
 
   // Handles a message to destroy unused ports.
-  virtual void OnMessage(talk_base::Message *msg);
+  virtual void OnMessage(rtc::Message *msg);
 
   DISALLOW_EVIL_CONSTRUCTORS(RawTransportChannel);
 };
diff --git a/p2p/base/relayport.cc b/p2p/base/relayport.cc
index 23571ea..78bf65a 100644
--- a/p2p/base/relayport.cc
+++ b/p2p/base/relayport.cc
@@ -25,9 +25,9 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/asyncpacketsocket.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/asyncpacketsocket.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
 #include "talk/p2p/base/relayport.h"
 
 namespace cricket {
@@ -44,16 +44,16 @@ static const int kSoftConnectTimeoutMs     = 3 * 1000;
 class RelayConnection : public sigslot::has_slots<> {
  public:
   RelayConnection(const ProtocolAddress* protocol_address,
-                  talk_base::AsyncPacketSocket* socket,
-                  talk_base::Thread* thread);
+                  rtc::AsyncPacketSocket* socket,
+                  rtc::Thread* thread);
   ~RelayConnection();
-  talk_base::AsyncPacketSocket* socket() const { return socket_; }
+  rtc::AsyncPacketSocket* socket() const { return socket_; }
 
   const ProtocolAddress* protocol_address() {
     return protocol_address_;
   }
 
-  talk_base::SocketAddress GetAddress() const {
+  rtc::SocketAddress GetAddress() const {
     return protocol_address_->address;
   }
 
@@ -61,13 +61,13 @@ class RelayConnection : public sigslot::has_slots<> {
     return protocol_address_->proto;
   }
 
-  int SetSocketOption(talk_base::Socket::Option opt, int value);
+  int SetSocketOption(rtc::Socket::Option opt, int value);
 
   // Validates a response to a STUN allocate request.
   bool CheckResponse(StunMessage* msg);
 
   // Sends data to the relay server.
-  int Send(const void* pv, size_t cb, const talk_base::PacketOptions& options);
+  int Send(const void* pv, size_t cb, const rtc::PacketOptions& options);
 
   // Sends a STUN allocate request message to the relay server.
   void SendAllocateRequest(RelayEntry* entry, int delay);
@@ -80,7 +80,7 @@ class RelayConnection : public sigslot::has_slots<> {
   void OnSendPacket(const void* data, size_t size, StunRequest* req);
 
  private:
-  talk_base::AsyncPacketSocket* socket_;
+  rtc::AsyncPacketSocket* socket_;
   const ProtocolAddress* protocol_address_;
   StunRequestManager *request_manager_;
 };
@@ -89,16 +89,16 @@ class RelayConnection : public sigslot::has_slots<> {
 // available protocol. We aim to use each connection for only a
 // specific destination address so that we can avoid wrapping every
 // packet in a STUN send / data indication.
-class RelayEntry : public talk_base::MessageHandler,
+class RelayEntry : public rtc::MessageHandler,
                    public sigslot::has_slots<> {
  public:
-  RelayEntry(RelayPort* port, const talk_base::SocketAddress& ext_addr);
+  RelayEntry(RelayPort* port, const rtc::SocketAddress& ext_addr);
   ~RelayEntry();
 
   RelayPort* port() { return port_; }
 
-  const talk_base::SocketAddress& address() const { return ext_addr_; }
-  void set_address(const talk_base::SocketAddress& addr) { ext_addr_ = addr; }
+  const rtc::SocketAddress& address() const { return ext_addr_; }
+  void set_address(const rtc::SocketAddress& addr) { ext_addr_ = addr; }
 
   bool connected() const { return connected_; }
   bool locked() const { return locked_; }
@@ -117,14 +117,14 @@ class RelayEntry : public talk_base::MessageHandler,
 
   // Called when this entry becomes connected.  The address given is the one
   // exposed to the outside world on the relay server.
-  void OnConnect(const talk_base::SocketAddress& mapped_addr,
+  void OnConnect(const rtc::SocketAddress& mapped_addr,
                  RelayConnection* socket);
 
   // Sends a packet to the given destination address using the socket of this
   // entry.  This will wrap the packet in STUN if necessary.
   int SendTo(const void* data, size_t size,
-             const talk_base::SocketAddress& addr,
-             const talk_base::PacketOptions& options);
+             const rtc::SocketAddress& addr,
+             const rtc::PacketOptions& options);
 
   // Schedules a keep-alive allocate request.
   void ScheduleKeepAlive();
@@ -132,41 +132,41 @@ class RelayEntry : public talk_base::MessageHandler,
   void SetServerIndex(size_t sindex) { server_index_ = sindex; }
 
   // Sets this option on the socket of each connection.
-  int SetSocketOption(talk_base::Socket::Option opt, int value);
+  int SetSocketOption(rtc::Socket::Option opt, int value);
 
   size_t ServerIndex() const { return server_index_; }
 
   // Try a different server address
-  void HandleConnectFailure(talk_base::AsyncPacketSocket* socket);
+  void HandleConnectFailure(rtc::AsyncPacketSocket* socket);
 
   // Implementation of the MessageHandler Interface.
-  virtual void OnMessage(talk_base::Message *pmsg);
+  virtual void OnMessage(rtc::Message *pmsg);
 
  private:
   RelayPort* port_;
-  talk_base::SocketAddress ext_addr_;
+  rtc::SocketAddress ext_addr_;
   size_t server_index_;
   bool connected_;
   bool locked_;
   RelayConnection* current_connection_;
 
   // Called when a TCP connection is established or fails
-  void OnSocketConnect(talk_base::AsyncPacketSocket* socket);
-  void OnSocketClose(talk_base::AsyncPacketSocket* socket, int error);
+  void OnSocketConnect(rtc::AsyncPacketSocket* socket);
+  void OnSocketClose(rtc::AsyncPacketSocket* socket, int error);
 
   // Called when a packet is received on this socket.
   void OnReadPacket(
-    talk_base::AsyncPacketSocket* socket,
+    rtc::AsyncPacketSocket* socket,
     const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time);
+    const rtc::SocketAddress& remote_addr,
+    const rtc::PacketTime& packet_time);
   // Called when the socket is currently able to send.
-  void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
+  void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 
   // Sends the given data on the socket to the server with no wrapping.  This
   // returns the number of bytes written or -1 if an error occurred.
   int SendPacket(const void* data, size_t size,
-                 const talk_base::PacketOptions& options);
+                 const rtc::PacketOptions& options);
 };
 
 // Handles an allocate request for a particular RelayEntry.
@@ -190,8 +190,8 @@ class AllocateRequest : public StunRequest {
 };
 
 RelayPort::RelayPort(
-    talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
-    talk_base::Network* network, const talk_base::IPAddress& ip,
+    rtc::Thread* thread, rtc::PacketSocketFactory* factory,
+    rtc::Network* network, const rtc::IPAddress& ip,
     int min_port, int max_port, const std::string& username,
     const std::string& password)
     : Port(thread, RELAY_PORT_TYPE, factory, network, ip, min_port, max_port,
@@ -199,7 +199,7 @@ RelayPort::RelayPort(
       ready_(false),
       error_(0) {
   entries_.push_back(
-      new RelayEntry(this, talk_base::SocketAddress()));
+      new RelayEntry(this, rtc::SocketAddress()));
   // TODO: set local preference value for TCP based candidates.
 }
 
@@ -213,8 +213,8 @@ void RelayPort::AddServerAddress(const ProtocolAddress& addr) {
   // Since HTTP proxies usually only allow 443,
   // let's up the priority on PROTO_SSLTCP
   if (addr.proto == PROTO_SSLTCP &&
-      (proxy().type == talk_base::PROXY_HTTPS ||
-       proxy().type == talk_base::PROXY_UNKNOWN)) {
+      (proxy().type == rtc::PROXY_HTTPS ||
+       proxy().type == rtc::PROXY_UNKNOWN)) {
     server_addr_.push_front(addr);
   } else {
     server_addr_.push_back(addr);
@@ -243,7 +243,7 @@ void RelayPort::SetReady() {
       // In case of Gturn, related address is set to null socket address.
       // This is due to as mapped address stun attribute is used for allocated
       // address.
-      AddAddress(iter->address, iter->address, talk_base::SocketAddress(),
+      AddAddress(iter->address, iter->address, rtc::SocketAddress(),
                  proto_name, RELAY_PORT_TYPE, ICE_TYPE_PREFERENCE_RELAY, false);
     }
     ready_ = true;
@@ -307,8 +307,8 @@ Connection* RelayPort::CreateConnection(const Candidate& address,
 }
 
 int RelayPort::SendTo(const void* data, size_t size,
-                      const talk_base::SocketAddress& addr,
-                      const talk_base::PacketOptions& options,
+                      const rtc::SocketAddress& addr,
+                      const rtc::PacketOptions& options,
                       bool payload) {
   // Try to find an entry for this specific address.  Note that the first entry
   // created was not given an address initially, so it can be set to the first
@@ -361,7 +361,7 @@ int RelayPort::SendTo(const void* data, size_t size,
   return static_cast<int>(size);
 }
 
-int RelayPort::SetOption(talk_base::Socket::Option opt, int value) {
+int RelayPort::SetOption(rtc::Socket::Option opt, int value) {
   int result = 0;
   for (size_t i = 0; i < entries_.size(); ++i) {
     if (entries_[i]->SetSocketOption(opt, value) < 0) {
@@ -373,7 +373,7 @@ int RelayPort::SetOption(talk_base::Socket::Option opt, int value) {
   return result;
 }
 
-int RelayPort::GetOption(talk_base::Socket::Option opt, int* value) {
+int RelayPort::GetOption(rtc::Socket::Option opt, int* value) {
   std::vector<OptionValue>::iterator it;
   for (it = options_.begin(); it < options_.end(); ++it) {
     if (it->first == opt) {
@@ -390,9 +390,9 @@ int RelayPort::GetError() {
 
 void RelayPort::OnReadPacket(
     const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
+    const rtc::SocketAddress& remote_addr,
     ProtocolType proto,
-    const talk_base::PacketTime& packet_time) {
+    const rtc::PacketTime& packet_time) {
   if (Connection* conn = GetConnection(remote_addr)) {
     conn->OnReadPacket(data, size, packet_time);
   } else {
@@ -401,8 +401,8 @@ void RelayPort::OnReadPacket(
 }
 
 RelayConnection::RelayConnection(const ProtocolAddress* protocol_address,
-                                 talk_base::AsyncPacketSocket* socket,
-                                 talk_base::Thread* thread)
+                                 rtc::AsyncPacketSocket* socket,
+                                 rtc::Thread* thread)
     : socket_(socket),
       protocol_address_(protocol_address) {
   request_manager_ = new StunRequestManager(thread);
@@ -415,7 +415,7 @@ RelayConnection::~RelayConnection() {
   delete socket_;
 }
 
-int RelayConnection::SetSocketOption(talk_base::Socket::Option opt,
+int RelayConnection::SetSocketOption(rtc::Socket::Option opt,
                                      int value) {
   if (socket_) {
     return socket_->SetOption(opt, value);
@@ -430,7 +430,7 @@ bool RelayConnection::CheckResponse(StunMessage* msg) {
 void RelayConnection::OnSendPacket(const void* data, size_t size,
                                    StunRequest* req) {
   // TODO(mallinath) Find a way to get DSCP value from Port.
-  talk_base::PacketOptions options;  // Default dscp set to NO_CHANGE.
+  rtc::PacketOptions options;  // Default dscp set to NO_CHANGE.
   int sent = socket_->SendTo(data, size, GetAddress(), options);
   if (sent <= 0) {
     LOG(LS_VERBOSE) << "OnSendPacket: failed sending to " << GetAddress() <<
@@ -440,7 +440,7 @@ void RelayConnection::OnSendPacket(const void* data, size_t size,
 }
 
 int RelayConnection::Send(const void* pv, size_t cb,
-                          const talk_base::PacketOptions& options) {
+                          const rtc::PacketOptions& options) {
   return socket_->SendTo(pv, cb, GetAddress(), options);
 }
 
@@ -449,7 +449,7 @@ void RelayConnection::SendAllocateRequest(RelayEntry* entry, int delay) {
 }
 
 RelayEntry::RelayEntry(RelayPort* port,
-                       const talk_base::SocketAddress& ext_addr)
+                       const rtc::SocketAddress& ext_addr)
     : port_(port), ext_addr_(ext_addr),
       server_index_(0), connected_(false), locked_(false),
       current_connection_(NULL) {
@@ -483,18 +483,18 @@ void RelayEntry::Connect() {
   LOG(LS_INFO) << "Connecting to relay via " << ProtoToString(ra->proto) <<
       " @ " << ra->address.ToSensitiveString();
 
-  talk_base::AsyncPacketSocket* socket = NULL;
+  rtc::AsyncPacketSocket* socket = NULL;
 
   if (ra->proto == PROTO_UDP) {
     // UDP sockets are simple.
     socket = port_->socket_factory()->CreateUdpSocket(
-        talk_base::SocketAddress(port_->ip(), 0),
+        rtc::SocketAddress(port_->ip(), 0),
         port_->min_port(), port_->max_port());
   } else if (ra->proto == PROTO_TCP || ra->proto == PROTO_SSLTCP) {
     int opts = (ra->proto == PROTO_SSLTCP) ?
-     talk_base::PacketSocketFactory::OPT_SSLTCP : 0;
+     rtc::PacketSocketFactory::OPT_SSLTCP : 0;
     socket = port_->socket_factory()->CreateClientTcpSocket(
-        talk_base::SocketAddress(port_->ip(), 0), ra->address,
+        rtc::SocketAddress(port_->ip(), 0), ra->address,
         port_->proxy(), port_->user_agent(), opts);
   } else {
     LOG(LS_WARNING) << "Unknown protocol (" << ra->proto << ")";
@@ -543,7 +543,7 @@ RelayConnection* RelayEntry::GetBestConnection(RelayConnection* conn1,
   return conn1->GetProtocol() <= conn2->GetProtocol() ? conn1 : conn2;
 }
 
-void RelayEntry::OnConnect(const talk_base::SocketAddress& mapped_addr,
+void RelayEntry::OnConnect(const rtc::SocketAddress& mapped_addr,
                            RelayConnection* connection) {
   // We are connected, notify our parent.
   ProtocolType proto = PROTO_UDP;
@@ -556,8 +556,8 @@ void RelayEntry::OnConnect(const talk_base::SocketAddress& mapped_addr,
 }
 
 int RelayEntry::SendTo(const void* data, size_t size,
-                       const talk_base::SocketAddress& addr,
-                       const talk_base::PacketOptions& options) {
+                       const rtc::SocketAddress& addr,
+                       const rtc::PacketOptions& options) {
   // If this connection is locked to the address given, then we can send the
   // packet with no wrapper.
   if (locked_ && (ext_addr_ == addr))
@@ -606,7 +606,7 @@ int RelayEntry::SendTo(const void* data, size_t size,
 
   // TODO: compute the HMAC.
 
-  talk_base::ByteBuffer buf;
+  rtc::ByteBuffer buf;
   request.Write(&buf);
 
   return SendPacket(buf.Data(), buf.Length(), options);
@@ -618,7 +618,7 @@ void RelayEntry::ScheduleKeepAlive() {
   }
 }
 
-int RelayEntry::SetSocketOption(talk_base::Socket::Option opt, int value) {
+int RelayEntry::SetSocketOption(rtc::Socket::Option opt, int value) {
   // Set the option on all available sockets.
   int socket_error = 0;
   if (current_connection_) {
@@ -628,7 +628,7 @@ int RelayEntry::SetSocketOption(talk_base::Socket::Option opt, int value) {
 }
 
 void RelayEntry::HandleConnectFailure(
-    talk_base::AsyncPacketSocket* socket) {
+    rtc::AsyncPacketSocket* socket) {
   // Make sure it's the current connection that has failed, it might
   // be an old socked that has not yet been disposed.
   if (!socket ||
@@ -642,7 +642,7 @@ void RelayEntry::HandleConnectFailure(
   }
 }
 
-void RelayEntry::OnMessage(talk_base::Message *pmsg) {
+void RelayEntry::OnMessage(rtc::Message *pmsg) {
   ASSERT(pmsg->message_id == kMessageConnectTimeout);
   if (current_connection_) {
     const ProtocolAddress* ra = current_connection_->protocol_address();
@@ -663,7 +663,7 @@ void RelayEntry::OnMessage(talk_base::Message *pmsg) {
   }
 }
 
-void RelayEntry::OnSocketConnect(talk_base::AsyncPacketSocket* socket) {
+void RelayEntry::OnSocketConnect(rtc::AsyncPacketSocket* socket) {
   LOG(INFO) << "relay tcp connected to " <<
       socket->GetRemoteAddress().ToSensitiveString();
   if (current_connection_ != NULL) {
@@ -671,17 +671,17 @@ void RelayEntry::OnSocketConnect(talk_base::AsyncPacketSocket* socket) {
   }
 }
 
-void RelayEntry::OnSocketClose(talk_base::AsyncPacketSocket* socket,
+void RelayEntry::OnSocketClose(rtc::AsyncPacketSocket* socket,
                                int error) {
   PLOG(LERROR, error) << "Relay connection failed: socket closed";
   HandleConnectFailure(socket);
 }
 
 void RelayEntry::OnReadPacket(
-    talk_base::AsyncPacketSocket* socket,
+    rtc::AsyncPacketSocket* socket,
     const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    const rtc::SocketAddress& remote_addr,
+    const rtc::PacketTime& packet_time) {
   // ASSERT(remote_addr == port_->server_addr());
   // TODO: are we worried about this?
 
@@ -702,7 +702,7 @@ void RelayEntry::OnReadPacket(
     return;
   }
 
-  talk_base::ByteBuffer buf(data, size);
+  rtc::ByteBuffer buf(data, size);
   RelayMessage msg;
   if (!msg.Read(&buf)) {
     LOG(INFO) << "Incoming packet was not STUN";
@@ -738,7 +738,7 @@ void RelayEntry::OnReadPacket(
     return;
   }
 
-  talk_base::SocketAddress remote_addr2(addr_attr->ipaddr(), addr_attr->port());
+  rtc::SocketAddress remote_addr2(addr_attr->ipaddr(), addr_attr->port());
 
   const StunByteStringAttribute* data_attr = msg.GetByteString(STUN_ATTR_DATA);
   if (!data_attr) {
@@ -751,14 +751,14 @@ void RelayEntry::OnReadPacket(
                       PROTO_UDP, packet_time);
 }
 
-void RelayEntry::OnReadyToSend(talk_base::AsyncPacketSocket* socket) {
+void RelayEntry::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
   if (connected()) {
     port_->OnReadyToSend();
   }
 }
 
 int RelayEntry::SendPacket(const void* data, size_t size,
-                           const talk_base::PacketOptions& options) {
+                           const rtc::PacketOptions& options) {
   int sent = 0;
   if (current_connection_) {
     // We are connected, no need to send packets anywere else than to
@@ -773,7 +773,7 @@ AllocateRequest::AllocateRequest(RelayEntry* entry,
     : StunRequest(new RelayMessage()),
       entry_(entry),
       connection_(connection) {
-  start_time_ = talk_base::Time();
+  start_time_ = rtc::Time();
 }
 
 void AllocateRequest::Prepare(StunMessage* request) {
@@ -788,7 +788,7 @@ void AllocateRequest::Prepare(StunMessage* request) {
 }
 
 int AllocateRequest::GetNextDelay() {
-  int delay = 100 * talk_base::_max(1 << count_, 2);
+  int delay = 100 * rtc::_max(1 << count_, 2);
   count_ += 1;
   if (count_ == 5)
     timeout_ = true;
@@ -803,7 +803,7 @@ void AllocateRequest::OnResponse(StunMessage* response) {
   } else if (addr_attr->family() != 1) {
     LOG(INFO) << "Mapped address has bad family";
   } else {
-    talk_base::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
+    rtc::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
     entry_->OnConnect(addr, connection_);
   }
 
@@ -822,7 +822,7 @@ void AllocateRequest::OnErrorResponse(StunMessage* response) {
               << " reason='" << attr->reason() << "'";
   }
 
-  if (talk_base::TimeSince(start_time_) <= kRetryTimeout)
+  if (rtc::TimeSince(start_time_) <= kRetryTimeout)
     entry_->ScheduleKeepAlive();
 }
 
diff --git a/p2p/base/relayport.h b/p2p/base/relayport.h
index 140c80f..f22d045 100644
--- a/p2p/base/relayport.h
+++ b/p2p/base/relayport.h
@@ -49,12 +49,12 @@ class RelayConnection;
 // successful all other connection attemts are aborted.
 class RelayPort : public Port {
  public:
-  typedef std::pair<talk_base::Socket::Option, int> OptionValue;
+  typedef std::pair<rtc::Socket::Option, int> OptionValue;
 
   // RelayPort doesn't yet do anything fancy in the ctor.
   static RelayPort* Create(
-      talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
-      talk_base::Network* network, const talk_base::IPAddress& ip,
+      rtc::Thread* thread, rtc::PacketSocketFactory* factory,
+      rtc::Network* network, const rtc::IPAddress& ip,
       int min_port, int max_port, const std::string& username,
       const std::string& password) {
     return new RelayPort(thread, factory, network, ip, min_port, max_port,
@@ -71,8 +71,8 @@ class RelayPort : public Port {
   virtual void PrepareAddress();
   virtual Connection* CreateConnection(const Candidate& address,
                                        CandidateOrigin origin);
-  virtual int SetOption(talk_base::Socket::Option opt, int value);
-  virtual int GetOption(talk_base::Socket::Option opt, int* value);
+  virtual int SetOption(rtc::Socket::Option opt, int value);
+  virtual int GetOption(rtc::Socket::Option opt, int* value);
   virtual int GetError();
 
   const ProtocolAddress * ServerAddress(size_t index) const;
@@ -83,8 +83,8 @@ class RelayPort : public Port {
   sigslot::signal1<const ProtocolAddress*> SignalSoftTimeout;
 
  protected:
-  RelayPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
-            talk_base::Network*, const talk_base::IPAddress& ip,
+  RelayPort(rtc::Thread* thread, rtc::PacketSocketFactory* factory,
+            rtc::Network*, const rtc::IPAddress& ip,
             int min_port, int max_port, const std::string& username,
             const std::string& password);
   bool Init();
@@ -92,15 +92,15 @@ class RelayPort : public Port {
   void SetReady();
 
   virtual int SendTo(const void* data, size_t size,
-                     const talk_base::SocketAddress& addr,
-                     const talk_base::PacketOptions& options,
+                     const rtc::SocketAddress& addr,
+                     const rtc::PacketOptions& options,
                      bool payload);
 
   // Dispatches the given packet to the port or connection as appropriate.
   void OnReadPacket(const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
+                    const rtc::SocketAddress& remote_addr,
                     ProtocolType proto,
-                    const talk_base::PacketTime& packet_time);
+                    const rtc::PacketTime& packet_time);
 
  private:
   friend class RelayEntry;
diff --git a/p2p/base/relayport_unittest.cc b/p2p/base/relayport_unittest.cc
index 987fd1e..f7b7fa7 100644
--- a/p2p/base/relayport_unittest.cc
+++ b/p2p/base/relayport_unittest.cc
@@ -25,21 +25,21 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/logging.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketadapters.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/thread.h"
-#include "talk/base/virtualsocketserver.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socketadapters.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/virtualsocketserver.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/relayport.h"
 #include "talk/p2p/base/relayserver.h"
 
-using talk_base::SocketAddress;
+using rtc::SocketAddress;
 
 static const SocketAddress kLocalAddress = SocketAddress("192.168.1.2", 0);
 static const SocketAddress kRelayUdpAddr = SocketAddress("99.99.99.1", 5000);
@@ -61,15 +61,15 @@ class RelayPortTest : public testing::Test,
                       public sigslot::has_slots<> {
  public:
   RelayPortTest()
-      : main_(talk_base::Thread::Current()),
-        physical_socket_server_(new talk_base::PhysicalSocketServer),
-        virtual_socket_server_(new talk_base::VirtualSocketServer(
+      : main_(rtc::Thread::Current()),
+        physical_socket_server_(new rtc::PhysicalSocketServer),
+        virtual_socket_server_(new rtc::VirtualSocketServer(
             physical_socket_server_.get())),
         ss_scope_(virtual_socket_server_.get()),
-        network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY), 32),
-        socket_factory_(talk_base::Thread::Current()),
-        username_(talk_base::CreateRandomString(16)),
-        password_(talk_base::CreateRandomString(16)),
+        network_("unittest", "unittest", rtc::IPAddress(INADDR_ANY), 32),
+        socket_factory_(rtc::Thread::Current()),
+        username_(rtc::CreateRandomString(16)),
+        password_(rtc::CreateRandomString(16)),
         relay_port_(cricket::RelayPort::Create(main_, &socket_factory_,
                                                &network_,
                                                kLocalAddress.ipaddr(),
@@ -77,10 +77,10 @@ class RelayPortTest : public testing::Test,
         relay_server_(new cricket::RelayServer(main_)) {
   }
 
-  void OnReadPacket(talk_base::AsyncPacketSocket* socket,
+  void OnReadPacket(rtc::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time) {
+                    const rtc::SocketAddress& remote_addr,
+                    const rtc::PacketTime& packet_time) {
     received_packet_count_[socket]++;
   }
 
@@ -94,17 +94,17 @@ class RelayPortTest : public testing::Test,
 
  protected:
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
 
   virtual void SetUp() {
     // The relay server needs an external socket to work properly.
-    talk_base::AsyncUDPSocket* ext_socket =
+    rtc::AsyncUDPSocket* ext_socket =
         CreateAsyncUdpSocket(kRelayExtAddr);
     relay_server_->AddExternalSocket(ext_socket);
 
@@ -126,9 +126,9 @@ class RelayPortTest : public testing::Test,
   // abort any other connection attempts.
   void TestConnectUdp() {
     // Add a UDP socket to the relay server.
-    talk_base::AsyncUDPSocket* internal_udp_socket =
+    rtc::AsyncUDPSocket* internal_udp_socket =
         CreateAsyncUdpSocket(kRelayUdpAddr);
-    talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
+    rtc::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
 
     relay_server_->AddInternalSocket(internal_udp_socket);
     relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);
@@ -165,7 +165,7 @@ class RelayPortTest : public testing::Test,
         cricket::ProtocolAddress(kRelayUdpAddr, cricket::PROTO_UDP);
 
     // Create a server socket for the RelayServer.
-    talk_base::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
+    rtc::AsyncSocket* server_socket = CreateServerSocket(kRelayTcpAddr);
     relay_server_->AddInternalServerSocket(server_socket, cricket::PROTO_TCP);
 
     // Add server addresses to the relay port and let it start.
@@ -198,14 +198,14 @@ class RelayPortTest : public testing::Test,
         cricket::ProtocolAddress(kRelayTcpAddr, cricket::PROTO_TCP);
 
     // Create a ssl server socket for the RelayServer.
-    talk_base::AsyncSocket* ssl_server_socket =
+    rtc::AsyncSocket* ssl_server_socket =
         CreateServerSocket(kRelaySslAddr);
     relay_server_->AddInternalServerSocket(ssl_server_socket,
                                            cricket::PROTO_SSLTCP);
 
     // Create a tcp server socket that listens on the fake address so
     // the relay port can attempt to connect to it.
-    talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_server_socket(
+    rtc::scoped_ptr<rtc::AsyncSocket> tcp_server_socket(
         CreateServerSocket(kRelayTcpAddr));
 
     // Add server addresses to the relay port and let it start.
@@ -229,18 +229,18 @@ class RelayPortTest : public testing::Test,
   }
 
  private:
-  talk_base::AsyncUDPSocket* CreateAsyncUdpSocket(const SocketAddress addr) {
-    talk_base::AsyncSocket* socket =
+  rtc::AsyncUDPSocket* CreateAsyncUdpSocket(const SocketAddress addr) {
+    rtc::AsyncSocket* socket =
         virtual_socket_server_->CreateAsyncSocket(SOCK_DGRAM);
-    talk_base::AsyncUDPSocket* packet_socket =
-        talk_base::AsyncUDPSocket::Create(socket, addr);
+    rtc::AsyncUDPSocket* packet_socket =
+        rtc::AsyncUDPSocket::Create(socket, addr);
     EXPECT_TRUE(packet_socket != NULL);
     packet_socket->SignalReadPacket.connect(this, &RelayPortTest::OnReadPacket);
     return packet_socket;
   }
 
-  talk_base::AsyncSocket* CreateServerSocket(const SocketAddress addr) {
-    talk_base::AsyncSocket* socket =
+  rtc::AsyncSocket* CreateServerSocket(const SocketAddress addr) {
+    rtc::AsyncSocket* socket =
         virtual_socket_server_->CreateAsyncSocket(SOCK_STREAM);
     EXPECT_GE(socket->Bind(addr), 0);
     EXPECT_GE(socket->Listen(5), 0);
@@ -267,19 +267,19 @@ class RelayPortTest : public testing::Test,
     return false;
   }
 
-  typedef std::map<talk_base::AsyncPacketSocket*, int> PacketMap;
+  typedef std::map<rtc::AsyncPacketSocket*, int> PacketMap;
 
-  talk_base::Thread* main_;
-  talk_base::scoped_ptr<talk_base::PhysicalSocketServer>
+  rtc::Thread* main_;
+  rtc::scoped_ptr<rtc::PhysicalSocketServer>
       physical_socket_server_;
-  talk_base::scoped_ptr<talk_base::VirtualSocketServer> virtual_socket_server_;
-  talk_base::SocketServerScope ss_scope_;
-  talk_base::Network network_;
-  talk_base::BasicPacketSocketFactory socket_factory_;
+  rtc::scoped_ptr<rtc::VirtualSocketServer> virtual_socket_server_;
+  rtc::SocketServerScope ss_scope_;
+  rtc::Network network_;
+  rtc::BasicPacketSocketFactory socket_factory_;
   std::string username_;
   std::string password_;
-  talk_base::scoped_ptr<cricket::RelayPort> relay_port_;
-  talk_base::scoped_ptr<cricket::RelayServer> relay_server_;
+  rtc::scoped_ptr<cricket::RelayPort> relay_port_;
+  rtc::scoped_ptr<cricket::RelayServer> relay_server_;
   std::vector<cricket::ProtocolAddress> failed_connections_;
   std::vector<cricket::ProtocolAddress> soft_timedout_connections_;
   PacketMap received_packet_count_;
diff --git a/p2p/base/relayserver.cc b/p2p/base/relayserver.cc
index 3dd8506..b5d1ac6 100644
--- a/p2p/base/relayserver.cc
+++ b/p2p/base/relayserver.cc
@@ -33,10 +33,10 @@
 
 #include <algorithm>
 
-#include "talk/base/asynctcpsocket.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/socketadapters.h"
+#include "webrtc/base/asynctcpsocket.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/socketadapters.h"
 
 namespace cricket {
 
@@ -47,9 +47,9 @@ const int MAX_LIFETIME = 15 * 60 * 1000;
 const uint32 USERNAME_LENGTH = 16;
 
 // Calls SendTo on the given socket and logs any bad results.
-void Send(talk_base::AsyncPacketSocket* socket, const char* bytes, size_t size,
-          const talk_base::SocketAddress& addr) {
-  talk_base::PacketOptions options;
+void Send(rtc::AsyncPacketSocket* socket, const char* bytes, size_t size,
+          const rtc::SocketAddress& addr) {
+  rtc::PacketOptions options;
   int result = socket->SendTo(bytes, size, addr, options);
   if (result < static_cast<int>(size)) {
     LOG(LS_ERROR) << "SendTo wrote only " << result << " of " << size
@@ -61,16 +61,16 @@ void Send(talk_base::AsyncPacketSocket* socket, const char* bytes, size_t size,
 
 // Sends the given STUN message on the given socket.
 void SendStun(const StunMessage& msg,
-              talk_base::AsyncPacketSocket* socket,
-              const talk_base::SocketAddress& addr) {
-  talk_base::ByteBuffer buf;
+              rtc::AsyncPacketSocket* socket,
+              const rtc::SocketAddress& addr) {
+  rtc::ByteBuffer buf;
   msg.Write(&buf);
   Send(socket, buf.Data(), buf.Length(), addr);
 }
 
 // Constructs a STUN error response and sends it on the given socket.
-void SendStunError(const StunMessage& msg, talk_base::AsyncPacketSocket* socket,
-                   const talk_base::SocketAddress& remote_addr, int error_code,
+void SendStunError(const StunMessage& msg, rtc::AsyncPacketSocket* socket,
+                   const rtc::SocketAddress& remote_addr, int error_code,
                    const char* error_desc, const std::string& magic_cookie) {
   RelayMessage err_msg;
   err_msg.SetType(GetStunErrorResponseType(msg.type()));
@@ -95,7 +95,7 @@ void SendStunError(const StunMessage& msg, talk_base::AsyncPacketSocket* socket,
   SendStun(err_msg, socket, remote_addr);
 }
 
-RelayServer::RelayServer(talk_base::Thread* thread)
+RelayServer::RelayServer(rtc::Thread* thread)
   : thread_(thread), log_bindings_(true) {
 }
 
@@ -110,20 +110,20 @@ RelayServer::~RelayServer() {
   for (size_t i = 0; i < removed_sockets_.size(); ++i)
     delete removed_sockets_[i];
   while (!server_sockets_.empty()) {
-    talk_base::AsyncSocket* socket = server_sockets_.begin()->first;
+    rtc::AsyncSocket* socket = server_sockets_.begin()->first;
     server_sockets_.erase(server_sockets_.begin()->first);
     delete socket;
   }
 }
 
-void RelayServer::AddInternalSocket(talk_base::AsyncPacketSocket* socket) {
+void RelayServer::AddInternalSocket(rtc::AsyncPacketSocket* socket) {
   ASSERT(internal_sockets_.end() ==
       std::find(internal_sockets_.begin(), internal_sockets_.end(), socket));
   internal_sockets_.push_back(socket);
   socket->SignalReadPacket.connect(this, &RelayServer::OnInternalPacket);
 }
 
-void RelayServer::RemoveInternalSocket(talk_base::AsyncPacketSocket* socket) {
+void RelayServer::RemoveInternalSocket(rtc::AsyncPacketSocket* socket) {
   SocketList::iterator iter =
       std::find(internal_sockets_.begin(), internal_sockets_.end(), socket);
   ASSERT(iter != internal_sockets_.end());
@@ -132,14 +132,14 @@ void RelayServer::RemoveInternalSocket(talk_base::AsyncPacketSocket* socket) {
   socket->SignalReadPacket.disconnect(this);
 }
 
-void RelayServer::AddExternalSocket(talk_base::AsyncPacketSocket* socket) {
+void RelayServer::AddExternalSocket(rtc::AsyncPacketSocket* socket) {
   ASSERT(external_sockets_.end() ==
       std::find(external_sockets_.begin(), external_sockets_.end(), socket));
   external_sockets_.push_back(socket);
   socket->SignalReadPacket.connect(this, &RelayServer::OnExternalPacket);
 }
 
-void RelayServer::RemoveExternalSocket(talk_base::AsyncPacketSocket* socket) {
+void RelayServer::RemoveExternalSocket(rtc::AsyncPacketSocket* socket) {
   SocketList::iterator iter =
       std::find(external_sockets_.begin(), external_sockets_.end(), socket);
   ASSERT(iter != external_sockets_.end());
@@ -148,7 +148,7 @@ void RelayServer::RemoveExternalSocket(talk_base::AsyncPacketSocket* socket) {
   socket->SignalReadPacket.disconnect(this);
 }
 
-void RelayServer::AddInternalServerSocket(talk_base::AsyncSocket* socket,
+void RelayServer::AddInternalServerSocket(rtc::AsyncSocket* socket,
                                           cricket::ProtocolType proto) {
   ASSERT(server_sockets_.end() ==
          server_sockets_.find(socket));
@@ -157,7 +157,7 @@ void RelayServer::AddInternalServerSocket(talk_base::AsyncSocket* socket,
 }
 
 void RelayServer::RemoveInternalServerSocket(
-    talk_base::AsyncSocket* socket) {
+    rtc::AsyncSocket* socket) {
   ServerSocketMap::iterator iter = server_sockets_.find(socket);
   ASSERT(iter != server_sockets_.end());
   server_sockets_.erase(iter);
@@ -168,7 +168,7 @@ int RelayServer::GetConnectionCount() const {
   return static_cast<int>(connections_.size());
 }
 
-talk_base::SocketAddressPair RelayServer::GetConnection(int connection) const {
+rtc::SocketAddressPair RelayServer::GetConnection(int connection) const {
   int i = 0;
   for (ConnectionMap::const_iterator it = connections_.begin();
        it != connections_.end(); ++it) {
@@ -177,10 +177,10 @@ talk_base::SocketAddressPair RelayServer::GetConnection(int connection) const {
     }
     ++i;
   }
-  return talk_base::SocketAddressPair();
+  return rtc::SocketAddressPair();
 }
 
-bool RelayServer::HasConnection(const talk_base::SocketAddress& address) const {
+bool RelayServer::HasConnection(const rtc::SocketAddress& address) const {
   for (ConnectionMap::const_iterator it = connections_.begin();
        it != connections_.end(); ++it) {
     if (it->second->addr_pair().destination() == address) {
@@ -190,18 +190,18 @@ bool RelayServer::HasConnection(const talk_base::SocketAddress& address) const {
   return false;
 }
 
-void RelayServer::OnReadEvent(talk_base::AsyncSocket* socket) {
+void RelayServer::OnReadEvent(rtc::AsyncSocket* socket) {
   ASSERT(server_sockets_.find(socket) != server_sockets_.end());
   AcceptConnection(socket);
 }
 
 void RelayServer::OnInternalPacket(
-    talk_base::AsyncPacketSocket* socket, const char* bytes, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    rtc::AsyncPacketSocket* socket, const char* bytes, size_t size,
+    const rtc::SocketAddress& remote_addr,
+    const rtc::PacketTime& packet_time) {
 
   // Get the address of the connection we just received on.
-  talk_base::SocketAddressPair ap(remote_addr, socket->GetLocalAddress());
+  rtc::SocketAddressPair ap(remote_addr, socket->GetLocalAddress());
   ASSERT(!ap.destination().IsNil());
 
   // If this did not come from an existing connection, it should be a STUN
@@ -241,12 +241,12 @@ void RelayServer::OnInternalPacket(
 }
 
 void RelayServer::OnExternalPacket(
-    talk_base::AsyncPacketSocket* socket, const char* bytes, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    rtc::AsyncPacketSocket* socket, const char* bytes, size_t size,
+    const rtc::SocketAddress& remote_addr,
+    const rtc::PacketTime& packet_time) {
 
   // Get the address of the connection we just received on.
-  talk_base::SocketAddressPair ap(remote_addr, socket->GetLocalAddress());
+  rtc::SocketAddressPair ap(remote_addr, socket->GetLocalAddress());
   ASSERT(!ap.destination().IsNil());
 
   // If this connection already exists, then forward the traffic.
@@ -266,7 +266,7 @@ void RelayServer::OnExternalPacket(
   // The first packet should always be a STUN / TURN packet.  If it isn't, then
   // we should just ignore this packet.
   RelayMessage msg;
-  talk_base::ByteBuffer buf(bytes, size);
+  rtc::ByteBuffer buf(bytes, size);
   if (!msg.Read(&buf)) {
     LOG(LS_WARNING) << "Dropping packet: first packet not STUN";
     return;
@@ -280,7 +280,7 @@ void RelayServer::OnExternalPacket(
     return;
   }
 
-  uint32 length = talk_base::_min(static_cast<uint32>(username_attr->length()),
+  uint32 length = rtc::_min(static_cast<uint32>(username_attr->length()),
                                   USERNAME_LENGTH);
   std::string username(username_attr->bytes(), length);
   // TODO: Check the HMAC.
@@ -310,12 +310,12 @@ void RelayServer::OnExternalPacket(
 }
 
 bool RelayServer::HandleStun(
-    const char* bytes, size_t size, const talk_base::SocketAddress& remote_addr,
-    talk_base::AsyncPacketSocket* socket, std::string* username,
+    const char* bytes, size_t size, const rtc::SocketAddress& remote_addr,
+    rtc::AsyncPacketSocket* socket, std::string* username,
     StunMessage* msg) {
 
   // Parse this into a stun message. Eat the message if this fails.
-  talk_base::ByteBuffer buf(bytes, size);
+  rtc::ByteBuffer buf(bytes, size);
   if (!msg->Read(&buf)) {
     return false;
   }
@@ -338,8 +338,8 @@ bool RelayServer::HandleStun(
 }
 
 void RelayServer::HandleStunAllocate(
-    const char* bytes, size_t size, const talk_base::SocketAddressPair& ap,
-    talk_base::AsyncPacketSocket* socket) {
+    const char* bytes, size_t size, const rtc::SocketAddressPair& ap,
+    rtc::AsyncPacketSocket* socket) {
 
   // Make sure this is a valid STUN request.
   RelayMessage request;
@@ -376,7 +376,7 @@ void RelayServer::HandleStunAllocate(
     const StunUInt32Attribute* lifetime_attr =
         request.GetUInt32(STUN_ATTR_LIFETIME);
     if (lifetime_attr)
-      lifetime = talk_base::_min(lifetime, lifetime_attr->value() * 1000);
+      lifetime = rtc::_min(lifetime, lifetime_attr->value() * 1000);
 
     binding = new RelayServerBinding(this, username, "0", lifetime);
     binding->SignalTimeout.connect(this, &RelayServer::OnTimeout);
@@ -442,7 +442,7 @@ void RelayServer::HandleStunAllocate(
   response.AddAttribute(magic_cookie_attr);
 
   size_t index = rand() % external_sockets_.size();
-  talk_base::SocketAddress ext_addr =
+  rtc::SocketAddress ext_addr =
       external_sockets_[index]->GetLocalAddress();
 
   StunAddressAttribute* addr_attr =
@@ -481,14 +481,14 @@ void RelayServer::HandleStunSend(
     return;
   }
 
-  talk_base::SocketAddress ext_addr(addr_attr->ipaddr(), addr_attr->port());
+  rtc::SocketAddress ext_addr(addr_attr->ipaddr(), addr_attr->port());
   RelayServerConnection* ext_conn =
       int_conn->binding()->GetExternalConnection(ext_addr);
   if (!ext_conn) {
     // Create a new connection to establish the relationship with this binding.
     ASSERT(external_sockets_.size() == 1);
-    talk_base::AsyncPacketSocket* socket = external_sockets_[0];
-    talk_base::SocketAddressPair ap(ext_addr, socket->GetLocalAddress());
+    rtc::AsyncPacketSocket* socket = external_sockets_[0];
+    rtc::SocketAddressPair ap(ext_addr, socket->GetLocalAddress());
     ext_conn = new RelayServerConnection(int_conn->binding(), ap, socket);
     ext_conn->binding()->AddExternalConnection(ext_conn);
     AddConnection(ext_conn);
@@ -545,14 +545,14 @@ void RelayServer::RemoveBinding(RelayServerBinding* binding) {
   }
 }
 
-void RelayServer::OnMessage(talk_base::Message *pmsg) {
+void RelayServer::OnMessage(rtc::Message *pmsg) {
 #if ENABLE_DEBUG
   static const uint32 kMessageAcceptConnection = 1;
   ASSERT(pmsg->message_id == kMessageAcceptConnection);
 #endif
-  talk_base::MessageData* data = pmsg->pdata;
-  talk_base::AsyncSocket* socket =
-      static_cast <talk_base::TypedMessageData<talk_base::AsyncSocket*>*>
+  rtc::MessageData* data = pmsg->pdata;
+  rtc::AsyncSocket* socket =
+      static_cast <rtc::TypedMessageData<rtc::AsyncSocket*>*>
       (data)->data();
   AcceptConnection(socket);
   delete data;
@@ -564,10 +564,10 @@ void RelayServer::OnTimeout(RelayServerBinding* binding) {
   thread_->Dispose(binding);
 }
 
-void RelayServer::AcceptConnection(talk_base::AsyncSocket* server_socket) {
+void RelayServer::AcceptConnection(rtc::AsyncSocket* server_socket) {
   // Check if someone is trying to connect to us.
-  talk_base::SocketAddress accept_addr;
-  talk_base::AsyncSocket* accepted_socket =
+  rtc::SocketAddress accept_addr;
+  rtc::AsyncSocket* accepted_socket =
       server_socket->Accept(&accept_addr);
   if (accepted_socket != NULL) {
     // We had someone trying to connect, now check which protocol to
@@ -575,10 +575,10 @@ void RelayServer::AcceptConnection(talk_base::AsyncSocket* server_socket) {
     ASSERT(server_sockets_[server_socket] == cricket::PROTO_TCP ||
            server_sockets_[server_socket] == cricket::PROTO_SSLTCP);
     if (server_sockets_[server_socket] == cricket::PROTO_SSLTCP) {
-      accepted_socket = new talk_base::AsyncSSLServerSocket(accepted_socket);
+      accepted_socket = new rtc::AsyncSSLServerSocket(accepted_socket);
     }
-    talk_base::AsyncTCPSocket* tcp_socket =
-        new talk_base::AsyncTCPSocket(accepted_socket, false);
+    rtc::AsyncTCPSocket* tcp_socket =
+        new rtc::AsyncTCPSocket(accepted_socket, false);
 
     // Finally add the socket so it can start communicating with the client.
     AddInternalSocket(tcp_socket);
@@ -586,8 +586,8 @@ void RelayServer::AcceptConnection(talk_base::AsyncSocket* server_socket) {
 }
 
 RelayServerConnection::RelayServerConnection(
-    RelayServerBinding* binding, const talk_base::SocketAddressPair& addrs,
-    talk_base::AsyncPacketSocket* socket)
+    RelayServerBinding* binding, const rtc::SocketAddressPair& addrs,
+    rtc::AsyncPacketSocket* socket)
   : binding_(binding), addr_pair_(addrs), socket_(socket), locked_(false) {
   // The creation of a new connection constitutes a use of the binding.
   binding_->NoteUsed();
@@ -606,7 +606,7 @@ void RelayServerConnection::Send(const char* data, size_t size) {
 }
 
 void RelayServerConnection::Send(
-    const char* data, size_t size, const talk_base::SocketAddress& from_addr) {
+    const char* data, size_t size, const rtc::SocketAddress& from_addr) {
   // If the from address is known to the client, we don't need to send it.
   if (locked() && (from_addr == default_dest_)) {
     Send(data, size);
@@ -707,7 +707,7 @@ void RelayServerBinding::AddExternalConnection(RelayServerConnection* conn) {
 }
 
 void RelayServerBinding::NoteUsed() {
-  last_used_ = talk_base::Time();
+  last_used_ = rtc::Time();
 }
 
 bool RelayServerBinding::HasMagicCookie(const char* bytes, size_t size) const {
@@ -719,7 +719,7 @@ bool RelayServerBinding::HasMagicCookie(const char* bytes, size_t size) const {
 }
 
 RelayServerConnection* RelayServerBinding::GetInternalConnection(
-    const talk_base::SocketAddress& ext_addr) {
+    const rtc::SocketAddress& ext_addr) {
 
   // Look for an internal connection that is locked to this address.
   for (size_t i = 0; i < internal_connections_.size(); ++i) {
@@ -734,7 +734,7 @@ RelayServerConnection* RelayServerBinding::GetInternalConnection(
 }
 
 RelayServerConnection* RelayServerBinding::GetExternalConnection(
-    const talk_base::SocketAddress& ext_addr) {
+    const rtc::SocketAddress& ext_addr) {
   for (size_t i = 0; i < external_connections_.size(); ++i) {
     if (ext_addr == external_connections_[i]->addr_pair().source())
       return external_connections_[i];
@@ -742,13 +742,13 @@ RelayServerConnection* RelayServerBinding::GetExternalConnection(
   return 0;
 }
 
-void RelayServerBinding::OnMessage(talk_base::Message *pmsg) {
+void RelayServerBinding::OnMessage(rtc::Message *pmsg) {
   if (pmsg->message_id == MSG_LIFETIME_TIMER) {
     ASSERT(!pmsg->pdata);
 
     // If the lifetime timeout has been exceeded, then send a signal.
     // Otherwise, just keep waiting.
-    if (talk_base::Time() >= last_used_ + lifetime_) {
+    if (rtc::Time() >= last_used_ + lifetime_) {
       LOG(LS_INFO) << "Expiring binding " << username_;
       SignalTimeout(this);
     } else {
diff --git a/p2p/base/relayserver.h b/p2p/base/relayserver.h
index 922a256..5a5b5e2 100644
--- a/p2p/base/relayserver.h
+++ b/p2p/base/relayserver.h
@@ -32,10 +32,10 @@
 #include <vector>
 #include <map>
 
-#include "talk/base/asyncudpsocket.h"
-#include "talk/base/socketaddresspair.h"
-#include "talk/base/thread.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/asyncudpsocket.h"
+#include "webrtc/base/socketaddresspair.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/p2p/base/port.h"
 #include "talk/p2p/base/stun.h"
 
@@ -46,14 +46,14 @@ class RelayServerConnection;
 
 // Relays traffic between connections to the server that are "bound" together.
 // All connections created with the same username/password are bound together.
-class RelayServer : public talk_base::MessageHandler,
+class RelayServer : public rtc::MessageHandler,
                     public sigslot::has_slots<> {
  public:
   // Creates a server, which will use this thread to post messages to itself.
-  explicit RelayServer(talk_base::Thread* thread);
+  explicit RelayServer(rtc::Thread* thread);
   ~RelayServer();
 
-  talk_base::Thread* thread() { return thread_; }
+  rtc::Thread* thread() { return thread_; }
 
   // Indicates whether we will print updates of the number of bindings.
   bool log_bindings() const { return log_bindings_; }
@@ -61,38 +61,38 @@ class RelayServer : public talk_base::MessageHandler,
 
   // Updates the set of sockets that the server uses to talk to "internal"
   // clients.  These are clients that do the "port allocations".
-  void AddInternalSocket(talk_base::AsyncPacketSocket* socket);
-  void RemoveInternalSocket(talk_base::AsyncPacketSocket* socket);
+  void AddInternalSocket(rtc::AsyncPacketSocket* socket);
+  void RemoveInternalSocket(rtc::AsyncPacketSocket* socket);
 
   // Updates the set of sockets that the server uses to talk to "external"
   // clients.  These are the clients that do not do allocations.  They do not
   // know that these addresses represent a relay server.
-  void AddExternalSocket(talk_base::AsyncPacketSocket* socket);
-  void RemoveExternalSocket(talk_base::AsyncPacketSocket* socket);
+  void AddExternalSocket(rtc::AsyncPacketSocket* socket);
+  void RemoveExternalSocket(rtc::AsyncPacketSocket* socket);
 
   // Starts listening for connections on this sockets. When someone
   // tries to connect, the connection will be accepted and a new
   // internal socket will be added.
-  void AddInternalServerSocket(talk_base::AsyncSocket* socket,
+  void AddInternalServerSocket(rtc::AsyncSocket* socket,
                                cricket::ProtocolType proto);
 
   // Removes this server socket from the list.
-  void RemoveInternalServerSocket(talk_base::AsyncSocket* socket);
+  void RemoveInternalServerSocket(rtc::AsyncSocket* socket);
 
   // Methods for testing and debuging.
   int GetConnectionCount() const;
-  talk_base::SocketAddressPair GetConnection(int connection) const;
-  bool HasConnection(const talk_base::SocketAddress& address) const;
+  rtc::SocketAddressPair GetConnection(int connection) const;
+  bool HasConnection(const rtc::SocketAddress& address) const;
 
  private:
-  typedef std::vector<talk_base::AsyncPacketSocket*> SocketList;
-  typedef std::map<talk_base::AsyncSocket*,
+  typedef std::vector<rtc::AsyncPacketSocket*> SocketList;
+  typedef std::map<rtc::AsyncSocket*,
                    cricket::ProtocolType> ServerSocketMap;
   typedef std::map<std::string, RelayServerBinding*> BindingMap;
-  typedef std::map<talk_base::SocketAddressPair,
+  typedef std::map<rtc::SocketAddressPair,
                    RelayServerConnection*> ConnectionMap;
 
-  talk_base::Thread* thread_;
+  rtc::Thread* thread_;
   bool log_bindings_;
   SocketList internal_sockets_;
   SocketList external_sockets_;
@@ -102,25 +102,25 @@ class RelayServer : public talk_base::MessageHandler,
   ConnectionMap connections_;
 
   // Called when a packet is received by the server on one of its sockets.
-  void OnInternalPacket(talk_base::AsyncPacketSocket* socket,
+  void OnInternalPacket(rtc::AsyncPacketSocket* socket,
                         const char* bytes, size_t size,
-                        const talk_base::SocketAddress& remote_addr,
-                        const talk_base::PacketTime& packet_time);
-  void OnExternalPacket(talk_base::AsyncPacketSocket* socket,
+                        const rtc::SocketAddress& remote_addr,
+                        const rtc::PacketTime& packet_time);
+  void OnExternalPacket(rtc::AsyncPacketSocket* socket,
                         const char* bytes, size_t size,
-                        const talk_base::SocketAddress& remote_addr,
-                        const talk_base::PacketTime& packet_time);
+                        const rtc::SocketAddress& remote_addr,
+                        const rtc::PacketTime& packet_time);
 
-  void OnReadEvent(talk_base::AsyncSocket* socket);
+  void OnReadEvent(rtc::AsyncSocket* socket);
 
   // Processes the relevant STUN request types from the client.
   bool HandleStun(const char* bytes, size_t size,
-                  const talk_base::SocketAddress& remote_addr,
-                  talk_base::AsyncPacketSocket* socket,
+                  const rtc::SocketAddress& remote_addr,
+                  rtc::AsyncPacketSocket* socket,
                   std::string* username, StunMessage* msg);
   void HandleStunAllocate(const char* bytes, size_t size,
-                          const talk_base::SocketAddressPair& ap,
-                          talk_base::AsyncPacketSocket* socket);
+                          const rtc::SocketAddressPair& ap,
+                          rtc::AsyncPacketSocket* socket);
   void HandleStun(RelayServerConnection* int_conn, const char* bytes,
                   size_t size);
   void HandleStunAllocate(RelayServerConnection* int_conn,
@@ -133,13 +133,13 @@ class RelayServer : public talk_base::MessageHandler,
   void RemoveBinding(RelayServerBinding* binding);
 
   // Handle messages in our worker thread.
-  void OnMessage(talk_base::Message *pmsg);
+  void OnMessage(rtc::Message *pmsg);
 
   // Called when the timer for checking lifetime times out.
   void OnTimeout(RelayServerBinding* binding);
 
   // Accept connections on this server socket.
-  void AcceptConnection(talk_base::AsyncSocket* server_socket);
+  void AcceptConnection(rtc::AsyncSocket* server_socket);
 
   friend class RelayServerConnection;
   friend class RelayServerBinding;
@@ -150,22 +150,22 @@ class RelayServer : public talk_base::MessageHandler,
 class RelayServerConnection {
  public:
   RelayServerConnection(RelayServerBinding* binding,
-                        const talk_base::SocketAddressPair& addrs,
-                        talk_base::AsyncPacketSocket* socket);
+                        const rtc::SocketAddressPair& addrs,
+                        rtc::AsyncPacketSocket* socket);
   ~RelayServerConnection();
 
   RelayServerBinding* binding() { return binding_; }
-  talk_base::AsyncPacketSocket* socket() { return socket_; }
+  rtc::AsyncPacketSocket* socket() { return socket_; }
 
   // Returns a pair where the source is the remote address and the destination
   // is the local address.
-  const talk_base::SocketAddressPair& addr_pair() { return addr_pair_; }
+  const rtc::SocketAddressPair& addr_pair() { return addr_pair_; }
 
   // Sends a packet to the connected client.  If an address is provided, then
   // we make sure the internal client receives it, wrapping if necessary.
   void Send(const char* data, size_t size);
   void Send(const char* data, size_t size,
-            const talk_base::SocketAddress& ext_addr);
+            const rtc::SocketAddress& ext_addr);
 
   // Sends a STUN message to the connected client with no wrapping.
   void SendStun(const StunMessage& msg);
@@ -179,24 +179,24 @@ class RelayServerConnection {
 
   // Records the address that raw packets should be forwarded to (for internal
   // packets only; for external, we already know where they go).
-  const talk_base::SocketAddress& default_destination() const {
+  const rtc::SocketAddress& default_destination() const {
     return default_dest_;
   }
-  void set_default_destination(const talk_base::SocketAddress& addr) {
+  void set_default_destination(const rtc::SocketAddress& addr) {
     default_dest_ = addr;
   }
 
  private:
   RelayServerBinding* binding_;
-  talk_base::SocketAddressPair addr_pair_;
-  talk_base::AsyncPacketSocket* socket_;
+  rtc::SocketAddressPair addr_pair_;
+  rtc::AsyncPacketSocket* socket_;
   bool locked_;
-  talk_base::SocketAddress default_dest_;
+  rtc::SocketAddress default_dest_;
 };
 
 // Records a set of internal and external connections that we relay between,
 // or in other words, that are "bound" together.
-class RelayServerBinding : public talk_base::MessageHandler {
+class RelayServerBinding : public rtc::MessageHandler {
  public:
   RelayServerBinding(
       RelayServer* server, const std::string& username,
@@ -225,12 +225,12 @@ class RelayServerBinding : public talk_base::MessageHandler {
   // Determines the connection to use to send packets to or from the given
   // external address.
   RelayServerConnection* GetInternalConnection(
-      const talk_base::SocketAddress& ext_addr);
+      const rtc::SocketAddress& ext_addr);
   RelayServerConnection* GetExternalConnection(
-      const talk_base::SocketAddress& ext_addr);
+      const rtc::SocketAddress& ext_addr);
 
   // MessageHandler:
-  void OnMessage(talk_base::Message *pmsg);
+  void OnMessage(rtc::Message *pmsg);
 
  private:
   RelayServer* server_;
diff --git a/p2p/base/relayserver_unittest.cc b/p2p/base/relayserver_unittest.cc
index 239f644..43d288d 100644
--- a/p2p/base/relayserver_unittest.cc
+++ b/p2p/base/relayserver_unittest.cc
@@ -27,17 +27,17 @@
 
 #include <string>
 
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/testclient.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/testclient.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/relayserver.h"
 
-using talk_base::SocketAddress;
+using rtc::SocketAddress;
 using namespace cricket;
 
 static const uint32 LIFETIME = 4;  // seconds
@@ -54,35 +54,35 @@ static const char* msg2 = "Lobster Thermidor a Crevette with a mornay sauce...";
 class RelayServerTest : public testing::Test {
  public:
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   RelayServerTest()
-      : main_(talk_base::Thread::Current()), ss_(main_->socketserver()),
-        username_(talk_base::CreateRandomString(12)),
-        password_(talk_base::CreateRandomString(12)) {
+      : main_(rtc::Thread::Current()), ss_(main_->socketserver()),
+        username_(rtc::CreateRandomString(12)),
+        password_(rtc::CreateRandomString(12)) {
   }
  protected:
   virtual void SetUp() {
     server_.reset(new RelayServer(main_));
 
     server_->AddInternalSocket(
-        talk_base::AsyncUDPSocket::Create(ss_, server_int_addr));
+        rtc::AsyncUDPSocket::Create(ss_, server_int_addr));
     server_->AddExternalSocket(
-        talk_base::AsyncUDPSocket::Create(ss_, server_ext_addr));
+        rtc::AsyncUDPSocket::Create(ss_, server_ext_addr));
 
-    client1_.reset(new talk_base::TestClient(
-        talk_base::AsyncUDPSocket::Create(ss_, client1_addr)));
-    client2_.reset(new talk_base::TestClient(
-        talk_base::AsyncUDPSocket::Create(ss_, client2_addr)));
+    client1_.reset(new rtc::TestClient(
+        rtc::AsyncUDPSocket::Create(ss_, client1_addr)));
+    client2_.reset(new rtc::TestClient(
+        rtc::AsyncUDPSocket::Create(ss_, client2_addr)));
   }
 
   void Allocate() {
-    talk_base::scoped_ptr<StunMessage> req(
+    rtc::scoped_ptr<StunMessage> req(
         CreateStunMessage(STUN_ALLOCATE_REQUEST));
     AddUsernameAttr(req.get(), username_);
     AddLifetimeAttr(req.get(), LIFETIME);
@@ -90,7 +90,7 @@ class RelayServerTest : public testing::Test {
     delete Receive1();
   }
   void Bind() {
-    talk_base::scoped_ptr<StunMessage> req(
+    rtc::scoped_ptr<StunMessage> req(
         CreateStunMessage(STUN_BINDING_REQUEST));
     AddUsernameAttr(req.get(), username_);
     Send2(req.get());
@@ -98,12 +98,12 @@ class RelayServerTest : public testing::Test {
   }
 
   void Send1(const StunMessage* msg) {
-    talk_base::ByteBuffer buf;
+    rtc::ByteBuffer buf;
     msg->Write(&buf);
     SendRaw1(buf.Data(), static_cast<int>(buf.Length()));
   }
   void Send2(const StunMessage* msg) {
-    talk_base::ByteBuffer buf;
+    rtc::ByteBuffer buf;
     msg->Write(&buf);
     SendRaw2(buf.Data(), static_cast<int>(buf.Length()));
   }
@@ -113,7 +113,7 @@ class RelayServerTest : public testing::Test {
   void SendRaw2(const char* data, int len) {
     return Send(client2_.get(), data, len, server_ext_addr);
   }
-  void Send(talk_base::TestClient* client, const char* data,
+  void Send(rtc::TestClient* client, const char* data,
             int len, const SocketAddress& addr) {
     client->SendTo(data, len, addr);
   }
@@ -130,20 +130,20 @@ class RelayServerTest : public testing::Test {
   std::string ReceiveRaw2() {
     return ReceiveRaw(client2_.get());
   }
-  StunMessage* Receive(talk_base::TestClient* client) {
+  StunMessage* Receive(rtc::TestClient* client) {
     StunMessage* msg = NULL;
-    talk_base::TestClient::Packet* packet = client->NextPacket();
+    rtc::TestClient::Packet* packet = client->NextPacket();
     if (packet) {
-      talk_base::ByteBuffer buf(packet->buf, packet->size);
+      rtc::ByteBuffer buf(packet->buf, packet->size);
       msg = new RelayMessage();
       msg->Read(&buf);
       delete packet;
     }
     return msg;
   }
-  std::string ReceiveRaw(talk_base::TestClient* client) {
+  std::string ReceiveRaw(rtc::TestClient* client) {
     std::string raw;
-    talk_base::TestClient::Packet* packet = client->NextPacket();
+    rtc::TestClient::Packet* packet = client->NextPacket();
     if (packet) {
       raw = std::string(packet->buf, packet->size);
       delete packet;
@@ -155,7 +155,7 @@ class RelayServerTest : public testing::Test {
     StunMessage* msg = new RelayMessage();
     msg->SetType(type);
     msg->SetTransactionID(
-        talk_base::CreateRandomString(kStunTransactionIdLength));
+        rtc::CreateRandomString(kStunTransactionIdLength));
     return msg;
   }
   static void AddMagicCookieAttr(StunMessage* msg) {
@@ -184,18 +184,18 @@ class RelayServerTest : public testing::Test {
     msg->AddAttribute(attr);
   }
 
-  talk_base::Thread* main_;
-  talk_base::SocketServer* ss_;
-  talk_base::scoped_ptr<RelayServer> server_;
-  talk_base::scoped_ptr<talk_base::TestClient> client1_;
-  talk_base::scoped_ptr<talk_base::TestClient> client2_;
+  rtc::Thread* main_;
+  rtc::SocketServer* ss_;
+  rtc::scoped_ptr<RelayServer> server_;
+  rtc::scoped_ptr<rtc::TestClient> client1_;
+  rtc::scoped_ptr<rtc::TestClient> client2_;
   std::string username_;
   std::string password_;
 };
 
 // Send a complete nonsense message and verify that it is eaten.
 TEST_F(RelayServerTest, TestBadRequest) {
-  talk_base::scoped_ptr<StunMessage> res;
+  rtc::scoped_ptr<StunMessage> res;
 
   SendRaw1(bad, static_cast<int>(strlen(bad)));
   res.reset(Receive1());
@@ -205,7 +205,7 @@ TEST_F(RelayServerTest, TestBadRequest) {
 
 // Send an allocate request without a username and verify it is rejected.
 TEST_F(RelayServerTest, TestAllocateNoUsername) {
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
 
   Send1(req.get());
@@ -224,7 +224,7 @@ TEST_F(RelayServerTest, TestAllocateNoUsername) {
 
 // Send a binding request and verify that it is rejected.
 TEST_F(RelayServerTest, TestBindingRequest) {
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_BINDING_REQUEST)), res;
   AddUsernameAttr(req.get(), username_);
 
@@ -244,7 +244,7 @@ TEST_F(RelayServerTest, TestBindingRequest) {
 
 // Send an allocate request and verify that it is accepted.
 TEST_F(RelayServerTest, TestAllocate) {
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
   AddUsernameAttr(req.get(), username_);
   AddLifetimeAttr(req.get(), LIFETIME);
@@ -274,7 +274,7 @@ TEST_F(RelayServerTest, TestAllocate) {
 TEST_F(RelayServerTest, TestReallocate) {
   Allocate();
 
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_ALLOCATE_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
@@ -304,7 +304,7 @@ TEST_F(RelayServerTest, TestReallocate) {
 TEST_F(RelayServerTest, TestRemoteBind) {
   Allocate();
 
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_BINDING_REQUEST)), res;
   AddUsernameAttr(req.get(), username_);
 
@@ -318,8 +318,8 @@ TEST_F(RelayServerTest, TestRemoteBind) {
       res->GetByteString(STUN_ATTR_DATA);
   ASSERT_TRUE(recv_data != NULL);
 
-  talk_base::ByteBuffer buf(recv_data->bytes(), recv_data->length());
-  talk_base::scoped_ptr<StunMessage> res2(new StunMessage());
+  rtc::ByteBuffer buf(recv_data->bytes(), recv_data->length());
+  rtc::scoped_ptr<StunMessage> res2(new StunMessage());
   EXPECT_TRUE(res2->Read(&buf));
   EXPECT_EQ(STUN_BINDING_REQUEST, res2->type());
   EXPECT_EQ(req->transaction_id(), res2->transaction_id());
@@ -350,7 +350,7 @@ TEST_F(RelayServerTest, TestSendRequestMissingUsername) {
   Allocate();
   Bind();
 
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
 
@@ -373,7 +373,7 @@ TEST_F(RelayServerTest, TestSendRequestBadUsername) {
   Allocate();
   Bind();
 
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), "foobarbizbaz");
@@ -398,7 +398,7 @@ TEST_F(RelayServerTest, TestSendRequestNoDestinationAddress) {
   Allocate();
   Bind();
 
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
@@ -422,7 +422,7 @@ TEST_F(RelayServerTest, TestSendRequestNoData) {
   Allocate();
   Bind();
 
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
@@ -447,7 +447,7 @@ TEST_F(RelayServerTest, TestSendRequestWrongType) {
   Allocate();
   Bind();
 
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_BINDING_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
@@ -473,7 +473,7 @@ TEST_F(RelayServerTest, TestSendRaw) {
   Bind();
 
   for (int i = 0; i < 10; i++) {
-    talk_base::scoped_ptr<StunMessage> req(
+    rtc::scoped_ptr<StunMessage> req(
         CreateStunMessage(STUN_SEND_REQUEST)), res;
     AddMagicCookieAttr(req.get());
     AddUsernameAttr(req.get(), username_);
@@ -513,9 +513,9 @@ TEST_F(RelayServerTest, TestExpiration) {
   Bind();
 
   // Wait twice the lifetime to make sure the server has expired the binding.
-  talk_base::Thread::Current()->ProcessMessages((LIFETIME * 2) * 1000);
+  rtc::Thread::Current()->ProcessMessages((LIFETIME * 2) * 1000);
 
-  talk_base::scoped_ptr<StunMessage> req(
+  rtc::scoped_ptr<StunMessage> req(
       CreateStunMessage(STUN_SEND_REQUEST)), res;
   AddMagicCookieAttr(req.get());
   AddUsernameAttr(req.get(), username_);
diff --git a/p2p/base/session.cc b/p2p/base/session.cc
index 0eefe6c..6c98fe1 100644
--- a/p2p/base/session.cc
+++ b/p2p/base/session.cc
@@ -27,12 +27,12 @@
 
 #include "talk/p2p/base/session.h"
 
-#include "talk/base/bind.h"
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/helpers.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sslstreamadapter.h"
+#include "webrtc/base/bind.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sslstreamadapter.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/jid.h"
 #include "talk/p2p/base/dtlstransport.h"
@@ -46,7 +46,7 @@
 
 namespace cricket {
 
-using talk_base::Bind;
+using rtc::Bind;
 
 bool BadMessage(const buzz::QName type,
                 const std::string& text,
@@ -69,13 +69,13 @@ const std::string& TransportProxy::type() const {
 }
 
 TransportChannel* TransportProxy::GetChannel(int component) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   return GetChannelProxy(component);
 }
 
 TransportChannel* TransportProxy::CreateChannel(
     const std::string& name, int component) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(GetChannel(component) == NULL);
   ASSERT(!transport_->get()->HasChannel(component));
 
@@ -99,7 +99,7 @@ bool TransportProxy::HasChannel(int component) {
 }
 
 void TransportProxy::DestroyChannel(int component) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   TransportChannel* channel = GetChannel(component);
   if (channel) {
     // If the state of TransportProxy is not NEGOTIATED
@@ -204,7 +204,7 @@ TransportChannelImpl* TransportProxy::GetOrCreateChannelProxyImpl(
 
 TransportChannelImpl* TransportProxy::GetOrCreateChannelProxyImpl_w(
     int component) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   TransportChannelImpl* impl = transport_->get()->GetChannel(component);
   if (impl == NULL) {
     impl = transport_->get()->CreateChannel(component);
@@ -220,7 +220,7 @@ void TransportProxy::SetupChannelProxy(
 
 void TransportProxy::SetupChannelProxy_w(
     int component, TransportChannelProxy* transproxy) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   TransportChannelImpl* impl = GetOrCreateChannelProxyImpl(component);
   ASSERT(impl != NULL);
   transproxy->SetImplementation(impl);
@@ -234,7 +234,7 @@ void TransportProxy::ReplaceChannelProxyImpl(TransportChannelProxy* proxy,
 
 void TransportProxy::ReplaceChannelProxyImpl_w(TransportChannelProxy* proxy,
                                                TransportChannelImpl* impl) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(proxy != NULL);
   proxy->SetImplementation(impl);
 }
@@ -336,7 +336,7 @@ bool TransportProxy::OnRemoteCandidates(const Candidates& candidates,
 }
 
 void TransportProxy::SetIdentity(
-    talk_base::SSLIdentity* identity) {
+    rtc::SSLIdentity* identity) {
   transport_->get()->SetIdentity(identity);
 }
 
@@ -377,11 +377,11 @@ std::string BaseSession::StateToString(State state) {
     default:
       break;
   }
-  return "STATE_" + talk_base::ToString(state);
+  return "STATE_" + rtc::ToString(state);
 }
 
-BaseSession::BaseSession(talk_base::Thread* signaling_thread,
-                         talk_base::Thread* worker_thread,
+BaseSession::BaseSession(rtc::Thread* signaling_thread,
+                         rtc::Thread* worker_thread,
                          PortAllocator* port_allocator,
                          const std::string& sid,
                          const std::string& content_type,
@@ -396,7 +396,7 @@ BaseSession::BaseSession(talk_base::Thread* signaling_thread,
       transport_type_(NS_GINGLE_P2P),
       initiator_(initiator),
       identity_(NULL),
-      ice_tiebreaker_(talk_base::CreateRandomId64()),
+      ice_tiebreaker_(rtc::CreateRandomId64()),
       role_switch_(false) {
   ASSERT(signaling_thread->IsCurrent());
 }
@@ -447,7 +447,7 @@ const SessionDescription* BaseSession::initiator_description() const {
   return initiator_ ? local_description_.get() : remote_description_.get();
 }
 
-bool BaseSession::SetIdentity(talk_base::SSLIdentity* identity) {
+bool BaseSession::SetIdentity(rtc::SSLIdentity* identity) {
   if (identity_)
     return false;
   identity_ = identity;
@@ -910,7 +910,7 @@ bool BaseSession::GetContentAction(ContentAction* action,
   return true;
 }
 
-void BaseSession::OnMessage(talk_base::Message *pmsg) {
+void BaseSession::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
   case MSG_TIMEOUT:
     // Session timeout has occured.
@@ -1562,7 +1562,7 @@ void Session::SetError(Error error, const std::string& error_desc) {
     signaling_thread()->Post(this, MSG_ERROR);
 }
 
-void Session::OnMessage(talk_base::Message* pmsg) {
+void Session::OnMessage(rtc::Message* pmsg) {
   // preserve this because BaseSession::OnMessage may modify it
   State orig_state = state();
 
@@ -1710,7 +1710,7 @@ bool Session::SendMessage(ActionType type, const XmlElements& action_elems,
 
 bool Session::SendMessage(ActionType type, const XmlElements& action_elems,
                           const std::string& remote_name, SessionError* error) {
-  talk_base::scoped_ptr<buzz::XmlElement> stanza(
+  rtc::scoped_ptr<buzz::XmlElement> stanza(
       new buzz::XmlElement(buzz::QN_IQ));
 
   SessionMessage msg(current_protocol_, type, id(), initiator_name());
@@ -1724,7 +1724,7 @@ bool Session::SendMessage(ActionType type, const XmlElements& action_elems,
 template <typename Action>
 bool Session::SendMessage(ActionType type, const Action& action,
                           SessionError* error) {
-  talk_base::scoped_ptr<buzz::XmlElement> stanza(
+  rtc::scoped_ptr<buzz::XmlElement> stanza(
       new buzz::XmlElement(buzz::QN_IQ));
   if (!WriteActionMessage(type, action, stanza.get(), error))
     return false;
@@ -1765,7 +1765,7 @@ bool Session::WriteActionMessage(SignalingProtocol protocol,
 }
 
 void Session::SendAcknowledgementMessage(const buzz::XmlElement* stanza) {
-  talk_base::scoped_ptr<buzz::XmlElement> ack(
+  rtc::scoped_ptr<buzz::XmlElement> ack(
       new buzz::XmlElement(buzz::QN_IQ));
   ack->SetAttr(buzz::QN_TO, remote_name());
   ack->SetAttr(buzz::QN_ID, stanza->Attr(buzz::QN_ID));
diff --git a/p2p/base/session.h b/p2p/base/session.h
index 4f99f16..2c6c252 100644
--- a/p2p/base/session.h
+++ b/p2p/base/session.h
@@ -33,10 +33,10 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/refcount.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/scoped_ref_ptr.h"
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/socketaddress.h"
 #include "talk/p2p/base/parsing.h"
 #include "talk/p2p/base/port.h"
 #include "talk/p2p/base/sessionclient.h"
@@ -55,7 +55,7 @@ class TransportChannel;
 class TransportChannelProxy;
 class TransportChannelImpl;
 
-typedef talk_base::RefCountedObject<talk_base::scoped_ptr<Transport> >
+typedef rtc::RefCountedObject<rtc::scoped_ptr<Transport> >
 TransportWrapper;
 
 // Used for errors that will send back a specific error message to the
@@ -91,7 +91,7 @@ class TransportProxy : public sigslot::has_slots<>,
                        public CandidateTranslator {
  public:
   TransportProxy(
-      talk_base::Thread* worker_thread,
+      rtc::Thread* worker_thread,
       const std::string& sid,
       const std::string& content_name,
       TransportWrapper* transport)
@@ -145,7 +145,7 @@ class TransportProxy : public sigslot::has_slots<>,
 
   // Simple functions that thunk down to the same functions on Transport.
   void SetIceRole(IceRole role);
-  void SetIdentity(talk_base::SSLIdentity* identity);
+  void SetIdentity(rtc::SSLIdentity* identity);
   bool SetLocalTransportDescription(const TransportDescription& description,
                                     ContentAction action,
                                     std::string* error_desc);
@@ -195,10 +195,10 @@ class TransportProxy : public sigslot::has_slots<>,
   void ReplaceChannelProxyImpl_w(TransportChannelProxy* proxy,
                                  TransportChannelImpl* impl);
 
-  talk_base::Thread* const worker_thread_;
+  rtc::Thread* const worker_thread_;
   const std::string sid_;
   const std::string content_name_;
-  talk_base::scoped_refptr<TransportWrapper> transport_;
+  rtc::scoped_refptr<TransportWrapper> transport_;
   bool connecting_;
   bool negotiated_;
   ChannelMap channels_;
@@ -228,7 +228,7 @@ struct SessionStats {
 // packets are represented by TransportChannels.  The application-level protocol
 // is represented by SessionDecription objects.
 class BaseSession : public sigslot::has_slots<>,
-                    public talk_base::MessageHandler {
+                    public rtc::MessageHandler {
  public:
   enum {
     MSG_TIMEOUT = 0,
@@ -267,8 +267,8 @@ class BaseSession : public sigslot::has_slots<>,
   // Convert State to a readable string.
   static std::string StateToString(State state);
 
-  BaseSession(talk_base::Thread* signaling_thread,
-              talk_base::Thread* worker_thread,
+  BaseSession(rtc::Thread* signaling_thread,
+              rtc::Thread* worker_thread,
               PortAllocator* port_allocator,
               const std::string& sid,
               const std::string& content_type,
@@ -276,8 +276,8 @@ class BaseSession : public sigslot::has_slots<>,
   virtual ~BaseSession();
 
   // These are const to allow them to be called from const methods.
-  talk_base::Thread* signaling_thread() const { return signaling_thread_; }
-  talk_base::Thread* worker_thread() const { return worker_thread_; }
+  rtc::Thread* signaling_thread() const { return signaling_thread_; }
+  rtc::Thread* worker_thread() const { return worker_thread_; }
   PortAllocator* port_allocator() const { return port_allocator_; }
 
   // The ID of this session.
@@ -371,11 +371,11 @@ class BaseSession : public sigslot::has_slots<>,
   // This avoids exposing the internal structures used to track them.
   virtual bool GetStats(SessionStats* stats);
 
-  talk_base::SSLIdentity* identity() { return identity_; }
+  rtc::SSLIdentity* identity() { return identity_; }
 
  protected:
   // Specifies the identity to use in this session.
-  bool SetIdentity(talk_base::SSLIdentity* identity);
+  bool SetIdentity(rtc::SSLIdentity* identity);
 
   bool PushdownTransportDescription(ContentSource source,
                                     ContentAction action,
@@ -464,7 +464,7 @@ class BaseSession : public sigslot::has_slots<>,
   virtual void OnRoleConflict();
 
   // Handles messages posted to us.
-  virtual void OnMessage(talk_base::Message *pmsg);
+  virtual void OnMessage(rtc::Message *pmsg);
 
  protected:
   State state_;
@@ -504,16 +504,16 @@ class BaseSession : public sigslot::has_slots<>,
   // Gets the ContentAction and ContentSource according to the session state.
   bool GetContentAction(ContentAction* action, ContentSource* source);
 
-  talk_base::Thread* const signaling_thread_;
-  talk_base::Thread* const worker_thread_;
+  rtc::Thread* const signaling_thread_;
+  rtc::Thread* const worker_thread_;
   PortAllocator* const port_allocator_;
   const std::string sid_;
   const std::string content_type_;
   const std::string transport_type_;
   bool initiator_;
-  talk_base::SSLIdentity* identity_;
-  talk_base::scoped_ptr<const SessionDescription> local_description_;
-  talk_base::scoped_ptr<SessionDescription> remote_description_;
+  rtc::SSLIdentity* identity_;
+  rtc::scoped_ptr<const SessionDescription> local_description_;
+  rtc::scoped_ptr<SessionDescription> remote_description_;
   uint64 ice_tiebreaker_;
   // This flag will be set to true after the first role switch. This flag
   // will enable us to stop any role switch during the call.
@@ -628,7 +628,7 @@ class Session : public BaseSession {
                                     const std::string& type,
                                     const std::string& text,
                                     const buzz::XmlElement* extra_info);
-  virtual void OnMessage(talk_base::Message *pmsg);
+  virtual void OnMessage(rtc::Message *pmsg);
 
   // Send various kinds of session messages.
   bool SendInitiateMessage(const SessionDescription* sdesc,
diff --git a/p2p/base/session_unittest.cc b/p2p/base/session_unittest.cc
index 1c08bf1..758c5e9 100644
--- a/p2p/base/session_unittest.cc
+++ b/p2p/base/session_unittest.cc
@@ -31,14 +31,14 @@
 #include <deque>
 #include <map>
 
-#include "talk/base/base64.h"
-#include "talk/base/common.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/natserver.h"
-#include "talk/base/natsocketfactory.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/base64.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/natserver.h"
+#include "webrtc/base/natsocketfactory.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/parsing.h"
@@ -82,17 +82,17 @@ int GetPort(int port_index) {
 }
 
 std::string GetPortString(int port_index) {
-  return talk_base::ToString(GetPort(port_index));
+  return rtc::ToString(GetPort(port_index));
 }
 
 // Only works for port_index < 10, which is fine for our purposes.
 std::string GetUsername(int port_index) {
-  return "username" + std::string(8, talk_base::ToString(port_index)[0]);
+  return "username" + std::string(8, rtc::ToString(port_index)[0]);
 }
 
 // Only works for port_index < 10, which is fine for our purposes.
 std::string GetPassword(int port_index) {
-  return "password" + std::string(8, talk_base::ToString(port_index)[0]);
+  return "password" + std::string(8, rtc::ToString(port_index)[0]);
 }
 
 std::string IqAck(const std::string& id,
@@ -164,7 +164,7 @@ std::string P2pCandidateXml(const std::string& name, int port_index) {
   if (name == "rtcp" || name == "video_rtcp" || name == "chanb") {
     char next_ch = username[username.size() - 1];
     ASSERT(username.size() > 0);
-    talk_base::Base64::GetNextBase64Char(next_ch, &next_ch);
+    rtc::Base64::GetNextBase64Char(next_ch, &next_ch);
     username[username.size() - 1] = next_ch;
   }
   return "<candidate"
@@ -599,8 +599,8 @@ class TestPortAllocatorSession : public cricket::PortAllocatorSession {
         ports_(kNumPorts),
         address_("127.0.0.1", 0),
         network_("network", "unittest",
-                 talk_base::IPAddress(INADDR_LOOPBACK), 8),
-        socket_factory_(talk_base::Thread::Current()),
+                 rtc::IPAddress(INADDR_LOOPBACK), 8),
+        socket_factory_(rtc::Thread::Current()),
         running_(false),
         port_(28653) {
     network_.AddIP(address_.ipaddr());
@@ -615,7 +615,7 @@ class TestPortAllocatorSession : public cricket::PortAllocatorSession {
     for (int i = 0; i < kNumPorts; i++) {
       int index = port_offset_ + i;
       ports_[i] = cricket::UDPPort::Create(
-          talk_base::Thread::Current(), &socket_factory_,
+          rtc::Thread::Current(), &socket_factory_,
           &network_, address_.ipaddr(), GetPort(index), GetPort(index),
           GetUsername(index), GetPassword(index));
       AddPort(ports_[i]);
@@ -651,9 +651,9 @@ class TestPortAllocatorSession : public cricket::PortAllocatorSession {
  private:
   int port_offset_;
   std::vector<cricket::Port*> ports_;
-  talk_base::SocketAddress address_;
-  talk_base::Network network_;
-  talk_base::BasicPacketSocketFactory socket_factory_;
+  rtc::SocketAddress address_;
+  rtc::Network network_;
+  rtc::BasicPacketSocketFactory socket_factory_;
   bool running_;
   int port_;
 };
@@ -801,7 +801,7 @@ struct ChannelHandler : sigslot::has_slots<> {
   }
 
   void OnReadPacket(cricket::TransportChannel* p, const char* buf,
-                    size_t size, const talk_base::PacketTime& time, int flags) {
+                    size_t size, const rtc::PacketTime& time, int flags) {
     if (memcmp(buf, name.c_str(), name.size()) != 0)
       return;  // drop packet if packet doesn't belong to this channel. This
                // can happen when transport channels are muxed together.
@@ -815,7 +815,7 @@ struct ChannelHandler : sigslot::has_slots<> {
   }
 
   void Send(const char* data, size_t size) {
-    talk_base::PacketOptions options;
+    rtc::PacketOptions options;
     std::string data_with_id(name);
     data_with_id += data;
     int result = channel->SendPacket(data_with_id.c_str(), data_with_id.size(),
@@ -1108,15 +1108,15 @@ class TestClient : public sigslot::has_slots<> {
   cricket::ContentAction last_content_action;
   cricket::ContentSource last_content_source;
   std::deque<buzz::XmlElement*> sent_stanzas;
-  talk_base::scoped_ptr<buzz::XmlElement> last_expected_sent_stanza;
+  rtc::scoped_ptr<buzz::XmlElement> last_expected_sent_stanza;
 
   cricket::SessionManager* session_manager;
   TestSessionClient* client;
   cricket::PortAllocator* port_allocator_;
   cricket::Session* session;
   cricket::BaseSession::State last_session_state;
-  talk_base::scoped_ptr<ChannelHandler> chan_a;
-  talk_base::scoped_ptr<ChannelHandler> chan_b;
+  rtc::scoped_ptr<ChannelHandler> chan_a;
+  rtc::scoped_ptr<ChannelHandler> chan_b;
   bool blow_up_on_error;
   int error_count;
 };
@@ -1125,11 +1125,11 @@ class SessionTest : public testing::Test {
  protected:
   virtual void SetUp() {
     // Seed needed for each test to satisfy expectations.
-    talk_base::SetRandomTestMode(true);
+    rtc::SetRandomTestMode(true);
   }
 
   virtual void TearDown() {
-    talk_base::SetRandomTestMode(false);
+    rtc::SetRandomTestMode(false);
   }
 
   // Tests sending data between two clients, over two channels.
@@ -1185,17 +1185,17 @@ class SessionTest : public testing::Test {
                    const std::string& transport_info_reply_b_xml,
                    const std::string& accept_xml,
                    bool bundle = false) {
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, initiator_protocol,
                        content_type,
                        content_name_a,  channel_name_a,
                        content_name_b,  channel_name_b));
-    talk_base::scoped_ptr<TestClient> responder(
+    rtc::scoped_ptr<TestClient> responder(
         new TestClient(allocator.get(), &next_message_id,
                        kResponder, responder_protocol,
                        content_type,
@@ -1624,18 +1624,18 @@ class SessionTest : public testing::Test {
         protocol, content_name, content_type);
     std::string responder_full = kResponder + "/full";
 
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, protocol,
                        content_type,
                        content_name, channel_name_a,
                        content_name, channel_name_b));
 
-    talk_base::scoped_ptr<TestClient> responder(
+    rtc::scoped_ptr<TestClient> responder(
         new TestClient(allocator.get(), &next_message_id,
                        responder_full, protocol,
                        content_type,
@@ -1676,7 +1676,7 @@ class SessionTest : public testing::Test {
     // Send an unauthorized redirect to the initiator and expect it be ignored.
     initiator->blow_up_on_error = false;
     const buzz::XmlElement* initiate_stanza = initiator->stanza();
-    talk_base::scoped_ptr<buzz::XmlElement> redirect_stanza(
+    rtc::scoped_ptr<buzz::XmlElement> redirect_stanza(
         buzz::XmlElement::ForStr(
             IqError("ER", kResponder, kInitiator,
                     RedirectXml(protocol, initiate_xml, "not@allowed.com"))));
@@ -1706,18 +1706,18 @@ class SessionTest : public testing::Test {
         protocol, content_name, content_type);
     std::string responder_full = kResponder + "/full";
 
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, protocol,
                        content_type,
                        content_name, channel_name_a,
                        content_name, channel_name_b));
 
-    talk_base::scoped_ptr<TestClient> responder(
+    rtc::scoped_ptr<TestClient> responder(
         new TestClient(allocator.get(), &next_message_id,
                        responder_full, protocol,
                        content_type,
@@ -1758,7 +1758,7 @@ class SessionTest : public testing::Test {
     // Send a redirect to the initiator and expect all of the message
     // to be resent.
     const buzz::XmlElement* initiate_stanza = initiator->stanza();
-    talk_base::scoped_ptr<buzz::XmlElement> redirect_stanza(
+    rtc::scoped_ptr<buzz::XmlElement> redirect_stanza(
         buzz::XmlElement::ForStr(
             IqError("ER2", kResponder, kInitiator,
                     RedirectXml(protocol, initiate_xml, responder_full))));
@@ -1851,18 +1851,18 @@ class SessionTest : public testing::Test {
     std::string channel_name_b = "rtcp";
     cricket::SignalingProtocol protocol = PROTOCOL_JINGLE;
 
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, protocol,
                        content_type,
                        content_name,  channel_name_a,
                        content_name,  channel_name_b));
 
-    talk_base::scoped_ptr<TestClient> responder(
+    rtc::scoped_ptr<TestClient> responder(
         new TestClient(allocator.get(), &next_message_id,
                        kResponder, protocol,
                        content_type,
@@ -1988,18 +1988,18 @@ class SessionTest : public testing::Test {
     std::string content_name = "main";
     std::string content_type = "http://oink.splat/session";
 
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, protocol,
                        content_type,
                        content_name, "a",
                        content_name, "b"));
 
-    talk_base::scoped_ptr<TestClient> responder(
+    rtc::scoped_ptr<TestClient> responder(
         new TestClient(allocator.get(), &next_message_id,
                        kResponder, protocol,
                        content_type,
@@ -2042,11 +2042,11 @@ class SessionTest : public testing::Test {
     std::string content_name = "main";
     std::string content_type = "http://oink.splat/session";
 
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, protocol,
                        content_type,
@@ -2124,13 +2124,13 @@ class SessionTest : public testing::Test {
   }
 
   void TestSendDescriptionInfo() {
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
     std::string content_name = "content-name";
     std::string content_type = "content-type";
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, PROTOCOL_JINGLE,
                        content_type,
@@ -2178,13 +2178,13 @@ class SessionTest : public testing::Test {
   }
 
   void TestCallerSignalNewDescription() {
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
     std::string content_name = "content-name";
     std::string content_type = "content-type";
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, PROTOCOL_JINGLE,
                        content_type,
@@ -2218,13 +2218,13 @@ class SessionTest : public testing::Test {
   }
 
   void TestCalleeSignalNewDescription() {
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
     std::string content_name = "content-name";
     std::string content_type = "content-type";
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, PROTOCOL_JINGLE,
                        content_type,
@@ -2258,13 +2258,13 @@ class SessionTest : public testing::Test {
   }
 
   void TestGetTransportStats() {
-    talk_base::scoped_ptr<cricket::PortAllocator> allocator(
+    rtc::scoped_ptr<cricket::PortAllocator> allocator(
         new TestPortAllocator());
     int next_message_id = 0;
 
     std::string content_name = "content-name";
     std::string content_type = "content-type";
-    talk_base::scoped_ptr<TestClient> initiator(
+    rtc::scoped_ptr<TestClient> initiator(
         new TestClient(allocator.get(), &next_message_id,
                        kInitiator, PROTOCOL_JINGLE,
                        content_type,
diff --git a/p2p/base/sessiondescription.h b/p2p/base/sessiondescription.h
index d33b4c3..8d56a96 100644
--- a/p2p/base/sessiondescription.h
+++ b/p2p/base/sessiondescription.h
@@ -31,7 +31,7 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/constructormagic.h"
+#include "webrtc/base/constructormagic.h"
 #include "talk/p2p/base/transportinfo.h"
 
 namespace cricket {
diff --git a/p2p/base/sessionmanager.cc b/p2p/base/sessionmanager.cc
index 15b7452..a8782c4 100644
--- a/p2p/base/sessionmanager.cc
+++ b/p2p/base/sessionmanager.cc
@@ -27,11 +27,11 @@
 
 #include "talk/p2p/base/sessionmanager.h"
 
-#include "talk/base/common.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/session.h"
 #include "talk/p2p/base/sessionmessages.h"
@@ -41,11 +41,11 @@
 namespace cricket {
 
 SessionManager::SessionManager(PortAllocator *allocator,
-                               talk_base::Thread *worker) {
+                               rtc::Thread *worker) {
   allocator_ = allocator;
-  signaling_thread_ = talk_base::Thread::Current();
+  signaling_thread_ = rtc::Thread::Current();
   if (worker == NULL) {
-    worker_thread_ = talk_base::Thread::Current();
+    worker_thread_ = rtc::Thread::Current();
   } else {
     worker_thread_ = worker;
   }
@@ -87,7 +87,7 @@ Session* SessionManager::CreateSession(const std::string& id,
                                        const std::string& local_name,
                                        const std::string& content_type) {
   std::string sid =
-      id.empty() ? talk_base::ToString(talk_base::CreateRandomId64()) : id;
+      id.empty() ? rtc::ToString(rtc::CreateRandomId64()) : id;
   return CreateSession(local_name, local_name, sid, content_type, false);
 }
 
@@ -231,7 +231,7 @@ void SessionManager::OnFailedSend(const buzz::XmlElement* orig_stanza,
 
   Session* session = FindSession(msg.sid, msg.to);
   if (session) {
-    talk_base::scoped_ptr<buzz::XmlElement> synthetic_error;
+    rtc::scoped_ptr<buzz::XmlElement> synthetic_error;
     if (!error_stanza) {
       // A failed send is semantically equivalent to an error response, so we
       // can just turn the former into the latter.
@@ -250,7 +250,7 @@ void SessionManager::SendErrorMessage(const buzz::XmlElement* stanza,
                                       const std::string& type,
                                       const std::string& text,
                                       const buzz::XmlElement* extra_info) {
-  talk_base::scoped_ptr<buzz::XmlElement> msg(
+  rtc::scoped_ptr<buzz::XmlElement> msg(
       CreateErrorMessage(stanza, name, type, text, extra_info));
   SignalOutgoingMessage(this, msg.get());
 }
diff --git a/p2p/base/sessionmanager.h b/p2p/base/sessionmanager.h
index d88e050..55cf78d 100644
--- a/p2p/base/sessionmanager.h
+++ b/p2p/base/sessionmanager.h
@@ -33,8 +33,8 @@
 #include <utility>
 #include <vector>
 
-#include "talk/base/sigslot.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/portallocator.h"
 #include "talk/p2p/base/transportdescriptionfactory.h"
 
@@ -53,12 +53,12 @@ class SessionClient;
 class SessionManager : public sigslot::has_slots<> {
  public:
   SessionManager(PortAllocator *allocator,
-                 talk_base::Thread *worker_thread = NULL);
+                 rtc::Thread *worker_thread = NULL);
   virtual ~SessionManager();
 
   PortAllocator *port_allocator() const { return allocator_; }
-  talk_base::Thread *worker_thread() const { return worker_thread_; }
-  talk_base::Thread *signaling_thread() const { return signaling_thread_; }
+  rtc::Thread *worker_thread() const { return worker_thread_; }
+  rtc::Thread *signaling_thread() const { return signaling_thread_; }
 
   int session_timeout() const { return timeout_; }
   void set_session_timeout(int timeout) { timeout_ = timeout; }
@@ -72,7 +72,7 @@ class SessionManager : public sigslot::has_slots<> {
   void set_secure(SecurePolicy policy) {
     transport_desc_factory_.set_secure(policy);
   }
-  void set_identity(talk_base::SSLIdentity* identity) {
+  void set_identity(rtc::SSLIdentity* identity) {
     transport_desc_factory_.set_identity(identity);
   }
   const TransportDescriptionFactory* transport_desc_factory() const {
@@ -198,8 +198,8 @@ class SessionManager : public sigslot::has_slots<> {
                       const buzz::XmlElement* extra_info);
 
   PortAllocator *allocator_;
-  talk_base::Thread *signaling_thread_;
-  talk_base::Thread *worker_thread_;
+  rtc::Thread *signaling_thread_;
+  rtc::Thread *worker_thread_;
   int timeout_;
   TransportDescriptionFactory transport_desc_factory_;
   SessionMap session_map_;
diff --git a/p2p/base/sessionmessages.cc b/p2p/base/sessionmessages.cc
index 7a03d76..a542dfd 100644
--- a/p2p/base/sessionmessages.cc
+++ b/p2p/base/sessionmessages.cc
@@ -30,9 +30,9 @@
 #include <stdio.h>
 #include <string>
 
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/p2ptransport.h"
 #include "talk/p2p/base/parsing.h"
@@ -491,7 +491,7 @@ bool WriteGingleCandidates(const Candidates& candidates,
     return false;
 
   for (size_t i = 0; i < candidates.size(); ++i) {
-    talk_base::scoped_ptr<buzz::XmlElement> element;
+    rtc::scoped_ptr<buzz::XmlElement> element;
     if (!trans_parser->WriteGingleCandidate(candidates[i], translator,
                                             element.accept(), error)) {
       return false;
@@ -627,7 +627,7 @@ bool ParseGingleContentInfos(const buzz::XmlElement* session,
     // namespace and only parse the codecs relevant to that namespace.
     // We use this to control which codecs get parsed: first audio,
     // then video.
-    talk_base::scoped_ptr<buzz::XmlElement> audio_elem(
+    rtc::scoped_ptr<buzz::XmlElement> audio_elem(
         new buzz::XmlElement(QN_GINGLE_AUDIO_CONTENT));
     CopyXmlChildren(content_elem, audio_elem.get());
     if (!ParseContentInfo(PROTOCOL_GINGLE, CN_AUDIO, NS_JINGLE_RTP,
diff --git a/p2p/base/sessionmessages.h b/p2p/base/sessionmessages.h
index 5cd565c..d11c460 100644
--- a/p2p/base/sessionmessages.h
+++ b/p2p/base/sessionmessages.h
@@ -32,7 +32,7 @@
 #include <vector>
 #include <map>
 
-#include "talk/base/basictypes.h"
+#include "webrtc/base/basictypes.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/parsing.h"
 #include "talk/p2p/base/sessiondescription.h"  // Needed to delete contents.
diff --git a/p2p/base/stun.cc b/p2p/base/stun.cc
index 6331ba9..be96b76 100644
--- a/p2p/base/stun.cc
+++ b/p2p/base/stun.cc
@@ -29,15 +29,15 @@
 
 #include <string.h>
 
-#include "talk/base/byteorder.h"
-#include "talk/base/common.h"
-#include "talk/base/crc32.h"
-#include "talk/base/logging.h"
-#include "talk/base/messagedigest.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/crc32.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/messagedigest.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringencode.h"
 
-using talk_base::ByteBuffer;
+using rtc::ByteBuffer;
 
 namespace cricket {
 
@@ -151,7 +151,7 @@ bool StunMessage::ValidateMessageIntegrity(const char* data, size_t size,
   }
 
   // Getting the message length from the STUN header.
-  uint16 msg_length = talk_base::GetBE16(&data[2]);
+  uint16 msg_length = rtc::GetBE16(&data[2]);
   if (size != (msg_length + kStunHeaderSize)) {
     return false;
   }
@@ -162,8 +162,8 @@ bool StunMessage::ValidateMessageIntegrity(const char* data, size_t size,
   while (current_pos < size) {
     uint16 attr_type, attr_length;
     // Getting attribute type and length.
-    attr_type = talk_base::GetBE16(&data[current_pos]);
-    attr_length = talk_base::GetBE16(&data[current_pos + sizeof(attr_type)]);
+    attr_type = rtc::GetBE16(&data[current_pos]);
+    attr_length = rtc::GetBE16(&data[current_pos + sizeof(attr_type)]);
 
     // If M-I, sanity check it, and break out.
     if (attr_type == STUN_ATTR_MESSAGE_INTEGRITY) {
@@ -188,7 +188,7 @@ bool StunMessage::ValidateMessageIntegrity(const char* data, size_t size,
 
   // Getting length of the message to calculate Message Integrity.
   size_t mi_pos = current_pos;
-  talk_base::scoped_ptr<char[]> temp_data(new char[current_pos]);
+  rtc::scoped_ptr<char[]> temp_data(new char[current_pos]);
   memcpy(temp_data.get(), data, current_pos);
   if (size > mi_pos + kStunAttributeHeaderSize + kStunMessageIntegritySize) {
     // Stun message has other attributes after message integrity.
@@ -203,12 +203,12 @@ bool StunMessage::ValidateMessageIntegrity(const char* data, size_t size,
     //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     //     |0 0|     STUN Message Type     |         Message Length        |
     //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-    talk_base::SetBE16(temp_data.get() + 2,
+    rtc::SetBE16(temp_data.get() + 2,
                        static_cast<uint16>(new_adjusted_len));
   }
 
   char hmac[kStunMessageIntegritySize];
-  size_t ret = talk_base::ComputeHmac(talk_base::DIGEST_SHA_1,
+  size_t ret = rtc::ComputeHmac(rtc::DIGEST_SHA_1,
                                       password.c_str(), password.size(),
                                       temp_data.get(), mi_pos,
                                       hmac, sizeof(hmac));
@@ -236,14 +236,14 @@ bool StunMessage::AddMessageIntegrity(const char* key,
   VERIFY(AddAttribute(msg_integrity_attr));
 
   // Calculate the HMAC for the message.
-  talk_base::ByteBuffer buf;
+  rtc::ByteBuffer buf;
   if (!Write(&buf))
     return false;
 
   int msg_len_for_hmac = static_cast<int>(
       buf.Length() - kStunAttributeHeaderSize - msg_integrity_attr->length());
   char hmac[kStunMessageIntegritySize];
-  size_t ret = talk_base::ComputeHmac(talk_base::DIGEST_SHA_1,
+  size_t ret = rtc::ComputeHmac(rtc::DIGEST_SHA_1,
                                       key, keylen,
                                       buf.Data(), msg_len_for_hmac,
                                       hmac, sizeof(hmac));
@@ -272,21 +272,21 @@ bool StunMessage::ValidateFingerprint(const char* data, size_t size) {
   // Skip the rest if the magic cookie isn't present.
   const char* magic_cookie =
       data + kStunTransactionIdOffset - kStunMagicCookieLength;
-  if (talk_base::GetBE32(magic_cookie) != kStunMagicCookie)
+  if (rtc::GetBE32(magic_cookie) != kStunMagicCookie)
     return false;
 
   // Check the fingerprint type and length.
   const char* fingerprint_attr_data = data + size - fingerprint_attr_size;
-  if (talk_base::GetBE16(fingerprint_attr_data) != STUN_ATTR_FINGERPRINT ||
-      talk_base::GetBE16(fingerprint_attr_data + sizeof(uint16)) !=
+  if (rtc::GetBE16(fingerprint_attr_data) != STUN_ATTR_FINGERPRINT ||
+      rtc::GetBE16(fingerprint_attr_data + sizeof(uint16)) !=
           StunUInt32Attribute::SIZE)
     return false;
 
   // Check the fingerprint value.
   uint32 fingerprint =
-      talk_base::GetBE32(fingerprint_attr_data + kStunAttributeHeaderSize);
+      rtc::GetBE32(fingerprint_attr_data + kStunAttributeHeaderSize);
   return ((fingerprint ^ STUN_FINGERPRINT_XOR_VALUE) ==
-      talk_base::ComputeCrc32(data, size - fingerprint_attr_size));
+      rtc::ComputeCrc32(data, size - fingerprint_attr_size));
 }
 
 bool StunMessage::AddFingerprint() {
@@ -297,13 +297,13 @@ bool StunMessage::AddFingerprint() {
   VERIFY(AddAttribute(fingerprint_attr));
 
   // Calculate the CRC-32 for the message and insert it.
-  talk_base::ByteBuffer buf;
+  rtc::ByteBuffer buf;
   if (!Write(&buf))
     return false;
 
   int msg_len_for_crc32 = static_cast<int>(
       buf.Length() - kStunAttributeHeaderSize - fingerprint_attr->length());
-  uint32 c = talk_base::ComputeCrc32(buf.Data(), msg_len_for_crc32);
+  uint32 c = rtc::ComputeCrc32(buf.Data(), msg_len_for_crc32);
 
   // Insert the correct CRC-32, XORed with a constant, into the attribute.
   fingerprint_attr->SetValue(c ^ STUN_FINGERPRINT_XOR_VALUE);
@@ -333,7 +333,7 @@ bool StunMessage::Read(ByteBuffer* buf) {
 
   uint32 magic_cookie_int =
       *reinterpret_cast<const uint32*>(magic_cookie.data());
-  if (talk_base::NetworkToHost32(magic_cookie_int) != kStunMagicCookie) {
+  if (rtc::NetworkToHost32(magic_cookie_int) != kStunMagicCookie) {
     // If magic cookie is invalid it means that the peer implements
     // RFC3489 instead of RFC5389.
     transaction_id.insert(0, magic_cookie);
@@ -433,14 +433,14 @@ StunAttribute::StunAttribute(uint16 type, uint16 length)
     : type_(type), length_(length) {
 }
 
-void StunAttribute::ConsumePadding(talk_base::ByteBuffer* buf) const {
+void StunAttribute::ConsumePadding(rtc::ByteBuffer* buf) const {
   int remainder = length_ % 4;
   if (remainder > 0) {
     buf->Consume(4 - remainder);
   }
 }
 
-void StunAttribute::WritePadding(talk_base::ByteBuffer* buf) const {
+void StunAttribute::WritePadding(rtc::ByteBuffer* buf) const {
   int remainder = length_ % 4;
   if (remainder > 0) {
     char zeroes[4] = {0};
@@ -501,7 +501,7 @@ StunUInt16ListAttribute* StunAttribute::CreateUnknownAttributes() {
 }
 
 StunAddressAttribute::StunAddressAttribute(uint16 type,
-   const talk_base::SocketAddress& addr)
+   const rtc::SocketAddress& addr)
    : StunAttribute(type, 0) {
   SetAddress(addr);
 }
@@ -530,8 +530,8 @@ bool StunAddressAttribute::Read(ByteBuffer* buf) {
     if (!buf->ReadBytes(reinterpret_cast<char*>(&v4addr), sizeof(v4addr))) {
       return false;
     }
-    talk_base::IPAddress ipaddr(v4addr);
-    SetAddress(talk_base::SocketAddress(ipaddr, port));
+    rtc::IPAddress ipaddr(v4addr);
+    SetAddress(rtc::SocketAddress(ipaddr, port));
   } else if (stun_family == STUN_ADDRESS_IPV6) {
     in6_addr v6addr;
     if (length() != SIZE_IP6) {
@@ -540,8 +540,8 @@ bool StunAddressAttribute::Read(ByteBuffer* buf) {
     if (!buf->ReadBytes(reinterpret_cast<char*>(&v6addr), sizeof(v6addr))) {
       return false;
     }
-    talk_base::IPAddress ipaddr(v6addr);
-    SetAddress(talk_base::SocketAddress(ipaddr, port));
+    rtc::IPAddress ipaddr(v6addr);
+    SetAddress(rtc::SocketAddress(ipaddr, port));
   } else {
     return false;
   }
@@ -573,7 +573,7 @@ bool StunAddressAttribute::Write(ByteBuffer* buf) const {
 }
 
 StunXorAddressAttribute::StunXorAddressAttribute(uint16 type,
-    const talk_base::SocketAddress& addr)
+    const rtc::SocketAddress& addr)
     : StunAddressAttribute(type, addr), owner_(NULL) {
 }
 
@@ -582,15 +582,15 @@ StunXorAddressAttribute::StunXorAddressAttribute(uint16 type,
                                                  StunMessage* owner)
     : StunAddressAttribute(type, length), owner_(owner) {}
 
-talk_base::IPAddress StunXorAddressAttribute::GetXoredIP() const {
+rtc::IPAddress StunXorAddressAttribute::GetXoredIP() const {
   if (owner_) {
-    talk_base::IPAddress ip = ipaddr();
+    rtc::IPAddress ip = ipaddr();
     switch (ip.family()) {
       case AF_INET: {
         in_addr v4addr = ip.ipv4_address();
         v4addr.s_addr =
-            (v4addr.s_addr ^ talk_base::HostToNetwork32(kStunMagicCookie));
-        return talk_base::IPAddress(v4addr);
+            (v4addr.s_addr ^ rtc::HostToNetwork32(kStunMagicCookie));
+        return rtc::IPAddress(v4addr);
       }
       case AF_INET6: {
         in6_addr v6addr = ip.ipv6_address();
@@ -603,11 +603,11 @@ talk_base::IPAddress StunXorAddressAttribute::GetXoredIP() const {
           // Transaction ID is in network byte order, but magic cookie
           // is stored in host byte order.
           ip_as_ints[0] =
-              (ip_as_ints[0] ^ talk_base::HostToNetwork32(kStunMagicCookie));
+              (ip_as_ints[0] ^ rtc::HostToNetwork32(kStunMagicCookie));
           ip_as_ints[1] = (ip_as_ints[1] ^ transactionid_as_ints[0]);
           ip_as_ints[2] = (ip_as_ints[2] ^ transactionid_as_ints[1]);
           ip_as_ints[3] = (ip_as_ints[3] ^ transactionid_as_ints[2]);
-          return talk_base::IPAddress(v6addr);
+          return rtc::IPAddress(v6addr);
         }
         break;
       }
@@ -615,15 +615,15 @@ talk_base::IPAddress StunXorAddressAttribute::GetXoredIP() const {
   }
   // Invalid ip family or transaction ID, or missing owner.
   // Return an AF_UNSPEC address.
-  return talk_base::IPAddress();
+  return rtc::IPAddress();
 }
 
 bool StunXorAddressAttribute::Read(ByteBuffer* buf) {
   if (!StunAddressAttribute::Read(buf))
     return false;
   uint16 xoredport = port() ^ (kStunMagicCookie >> 16);
-  talk_base::IPAddress xored_ip = GetXoredIP();
-  SetAddress(talk_base::SocketAddress(xored_ip, xoredport));
+  rtc::IPAddress xored_ip = GetXoredIP();
+  SetAddress(rtc::SocketAddress(xored_ip, xoredport));
   return true;
 }
 
@@ -633,7 +633,7 @@ bool StunXorAddressAttribute::Write(ByteBuffer* buf) const {
     LOG(LS_ERROR) << "Error writing xor-address attribute: unknown family.";
     return false;
   }
-  talk_base::IPAddress xored_ip = GetXoredIP();
+  rtc::IPAddress xored_ip = GetXoredIP();
   if (xored_ip.family() == AF_UNSPEC) {
     return false;
   }
@@ -916,9 +916,9 @@ bool ComputeStunCredentialHash(const std::string& username,
   input += ':';
   input += password;
 
-  char digest[talk_base::MessageDigest::kMaxSize];
-  size_t size = talk_base::ComputeDigest(
-      talk_base::DIGEST_MD5, input.c_str(), input.size(),
+  char digest[rtc::MessageDigest::kMaxSize];
+  size_t size = rtc::ComputeDigest(
+      rtc::DIGEST_MD5, input.c_str(), input.size(),
       digest, sizeof(digest));
   if (size == 0) {
     return false;
diff --git a/p2p/base/stun.h b/p2p/base/stun.h
index 6416e51..b22b51e 100644
--- a/p2p/base/stun.h
+++ b/p2p/base/stun.h
@@ -34,9 +34,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/bytebuffer.h"
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/socketaddress.h"
 
 namespace cricket {
 
@@ -195,11 +195,11 @@ class StunMessage {
 
   // Parses the STUN packet in the given buffer and records it here. The
   // return value indicates whether this was successful.
-  bool Read(talk_base::ByteBuffer* buf);
+  bool Read(rtc::ByteBuffer* buf);
 
   // Writes this object into a STUN packet. The return value indicates whether
   // this was successful.
-  bool Write(talk_base::ByteBuffer* buf) const;
+  bool Write(rtc::ByteBuffer* buf) const;
 
   // Creates an empty message. Overridable by derived classes.
   virtual StunMessage* CreateNew() const { return new StunMessage(); }
@@ -236,11 +236,11 @@ class StunAttribute {
 
   // Reads the body (not the type or length) for this type of attribute from
   // the given buffer.  Return value is true if successful.
-  virtual bool Read(talk_base::ByteBuffer* buf) = 0;
+  virtual bool Read(rtc::ByteBuffer* buf) = 0;
 
   // Writes the body (not the type or length) to the given buffer.  Return
   // value is true if successful.
-  virtual bool Write(talk_base::ByteBuffer* buf) const = 0;
+  virtual bool Write(rtc::ByteBuffer* buf) const = 0;
 
   // Creates an attribute object with the given type and smallest length.
   static StunAttribute* Create(StunAttributeValueType value_type, uint16 type,
@@ -258,8 +258,8 @@ class StunAttribute {
  protected:
   StunAttribute(uint16 type, uint16 length);
   void SetLength(uint16 length) { length_ = length; }
-  void WritePadding(talk_base::ByteBuffer* buf) const;
-  void ConsumePadding(talk_base::ByteBuffer* buf) const;
+  void WritePadding(rtc::ByteBuffer* buf) const;
+  void ConsumePadding(rtc::ByteBuffer* buf) const;
 
  private:
   uint16 type_;
@@ -272,7 +272,7 @@ class StunAddressAttribute : public StunAttribute {
   static const uint16 SIZE_UNDEF = 0;
   static const uint16 SIZE_IP4 = 8;
   static const uint16 SIZE_IP6 = 20;
-  StunAddressAttribute(uint16 type, const talk_base::SocketAddress& addr);
+  StunAddressAttribute(uint16 type, const rtc::SocketAddress& addr);
   StunAddressAttribute(uint16 type, uint16 length);
 
   virtual StunAttributeValueType value_type() const {
@@ -289,22 +289,22 @@ class StunAddressAttribute : public StunAttribute {
     return STUN_ADDRESS_UNDEF;
   }
 
-  const talk_base::SocketAddress& GetAddress() const { return address_; }
-  const talk_base::IPAddress& ipaddr() const { return address_.ipaddr(); }
+  const rtc::SocketAddress& GetAddress() const { return address_; }
+  const rtc::IPAddress& ipaddr() const { return address_.ipaddr(); }
   uint16 port() const { return address_.port(); }
 
-  void SetAddress(const talk_base::SocketAddress& addr) {
+  void SetAddress(const rtc::SocketAddress& addr) {
     address_ = addr;
     EnsureAddressLength();
   }
-  void SetIP(const talk_base::IPAddress& ip) {
+  void SetIP(const rtc::IPAddress& ip) {
     address_.SetIP(ip);
     EnsureAddressLength();
   }
   void SetPort(uint16 port) { address_.SetPort(port); }
 
-  virtual bool Read(talk_base::ByteBuffer* buf);
-  virtual bool Write(talk_base::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBuffer* buf);
+  virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
   void EnsureAddressLength() {
@@ -323,7 +323,7 @@ class StunAddressAttribute : public StunAttribute {
       }
     }
   }
-  talk_base::SocketAddress address_;
+  rtc::SocketAddress address_;
 };
 
 // Implements STUN attributes that record an Internet address. When encoded
@@ -331,7 +331,7 @@ class StunAddressAttribute : public StunAttribute {
 // transaction ID of the message.
 class StunXorAddressAttribute : public StunAddressAttribute {
  public:
-  StunXorAddressAttribute(uint16 type, const talk_base::SocketAddress& addr);
+  StunXorAddressAttribute(uint16 type, const rtc::SocketAddress& addr);
   StunXorAddressAttribute(uint16 type, uint16 length,
                           StunMessage* owner);
 
@@ -341,11 +341,11 @@ class StunXorAddressAttribute : public StunAddressAttribute {
   virtual void SetOwner(StunMessage* owner) {
     owner_ = owner;
   }
-  virtual bool Read(talk_base::ByteBuffer* buf);
-  virtual bool Write(talk_base::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBuffer* buf);
+  virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
-  talk_base::IPAddress GetXoredIP() const;
+  rtc::IPAddress GetXoredIP() const;
   StunMessage* owner_;
 };
 
@@ -366,8 +366,8 @@ class StunUInt32Attribute : public StunAttribute {
   bool GetBit(size_t index) const;
   void SetBit(size_t index, bool value);
 
-  virtual bool Read(talk_base::ByteBuffer* buf);
-  virtual bool Write(talk_base::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBuffer* buf);
+  virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
   uint32 bits_;
@@ -386,8 +386,8 @@ class StunUInt64Attribute : public StunAttribute {
   uint64 value() const { return bits_; }
   void SetValue(uint64 bits) { bits_ = bits; }
 
-  virtual bool Read(talk_base::ByteBuffer* buf);
-  virtual bool Write(talk_base::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBuffer* buf);
+  virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
   uint64 bits_;
@@ -415,8 +415,8 @@ class StunByteStringAttribute : public StunAttribute {
   uint8 GetByte(size_t index) const;
   void SetByte(size_t index, uint8 value);
 
-  virtual bool Read(talk_base::ByteBuffer* buf);
-  virtual bool Write(talk_base::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBuffer* buf);
+  virtual bool Write(rtc::ByteBuffer* buf) const;
 
  private:
   void SetBytes(char* bytes, size_t length);
@@ -448,8 +448,8 @@ class StunErrorCodeAttribute : public StunAttribute {
   void SetNumber(uint8 number) { number_ = number; }
   void SetReason(const std::string& reason);
 
-  bool Read(talk_base::ByteBuffer* buf);
-  bool Write(talk_base::ByteBuffer* buf) const;
+  bool Read(rtc::ByteBuffer* buf);
+  bool Write(rtc::ByteBuffer* buf) const;
 
  private:
   uint8 class_;
@@ -472,8 +472,8 @@ class StunUInt16ListAttribute : public StunAttribute {
   void SetType(int index, uint16 value);
   void AddType(uint16 value);
 
-  bool Read(talk_base::ByteBuffer* buf);
-  bool Write(talk_base::ByteBuffer* buf) const;
+  bool Read(rtc::ByteBuffer* buf);
+  bool Write(rtc::ByteBuffer* buf) const;
 
  private:
   std::vector<uint16>* attr_types_;
diff --git a/p2p/base/stun_unittest.cc b/p2p/base/stun_unittest.cc
index 71d8750..05a0f6c 100644
--- a/p2p/base/stun_unittest.cc
+++ b/p2p/base/stun_unittest.cc
@@ -27,12 +27,12 @@
 
 #include <string>
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/messagedigest.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/messagedigest.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socketaddress.h"
 #include "talk/p2p/base/stun.h"
 
 namespace cricket {
@@ -56,7 +56,7 @@ class StunTest : public ::testing::Test {
   void CheckStunAddressAttribute(const StunAddressAttribute* addr,
                                  StunAddressFamily expected_family,
                                  int expected_port,
-                                 talk_base::IPAddress expected_address) {
+                                 rtc::IPAddress expected_address) {
     ASSERT_EQ(expected_family, addr->family());
     ASSERT_EQ(expected_port, addr->port());
 
@@ -78,7 +78,7 @@ class StunTest : public ::testing::Test {
                                  const unsigned char* testcase,
                                  size_t size) {
     const char* input = reinterpret_cast<const char*>(testcase);
-    talk_base::ByteBuffer buf(input, size);
+    rtc::ByteBuffer buf(input, size);
     if (msg->Read(&buf)) {
       // Returns the size the stun message should report itself as being
       return (size - 20);
@@ -267,9 +267,9 @@ static const char kRfc5769SampleMsgClientSoftware[] = "STUN test client";
 static const char kRfc5769SampleMsgServerSoftware[] = "test vector";
 static const char kRfc5769SampleMsgUsername[] = "evtj:h6vY";
 static const char kRfc5769SampleMsgPassword[] = "VOkJxbRl1RmTxUk/WvJxBt";
-static const talk_base::SocketAddress kRfc5769SampleMsgMappedAddress(
+static const rtc::SocketAddress kRfc5769SampleMsgMappedAddress(
     "192.0.2.1", 32853);
-static const talk_base::SocketAddress kRfc5769SampleMsgIPv6MappedAddress(
+static const rtc::SocketAddress kRfc5769SampleMsgIPv6MappedAddress(
     "2001:db8:1234:5678:11:2233:4455:6677", 32853);
 
 static const unsigned char kRfc5769SampleMsgWithAuthTransactionId[] = {
@@ -533,7 +533,7 @@ TEST_F(StunTest, ReadMessageWithIPv4AddressAttribute) {
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
-  talk_base::IPAddress test_address(kIPv4TestAddress1);
+  rtc::IPAddress test_address(kIPv4TestAddress1);
   CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
                             kTestMessagePort4, test_address);
 }
@@ -547,7 +547,7 @@ TEST_F(StunTest, ReadMessageWithIPv4XorAddressAttribute) {
 
   const StunAddressAttribute* addr =
       msg.GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
-  talk_base::IPAddress test_address(kIPv4TestAddress1);
+  rtc::IPAddress test_address(kIPv4TestAddress1);
   CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
                             kTestMessagePort3, test_address);
 }
@@ -558,7 +558,7 @@ TEST_F(StunTest, ReadMessageWithIPv6AddressAttribute) {
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
-  talk_base::IPAddress test_address(kIPv6TestAddress1);
+  rtc::IPAddress test_address(kIPv6TestAddress1);
 
   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
@@ -571,7 +571,7 @@ TEST_F(StunTest, ReadMessageWithInvalidAddressAttribute) {
   CheckStunHeader(msg, STUN_BINDING_REQUEST, size);
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
 
-  talk_base::IPAddress test_address(kIPv6TestAddress1);
+  rtc::IPAddress test_address(kIPv6TestAddress1);
 
   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
@@ -582,7 +582,7 @@ TEST_F(StunTest, ReadMessageWithIPv6XorAddressAttribute) {
   StunMessage msg;
   size_t size = ReadStunMessage(&msg, kStunMessageWithIPv6XorMappedAddress);
 
-  talk_base::IPAddress test_address(kIPv6TestAddress1);
+  rtc::IPAddress test_address(kIPv6TestAddress1);
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
@@ -711,7 +711,7 @@ TEST_F(StunTest, ReadLegacyMessage) {
   CheckStunTransactionID(msg, &rfc3489_packet[4], kStunTransactionIdLength + 4);
 
   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
-  talk_base::IPAddress test_address(kIPv4TestAddress1);
+  rtc::IPAddress test_address(kIPv4TestAddress1);
   CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
                             kTestMessagePort4, test_address);
 }
@@ -721,7 +721,7 @@ TEST_F(StunTest, SetIPv6XorAddressAttributeOwner) {
   StunMessage msg2;
   size_t size = ReadStunMessage(&msg, kStunMessageWithIPv6XorMappedAddress);
 
-  talk_base::IPAddress test_address(kIPv6TestAddress1);
+  rtc::IPAddress test_address(kIPv6TestAddress1);
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
   CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
@@ -740,8 +740,8 @@ TEST_F(StunTest, SetIPv6XorAddressAttributeOwner) {
   // The internal IP address shouldn't change.
   ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
 
-  talk_base::ByteBuffer correct_buf;
-  talk_base::ByteBuffer wrong_buf;
+  rtc::ByteBuffer correct_buf;
+  rtc::ByteBuffer wrong_buf;
   EXPECT_TRUE(addr->Write(&correct_buf));
   EXPECT_TRUE(addr2.Write(&wrong_buf));
   // But when written out, the buffers should look different.
@@ -768,7 +768,7 @@ TEST_F(StunTest, SetIPv4XorAddressAttributeOwner) {
   StunMessage msg2;
   size_t size = ReadStunMessage(&msg, kStunMessageWithIPv4XorMappedAddress);
 
-  talk_base::IPAddress test_address(kIPv4TestAddress1);
+  rtc::IPAddress test_address(kIPv4TestAddress1);
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, size);
   CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
@@ -787,8 +787,8 @@ TEST_F(StunTest, SetIPv4XorAddressAttributeOwner) {
   // The internal IP address shouldn't change.
   ASSERT_EQ(addr2.ipaddr(), addr->ipaddr());
 
-  talk_base::ByteBuffer correct_buf;
-  talk_base::ByteBuffer wrong_buf;
+  rtc::ByteBuffer correct_buf;
+  rtc::ByteBuffer wrong_buf;
   EXPECT_TRUE(addr->Write(&correct_buf));
   EXPECT_TRUE(addr2.Write(&wrong_buf));
   // The same address data should be written.
@@ -807,11 +807,11 @@ TEST_F(StunTest, SetIPv4XorAddressAttributeOwner) {
 }
 
 TEST_F(StunTest, CreateIPv6AddressAttribute) {
-  talk_base::IPAddress test_ip(kIPv6TestAddress2);
+  rtc::IPAddress test_ip(kIPv6TestAddress2);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
-  talk_base::SocketAddress test_addr(test_ip, kTestMessagePort2);
+  rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
   addr->SetAddress(test_addr);
 
   CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV6,
@@ -822,11 +822,11 @@ TEST_F(StunTest, CreateIPv6AddressAttribute) {
 TEST_F(StunTest, CreateIPv4AddressAttribute) {
   struct in_addr test_in_addr;
   test_in_addr.s_addr = 0xBEB0B0BE;
-  talk_base::IPAddress test_ip(test_in_addr);
+  rtc::IPAddress test_ip(test_in_addr);
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
-  talk_base::SocketAddress test_addr(test_ip, kTestMessagePort2);
+  rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
   addr->SetAddress(test_addr);
 
   CheckStunAddressAttribute(addr, STUN_ADDRESS_IPV4,
@@ -840,17 +840,17 @@ TEST_F(StunTest, CreateAddressInArbitraryOrder) {
   StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
   // Port first
   addr->SetPort(kTestMessagePort1);
-  addr->SetIP(talk_base::IPAddress(kIPv4TestAddress1));
+  addr->SetIP(rtc::IPAddress(kIPv4TestAddress1));
   ASSERT_EQ(kTestMessagePort1, addr->port());
-  ASSERT_EQ(talk_base::IPAddress(kIPv4TestAddress1), addr->ipaddr());
+  ASSERT_EQ(rtc::IPAddress(kIPv4TestAddress1), addr->ipaddr());
 
   StunAddressAttribute* addr2 =
   StunAttribute::CreateAddress(STUN_ATTR_DESTINATION_ADDRESS);
   // IP first
-  addr2->SetIP(talk_base::IPAddress(kIPv4TestAddress1));
+  addr2->SetIP(rtc::IPAddress(kIPv4TestAddress1));
   addr2->SetPort(kTestMessagePort2);
   ASSERT_EQ(kTestMessagePort2, addr2->port());
-  ASSERT_EQ(talk_base::IPAddress(kIPv4TestAddress1), addr2->ipaddr());
+  ASSERT_EQ(rtc::IPAddress(kIPv4TestAddress1), addr2->ipaddr());
 
   delete addr;
   delete addr2;
@@ -860,7 +860,7 @@ TEST_F(StunTest, WriteMessageWithIPv6AddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv6MappedAddress);
 
-  talk_base::IPAddress test_ip(kIPv6TestAddress1);
+  rtc::IPAddress test_ip(kIPv6TestAddress1);
 
   msg.SetType(STUN_BINDING_REQUEST);
   msg.SetTransactionID(
@@ -870,13 +870,13 @@ TEST_F(StunTest, WriteMessageWithIPv6AddressAttribute) {
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
-  talk_base::SocketAddress test_addr(test_ip, kTestMessagePort2);
+  rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
   addr->SetAddress(test_addr);
   EXPECT_TRUE(msg.AddAttribute(addr));
 
   CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
 
-  talk_base::ByteBuffer out;
+  rtc::ByteBuffer out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6MappedAddress));
   int len1 = static_cast<int>(out.Length());
@@ -889,7 +889,7 @@ TEST_F(StunTest, WriteMessageWithIPv4AddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv4MappedAddress);
 
-  talk_base::IPAddress test_ip(kIPv4TestAddress1);
+  rtc::IPAddress test_ip(kIPv4TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
@@ -899,13 +899,13 @@ TEST_F(StunTest, WriteMessageWithIPv4AddressAttribute) {
 
   StunAddressAttribute* addr =
       StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
-  talk_base::SocketAddress test_addr(test_ip, kTestMessagePort4);
+  rtc::SocketAddress test_addr(test_ip, kTestMessagePort4);
   addr->SetAddress(test_addr);
   EXPECT_TRUE(msg.AddAttribute(addr));
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
 
-  talk_base::ByteBuffer out;
+  rtc::ByteBuffer out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4MappedAddress));
   int len1 = static_cast<int>(out.Length());
@@ -918,7 +918,7 @@ TEST_F(StunTest, WriteMessageWithIPv6XorAddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv6XorMappedAddress);
 
-  talk_base::IPAddress test_ip(kIPv6TestAddress1);
+  rtc::IPAddress test_ip(kIPv6TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
@@ -928,13 +928,13 @@ TEST_F(StunTest, WriteMessageWithIPv6XorAddressAttribute) {
 
   StunAddressAttribute* addr =
       StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
-  talk_base::SocketAddress test_addr(test_ip, kTestMessagePort1);
+  rtc::SocketAddress test_addr(test_ip, kTestMessagePort1);
   addr->SetAddress(test_addr);
   EXPECT_TRUE(msg.AddAttribute(addr));
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
 
-  talk_base::ByteBuffer out;
+  rtc::ByteBuffer out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv6XorMappedAddress));
   int len1 = static_cast<int>(out.Length());
@@ -948,7 +948,7 @@ TEST_F(StunTest, WriteMessageWithIPv4XoreAddressAttribute) {
   StunMessage msg;
   size_t size = sizeof(kStunMessageWithIPv4XorMappedAddress);
 
-  talk_base::IPAddress test_ip(kIPv4TestAddress1);
+  rtc::IPAddress test_ip(kIPv4TestAddress1);
 
   msg.SetType(STUN_BINDING_RESPONSE);
   msg.SetTransactionID(
@@ -958,13 +958,13 @@ TEST_F(StunTest, WriteMessageWithIPv4XoreAddressAttribute) {
 
   StunAddressAttribute* addr =
       StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
-  talk_base::SocketAddress test_addr(test_ip, kTestMessagePort3);
+  rtc::SocketAddress test_addr(test_ip, kTestMessagePort3);
   addr->SetAddress(test_addr);
   EXPECT_TRUE(msg.AddAttribute(addr));
 
   CheckStunHeader(msg, STUN_BINDING_RESPONSE, (size - 20));
 
-  talk_base::ByteBuffer out;
+  rtc::ByteBuffer out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(out.Length(), sizeof(kStunMessageWithIPv4XorMappedAddress));
   int len1 = static_cast<int>(out.Length());
@@ -1052,7 +1052,7 @@ TEST_F(StunTest, WriteMessageWithAnErrorCodeAttribute) {
   EXPECT_TRUE(msg.AddAttribute(errorcode));
   CheckStunHeader(msg, STUN_BINDING_ERROR_RESPONSE, (size - 20));
 
-  talk_base::ByteBuffer out;
+  rtc::ByteBuffer out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(size, out.Length());
   // No padding.
@@ -1075,7 +1075,7 @@ TEST_F(StunTest, WriteMessageWithAUInt16ListAttribute) {
   EXPECT_TRUE(msg.AddAttribute(list));
   CheckStunHeader(msg, STUN_BINDING_REQUEST, (size - 20));
 
-  talk_base::ByteBuffer out;
+  rtc::ByteBuffer out;
   EXPECT_TRUE(msg.Write(&out));
   ASSERT_EQ(size, out.Length());
   // Check everything up to the padding.
@@ -1087,7 +1087,7 @@ TEST_F(StunTest, WriteMessageWithAUInt16ListAttribute) {
 void CheckFailureToRead(const unsigned char* testcase, size_t length) {
   StunMessage msg;
   const char* input = reinterpret_cast<const char*>(testcase);
-  talk_base::ByteBuffer buf(input, length);
+  rtc::ByteBuffer buf(input, length);
   ASSERT_FALSE(msg.Read(&buf));
 }
 
@@ -1179,7 +1179,7 @@ TEST_F(StunTest, ValidateMessageIntegrity) {
 // the RFC5769 test messages used include attributes not found in basic STUN.
 TEST_F(StunTest, AddMessageIntegrity) {
   IceMessage msg;
-  talk_base::ByteBuffer buf(
+  rtc::ByteBuffer buf(
       reinterpret_cast<const char*>(kRfc5769SampleRequestWithoutMI),
       sizeof(kRfc5769SampleRequestWithoutMI));
   EXPECT_TRUE(msg.Read(&buf));
@@ -1190,14 +1190,14 @@ TEST_F(StunTest, AddMessageIntegrity) {
   EXPECT_EQ(0, memcmp(
       mi_attr->bytes(), kCalculatedHmac1, sizeof(kCalculatedHmac1)));
 
-  talk_base::ByteBuffer buf1;
+  rtc::ByteBuffer buf1;
   EXPECT_TRUE(msg.Write(&buf1));
   EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
         reinterpret_cast<const char*>(buf1.Data()), buf1.Length(),
         kRfc5769SampleMsgPassword));
 
   IceMessage msg2;
-  talk_base::ByteBuffer buf2(
+  rtc::ByteBuffer buf2(
       reinterpret_cast<const char*>(kRfc5769SampleResponseWithoutMI),
       sizeof(kRfc5769SampleResponseWithoutMI));
   EXPECT_TRUE(msg2.Read(&buf2));
@@ -1208,7 +1208,7 @@ TEST_F(StunTest, AddMessageIntegrity) {
   EXPECT_EQ(
       0, memcmp(mi_attr2->bytes(), kCalculatedHmac2, sizeof(kCalculatedHmac2)));
 
-  talk_base::ByteBuffer buf3;
+  rtc::ByteBuffer buf3;
   EXPECT_TRUE(msg2.Write(&buf3));
   EXPECT_TRUE(StunMessage::ValidateMessageIntegrity(
         reinterpret_cast<const char*>(buf3.Data()), buf3.Length(),
@@ -1254,13 +1254,13 @@ TEST_F(StunTest, ValidateFingerprint) {
 
 TEST_F(StunTest, AddFingerprint) {
   IceMessage msg;
-  talk_base::ByteBuffer buf(
+  rtc::ByteBuffer buf(
       reinterpret_cast<const char*>(kRfc5769SampleRequestWithoutMI),
       sizeof(kRfc5769SampleRequestWithoutMI));
   EXPECT_TRUE(msg.Read(&buf));
   EXPECT_TRUE(msg.AddFingerprint());
 
-  talk_base::ByteBuffer buf1;
+  rtc::ByteBuffer buf1;
   EXPECT_TRUE(msg.Write(&buf1));
   EXPECT_TRUE(StunMessage::ValidateFingerprint(
       reinterpret_cast<const char*>(buf1.Data()), buf1.Length()));
@@ -1303,7 +1303,7 @@ TEST_F(StunTest, ReadRelayMessage) {
 
   const char* input = reinterpret_cast<const char*>(kRelayMessage);
   size_t size = sizeof(kRelayMessage);
-  talk_base::ByteBuffer buf(input, size);
+  rtc::ByteBuffer buf(input, size);
   EXPECT_TRUE(msg.Read(&buf));
 
   EXPECT_EQ(STUN_BINDING_REQUEST, msg.type());
@@ -1315,7 +1315,7 @@ TEST_F(StunTest, ReadRelayMessage) {
 
   in_addr legacy_in_addr;
   legacy_in_addr.s_addr = htonl(17U);
-  talk_base::IPAddress legacy_ip(legacy_in_addr);
+  rtc::IPAddress legacy_ip(legacy_in_addr);
 
   const StunAddressAttribute* addr = msg.GetAddress(STUN_ATTR_MAPPED_ADDRESS);
   ASSERT_TRUE(addr != NULL);
@@ -1399,7 +1399,7 @@ TEST_F(StunTest, ReadRelayMessage) {
   bytes2->CopyBytes("abcdefg");
   EXPECT_TRUE(msg2.AddAttribute(bytes2));
 
-  talk_base::ByteBuffer out;
+  rtc::ByteBuffer out;
   EXPECT_TRUE(msg.Write(&out));
   EXPECT_EQ(size, out.Length());
   size_t len1 = out.Length();
@@ -1407,7 +1407,7 @@ TEST_F(StunTest, ReadRelayMessage) {
   out.ReadString(&outstring, len1);
   EXPECT_EQ(0, memcmp(outstring.c_str(), input, len1));
 
-  talk_base::ByteBuffer out2;
+  rtc::ByteBuffer out2;
   EXPECT_TRUE(msg2.Write(&out2));
   EXPECT_EQ(size, out2.Length());
   size_t len2 = out2.Length();
diff --git a/p2p/base/stunport.cc b/p2p/base/stunport.cc
index 9155c6d..57c7850 100644
--- a/p2p/base/stunport.cc
+++ b/p2p/base/stunport.cc
@@ -27,10 +27,10 @@
 
 #include "talk/p2p/base/stunport.h"
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/helpers.h"
-#include "talk/base/nethelpers.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/nethelpers.h"
 #include "talk/p2p/base/common.h"
 #include "talk/p2p/base/stun.h"
 
@@ -45,15 +45,15 @@ const int RETRY_TIMEOUT = 50 * 1000;    // ICE says 50 secs
 class StunBindingRequest : public StunRequest {
  public:
   StunBindingRequest(UDPPort* port, bool keep_alive,
-                     const talk_base::SocketAddress& addr)
+                     const rtc::SocketAddress& addr)
     : port_(port), keep_alive_(keep_alive), server_addr_(addr) {
-    start_time_ = talk_base::Time();
+    start_time_ = rtc::Time();
   }
 
   virtual ~StunBindingRequest() {
   }
 
-  const talk_base::SocketAddress& server_addr() const { return server_addr_; }
+  const rtc::SocketAddress& server_addr() const { return server_addr_; }
 
   virtual void Prepare(StunMessage* request) {
     request->SetType(STUN_BINDING_REQUEST);
@@ -68,7 +68,7 @@ class StunBindingRequest : public StunRequest {
                addr_attr->family() != STUN_ADDRESS_IPV6) {
       LOG(LS_ERROR) << "Binding address has bad family";
     } else {
-      talk_base::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
+      rtc::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
       port_->OnStunBindingRequestSucceeded(server_addr_, addr);
     }
 
@@ -95,7 +95,7 @@ class StunBindingRequest : public StunRequest {
     port_->OnStunBindingOrResolveRequestFailed(server_addr_);
 
     if (keep_alive_
-        && (talk_base::TimeSince(start_time_) <= RETRY_TIMEOUT)) {
+        && (rtc::TimeSince(start_time_) <= RETRY_TIMEOUT)) {
       port_->requests_.SendDelayed(
           new StunBindingRequest(port_, true, server_addr_),
           port_->stun_keepalive_delay());
@@ -110,7 +110,7 @@ class StunBindingRequest : public StunRequest {
     port_->OnStunBindingOrResolveRequestFailed(server_addr_);
 
     if (keep_alive_
-        && (talk_base::TimeSince(start_time_) <= RETRY_TIMEOUT)) {
+        && (rtc::TimeSince(start_time_) <= RETRY_TIMEOUT)) {
       port_->requests_.SendDelayed(
           new StunBindingRequest(port_, true, server_addr_),
           RETRY_DELAY);
@@ -120,12 +120,12 @@ class StunBindingRequest : public StunRequest {
  private:
   UDPPort* port_;
   bool keep_alive_;
-  const talk_base::SocketAddress server_addr_;
+  const rtc::SocketAddress server_addr_;
   uint32 start_time_;
 };
 
 UDPPort::AddressResolver::AddressResolver(
-    talk_base::PacketSocketFactory* factory)
+    rtc::PacketSocketFactory* factory)
     : socket_factory_(factory) {}
 
 UDPPort::AddressResolver::~AddressResolver() {
@@ -136,14 +136,14 @@ UDPPort::AddressResolver::~AddressResolver() {
 }
 
 void UDPPort::AddressResolver::Resolve(
-    const talk_base::SocketAddress& address) {
+    const rtc::SocketAddress& address) {
   if (resolvers_.find(address) != resolvers_.end())
     return;
 
-  talk_base::AsyncResolverInterface* resolver =
+  rtc::AsyncResolverInterface* resolver =
       socket_factory_->CreateAsyncResolver();
   resolvers_.insert(
-      std::pair<talk_base::SocketAddress, talk_base::AsyncResolverInterface*>(
+      std::pair<rtc::SocketAddress, rtc::AsyncResolverInterface*>(
           address, resolver));
 
   resolver->SignalDone.connect(this,
@@ -153,9 +153,9 @@ void UDPPort::AddressResolver::Resolve(
 }
 
 bool UDPPort::AddressResolver::GetResolvedAddress(
-    const talk_base::SocketAddress& input,
+    const rtc::SocketAddress& input,
     int family,
-    talk_base::SocketAddress* output) const {
+    rtc::SocketAddress* output) const {
   ResolverMap::const_iterator it = resolvers_.find(input);
   if (it == resolvers_.end())
     return false;
@@ -164,7 +164,7 @@ bool UDPPort::AddressResolver::GetResolvedAddress(
 }
 
 void UDPPort::AddressResolver::OnResolveResult(
-    talk_base::AsyncResolverInterface* resolver) {
+    rtc::AsyncResolverInterface* resolver) {
   for (ResolverMap::iterator it = resolvers_.begin();
        it != resolvers_.end(); ++it) {
     if (it->second == resolver) {
@@ -174,10 +174,10 @@ void UDPPort::AddressResolver::OnResolveResult(
   }
 }
 
-UDPPort::UDPPort(talk_base::Thread* thread,
-                 talk_base::PacketSocketFactory* factory,
-                 talk_base::Network* network,
-                 talk_base::AsyncPacketSocket* socket,
+UDPPort::UDPPort(rtc::Thread* thread,
+                 rtc::PacketSocketFactory* factory,
+                 rtc::Network* network,
+                 rtc::AsyncPacketSocket* socket,
                  const std::string& username, const std::string& password)
     : Port(thread, factory, network, socket->GetLocalAddress().ipaddr(),
            username, password),
@@ -188,10 +188,10 @@ UDPPort::UDPPort(talk_base::Thread* thread,
       stun_keepalive_delay_(KEEPALIVE_DELAY) {
 }
 
-UDPPort::UDPPort(talk_base::Thread* thread,
-                 talk_base::PacketSocketFactory* factory,
-                 talk_base::Network* network,
-                 const talk_base::IPAddress& ip, int min_port, int max_port,
+UDPPort::UDPPort(rtc::Thread* thread,
+                 rtc::PacketSocketFactory* factory,
+                 rtc::Network* network,
+                 const rtc::IPAddress& ip, int min_port, int max_port,
                  const std::string& username, const std::string& password)
     : Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port,
            username, password),
@@ -206,7 +206,7 @@ bool UDPPort::Init() {
   if (!SharedSocket()) {
     ASSERT(socket_ == NULL);
     socket_ = socket_factory()->CreateUdpSocket(
-        talk_base::SocketAddress(ip(), 0), min_port(), max_port());
+        rtc::SocketAddress(ip(), 0), min_port(), max_port());
     if (!socket_) {
       LOG_J(LS_WARNING, this) << "UDP socket creation failed";
       return false;
@@ -226,7 +226,7 @@ UDPPort::~UDPPort() {
 
 void UDPPort::PrepareAddress() {
   ASSERT(requests_.empty());
-  if (socket_->GetState() == talk_base::AsyncPacketSocket::STATE_BOUND) {
+  if (socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND) {
     OnLocalAddressReady(socket_, socket_->GetLocalAddress());
   }
 }
@@ -262,8 +262,8 @@ Connection* UDPPort::CreateConnection(const Candidate& address,
 }
 
 int UDPPort::SendTo(const void* data, size_t size,
-                    const talk_base::SocketAddress& addr,
-                    const talk_base::PacketOptions& options,
+                    const rtc::SocketAddress& addr,
+                    const rtc::PacketOptions& options,
                     bool payload) {
   int sent = socket_->SendTo(data, size, addr, options);
   if (sent < 0) {
@@ -274,11 +274,11 @@ int UDPPort::SendTo(const void* data, size_t size,
   return sent;
 }
 
-int UDPPort::SetOption(talk_base::Socket::Option opt, int value) {
+int UDPPort::SetOption(rtc::Socket::Option opt, int value) {
   return socket_->SetOption(opt, value);
 }
 
-int UDPPort::GetOption(talk_base::Socket::Option opt, int* value) {
+int UDPPort::GetOption(rtc::Socket::Option opt, int* value) {
   return socket_->GetOption(opt, value);
 }
 
@@ -286,18 +286,18 @@ int UDPPort::GetError() {
   return error_;
 }
 
-void UDPPort::OnLocalAddressReady(talk_base::AsyncPacketSocket* socket,
-                                  const talk_base::SocketAddress& address) {
-  AddAddress(address, address, talk_base::SocketAddress(),
+void UDPPort::OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
+                                  const rtc::SocketAddress& address) {
+  AddAddress(address, address, rtc::SocketAddress(),
              UDP_PROTOCOL_NAME, LOCAL_PORT_TYPE,
              ICE_TYPE_PREFERENCE_HOST, false);
   MaybePrepareStunCandidate();
 }
 
 void UDPPort::OnReadPacket(
-  talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-  const talk_base::SocketAddress& remote_addr,
-  const talk_base::PacketTime& packet_time) {
+  rtc::AsyncPacketSocket* socket, const char* data, size_t size,
+  const rtc::SocketAddress& remote_addr,
+  const rtc::PacketTime& packet_time) {
   ASSERT(socket == socket_);
   ASSERT(!remote_addr.IsUnresolved());
 
@@ -317,7 +317,7 @@ void UDPPort::OnReadPacket(
   }
 }
 
-void UDPPort::OnReadyToSend(talk_base::AsyncPacketSocket* socket) {
+void UDPPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
   Port::OnReadyToSend();
 }
 
@@ -332,7 +332,7 @@ void UDPPort::SendStunBindingRequests() {
   }
 }
 
-void UDPPort::ResolveStunAddress(const talk_base::SocketAddress& stun_addr) {
+void UDPPort::ResolveStunAddress(const rtc::SocketAddress& stun_addr) {
   if (!resolver_) {
     resolver_.reset(new AddressResolver(socket_factory()));
     resolver_->SignalDone.connect(this, &UDPPort::OnResolveResult);
@@ -341,11 +341,11 @@ void UDPPort::ResolveStunAddress(const talk_base::SocketAddress& stun_addr) {
   resolver_->Resolve(stun_addr);
 }
 
-void UDPPort::OnResolveResult(const talk_base::SocketAddress& input,
+void UDPPort::OnResolveResult(const rtc::SocketAddress& input,
                               int error) {
   ASSERT(resolver_.get() != NULL);
 
-  talk_base::SocketAddress resolved;
+  rtc::SocketAddress resolved;
   if (error != 0 ||
       !resolver_->GetResolvedAddress(input, ip().family(), &resolved))  {
     LOG_J(LS_WARNING, this) << "StunPort: stun host lookup received error "
@@ -363,11 +363,11 @@ void UDPPort::OnResolveResult(const talk_base::SocketAddress& input,
 }
 
 void UDPPort::SendStunBindingRequest(
-    const talk_base::SocketAddress& stun_addr) {
+    const rtc::SocketAddress& stun_addr) {
   if (stun_addr.IsUnresolved()) {
     ResolveStunAddress(stun_addr);
 
-  } else if (socket_->GetState() == talk_base::AsyncPacketSocket::STATE_BOUND) {
+  } else if (socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND) {
     // Check if |server_addr_| is compatible with the port's ip.
     if (IsCompatibleAddress(stun_addr)) {
       requests_.Send(new StunBindingRequest(this, true, stun_addr));
@@ -381,8 +381,8 @@ void UDPPort::SendStunBindingRequest(
 }
 
 void UDPPort::OnStunBindingRequestSucceeded(
-    const talk_base::SocketAddress& stun_server_addr,
-    const talk_base::SocketAddress& stun_reflected_addr) {
+    const rtc::SocketAddress& stun_server_addr,
+    const rtc::SocketAddress& stun_reflected_addr) {
   if (bind_request_succeeded_servers_.find(stun_server_addr) !=
           bind_request_succeeded_servers_.end()) {
     return;
@@ -401,7 +401,7 @@ void UDPPort::OnStunBindingRequestSucceeded(
 }
 
 void UDPPort::OnStunBindingOrResolveRequestFailed(
-    const talk_base::SocketAddress& stun_server_addr) {
+    const rtc::SocketAddress& stun_server_addr) {
   if (bind_request_failed_servers_.find(stun_server_addr) !=
           bind_request_failed_servers_.end()) {
     return;
@@ -438,7 +438,7 @@ void UDPPort::MaybeSetPortCompleteOrError() {
 // TODO: merge this with SendTo above.
 void UDPPort::OnSendPacket(const void* data, size_t size, StunRequest* req) {
   StunBindingRequest* sreq = static_cast<StunBindingRequest*>(req);
-  talk_base::PacketOptions options(DefaultDscpValue());
+  rtc::PacketOptions options(DefaultDscpValue());
   if (socket_->SendTo(data, size, sreq->server_addr(), options) < 0)
     PLOG(LERROR, socket_->GetError()) << "sendto";
 }
diff --git a/p2p/base/stunport.h b/p2p/base/stunport.h
index 367db22..d5457ba 100644
--- a/p2p/base/stunport.h
+++ b/p2p/base/stunport.h
@@ -30,12 +30,12 @@
 
 #include <string>
 
-#include "talk/base/asyncpacketsocket.h"
+#include "webrtc/base/asyncpacketsocket.h"
 #include "talk/p2p/base/port.h"
 #include "talk/p2p/base/stunrequest.h"
 
 // TODO(mallinath) - Rename stunport.cc|h to udpport.cc|h.
-namespace talk_base {
+namespace rtc {
 class AsyncResolver;
 class SignalThread;
 }
@@ -45,10 +45,10 @@ namespace cricket {
 // Communicates using the address on the outside of a NAT.
 class UDPPort : public Port {
  public:
-  static UDPPort* Create(talk_base::Thread* thread,
-                         talk_base::PacketSocketFactory* factory,
-                         talk_base::Network* network,
-                         talk_base::AsyncPacketSocket* socket,
+  static UDPPort* Create(rtc::Thread* thread,
+                         rtc::PacketSocketFactory* factory,
+                         rtc::Network* network,
+                         rtc::AsyncPacketSocket* socket,
                          const std::string& username,
                          const std::string& password) {
     UDPPort* port = new UDPPort(thread, factory, network, socket,
@@ -60,10 +60,10 @@ class UDPPort : public Port {
     return port;
   }
 
-  static UDPPort* Create(talk_base::Thread* thread,
-                         talk_base::PacketSocketFactory* factory,
-                         talk_base::Network* network,
-                         const talk_base::IPAddress& ip,
+  static UDPPort* Create(rtc::Thread* thread,
+                         rtc::PacketSocketFactory* factory,
+                         rtc::Network* network,
+                         const rtc::IPAddress& ip,
                          int min_port, int max_port,
                          const std::string& username,
                          const std::string& password) {
@@ -78,7 +78,7 @@ class UDPPort : public Port {
   }
   virtual ~UDPPort();
 
-  talk_base::SocketAddress GetLocalAddress() const {
+  rtc::SocketAddress GetLocalAddress() const {
     return socket_->GetLocalAddress();
   }
 
@@ -94,14 +94,14 @@ class UDPPort : public Port {
 
   virtual Connection* CreateConnection(const Candidate& address,
                                        CandidateOrigin origin);
-  virtual int SetOption(talk_base::Socket::Option opt, int value);
-  virtual int GetOption(talk_base::Socket::Option opt, int* value);
+  virtual int SetOption(rtc::Socket::Option opt, int value);
+  virtual int GetOption(rtc::Socket::Option opt, int* value);
   virtual int GetError();
 
   virtual bool HandleIncomingPacket(
-      talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      const talk_base::PacketTime& packet_time) {
+      rtc::AsyncPacketSocket* socket, const char* data, size_t size,
+      const rtc::SocketAddress& remote_addr,
+      const rtc::PacketTime& packet_time) {
     // All packets given to UDP port will be consumed.
     OnReadPacket(socket, data, size, remote_addr, packet_time);
     return true;
@@ -115,30 +115,30 @@ class UDPPort : public Port {
   }
 
  protected:
-  UDPPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
-          talk_base::Network* network, const talk_base::IPAddress& ip,
+  UDPPort(rtc::Thread* thread, rtc::PacketSocketFactory* factory,
+          rtc::Network* network, const rtc::IPAddress& ip,
           int min_port, int max_port,
           const std::string& username, const std::string& password);
 
-  UDPPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
-          talk_base::Network* network, talk_base::AsyncPacketSocket* socket,
+  UDPPort(rtc::Thread* thread, rtc::PacketSocketFactory* factory,
+          rtc::Network* network, rtc::AsyncPacketSocket* socket,
           const std::string& username, const std::string& password);
 
   bool Init();
 
   virtual int SendTo(const void* data, size_t size,
-                     const talk_base::SocketAddress& addr,
-                     const talk_base::PacketOptions& options,
+                     const rtc::SocketAddress& addr,
+                     const rtc::PacketOptions& options,
                      bool payload);
 
-  void OnLocalAddressReady(talk_base::AsyncPacketSocket* socket,
-                           const talk_base::SocketAddress& address);
-  void OnReadPacket(talk_base::AsyncPacketSocket* socket,
+  void OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
+                           const rtc::SocketAddress& address);
+  void OnReadPacket(rtc::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time);
+                    const rtc::SocketAddress& remote_addr,
+                    const rtc::PacketTime& packet_time);
 
-  void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
+  void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 
   // This method will send STUN binding request if STUN server address is set.
   void MaybePrepareStunCandidate();
@@ -147,45 +147,45 @@ class UDPPort : public Port {
 
  private:
   // A helper class which can be called repeatedly to resolve multiple
-  // addresses, as opposed to talk_base::AsyncResolverInterface, which can only
+  // addresses, as opposed to rtc::AsyncResolverInterface, which can only
   // resolve one address per instance.
   class AddressResolver : public sigslot::has_slots<> {
    public:
-    explicit AddressResolver(talk_base::PacketSocketFactory* factory);
+    explicit AddressResolver(rtc::PacketSocketFactory* factory);
     ~AddressResolver();
 
-    void Resolve(const talk_base::SocketAddress& address);
-    bool GetResolvedAddress(const talk_base::SocketAddress& input,
+    void Resolve(const rtc::SocketAddress& address);
+    bool GetResolvedAddress(const rtc::SocketAddress& input,
                             int family,
-                            talk_base::SocketAddress* output) const;
+                            rtc::SocketAddress* output) const;
 
     // The signal is sent when resolving the specified address is finished. The
     // first argument is the input address, the second argument is the error
     // or 0 if it succeeded.
-    sigslot::signal2<const talk_base::SocketAddress&, int> SignalDone;
+    sigslot::signal2<const rtc::SocketAddress&, int> SignalDone;
 
    private:
-    typedef std::map<talk_base::SocketAddress,
-                     talk_base::AsyncResolverInterface*> ResolverMap;
+    typedef std::map<rtc::SocketAddress,
+                     rtc::AsyncResolverInterface*> ResolverMap;
 
-    void OnResolveResult(talk_base::AsyncResolverInterface* resolver);
+    void OnResolveResult(rtc::AsyncResolverInterface* resolver);
 
-    talk_base::PacketSocketFactory* socket_factory_;
+    rtc::PacketSocketFactory* socket_factory_;
     ResolverMap resolvers_;
   };
 
   // DNS resolution of the STUN server.
-  void ResolveStunAddress(const talk_base::SocketAddress& stun_addr);
-  void OnResolveResult(const talk_base::SocketAddress& input, int error);
+  void ResolveStunAddress(const rtc::SocketAddress& stun_addr);
+  void OnResolveResult(const rtc::SocketAddress& input, int error);
 
-  void SendStunBindingRequest(const talk_base::SocketAddress& stun_addr);
+  void SendStunBindingRequest(const rtc::SocketAddress& stun_addr);
 
   // Below methods handles binding request responses.
   void OnStunBindingRequestSucceeded(
-      const talk_base::SocketAddress& stun_server_addr,
-      const talk_base::SocketAddress& stun_reflected_addr);
+      const rtc::SocketAddress& stun_server_addr,
+      const rtc::SocketAddress& stun_reflected_addr);
   void OnStunBindingOrResolveRequestFailed(
-      const talk_base::SocketAddress& stun_server_addr);
+      const rtc::SocketAddress& stun_server_addr);
 
   // Sends STUN requests to the server.
   void OnSendPacket(const void* data, size_t size, StunRequest* req);
@@ -198,9 +198,9 @@ class UDPPort : public Port {
   ServerAddresses bind_request_succeeded_servers_;
   ServerAddresses bind_request_failed_servers_;
   StunRequestManager requests_;
-  talk_base::AsyncPacketSocket* socket_;
+  rtc::AsyncPacketSocket* socket_;
   int error_;
-  talk_base::scoped_ptr<AddressResolver> resolver_;
+  rtc::scoped_ptr<AddressResolver> resolver_;
   bool ready_;
   int stun_keepalive_delay_;
 
@@ -210,10 +210,10 @@ class UDPPort : public Port {
 class StunPort : public UDPPort {
  public:
   static StunPort* Create(
-      talk_base::Thread* thread,
-      talk_base::PacketSocketFactory* factory,
-      talk_base::Network* network,
-      const talk_base::IPAddress& ip,
+      rtc::Thread* thread,
+      rtc::PacketSocketFactory* factory,
+      rtc::Network* network,
+      const rtc::IPAddress& ip,
       int min_port, int max_port,
       const std::string& username,
       const std::string& password,
@@ -235,8 +235,8 @@ class StunPort : public UDPPort {
   }
 
  protected:
-  StunPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
-           talk_base::Network* network, const talk_base::IPAddress& ip,
+  StunPort(rtc::Thread* thread, rtc::PacketSocketFactory* factory,
+           rtc::Network* network, const rtc::IPAddress& ip,
            int min_port, int max_port,
            const std::string& username, const std::string& password,
            const ServerAddresses& servers)
diff --git a/p2p/base/stunport_unittest.cc b/p2p/base/stunport_unittest.cc
index 0965712..8d2c7cf 100644
--- a/p2p/base/stunport_unittest.cc
+++ b/p2p/base/stunport_unittest.cc
@@ -25,19 +25,19 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/virtualsocketserver.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/virtualsocketserver.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/stunport.h"
 #include "talk/p2p/base/teststunserver.h"
 
 using cricket::ServerAddresses;
-using talk_base::SocketAddress;
+using rtc::SocketAddress;
 
 static const SocketAddress kLocalAddr("127.0.0.1", 0);
 static const SocketAddress kStunAddr1("127.0.0.1", 5000);
@@ -56,15 +56,15 @@ class StunPortTest : public testing::Test,
                      public sigslot::has_slots<> {
  public:
   StunPortTest()
-      : pss_(new talk_base::PhysicalSocketServer),
-        ss_(new talk_base::VirtualSocketServer(pss_.get())),
+      : pss_(new rtc::PhysicalSocketServer),
+        ss_(new rtc::VirtualSocketServer(pss_.get())),
         ss_scope_(ss_.get()),
-        network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY), 32),
-        socket_factory_(talk_base::Thread::Current()),
+        network_("unittest", "unittest", rtc::IPAddress(INADDR_ANY), 32),
+        socket_factory_(rtc::Thread::Current()),
         stun_server_1_(new cricket::TestStunServer(
-          talk_base::Thread::Current(), kStunAddr1)),
+          rtc::Thread::Current(), kStunAddr1)),
         stun_server_2_(new cricket::TestStunServer(
-          talk_base::Thread::Current(), kStunAddr2)),
+          rtc::Thread::Current(), kStunAddr2)),
         done_(false), error_(false), stun_keepalive_delay_(0) {
   }
 
@@ -72,7 +72,7 @@ class StunPortTest : public testing::Test,
   bool done() const { return done_; }
   bool error() const { return error_; }
 
-  void CreateStunPort(const talk_base::SocketAddress& server_addr) {
+  void CreateStunPort(const rtc::SocketAddress& server_addr) {
     ServerAddresses stun_servers;
     stun_servers.insert(server_addr);
     CreateStunPort(stun_servers);
@@ -80,9 +80,9 @@ class StunPortTest : public testing::Test,
 
   void CreateStunPort(const ServerAddresses& stun_servers) {
     stun_port_.reset(cricket::StunPort::Create(
-        talk_base::Thread::Current(), &socket_factory_, &network_,
-        kLocalAddr.ipaddr(), 0, 0, talk_base::CreateRandomString(16),
-        talk_base::CreateRandomString(22), stun_servers));
+        rtc::Thread::Current(), &socket_factory_, &network_,
+        kLocalAddr.ipaddr(), 0, 0, rtc::CreateRandomString(16),
+        rtc::CreateRandomString(22), stun_servers));
     stun_port_->set_stun_keepalive_delay(stun_keepalive_delay_);
     stun_port_->SignalPortComplete.connect(this,
         &StunPortTest::OnPortComplete);
@@ -90,15 +90,15 @@ class StunPortTest : public testing::Test,
         &StunPortTest::OnPortError);
   }
 
-  void CreateSharedStunPort(const talk_base::SocketAddress& server_addr) {
+  void CreateSharedStunPort(const rtc::SocketAddress& server_addr) {
     socket_.reset(socket_factory_.CreateUdpSocket(
-        talk_base::SocketAddress(kLocalAddr.ipaddr(), 0), 0, 0));
+        rtc::SocketAddress(kLocalAddr.ipaddr(), 0), 0, 0));
     ASSERT_TRUE(socket_ != NULL);
     socket_->SignalReadPacket.connect(this, &StunPortTest::OnReadPacket);
     stun_port_.reset(cricket::UDPPort::Create(
-        talk_base::Thread::Current(), &socket_factory_,
+        rtc::Thread::Current(), &socket_factory_,
         &network_, socket_.get(),
-        talk_base::CreateRandomString(16), talk_base::CreateRandomString(22)));
+        rtc::CreateRandomString(16), rtc::CreateRandomString(22)));
     ASSERT_TRUE(stun_port_ != NULL);
     ServerAddresses stun_servers;
     stun_servers.insert(server_addr);
@@ -113,28 +113,28 @@ class StunPortTest : public testing::Test,
     stun_port_->PrepareAddress();
   }
 
-  void OnReadPacket(talk_base::AsyncPacketSocket* socket, const char* data,
-                    size_t size, const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time) {
+  void OnReadPacket(rtc::AsyncPacketSocket* socket, const char* data,
+                    size_t size, const rtc::SocketAddress& remote_addr,
+                    const rtc::PacketTime& packet_time) {
     stun_port_->HandleIncomingPacket(
-        socket, data, size, remote_addr, talk_base::PacketTime());
+        socket, data, size, remote_addr, rtc::PacketTime());
   }
 
   void SendData(const char* data, size_t len) {
     stun_port_->HandleIncomingPacket(
-        socket_.get(), data, len, talk_base::SocketAddress("22.22.22.22", 0),
-        talk_base::PacketTime());
+        socket_.get(), data, len, rtc::SocketAddress("22.22.22.22", 0),
+        rtc::PacketTime());
   }
 
  protected:
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
     // Ensure the RNG is inited.
-    talk_base::InitRandom(NULL, 0);
+    rtc::InitRandom(NULL, 0);
 
   }
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   void OnPortComplete(cricket::Port* port) {
@@ -151,15 +151,15 @@ class StunPortTest : public testing::Test,
   }
 
  private:
-  talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
-  talk_base::scoped_ptr<talk_base::VirtualSocketServer> ss_;
-  talk_base::SocketServerScope ss_scope_;
-  talk_base::Network network_;
-  talk_base::BasicPacketSocketFactory socket_factory_;
-  talk_base::scoped_ptr<cricket::UDPPort> stun_port_;
-  talk_base::scoped_ptr<cricket::TestStunServer> stun_server_1_;
-  talk_base::scoped_ptr<cricket::TestStunServer> stun_server_2_;
-  talk_base::scoped_ptr<talk_base::AsyncPacketSocket> socket_;
+  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
+  rtc::scoped_ptr<rtc::VirtualSocketServer> ss_;
+  rtc::SocketServerScope ss_scope_;
+  rtc::Network network_;
+  rtc::BasicPacketSocketFactory socket_factory_;
+  rtc::scoped_ptr<cricket::UDPPort> stun_port_;
+  rtc::scoped_ptr<cricket::TestStunServer> stun_server_1_;
+  rtc::scoped_ptr<cricket::TestStunServer> stun_server_2_;
+  rtc::scoped_ptr<rtc::AsyncPacketSocket> socket_;
   bool done_;
   bool error_;
   int stun_keepalive_delay_;
@@ -223,7 +223,7 @@ TEST_F(StunPortTest, TestKeepAliveResponse) {
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
   // Waiting for 1 seond, which will allow us to process
   // response for keepalive binding request. 500 ms is the keepalive delay.
-  talk_base::Thread::Current()->ProcessMessages(1000);
+  rtc::Thread::Current()->ProcessMessages(1000);
   ASSERT_EQ(1U, port()->Candidates().size());
 }
 
diff --git a/p2p/base/stunrequest.cc b/p2p/base/stunrequest.cc
index b3b1118..148718f 100644
--- a/p2p/base/stunrequest.cc
+++ b/p2p/base/stunrequest.cc
@@ -27,9 +27,9 @@
 
 #include "talk/p2p/base/stunrequest.h"
 
-#include "talk/base/common.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
 
 namespace cricket {
 
@@ -39,7 +39,7 @@ const int MAX_SENDS = 9;
 const int DELAY_UNIT = 100;  // 100 milliseconds
 const int DELAY_MAX_FACTOR = 16;
 
-StunRequestManager::StunRequestManager(talk_base::Thread* thread)
+StunRequestManager::StunRequestManager(rtc::Thread* thread)
     : thread_(thread) {
 }
 
@@ -122,8 +122,8 @@ bool StunRequestManager::CheckResponse(const char* data, size_t size) {
 
   // Parse the STUN message and continue processing as usual.
 
-  talk_base::ByteBuffer buf(data, size);
-  talk_base::scoped_ptr<StunMessage> response(iter->second->msg_->CreateNew());
+  rtc::ByteBuffer buf(data, size);
+  rtc::scoped_ptr<StunMessage> response(iter->second->msg_->CreateNew());
   if (!response->Read(&buf))
     return false;
 
@@ -134,14 +134,14 @@ StunRequest::StunRequest()
     : count_(0), timeout_(false), manager_(0),
       msg_(new StunMessage()), tstamp_(0) {
   msg_->SetTransactionID(
-      talk_base::CreateRandomString(kStunTransactionIdLength));
+      rtc::CreateRandomString(kStunTransactionIdLength));
 }
 
 StunRequest::StunRequest(StunMessage* request)
     : count_(0), timeout_(false), manager_(0),
       msg_(request), tstamp_(0) {
   msg_->SetTransactionID(
-      talk_base::CreateRandomString(kStunTransactionIdLength));
+      rtc::CreateRandomString(kStunTransactionIdLength));
 }
 
 StunRequest::~StunRequest() {
@@ -170,7 +170,7 @@ const StunMessage* StunRequest::msg() const {
 }
 
 uint32 StunRequest::Elapsed() const {
-  return talk_base::TimeSince(tstamp_);
+  return rtc::TimeSince(tstamp_);
 }
 
 
@@ -179,7 +179,7 @@ void StunRequest::set_manager(StunRequestManager* manager) {
   manager_ = manager;
 }
 
-void StunRequest::OnMessage(talk_base::Message* pmsg) {
+void StunRequest::OnMessage(rtc::Message* pmsg) {
   ASSERT(manager_ != NULL);
   ASSERT(pmsg->message_id == MSG_STUN_SEND);
 
@@ -189,9 +189,9 @@ void StunRequest::OnMessage(talk_base::Message* pmsg) {
     return;
   }
 
-  tstamp_ = talk_base::Time();
+  tstamp_ = rtc::Time();
 
-  talk_base::ByteBuffer buf;
+  rtc::ByteBuffer buf;
   msg_->Write(&buf);
   manager_->SignalSendPacket(buf.Data(), buf.Length(), this);
 
@@ -200,7 +200,7 @@ void StunRequest::OnMessage(talk_base::Message* pmsg) {
 }
 
 int StunRequest::GetNextDelay() {
-  int delay = DELAY_UNIT * talk_base::_min(1 << count_, DELAY_MAX_FACTOR);
+  int delay = DELAY_UNIT * rtc::_min(1 << count_, DELAY_MAX_FACTOR);
   count_ += 1;
   if (count_ == MAX_SENDS)
     timeout_ = true;
diff --git a/p2p/base/stunrequest.h b/p2p/base/stunrequest.h
index f2c85b3..8e6fbf2 100644
--- a/p2p/base/stunrequest.h
+++ b/p2p/base/stunrequest.h
@@ -28,8 +28,8 @@
 #ifndef TALK_P2P_BASE_STUNREQUEST_H_
 #define TALK_P2P_BASE_STUNREQUEST_H_
 
-#include "talk/base/sigslot.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/stun.h"
 #include <map>
 #include <string>
@@ -42,7 +42,7 @@ class StunRequest;
 // response or determine that the request has timed out.
 class StunRequestManager {
 public:
-  StunRequestManager(talk_base::Thread* thread);
+  StunRequestManager(rtc::Thread* thread);
   ~StunRequestManager();
 
   // Starts sending the given request (perhaps after a delay).
@@ -69,7 +69,7 @@ public:
 private:
   typedef std::map<std::string, StunRequest*> RequestMap;
 
-  talk_base::Thread* thread_;
+  rtc::Thread* thread_;
   RequestMap requests_;
 
   friend class StunRequest;
@@ -77,7 +77,7 @@ private:
 
 // Represents an individual request to be sent.  The STUN message can either be
 // constructed beforehand or built on demand.
-class StunRequest : public talk_base::MessageHandler {
+class StunRequest : public rtc::MessageHandler {
 public:
   StunRequest();
   StunRequest(StunMessage* request);
@@ -119,7 +119,7 @@ private:
   void set_manager(StunRequestManager* manager);
 
   // Handles messages for sending and timeout.
-  void OnMessage(talk_base::Message* pmsg);
+  void OnMessage(rtc::Message* pmsg);
 
   StunRequestManager* manager_;
   StunMessage* msg_;
diff --git a/p2p/base/stunrequest_unittest.cc b/p2p/base/stunrequest_unittest.cc
index 508660c..6d6ecad 100644
--- a/p2p/base/stunrequest_unittest.cc
+++ b/p2p/base/stunrequest_unittest.cc
@@ -25,11 +25,11 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/p2p/base/stunrequest.h"
 
 using namespace cricket;
@@ -38,15 +38,15 @@ class StunRequestTest : public testing::Test,
                         public sigslot::has_slots<> {
  public:
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   StunRequestTest()
-      : manager_(talk_base::Thread::Current()),
+      : manager_(rtc::Thread::Current()),
         request_count_(0), response_(NULL),
         success_(false), failure_(false), timeout_(false) {
     manager_.SignalSendPacket.connect(this, &StunRequestTest::OnSendPacket);
@@ -171,13 +171,13 @@ TEST_F(StunRequestTest, TestUnexpected) {
 TEST_F(StunRequestTest, TestBackoff) {
   StunMessage* req = CreateStunMessage(STUN_BINDING_REQUEST, NULL);
 
-  uint32 start = talk_base::Time();
+  uint32 start = rtc::Time();
   manager_.Send(new StunRequestThunker(req, this));
   StunMessage* res = CreateStunMessage(STUN_BINDING_RESPONSE, req);
   for (int i = 0; i < 9; ++i) {
     while (request_count_ == i)
-      talk_base::Thread::Current()->ProcessMessages(1);
-    int32 elapsed = talk_base::TimeSince(start);
+      rtc::Thread::Current()->ProcessMessages(1);
+    int32 elapsed = rtc::TimeSince(start);
     LOG(LS_INFO) << "STUN request #" << (i + 1)
                  << " sent at " << elapsed << " ms";
     EXPECT_GE(TotalDelay(i + 1), elapsed);
@@ -197,7 +197,7 @@ TEST_F(StunRequestTest, TestTimeout) {
   StunMessage* res = CreateStunMessage(STUN_BINDING_RESPONSE, req);
 
   manager_.Send(new StunRequestThunker(req, this));
-  talk_base::Thread::Current()->ProcessMessages(10000);  // > STUN timeout
+  rtc::Thread::Current()->ProcessMessages(10000);  // > STUN timeout
   EXPECT_FALSE(manager_.CheckResponse(res));
 
   EXPECT_TRUE(response_ == NULL);
diff --git a/p2p/base/stunserver.cc b/p2p/base/stunserver.cc
index ee6c643..d9633f0 100644
--- a/p2p/base/stunserver.cc
+++ b/p2p/base/stunserver.cc
@@ -27,12 +27,12 @@
 
 #include "talk/p2p/base/stunserver.h"
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/logging.h"
 
 namespace cricket {
 
-StunServer::StunServer(talk_base::AsyncUDPSocket* socket) : socket_(socket) {
+StunServer::StunServer(rtc::AsyncUDPSocket* socket) : socket_(socket) {
   socket_->SignalReadPacket.connect(this, &StunServer::OnPacket);
 }
 
@@ -41,11 +41,11 @@ StunServer::~StunServer() {
 }
 
 void StunServer::OnPacket(
-    talk_base::AsyncPacketSocket* socket, const char* buf, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    rtc::AsyncPacketSocket* socket, const char* buf, size_t size,
+    const rtc::SocketAddress& remote_addr,
+    const rtc::PacketTime& packet_time) {
   // Parse the STUN message; eat any messages that fail to parse.
-  talk_base::ByteBuffer bbuf(buf, size);
+  rtc::ByteBuffer bbuf(buf, size);
   StunMessage msg;
   if (!msg.Read(&bbuf)) {
     return;
@@ -66,7 +66,7 @@ void StunServer::OnPacket(
 }
 
 void StunServer::OnBindingRequest(
-    StunMessage* msg, const talk_base::SocketAddress& remote_addr) {
+    StunMessage* msg, const rtc::SocketAddress& remote_addr) {
   StunMessage response;
   response.SetType(STUN_BINDING_RESPONSE);
   response.SetTransactionID(msg->transaction_id());
@@ -85,7 +85,7 @@ void StunServer::OnBindingRequest(
 }
 
 void StunServer::SendErrorResponse(
-    const StunMessage& msg, const talk_base::SocketAddress& addr,
+    const StunMessage& msg, const rtc::SocketAddress& addr,
     int error_code, const char* error_desc) {
   StunMessage err_msg;
   err_msg.SetType(GetStunErrorResponseType(msg.type()));
@@ -100,10 +100,10 @@ void StunServer::SendErrorResponse(
 }
 
 void StunServer::SendResponse(
-    const StunMessage& msg, const talk_base::SocketAddress& addr) {
-  talk_base::ByteBuffer buf;
+    const StunMessage& msg, const rtc::SocketAddress& addr) {
+  rtc::ByteBuffer buf;
   msg.Write(&buf);
-  talk_base::PacketOptions options;
+  rtc::PacketOptions options;
   if (socket_->SendTo(buf.Data(), buf.Length(), addr, options) < 0)
     LOG_ERR(LS_ERROR) << "sendto";
 }
diff --git a/p2p/base/stunserver.h b/p2p/base/stunserver.h
index c5d12e1..e5d72bc 100644
--- a/p2p/base/stunserver.h
+++ b/p2p/base/stunserver.h
@@ -28,8 +28,8 @@
 #ifndef TALK_P2P_BASE_STUNSERVER_H_
 #define TALK_P2P_BASE_STUNSERVER_H_
 
-#include "talk/base/asyncudpsocket.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/asyncudpsocket.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/p2p/base/stun.h"
 
 namespace cricket {
@@ -39,38 +39,38 @@ const int STUN_SERVER_PORT = 3478;
 class StunServer : public sigslot::has_slots<> {
  public:
   // Creates a STUN server, which will listen on the given socket.
-  explicit StunServer(talk_base::AsyncUDPSocket* socket);
+  explicit StunServer(rtc::AsyncUDPSocket* socket);
   // Removes the STUN server from the socket and deletes the socket.
   ~StunServer();
 
  protected:
   // Slot for AsyncSocket.PacketRead:
   void OnPacket(
-      talk_base::AsyncPacketSocket* socket, const char* buf, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      const talk_base::PacketTime& packet_time);
+      rtc::AsyncPacketSocket* socket, const char* buf, size_t size,
+      const rtc::SocketAddress& remote_addr,
+      const rtc::PacketTime& packet_time);
 
   // Handlers for the different types of STUN/TURN requests:
   void OnBindingRequest(StunMessage* msg,
-      const talk_base::SocketAddress& addr);
+      const rtc::SocketAddress& addr);
   void OnAllocateRequest(StunMessage* msg,
-      const talk_base::SocketAddress& addr);
+      const rtc::SocketAddress& addr);
   void OnSharedSecretRequest(StunMessage* msg,
-      const talk_base::SocketAddress& addr);
+      const rtc::SocketAddress& addr);
   void OnSendRequest(StunMessage* msg,
-      const talk_base::SocketAddress& addr);
+      const rtc::SocketAddress& addr);
 
   // Sends an error response to the given message back to the user.
   void SendErrorResponse(
-      const StunMessage& msg, const talk_base::SocketAddress& addr,
+      const StunMessage& msg, const rtc::SocketAddress& addr,
       int error_code, const char* error_desc);
 
   // Sends the given message to the appropriate destination.
   void SendResponse(const StunMessage& msg,
-       const talk_base::SocketAddress& addr);
+       const rtc::SocketAddress& addr);
 
  private:
-  talk_base::scoped_ptr<talk_base::AsyncUDPSocket> socket_;
+  rtc::scoped_ptr<rtc::AsyncUDPSocket> socket_;
 };
 
 }  // namespace cricket
diff --git a/p2p/base/stunserver_unittest.cc b/p2p/base/stunserver_unittest.cc
index a6f56a5..1c26e22 100644
--- a/p2p/base/stunserver_unittest.cc
+++ b/p2p/base/stunserver_unittest.cc
@@ -27,36 +27,36 @@
 
 #include <string>
 
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/virtualsocketserver.h"
-#include "talk/base/testclient.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/virtualsocketserver.h"
+#include "webrtc/base/testclient.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/stunserver.h"
 
 using namespace cricket;
 
-static const talk_base::SocketAddress server_addr("99.99.99.1", 3478);
-static const talk_base::SocketAddress client_addr("1.2.3.4", 1234);
+static const rtc::SocketAddress server_addr("99.99.99.1", 3478);
+static const rtc::SocketAddress client_addr("1.2.3.4", 1234);
 
 class StunServerTest : public testing::Test {
  public:
   StunServerTest()
-    : pss_(new talk_base::PhysicalSocketServer),
-      ss_(new talk_base::VirtualSocketServer(pss_.get())),
+    : pss_(new rtc::PhysicalSocketServer),
+      ss_(new rtc::VirtualSocketServer(pss_.get())),
       worker_(ss_.get()) {
   }
   virtual void SetUp() {
     server_.reset(new StunServer(
-        talk_base::AsyncUDPSocket::Create(ss_.get(), server_addr)));
-    client_.reset(new talk_base::TestClient(
-        talk_base::AsyncUDPSocket::Create(ss_.get(), client_addr)));
+        rtc::AsyncUDPSocket::Create(ss_.get(), server_addr)));
+    client_.reset(new rtc::TestClient(
+        rtc::AsyncUDPSocket::Create(ss_.get(), client_addr)));
 
     worker_.Start();
   }
   void Send(const StunMessage& msg) {
-    talk_base::ByteBuffer buf;
+    rtc::ByteBuffer buf;
     msg.Write(&buf);
     Send(buf.Data(), static_cast<int>(buf.Length()));
   }
@@ -65,9 +65,9 @@ class StunServerTest : public testing::Test {
   }
   StunMessage* Receive() {
     StunMessage* msg = NULL;
-    talk_base::TestClient::Packet* packet = client_->NextPacket();
+    rtc::TestClient::Packet* packet = client_->NextPacket();
     if (packet) {
-      talk_base::ByteBuffer buf(packet->buf, packet->size);
+      rtc::ByteBuffer buf(packet->buf, packet->size);
       msg = new StunMessage();
       msg->Read(&buf);
       delete packet;
@@ -75,11 +75,11 @@ class StunServerTest : public testing::Test {
     return msg;
   }
  private:
-  talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
-  talk_base::scoped_ptr<talk_base::VirtualSocketServer> ss_;
-  talk_base::Thread worker_;
-  talk_base::scoped_ptr<StunServer> server_;
-  talk_base::scoped_ptr<talk_base::TestClient> client_;
+  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
+  rtc::scoped_ptr<rtc::VirtualSocketServer> ss_;
+  rtc::Thread worker_;
+  rtc::scoped_ptr<StunServer> server_;
+  rtc::scoped_ptr<rtc::TestClient> client_;
 };
 
 // Disable for TSan v2, see
diff --git a/p2p/base/tcpport.cc b/p2p/base/tcpport.cc
index 069323a..f6d9ae6 100644
--- a/p2p/base/tcpport.cc
+++ b/p2p/base/tcpport.cc
@@ -27,15 +27,15 @@
 
 #include "talk/p2p/base/tcpport.h"
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
 #include "talk/p2p/base/common.h"
 
 namespace cricket {
 
-TCPPort::TCPPort(talk_base::Thread* thread,
-                 talk_base::PacketSocketFactory* factory,
-                 talk_base::Network* network, const talk_base::IPAddress& ip,
+TCPPort::TCPPort(rtc::Thread* thread,
+                 rtc::PacketSocketFactory* factory,
+                 rtc::Network* network, const rtc::IPAddress& ip,
                  int min_port, int max_port, const std::string& username,
                  const std::string& password, bool allow_listen)
     : Port(thread, LOCAL_PORT_TYPE, factory, network, ip, min_port, max_port,
@@ -53,7 +53,7 @@ bool TCPPort::Init() {
     // Treat failure to create or bind a TCP socket as fatal.  This
     // should never happen.
     socket_ = socket_factory()->CreateServerTcpSocket(
-        talk_base::SocketAddress(ip(), 0), min_port(), max_port(),
+        rtc::SocketAddress(ip(), 0), min_port(), max_port(),
         false /* ssl */);
     if (!socket_) {
       LOG_J(LS_ERROR, this) << "TCP socket creation failed.";
@@ -100,7 +100,7 @@ Connection* TCPPort::CreateConnection(const Candidate& address,
   }
 
   TCPConnection* conn = NULL;
-  if (talk_base::AsyncPacketSocket* socket =
+  if (rtc::AsyncPacketSocket* socket =
       GetIncoming(address.address(), true)) {
     socket->SignalReadPacket.disconnect(this);
     conn = new TCPConnection(this, address, socket);
@@ -118,28 +118,28 @@ void TCPPort::PrepareAddress() {
     // failed, we still want ot add the socket address.
     LOG(LS_VERBOSE) << "Preparing TCP address, current state: "
                     << socket_->GetState();
-    if (socket_->GetState() == talk_base::AsyncPacketSocket::STATE_BOUND ||
-        socket_->GetState() == talk_base::AsyncPacketSocket::STATE_CLOSED)
+    if (socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND ||
+        socket_->GetState() == rtc::AsyncPacketSocket::STATE_CLOSED)
       AddAddress(socket_->GetLocalAddress(), socket_->GetLocalAddress(),
-                 talk_base::SocketAddress(),
+                 rtc::SocketAddress(),
                  TCP_PROTOCOL_NAME, LOCAL_PORT_TYPE,
                  ICE_TYPE_PREFERENCE_HOST_TCP, true);
   } else {
     LOG_J(LS_INFO, this) << "Not listening due to firewall restrictions.";
     // Note: We still add the address, since otherwise the remote side won't
     // recognize our incoming TCP connections.
-    AddAddress(talk_base::SocketAddress(ip(), 0),
-               talk_base::SocketAddress(ip(), 0), talk_base::SocketAddress(),
+    AddAddress(rtc::SocketAddress(ip(), 0),
+               rtc::SocketAddress(ip(), 0), rtc::SocketAddress(),
                TCP_PROTOCOL_NAME, LOCAL_PORT_TYPE, ICE_TYPE_PREFERENCE_HOST_TCP,
                true);
   }
 }
 
 int TCPPort::SendTo(const void* data, size_t size,
-                    const talk_base::SocketAddress& addr,
-                    const talk_base::PacketOptions& options,
+                    const rtc::SocketAddress& addr,
+                    const rtc::PacketOptions& options,
                     bool payload) {
-  talk_base::AsyncPacketSocket * socket = NULL;
+  rtc::AsyncPacketSocket * socket = NULL;
   if (TCPConnection * conn = static_cast<TCPConnection*>(GetConnection(addr))) {
     socket = conn->socket();
   } else {
@@ -160,7 +160,7 @@ int TCPPort::SendTo(const void* data, size_t size,
   return sent;
 }
 
-int TCPPort::GetOption(talk_base::Socket::Option opt, int* value) {
+int TCPPort::GetOption(rtc::Socket::Option opt, int* value) {
   if (socket_) {
     return socket_->GetOption(opt, value);
   } else {
@@ -168,7 +168,7 @@ int TCPPort::GetOption(talk_base::Socket::Option opt, int* value) {
   }
 }
 
-int TCPPort::SetOption(talk_base::Socket::Option opt, int value) {
+int TCPPort::SetOption(rtc::Socket::Option opt, int value) {
   if (socket_) {
     return socket_->SetOption(opt, value);
   } else {
@@ -180,8 +180,8 @@ int TCPPort::GetError() {
   return error_;
 }
 
-void TCPPort::OnNewConnection(talk_base::AsyncPacketSocket* socket,
-                              talk_base::AsyncPacketSocket* new_socket) {
+void TCPPort::OnNewConnection(rtc::AsyncPacketSocket* socket,
+                              rtc::AsyncPacketSocket* new_socket) {
   ASSERT(socket == socket_);
 
   Incoming incoming;
@@ -195,9 +195,9 @@ void TCPPort::OnNewConnection(talk_base::AsyncPacketSocket* socket,
   incoming_.push_back(incoming);
 }
 
-talk_base::AsyncPacketSocket* TCPPort::GetIncoming(
-    const talk_base::SocketAddress& addr, bool remove) {
-  talk_base::AsyncPacketSocket* socket = NULL;
+rtc::AsyncPacketSocket* TCPPort::GetIncoming(
+    const rtc::SocketAddress& addr, bool remove) {
+  rtc::AsyncPacketSocket* socket = NULL;
   for (std::list<Incoming>::iterator it = incoming_.begin();
        it != incoming_.end(); ++it) {
     if (it->addr == addr) {
@@ -210,34 +210,34 @@ talk_base::AsyncPacketSocket* TCPPort::GetIncoming(
   return socket;
 }
 
-void TCPPort::OnReadPacket(talk_base::AsyncPacketSocket* socket,
+void TCPPort::OnReadPacket(rtc::AsyncPacketSocket* socket,
                            const char* data, size_t size,
-                           const talk_base::SocketAddress& remote_addr,
-                           const talk_base::PacketTime& packet_time) {
+                           const rtc::SocketAddress& remote_addr,
+                           const rtc::PacketTime& packet_time) {
   Port::OnReadPacket(data, size, remote_addr, PROTO_TCP);
 }
 
-void TCPPort::OnReadyToSend(talk_base::AsyncPacketSocket* socket) {
+void TCPPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
   Port::OnReadyToSend();
 }
 
-void TCPPort::OnAddressReady(talk_base::AsyncPacketSocket* socket,
-                             const talk_base::SocketAddress& address) {
-  AddAddress(address, address, talk_base::SocketAddress(), "tcp",
+void TCPPort::OnAddressReady(rtc::AsyncPacketSocket* socket,
+                             const rtc::SocketAddress& address) {
+  AddAddress(address, address, rtc::SocketAddress(), "tcp",
              LOCAL_PORT_TYPE, ICE_TYPE_PREFERENCE_HOST_TCP,
              true);
 }
 
 TCPConnection::TCPConnection(TCPPort* port, const Candidate& candidate,
-                             talk_base::AsyncPacketSocket* socket)
+                             rtc::AsyncPacketSocket* socket)
     : Connection(port, 0, candidate), socket_(socket), error_(0) {
   bool outgoing = (socket_ == NULL);
   if (outgoing) {
     // TODO: Handle failures here (unlikely since TCP).
     int opts = (candidate.protocol() == SSLTCP_PROTOCOL_NAME) ?
-        talk_base::PacketSocketFactory::OPT_SSLTCP : 0;
+        rtc::PacketSocketFactory::OPT_SSLTCP : 0;
     socket_ = port->socket_factory()->CreateClientTcpSocket(
-        talk_base::SocketAddress(port->ip(), 0),
+        rtc::SocketAddress(port->ip(), 0),
         candidate.address(), port->proxy(), port->user_agent(), opts);
     if (socket_) {
       LOG_J(LS_VERBOSE, this) << "Connecting from "
@@ -267,7 +267,7 @@ TCPConnection::~TCPConnection() {
 }
 
 int TCPConnection::Send(const void* data, size_t size,
-                        const talk_base::PacketOptions& options) {
+                        const rtc::PacketOptions& options) {
   if (!socket_) {
     error_ = ENOTCONN;
     return SOCKET_ERROR;
@@ -291,7 +291,7 @@ int TCPConnection::GetError() {
   return error_;
 }
 
-void TCPConnection::OnConnect(talk_base::AsyncPacketSocket* socket) {
+void TCPConnection::OnConnect(rtc::AsyncPacketSocket* socket) {
   ASSERT(socket == socket_);
   // Do not use this connection if the socket bound to a different address than
   // the one we asked for. This is seen in Chrome, where TCP sockets cannot be
@@ -308,7 +308,7 @@ void TCPConnection::OnConnect(talk_base::AsyncPacketSocket* socket) {
   }
 }
 
-void TCPConnection::OnClose(talk_base::AsyncPacketSocket* socket, int error) {
+void TCPConnection::OnClose(rtc::AsyncPacketSocket* socket, int error) {
   ASSERT(socket == socket_);
   LOG_J(LS_VERBOSE, this) << "Connection closed with error " << error;
   set_connected(false);
@@ -316,14 +316,14 @@ void TCPConnection::OnClose(talk_base::AsyncPacketSocket* socket, int error) {
 }
 
 void TCPConnection::OnReadPacket(
-  talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-  const talk_base::SocketAddress& remote_addr,
-  const talk_base::PacketTime& packet_time) {
+  rtc::AsyncPacketSocket* socket, const char* data, size_t size,
+  const rtc::SocketAddress& remote_addr,
+  const rtc::PacketTime& packet_time) {
   ASSERT(socket == socket_);
   Connection::OnReadPacket(data, size, packet_time);
 }
 
-void TCPConnection::OnReadyToSend(talk_base::AsyncPacketSocket* socket) {
+void TCPConnection::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
   ASSERT(socket == socket_);
   Connection::OnReadyToSend();
 }
diff --git a/p2p/base/tcpport.h b/p2p/base/tcpport.h
index c152ec0..8d1b963 100644
--- a/p2p/base/tcpport.h
+++ b/p2p/base/tcpport.h
@@ -30,7 +30,7 @@
 
 #include <string>
 #include <list>
-#include "talk/base/asyncpacketsocket.h"
+#include "webrtc/base/asyncpacketsocket.h"
 #include "talk/p2p/base/port.h"
 
 namespace cricket {
@@ -45,10 +45,10 @@ class TCPConnection;
 // call this TCPPort::OnReadPacket (3 arg) to dispatch to a connection.
 class TCPPort : public Port {
  public:
-  static TCPPort* Create(talk_base::Thread* thread,
-                         talk_base::PacketSocketFactory* factory,
-                         talk_base::Network* network,
-                         const talk_base::IPAddress& ip,
+  static TCPPort* Create(rtc::Thread* thread,
+                         rtc::PacketSocketFactory* factory,
+                         rtc::Network* network,
+                         const rtc::IPAddress& ip,
                          int min_port, int max_port,
                          const std::string& username,
                          const std::string& password,
@@ -69,51 +69,51 @@ class TCPPort : public Port {
 
   virtual void PrepareAddress();
 
-  virtual int GetOption(talk_base::Socket::Option opt, int* value);
-  virtual int SetOption(talk_base::Socket::Option opt, int value);
+  virtual int GetOption(rtc::Socket::Option opt, int* value);
+  virtual int SetOption(rtc::Socket::Option opt, int value);
   virtual int GetError();
 
  protected:
-  TCPPort(talk_base::Thread* thread, talk_base::PacketSocketFactory* factory,
-          talk_base::Network* network, const talk_base::IPAddress& ip,
+  TCPPort(rtc::Thread* thread, rtc::PacketSocketFactory* factory,
+          rtc::Network* network, const rtc::IPAddress& ip,
           int min_port, int max_port, const std::string& username,
           const std::string& password, bool allow_listen);
   bool Init();
 
   // Handles sending using the local TCP socket.
   virtual int SendTo(const void* data, size_t size,
-                     const talk_base::SocketAddress& addr,
-                     const talk_base::PacketOptions& options,
+                     const rtc::SocketAddress& addr,
+                     const rtc::PacketOptions& options,
                      bool payload);
 
   // Accepts incoming TCP connection.
-  void OnNewConnection(talk_base::AsyncPacketSocket* socket,
-                       talk_base::AsyncPacketSocket* new_socket);
+  void OnNewConnection(rtc::AsyncPacketSocket* socket,
+                       rtc::AsyncPacketSocket* new_socket);
 
  private:
   struct Incoming {
-    talk_base::SocketAddress addr;
-    talk_base::AsyncPacketSocket* socket;
+    rtc::SocketAddress addr;
+    rtc::AsyncPacketSocket* socket;
   };
 
-  talk_base::AsyncPacketSocket* GetIncoming(
-      const talk_base::SocketAddress& addr, bool remove = false);
+  rtc::AsyncPacketSocket* GetIncoming(
+      const rtc::SocketAddress& addr, bool remove = false);
 
   // Receives packet signal from the local TCP Socket.
-  void OnReadPacket(talk_base::AsyncPacketSocket* socket,
+  void OnReadPacket(rtc::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time);
+                    const rtc::SocketAddress& remote_addr,
+                    const rtc::PacketTime& packet_time);
 
-  void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
+  void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 
-  void OnAddressReady(talk_base::AsyncPacketSocket* socket,
-                      const talk_base::SocketAddress& address);
+  void OnAddressReady(rtc::AsyncPacketSocket* socket,
+                      const rtc::SocketAddress& address);
 
   // TODO: Is this still needed?
   bool incoming_only_;
   bool allow_listen_;
-  talk_base::AsyncPacketSocket* socket_;
+  rtc::AsyncPacketSocket* socket_;
   int error_;
   std::list<Incoming> incoming_;
 
@@ -124,25 +124,25 @@ class TCPConnection : public Connection {
  public:
   // Connection is outgoing unless socket is specified
   TCPConnection(TCPPort* port, const Candidate& candidate,
-                talk_base::AsyncPacketSocket* socket = 0);
+                rtc::AsyncPacketSocket* socket = 0);
   virtual ~TCPConnection();
 
   virtual int Send(const void* data, size_t size,
-                   const talk_base::PacketOptions& options);
+                   const rtc::PacketOptions& options);
   virtual int GetError();
 
-  talk_base::AsyncPacketSocket* socket() { return socket_; }
+  rtc::AsyncPacketSocket* socket() { return socket_; }
 
  private:
-  void OnConnect(talk_base::AsyncPacketSocket* socket);
-  void OnClose(talk_base::AsyncPacketSocket* socket, int error);
-  void OnReadPacket(talk_base::AsyncPacketSocket* socket,
+  void OnConnect(rtc::AsyncPacketSocket* socket);
+  void OnClose(rtc::AsyncPacketSocket* socket, int error);
+  void OnReadPacket(rtc::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time);
-  void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
+                    const rtc::SocketAddress& remote_addr,
+                    const rtc::PacketTime& packet_time);
+  void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 
-  talk_base::AsyncPacketSocket* socket_;
+  rtc::AsyncPacketSocket* socket_;
   int error_;
 
   friend class TCPPort;
diff --git a/p2p/base/testrelayserver.h b/p2p/base/testrelayserver.h
index 29e9fe4..c6fdf73 100644
--- a/p2p/base/testrelayserver.h
+++ b/p2p/base/testrelayserver.h
@@ -28,11 +28,11 @@
 #ifndef TALK_P2P_BASE_TESTRELAYSERVER_H_
 #define TALK_P2P_BASE_TESTRELAYSERVER_H_
 
-#include "talk/base/asynctcpsocket.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketadapters.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/asynctcpsocket.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socketadapters.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/relayserver.h"
 
 namespace cricket {
@@ -40,17 +40,17 @@ namespace cricket {
 // A test relay server. Useful for unit tests.
 class TestRelayServer : public sigslot::has_slots<> {
  public:
-  TestRelayServer(talk_base::Thread* thread,
-                  const talk_base::SocketAddress& udp_int_addr,
-                  const talk_base::SocketAddress& udp_ext_addr,
-                  const talk_base::SocketAddress& tcp_int_addr,
-                  const talk_base::SocketAddress& tcp_ext_addr,
-                  const talk_base::SocketAddress& ssl_int_addr,
-                  const talk_base::SocketAddress& ssl_ext_addr)
+  TestRelayServer(rtc::Thread* thread,
+                  const rtc::SocketAddress& udp_int_addr,
+                  const rtc::SocketAddress& udp_ext_addr,
+                  const rtc::SocketAddress& tcp_int_addr,
+                  const rtc::SocketAddress& tcp_ext_addr,
+                  const rtc::SocketAddress& ssl_int_addr,
+                  const rtc::SocketAddress& ssl_ext_addr)
       : server_(thread) {
-    server_.AddInternalSocket(talk_base::AsyncUDPSocket::Create(
+    server_.AddInternalSocket(rtc::AsyncUDPSocket::Create(
         thread->socketserver(), udp_int_addr));
-    server_.AddExternalSocket(talk_base::AsyncUDPSocket::Create(
+    server_.AddExternalSocket(rtc::AsyncUDPSocket::Create(
         thread->socketserver(), udp_ext_addr));
 
     tcp_int_socket_.reset(CreateListenSocket(thread, tcp_int_addr));
@@ -61,33 +61,33 @@ class TestRelayServer : public sigslot::has_slots<> {
   int GetConnectionCount() const {
     return server_.GetConnectionCount();
   }
-  talk_base::SocketAddressPair GetConnection(int connection) const {
+  rtc::SocketAddressPair GetConnection(int connection) const {
     return server_.GetConnection(connection);
   }
-  bool HasConnection(const talk_base::SocketAddress& address) const {
+  bool HasConnection(const rtc::SocketAddress& address) const {
     return server_.HasConnection(address);
   }
 
  private:
-  talk_base::AsyncSocket* CreateListenSocket(talk_base::Thread* thread,
-      const talk_base::SocketAddress& addr) {
-    talk_base::AsyncSocket* socket =
+  rtc::AsyncSocket* CreateListenSocket(rtc::Thread* thread,
+      const rtc::SocketAddress& addr) {
+    rtc::AsyncSocket* socket =
         thread->socketserver()->CreateAsyncSocket(addr.family(), SOCK_STREAM);
     socket->Bind(addr);
     socket->Listen(5);
     socket->SignalReadEvent.connect(this, &TestRelayServer::OnAccept);
     return socket;
   }
-  void OnAccept(talk_base::AsyncSocket* socket) {
+  void OnAccept(rtc::AsyncSocket* socket) {
     bool external = (socket == tcp_ext_socket_.get() ||
                      socket == ssl_ext_socket_.get());
     bool ssl = (socket == ssl_int_socket_.get() ||
                 socket == ssl_ext_socket_.get());
-    talk_base::AsyncSocket* raw_socket = socket->Accept(NULL);
+    rtc::AsyncSocket* raw_socket = socket->Accept(NULL);
     if (raw_socket) {
-      talk_base::AsyncTCPSocket* packet_socket = new talk_base::AsyncTCPSocket(
+      rtc::AsyncTCPSocket* packet_socket = new rtc::AsyncTCPSocket(
           (!ssl) ? raw_socket :
-          new talk_base::AsyncSSLServerSocket(raw_socket), false);
+          new rtc::AsyncSSLServerSocket(raw_socket), false);
       if (!external) {
         packet_socket->SignalClose.connect(this,
             &TestRelayServer::OnInternalClose);
@@ -99,18 +99,18 @@ class TestRelayServer : public sigslot::has_slots<> {
       }
     }
   }
-  void OnInternalClose(talk_base::AsyncPacketSocket* socket, int error) {
+  void OnInternalClose(rtc::AsyncPacketSocket* socket, int error) {
     server_.RemoveInternalSocket(socket);
   }
-  void OnExternalClose(talk_base::AsyncPacketSocket* socket, int error) {
+  void OnExternalClose(rtc::AsyncPacketSocket* socket, int error) {
     server_.RemoveExternalSocket(socket);
   }
  private:
   cricket::RelayServer server_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_int_socket_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> tcp_ext_socket_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> ssl_int_socket_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> ssl_ext_socket_;
+  rtc::scoped_ptr<rtc::AsyncSocket> tcp_int_socket_;
+  rtc::scoped_ptr<rtc::AsyncSocket> tcp_ext_socket_;
+  rtc::scoped_ptr<rtc::AsyncSocket> ssl_int_socket_;
+  rtc::scoped_ptr<rtc::AsyncSocket> ssl_ext_socket_;
 };
 
 }  // namespace cricket
diff --git a/p2p/base/teststunserver.h b/p2p/base/teststunserver.h
index 67bac21..131ce69 100644
--- a/p2p/base/teststunserver.h
+++ b/p2p/base/teststunserver.h
@@ -28,8 +28,8 @@
 #ifndef TALK_P2P_BASE_TESTSTUNSERVER_H_
 #define TALK_P2P_BASE_TESTSTUNSERVER_H_
 
-#include "talk/base/socketaddress.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/stunserver.h"
 
 namespace cricket {
@@ -37,16 +37,16 @@ namespace cricket {
 // A test STUN server. Useful for unit tests.
 class TestStunServer {
  public:
-  TestStunServer(talk_base::Thread* thread,
-                 const talk_base::SocketAddress& addr)
+  TestStunServer(rtc::Thread* thread,
+                 const rtc::SocketAddress& addr)
       : socket_(thread->socketserver()->CreateAsyncSocket(addr.family(),
                                                           SOCK_DGRAM)),
-        udp_socket_(talk_base::AsyncUDPSocket::Create(socket_, addr)),
+        udp_socket_(rtc::AsyncUDPSocket::Create(socket_, addr)),
         server_(udp_socket_) {
   }
  private:
-  talk_base::AsyncSocket* socket_;
-  talk_base::AsyncUDPSocket* udp_socket_;
+  rtc::AsyncSocket* socket_;
+  rtc::AsyncUDPSocket* udp_socket_;
   cricket::StunServer server_;
 };
 
diff --git a/p2p/base/testturnserver.h b/p2p/base/testturnserver.h
index 7a3c83f..3b7f765 100644
--- a/p2p/base/testturnserver.h
+++ b/p2p/base/testturnserver.h
@@ -30,8 +30,8 @@
 
 #include <string>
 
-#include "talk/base/asyncudpsocket.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/asyncudpsocket.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/stun.h"
 #include "talk/p2p/base/turnserver.h"
@@ -43,12 +43,12 @@ static const char kTestSoftware[] = "TestTurnServer";
 
 class TestTurnServer : public TurnAuthInterface {
  public:
-  TestTurnServer(talk_base::Thread* thread,
-                 const talk_base::SocketAddress& udp_int_addr,
-                 const talk_base::SocketAddress& udp_ext_addr)
+  TestTurnServer(rtc::Thread* thread,
+                 const rtc::SocketAddress& udp_int_addr,
+                 const rtc::SocketAddress& udp_ext_addr)
       : server_(thread) {
     AddInternalSocket(udp_int_addr, cricket::PROTO_UDP);
-    server_.SetExternalSocketFactory(new talk_base::BasicPacketSocketFactory(),
+    server_.SetExternalSocketFactory(new rtc::BasicPacketSocketFactory(),
         udp_ext_addr);
     server_.set_realm(kTestRealm);
     server_.set_software(kTestSoftware);
@@ -61,16 +61,16 @@ class TestTurnServer : public TurnAuthInterface {
 
   TurnServer* server() { return &server_; }
 
-  void AddInternalSocket(const talk_base::SocketAddress& int_addr,
+  void AddInternalSocket(const rtc::SocketAddress& int_addr,
                          ProtocolType proto) {
-    talk_base::Thread* thread = talk_base::Thread::Current();
+    rtc::Thread* thread = rtc::Thread::Current();
     if (proto == cricket::PROTO_UDP) {
-      server_.AddInternalSocket(talk_base::AsyncUDPSocket::Create(
+      server_.AddInternalSocket(rtc::AsyncUDPSocket::Create(
           thread->socketserver(), int_addr), proto);
     } else if (proto == cricket::PROTO_TCP) {
       // For TCP we need to create a server socket which can listen for incoming
       // new connections.
-      talk_base::AsyncSocket* socket =
+      rtc::AsyncSocket* socket =
           thread->socketserver()->CreateAsyncSocket(SOCK_STREAM);
       socket->Bind(int_addr);
       socket->Listen(5);
diff --git a/p2p/base/transport.cc b/p2p/base/transport.cc
index 2996487..825142a 100644
--- a/p2p/base/transport.cc
+++ b/p2p/base/transport.cc
@@ -27,9 +27,9 @@
 
 #include "talk/p2p/base/transport.h"
 
-#include "talk/base/bind.h"
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/bind.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/sessionmanager.h"
@@ -40,7 +40,7 @@
 
 namespace cricket {
 
-using talk_base::Bind;
+using rtc::Bind;
 
 enum {
   MSG_ONSIGNALINGREADY = 1,
@@ -57,7 +57,7 @@ enum {
   MSG_FAILED,
 };
 
-struct ChannelParams : public talk_base::MessageData {
+struct ChannelParams : public rtc::MessageData {
   ChannelParams() : channel(NULL), candidate(NULL) {}
   explicit ChannelParams(int component)
       : component(component), channel(NULL), candidate(NULL) {}
@@ -135,8 +135,8 @@ static bool IceCredentialsChanged(const TransportDescription& old_desc,
                                new_desc.ice_ufrag, new_desc.ice_pwd);
 }
 
-Transport::Transport(talk_base::Thread* signaling_thread,
-                     talk_base::Thread* worker_thread,
+Transport::Transport(rtc::Thread* signaling_thread,
+                     rtc::Thread* worker_thread,
                      const std::string& content_name,
                      const std::string& type,
                      PortAllocator* allocator)
@@ -165,25 +165,25 @@ void Transport::SetIceRole(IceRole role) {
   worker_thread_->Invoke<void>(Bind(&Transport::SetIceRole_w, this, role));
 }
 
-void Transport::SetIdentity(talk_base::SSLIdentity* identity) {
+void Transport::SetIdentity(rtc::SSLIdentity* identity) {
   worker_thread_->Invoke<void>(Bind(&Transport::SetIdentity_w, this, identity));
 }
 
-bool Transport::GetIdentity(talk_base::SSLIdentity** identity) {
+bool Transport::GetIdentity(rtc::SSLIdentity** identity) {
   // The identity is set on the worker thread, so for safety it must also be
   // acquired on the worker thread.
   return worker_thread_->Invoke<bool>(
       Bind(&Transport::GetIdentity_w, this, identity));
 }
 
-bool Transport::GetRemoteCertificate(talk_base::SSLCertificate** cert) {
+bool Transport::GetRemoteCertificate(rtc::SSLCertificate** cert) {
   // Channels can be deleted on the worker thread, so for safety the remote
   // certificate is acquired on the worker thread.
   return worker_thread_->Invoke<bool>(
       Bind(&Transport::GetRemoteCertificate_w, this, cert));
 }
 
-bool Transport::GetRemoteCertificate_w(talk_base::SSLCertificate** cert) {
+bool Transport::GetRemoteCertificate_w(rtc::SSLCertificate** cert) {
   ASSERT(worker_thread()->IsCurrent());
   if (channels_.empty())
     return false;
@@ -218,7 +218,7 @@ TransportChannelImpl* Transport::CreateChannel(int component) {
 TransportChannelImpl* Transport::CreateChannel_w(int component) {
   ASSERT(worker_thread()->IsCurrent());
   TransportChannelImpl *impl;
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
 
   // Create the entry if it does not exist.
   bool impl_exists = false;
@@ -276,13 +276,13 @@ TransportChannelImpl* Transport::CreateChannel_w(int component) {
 }
 
 TransportChannelImpl* Transport::GetChannel(int component) {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   ChannelMap::iterator iter = channels_.find(component);
   return (iter != channels_.end()) ? iter->second.get() : NULL;
 }
 
 bool Transport::HasChannels() {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   return !channels_.empty();
 }
 
@@ -296,7 +296,7 @@ void Transport::DestroyChannel_w(int component) {
 
   TransportChannelImpl* impl = NULL;
   {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     ChannelMap::iterator iter = channels_.find(component);
     if (iter == channels_.end())
       return;
@@ -343,8 +343,8 @@ void Transport::ConnectChannels_w() {
     LOG(LS_INFO) << "Transport::ConnectChannels_w: No local description has "
                  << "been set. Will generate one.";
     TransportDescription desc(NS_GINGLE_P2P, std::vector<std::string>(),
-                              talk_base::CreateRandomString(ICE_UFRAG_LENGTH),
-                              talk_base::CreateRandomString(ICE_PWD_LENGTH),
+                              rtc::CreateRandomString(ICE_UFRAG_LENGTH),
+                              rtc::CreateRandomString(ICE_PWD_LENGTH),
                               ICEMODE_FULL, CONNECTIONROLE_NONE, NULL,
                               Candidates());
     SetLocalTransportDescription_w(desc, CA_OFFER, NULL);
@@ -374,7 +374,7 @@ void Transport::DestroyAllChannels_w() {
   ASSERT(worker_thread()->IsCurrent());
   std::vector<TransportChannelImpl*> impls;
   {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     for (ChannelMap::iterator iter = channels_.begin();
          iter != channels_.end();
          ++iter) {
@@ -402,7 +402,7 @@ void Transport::ResetChannels_w() {
   connect_requested_ = false;
 
   // Clear out the old messages, they aren't relevant
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   ready_candidates_.clear();
 
   // Reset all of the channels
@@ -421,7 +421,7 @@ void Transport::OnSignalingReady() {
 
 void Transport::CallChannels_w(TransportChannelFunc func) {
   ASSERT(worker_thread()->IsCurrent());
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   for (ChannelMap::iterator iter = channels_.begin();
        iter != channels_.end();
        ++iter) {
@@ -483,7 +483,7 @@ bool Transport::GetStats_w(TransportStats* stats) {
   return true;
 }
 
-bool Transport::GetSslRole(talk_base::SSLRole* ssl_role) const {
+bool Transport::GetSslRole(rtc::SSLRole* ssl_role) const {
   return worker_thread_->Invoke<bool>(Bind(
       &Transport::GetSslRole_w, this, ssl_role));
 }
@@ -552,7 +552,7 @@ void Transport::OnChannelWritableState_s() {
 
 TransportState Transport::GetTransportState_s(bool read) {
   ASSERT(signaling_thread()->IsCurrent());
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   bool any = false;
   bool all = !channels_.empty();
   for (ChannelMap::iterator iter = channels_.begin();
@@ -583,7 +583,7 @@ void Transport::OnChannelRequestSignaling_s(int component) {
   LOG(LS_INFO) << "Transport: " << content_name_ << ", allocating candidates";
   // Resetting ICE state for the channel.
   {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     ChannelMap::iterator iter = channels_.find(component);
     if (iter != channels_.end())
       iter->second.set_candidates_allocated(false);
@@ -594,7 +594,7 @@ void Transport::OnChannelRequestSignaling_s(int component) {
 void Transport::OnChannelCandidateReady(TransportChannelImpl* channel,
                                         const Candidate& candidate) {
   ASSERT(worker_thread()->IsCurrent());
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   ready_candidates_.push_back(candidate);
 
   // We hold any messages until the client lets us connect.
@@ -610,7 +610,7 @@ void Transport::OnChannelCandidateReady_s() {
 
   std::vector<Candidate> candidates;
   {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     candidates.swap(ready_candidates_);
   }
 
@@ -638,7 +638,7 @@ void Transport::OnChannelRouteChange_s(const TransportChannel* channel,
 void Transport::OnChannelCandidatesAllocationDone(
     TransportChannelImpl* channel) {
   ASSERT(worker_thread()->IsCurrent());
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   ChannelMap::iterator iter = channels_.find(channel->component());
   ASSERT(iter != channels_.end());
   LOG(LS_INFO) << "Transport: " << content_name_ << ", component "
@@ -713,7 +713,7 @@ void Transport::MaybeCompleted_w() {
 }
 
 void Transport::SetIceRole_w(IceRole role) {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   ice_role_ = role;
   for (ChannelMap::iterator iter = channels_.begin();
        iter != channels_.end(); ++iter) {
@@ -722,7 +722,7 @@ void Transport::SetIceRole_w(IceRole role) {
 }
 
 void Transport::SetRemoteIceMode_w(IceMode mode) {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   remote_ice_mode_ = mode;
   // Shouldn't channels be created after this method executed?
   for (ChannelMap::iterator iter = channels_.begin();
@@ -736,7 +736,7 @@ bool Transport::SetLocalTransportDescription_w(
     ContentAction action,
     std::string* error_desc) {
   bool ret = true;
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
 
   if (!VerifyIceParams(desc)) {
     return BadTransportDescription("Invalid ice-ufrag or ice-pwd length",
@@ -773,7 +773,7 @@ bool Transport::SetRemoteTransportDescription_w(
     ContentAction action,
     std::string* error_desc) {
   bool ret = true;
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
 
   if (!VerifyIceParams(desc)) {
     return BadTransportDescription("Invalid ice-ufrag or ice-pwd length",
@@ -891,7 +891,7 @@ bool Transport::NegotiateTransportDescription_w(ContentAction local_role,
   return true;
 }
 
-void Transport::OnMessage(talk_base::Message* msg) {
+void Transport::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_ONSIGNALINGREADY:
       CallChannels_w(&TransportChannelImpl::OnSignalingReady);
@@ -944,7 +944,7 @@ void Transport::OnMessage(talk_base::Message* msg) {
 bool TransportParser::ParseAddress(const buzz::XmlElement* elem,
                                    const buzz::QName& address_name,
                                    const buzz::QName& port_name,
-                                   talk_base::SocketAddress* address,
+                                   rtc::SocketAddress* address,
                                    ParseError* error) {
   if (!elem->HasAttr(address_name))
     return BadParse("address does not have " + address_name.LocalPart(), error);
diff --git a/p2p/base/transport.h b/p2p/base/transport.h
index 5a4b75f..0ce12e7 100644
--- a/p2p/base/transport.h
+++ b/p2p/base/transport.h
@@ -49,16 +49,16 @@
 #include <string>
 #include <map>
 #include <vector>
-#include "talk/base/criticalsection.h"
-#include "talk/base/messagequeue.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/sslstreamadapter.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/sslstreamadapter.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/sessiondescription.h"
 #include "talk/p2p/base/transportinfo.h"
 
-namespace talk_base {
+namespace rtc {
 class Thread;
 }
 
@@ -123,7 +123,7 @@ class TransportParser {
   bool ParseAddress(const buzz::XmlElement* elem,
                     const buzz::QName& address_name,
                     const buzz::QName& port_name,
-                    talk_base::SocketAddress* address,
+                    rtc::SocketAddress* address,
                     ParseError* error);
 
   virtual ~TransportParser() {}
@@ -194,20 +194,20 @@ bool IceCredentialsChanged(const std::string& old_ufrag,
                            const std::string& new_ufrag,
                            const std::string& new_pwd);
 
-class Transport : public talk_base::MessageHandler,
+class Transport : public rtc::MessageHandler,
                   public sigslot::has_slots<> {
  public:
-  Transport(talk_base::Thread* signaling_thread,
-            talk_base::Thread* worker_thread,
+  Transport(rtc::Thread* signaling_thread,
+            rtc::Thread* worker_thread,
             const std::string& content_name,
             const std::string& type,
             PortAllocator* allocator);
   virtual ~Transport();
 
   // Returns the signaling thread. The app talks to Transport on this thread.
-  talk_base::Thread* signaling_thread() { return signaling_thread_; }
+  rtc::Thread* signaling_thread() { return signaling_thread_; }
   // Returns the worker thread. The actual networking is done on this thread.
-  talk_base::Thread* worker_thread() { return worker_thread_; }
+  rtc::Thread* worker_thread() { return worker_thread_; }
 
   // Returns the content_name of this transport.
   const std::string& content_name() const { return content_name_; }
@@ -254,13 +254,13 @@ class Transport : public talk_base::MessageHandler,
   uint64 IceTiebreaker() { return tiebreaker_; }
 
   // Must be called before applying local session description.
-  void SetIdentity(talk_base::SSLIdentity* identity);
+  void SetIdentity(rtc::SSLIdentity* identity);
 
   // Get a copy of the local identity provided by SetIdentity.
-  bool GetIdentity(talk_base::SSLIdentity** identity);
+  bool GetIdentity(rtc::SSLIdentity** identity);
 
   // Get a copy of the remote certificate in use by the specified channel.
-  bool GetRemoteCertificate(talk_base::SSLCertificate** cert);
+  bool GetRemoteCertificate(rtc::SSLCertificate** cert);
 
   TransportProtocol protocol() const { return protocol_; }
 
@@ -341,7 +341,7 @@ class Transport : public talk_base::MessageHandler,
   // Forwards the signal from TransportChannel to BaseSession.
   sigslot::signal0<> SignalRoleConflict;
 
-  virtual bool GetSslRole(talk_base::SSLRole* ssl_role) const;
+  virtual bool GetSslRole(rtc::SSLRole* ssl_role) const;
 
  protected:
   // These are called by Create/DestroyChannel above in order to create or
@@ -364,9 +364,9 @@ class Transport : public talk_base::MessageHandler,
     return remote_description_.get();
   }
 
-  virtual void SetIdentity_w(talk_base::SSLIdentity* identity) {}
+  virtual void SetIdentity_w(rtc::SSLIdentity* identity) {}
 
-  virtual bool GetIdentity_w(talk_base::SSLIdentity** identity) {
+  virtual bool GetIdentity_w(rtc::SSLIdentity** identity) {
     return false;
   }
 
@@ -395,7 +395,7 @@ class Transport : public talk_base::MessageHandler,
   virtual bool ApplyNegotiatedTransportDescription_w(
       TransportChannelImpl* channel, std::string* error_desc);
 
-  virtual bool GetSslRole_w(talk_base::SSLRole* ssl_role) const {
+  virtual bool GetSslRole_w(rtc::SSLRole* ssl_role) const {
     return false;
   }
 
@@ -452,7 +452,7 @@ class Transport : public talk_base::MessageHandler,
   void OnChannelConnectionRemoved(TransportChannelImpl* channel);
 
   // Dispatches messages to the appropriate handler (below).
-  void OnMessage(talk_base::Message* msg);
+  void OnMessage(rtc::Message* msg);
 
   // These are versions of the above methods that are called only on a
   // particular thread (s = signaling, w = worker).  The above methods post or
@@ -489,13 +489,13 @@ class Transport : public talk_base::MessageHandler,
                                        ContentAction action,
                                        std::string* error_desc);
   bool GetStats_w(TransportStats* infos);
-  bool GetRemoteCertificate_w(talk_base::SSLCertificate** cert);
+  bool GetRemoteCertificate_w(rtc::SSLCertificate** cert);
 
   // Sends SignalCompleted if we are now in that state.
   void MaybeCompleted_w();
 
-  talk_base::Thread* signaling_thread_;
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* signaling_thread_;
+  rtc::Thread* worker_thread_;
   std::string content_name_;
   std::string type_;
   PortAllocator* allocator_;
@@ -508,15 +508,15 @@ class Transport : public talk_base::MessageHandler,
   uint64 tiebreaker_;
   TransportProtocol protocol_;
   IceMode remote_ice_mode_;
-  talk_base::scoped_ptr<TransportDescription> local_description_;
-  talk_base::scoped_ptr<TransportDescription> remote_description_;
+  rtc::scoped_ptr<TransportDescription> local_description_;
+  rtc::scoped_ptr<TransportDescription> remote_description_;
 
   ChannelMap channels_;
   // Buffers the ready_candidates so that SignalCanidatesReady can
   // provide them in multiples.
   std::vector<Candidate> ready_candidates_;
   // Protects changes to channels and messages
-  talk_base::CriticalSection crit_;
+  rtc::CriticalSection crit_;
 
   DISALLOW_EVIL_CONSTRUCTORS(Transport);
 };
diff --git a/p2p/base/transport_unittest.cc b/p2p/base/transport_unittest.cc
index a83d256..f605bbc 100644
--- a/p2p/base/transport_unittest.cc
+++ b/p2p/base/transport_unittest.cc
@@ -25,9 +25,9 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/fakesslidentity.h"
-#include "talk/base/gunit.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/fakesslidentity.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/fakesession.h"
 #include "talk/p2p/base/parsing.h"
@@ -47,7 +47,7 @@ using cricket::IceRole;
 using cricket::TransportDescription;
 using cricket::WriteError;
 using cricket::ParseError;
-using talk_base::SocketAddress;
+using rtc::SocketAddress;
 
 static const char kIceUfrag1[] = "TESTICEUFRAG0001";
 static const char kIcePwd1[] = "TESTICEPWD00000000000001";
@@ -59,7 +59,7 @@ class TransportTest : public testing::Test,
                       public sigslot::has_slots<> {
  public:
   TransportTest()
-      : thread_(talk_base::Thread::Current()),
+      : thread_(rtc::Thread::Current()),
         transport_(new FakeTransport(
             thread_, thread_, "test content name", NULL)),
         channel_(NULL),
@@ -97,8 +97,8 @@ class TransportTest : public testing::Test,
     failed_ = true;
   }
 
-  talk_base::Thread* thread_;
-  talk_base::scoped_ptr<FakeTransport> transport_;
+  rtc::Thread* thread_;
+  rtc::scoped_ptr<FakeTransport> transport_;
   FakeTransportChannel* channel_;
   bool connecting_signalled_;
   bool completed_;
@@ -365,20 +365,20 @@ TEST_F(TransportTest, TestSetRemoteIceLiteInAnswer) {
 TEST_F(TransportTest, TestP2PTransportWriteAndParseCandidate) {
   Candidate test_candidate(
       "", 1, "udp",
-      talk_base::SocketAddress("2001:db8:fefe::1", 9999),
+      rtc::SocketAddress("2001:db8:fefe::1", 9999),
       738197504, "abcdef", "ghijkl", "foo", "testnet", 50, "");
   Candidate test_candidate2(
       "", 2, "tcp",
-      talk_base::SocketAddress("192.168.7.1", 9999),
+      rtc::SocketAddress("192.168.7.1", 9999),
       1107296256, "mnopqr", "stuvwx", "bar", "testnet2", 100, "");
-  talk_base::SocketAddress host_address("www.google.com", 24601);
-  host_address.SetResolvedIP(talk_base::IPAddress(0x0A000001));
+  rtc::SocketAddress host_address("www.google.com", 24601);
+  host_address.SetResolvedIP(rtc::IPAddress(0x0A000001));
   Candidate test_candidate3(
       "", 3, "spdy", host_address, 1476395008, "yzabcd",
       "efghij", "baz", "testnet3", 150, "");
   WriteError write_error;
   ParseError parse_error;
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   cricket::Candidate parsed_candidate;
   cricket::P2PTransportParser parser;
 
diff --git a/p2p/base/transportchannel.h b/p2p/base/transportchannel.h
index c548c1c..b804320 100644
--- a/p2p/base/transportchannel.h
+++ b/p2p/base/transportchannel.h
@@ -31,13 +31,13 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/asyncpacketsocket.h"
-#include "talk/base/basictypes.h"
-#include "talk/base/dscp.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/socket.h"
-#include "talk/base/sslidentity.h"
-#include "talk/base/sslstreamadapter.h"
+#include "webrtc/base/asyncpacketsocket.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/dscp.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/socket.h"
+#include "webrtc/base/sslidentity.h"
+#include "webrtc/base/sslstreamadapter.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/transport.h"
 #include "talk/p2p/base/transportdescription.h"
@@ -83,12 +83,12 @@ class TransportChannel : public sigslot::has_slots<> {
   // Attempts to send the given packet.  The return value is < 0 on failure.
   // TODO: Remove the default argument once channel code is updated.
   virtual int SendPacket(const char* data, size_t len,
-                         const talk_base::PacketOptions& options,
+                         const rtc::PacketOptions& options,
                          int flags = 0) = 0;
 
   // Sets a socket option on this channel.  Note that not all options are
   // supported by all transport types.
-  virtual int SetOption(talk_base::Socket::Option opt, int value) = 0;
+  virtual int SetOption(rtc::Socket::Option opt, int value) = 0;
 
   // Returns the most recent error that occurred on this channel.
   virtual int GetError() = 0;
@@ -100,7 +100,7 @@ class TransportChannel : public sigslot::has_slots<> {
   virtual bool IsDtlsActive() const = 0;
 
   // Default implementation.
-  virtual bool GetSslRole(talk_base::SSLRole* role) const = 0;
+  virtual bool GetSslRole(rtc::SSLRole* role) const = 0;
 
   // Sets up the ciphers to use for DTLS-SRTP.
   virtual bool SetSrtpCiphers(const std::vector<std::string>& ciphers) = 0;
@@ -109,10 +109,10 @@ class TransportChannel : public sigslot::has_slots<> {
   virtual bool GetSrtpCipher(std::string* cipher) = 0;
 
   // Gets a copy of the local SSL identity, owned by the caller.
-  virtual bool GetLocalIdentity(talk_base::SSLIdentity** identity) const = 0;
+  virtual bool GetLocalIdentity(rtc::SSLIdentity** identity) const = 0;
 
   // Gets a copy of the remote side's SSL certificate, owned by the caller.
-  virtual bool GetRemoteCertificate(talk_base::SSLCertificate** cert) const = 0;
+  virtual bool GetRemoteCertificate(rtc::SSLCertificate** cert) const = 0;
 
   // Allows key material to be extracted for external encryption.
   virtual bool ExportKeyingMaterial(const std::string& label,
@@ -124,7 +124,7 @@ class TransportChannel : public sigslot::has_slots<> {
 
   // Signalled each time a packet is received on this channel.
   sigslot::signal5<TransportChannel*, const char*,
-                   size_t, const talk_base::PacketTime&, int> SignalReadPacket;
+                   size_t, const rtc::PacketTime&, int> SignalReadPacket;
 
   // This signal occurs when there is a change in the way that packets are
   // being routed, i.e. to a different remote location. The candidate
diff --git a/p2p/base/transportchannelimpl.h b/p2p/base/transportchannelimpl.h
index 25c3121..fde980b 100644
--- a/p2p/base/transportchannelimpl.h
+++ b/p2p/base/transportchannelimpl.h
@@ -99,14 +99,14 @@ class TransportChannelImpl : public TransportChannel {
   // retains ownership and must delete it after this TransportChannelImpl is
   // destroyed.
   // TODO(bemasc): Fix the ownership semantics of this method.
-  virtual bool SetLocalIdentity(talk_base::SSLIdentity* identity) = 0;
+  virtual bool SetLocalIdentity(rtc::SSLIdentity* identity) = 0;
 
   // Set DTLS Remote fingerprint. Must be after local identity set.
   virtual bool SetRemoteFingerprint(const std::string& digest_alg,
     const uint8* digest,
     size_t digest_len) = 0;
 
-  virtual bool SetSslRole(talk_base::SSLRole role) = 0;
+  virtual bool SetSslRole(rtc::SSLRole role) = 0;
 
   // TransportChannel is forwarding this signal from PortAllocatorSession.
   sigslot::signal1<TransportChannelImpl*> SignalCandidatesAllocationDone;
diff --git a/p2p/base/transportchannelproxy.cc b/p2p/base/transportchannelproxy.cc
index fdcc509..28d7ff4 100644
--- a/p2p/base/transportchannelproxy.cc
+++ b/p2p/base/transportchannelproxy.cc
@@ -26,9 +26,9 @@
  */
 
 #include "talk/p2p/base/transportchannelproxy.h"
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/transport.h"
 #include "talk/p2p/base/transportchannelimpl.h"
 
@@ -44,7 +44,7 @@ TransportChannelProxy::TransportChannelProxy(const std::string& content_name,
     : TransportChannel(content_name, component),
       name_(name),
       impl_(NULL) {
-  worker_thread_ = talk_base::Thread::Current();
+  worker_thread_ = rtc::Thread::Current();
 }
 
 TransportChannelProxy::~TransportChannelProxy() {
@@ -55,7 +55,7 @@ TransportChannelProxy::~TransportChannelProxy() {
 }
 
 void TransportChannelProxy::SetImplementation(TransportChannelImpl* impl) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
 
   if (impl == impl_) {
     // Ignore if the |impl| has already been set.
@@ -101,9 +101,9 @@ void TransportChannelProxy::SetImplementation(TransportChannelImpl* impl) {
 }
 
 int TransportChannelProxy::SendPacket(const char* data, size_t len,
-                                      const talk_base::PacketOptions& options,
+                                      const rtc::PacketOptions& options,
                                       int flags) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   // Fail if we don't have an impl yet.
   if (!impl_) {
     return -1;
@@ -111,8 +111,8 @@ int TransportChannelProxy::SendPacket(const char* data, size_t len,
   return impl_->SendPacket(data, len, options, flags);
 }
 
-int TransportChannelProxy::SetOption(talk_base::Socket::Option opt, int value) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+int TransportChannelProxy::SetOption(rtc::Socket::Option opt, int value) {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     pending_options_.push_back(OptionPair(opt, value));
     return 0;
@@ -121,7 +121,7 @@ int TransportChannelProxy::SetOption(talk_base::Socket::Option opt, int value) {
 }
 
 int TransportChannelProxy::GetError() {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return 0;
   }
@@ -129,7 +129,7 @@ int TransportChannelProxy::GetError() {
 }
 
 bool TransportChannelProxy::GetStats(ConnectionInfos* infos) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return false;
   }
@@ -137,23 +137,23 @@ bool TransportChannelProxy::GetStats(ConnectionInfos* infos) {
 }
 
 bool TransportChannelProxy::IsDtlsActive() const {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return false;
   }
   return impl_->IsDtlsActive();
 }
 
-bool TransportChannelProxy::GetSslRole(talk_base::SSLRole* role) const {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+bool TransportChannelProxy::GetSslRole(rtc::SSLRole* role) const {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return false;
   }
   return impl_->GetSslRole(role);
 }
 
-bool TransportChannelProxy::SetSslRole(talk_base::SSLRole role) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+bool TransportChannelProxy::SetSslRole(rtc::SSLRole role) {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return false;
   }
@@ -162,7 +162,7 @@ bool TransportChannelProxy::SetSslRole(talk_base::SSLRole role) {
 
 bool TransportChannelProxy::SetSrtpCiphers(const std::vector<std::string>&
                                            ciphers) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   pending_srtp_ciphers_ = ciphers;  // Cache so we can send later, but always
                                     // set so it stays consistent.
   if (impl_) {
@@ -172,7 +172,7 @@ bool TransportChannelProxy::SetSrtpCiphers(const std::vector<std::string>&
 }
 
 bool TransportChannelProxy::GetSrtpCipher(std::string* cipher) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return false;
   }
@@ -180,8 +180,8 @@ bool TransportChannelProxy::GetSrtpCipher(std::string* cipher) {
 }
 
 bool TransportChannelProxy::GetLocalIdentity(
-    talk_base::SSLIdentity** identity) const {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+    rtc::SSLIdentity** identity) const {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return false;
   }
@@ -189,8 +189,8 @@ bool TransportChannelProxy::GetLocalIdentity(
 }
 
 bool TransportChannelProxy::GetRemoteCertificate(
-    talk_base::SSLCertificate** cert) const {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+    rtc::SSLCertificate** cert) const {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return false;
   }
@@ -203,7 +203,7 @@ bool TransportChannelProxy::ExportKeyingMaterial(const std::string& label,
                                                  bool use_context,
                                                  uint8* result,
                                                  size_t result_len) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return false;
   }
@@ -212,7 +212,7 @@ bool TransportChannelProxy::ExportKeyingMaterial(const std::string& label,
 }
 
 IceRole TransportChannelProxy::GetIceRole() const {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return ICEROLE_UNKNOWN;
   }
@@ -220,14 +220,14 @@ IceRole TransportChannelProxy::GetIceRole() const {
 }
 
 void TransportChannelProxy::OnReadableState(TransportChannel* channel) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
   set_readable(impl_->readable());
   // Note: SignalReadableState fired by set_readable.
 }
 
 void TransportChannelProxy::OnWritableState(TransportChannel* channel) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
   set_writable(impl_->writable());
   // Note: SignalWritableState fired by set_readable.
@@ -235,27 +235,27 @@ void TransportChannelProxy::OnWritableState(TransportChannel* channel) {
 
 void TransportChannelProxy::OnReadPacket(
     TransportChannel* channel, const char* data, size_t size,
-    const talk_base::PacketTime& packet_time, int flags) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+    const rtc::PacketTime& packet_time, int flags) {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
   SignalReadPacket(this, data, size, packet_time, flags);
 }
 
 void TransportChannelProxy::OnReadyToSend(TransportChannel* channel) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
   SignalReadyToSend(this);
 }
 
 void TransportChannelProxy::OnRouteChange(TransportChannel* channel,
                                           const Candidate& candidate) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
   SignalRouteChange(this, candidate);
 }
 
-void TransportChannelProxy::OnMessage(talk_base::Message* msg) {
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+void TransportChannelProxy::OnMessage(rtc::Message* msg) {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
   if (msg->message_id == MSG_UPDATESTATE) {
      // If impl_ is already readable or writable, push up those signals.
      set_readable(impl_ ? impl_->readable() : false);
diff --git a/p2p/base/transportchannelproxy.h b/p2p/base/transportchannelproxy.h
index cb38c7b..2a1d21a 100644
--- a/p2p/base/transportchannelproxy.h
+++ b/p2p/base/transportchannelproxy.h
@@ -32,10 +32,10 @@
 #include <utility>
 #include <vector>
 
-#include "talk/base/messagehandler.h"
+#include "webrtc/base/messagehandler.h"
 #include "talk/p2p/base/transportchannel.h"
 
-namespace talk_base {
+namespace rtc {
 class Thread;
 }
 
@@ -48,7 +48,7 @@ class TransportChannelImpl;
 // network negotiation is complete.  Hence, we create a proxy up front, and
 // when negotiation completes, connect the proxy to the implementaiton.
 class TransportChannelProxy : public TransportChannel,
-                              public talk_base::MessageHandler {
+                              public rtc::MessageHandler {
  public:
   TransportChannelProxy(const std::string& content_name,
                         const std::string& name,
@@ -64,19 +64,19 @@ class TransportChannelProxy : public TransportChannel,
   // Implementation of the TransportChannel interface.  These simply forward to
   // the implementation.
   virtual int SendPacket(const char* data, size_t len,
-                         const talk_base::PacketOptions& options,
+                         const rtc::PacketOptions& options,
                          int flags);
-  virtual int SetOption(talk_base::Socket::Option opt, int value);
+  virtual int SetOption(rtc::Socket::Option opt, int value);
   virtual int GetError();
   virtual IceRole GetIceRole() const;
   virtual bool GetStats(ConnectionInfos* infos);
   virtual bool IsDtlsActive() const;
-  virtual bool GetSslRole(talk_base::SSLRole* role) const;
-  virtual bool SetSslRole(talk_base::SSLRole role);
+  virtual bool GetSslRole(rtc::SSLRole* role) const;
+  virtual bool SetSslRole(rtc::SSLRole role);
   virtual bool SetSrtpCiphers(const std::vector<std::string>& ciphers);
   virtual bool GetSrtpCipher(std::string* cipher);
-  virtual bool GetLocalIdentity(talk_base::SSLIdentity** identity) const;
-  virtual bool GetRemoteCertificate(talk_base::SSLCertificate** cert) const;
+  virtual bool GetLocalIdentity(rtc::SSLIdentity** identity) const;
+  virtual bool GetRemoteCertificate(rtc::SSLCertificate** cert) const;
   virtual bool ExportKeyingMaterial(const std::string& label,
                             const uint8* context,
                             size_t context_len,
@@ -90,16 +90,16 @@ class TransportChannelProxy : public TransportChannel,
   void OnReadableState(TransportChannel* channel);
   void OnWritableState(TransportChannel* channel);
   void OnReadPacket(TransportChannel* channel, const char* data, size_t size,
-                    const talk_base::PacketTime& packet_time, int flags);
+                    const rtc::PacketTime& packet_time, int flags);
   void OnReadyToSend(TransportChannel* channel);
   void OnRouteChange(TransportChannel* channel, const Candidate& candidate);
 
-  void OnMessage(talk_base::Message* message);
+  void OnMessage(rtc::Message* message);
 
-  typedef std::pair<talk_base::Socket::Option, int> OptionPair;
+  typedef std::pair<rtc::Socket::Option, int> OptionPair;
   typedef std::vector<OptionPair> OptionList;
   std::string name_;
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* worker_thread_;
   TransportChannelImpl* impl_;
   OptionList pending_options_;
   std::vector<std::string> pending_srtp_ciphers_;
diff --git a/p2p/base/transportdescription.h b/p2p/base/transportdescription.h
index a8233a6..5891ca6 100644
--- a/p2p/base/transportdescription.h
+++ b/p2p/base/transportdescription.h
@@ -32,8 +32,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sslfingerprint.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sslfingerprint.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/constants.h"
 
@@ -109,7 +109,7 @@ struct TransportDescription {
                        const std::string& ice_pwd,
                        IceMode ice_mode,
                        ConnectionRole role,
-                       const talk_base::SSLFingerprint* identity_fingerprint,
+                       const rtc::SSLFingerprint* identity_fingerprint,
                        const Candidates& candidates)
       : transport_type(transport_type),
         transport_options(transport_options),
@@ -164,12 +164,12 @@ struct TransportDescription {
   }
   bool secure() const { return identity_fingerprint != NULL; }
 
-  static talk_base::SSLFingerprint* CopyFingerprint(
-      const talk_base::SSLFingerprint* from) {
+  static rtc::SSLFingerprint* CopyFingerprint(
+      const rtc::SSLFingerprint* from) {
     if (!from)
       return NULL;
 
-    return new talk_base::SSLFingerprint(*from);
+    return new rtc::SSLFingerprint(*from);
   }
 
   std::string transport_type;  // xmlns of <transport>
@@ -179,7 +179,7 @@ struct TransportDescription {
   IceMode ice_mode;
   ConnectionRole connection_role;
 
-  talk_base::scoped_ptr<talk_base::SSLFingerprint> identity_fingerprint;
+  rtc::scoped_ptr<rtc::SSLFingerprint> identity_fingerprint;
   Candidates candidates;
 };
 
diff --git a/p2p/base/transportdescriptionfactory.cc b/p2p/base/transportdescriptionfactory.cc
index c8fb0b3..0d6308e 100644
--- a/p2p/base/transportdescriptionfactory.cc
+++ b/p2p/base/transportdescriptionfactory.cc
@@ -27,11 +27,11 @@
 
 #include "talk/p2p/base/transportdescriptionfactory.h"
 
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/messagedigest.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sslfingerprint.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/messagedigest.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sslfingerprint.h"
 #include "talk/p2p/base/transportdescription.h"
 
 namespace cricket {
@@ -47,7 +47,7 @@ TransportDescriptionFactory::TransportDescriptionFactory()
 TransportDescription* TransportDescriptionFactory::CreateOffer(
     const TransportOptions& options,
     const TransportDescription* current_description) const {
-  talk_base::scoped_ptr<TransportDescription> desc(new TransportDescription());
+  rtc::scoped_ptr<TransportDescription> desc(new TransportDescription());
 
   // Set the transport type depending on the selected protocol.
   if (protocol_ == ICEPROTO_RFC5245) {
@@ -61,8 +61,8 @@ TransportDescription* TransportDescriptionFactory::CreateOffer(
 
   // Generate the ICE credentials if we don't already have them.
   if (!current_description || options.ice_restart) {
-    desc->ice_ufrag = talk_base::CreateRandomString(ICE_UFRAG_LENGTH);
-    desc->ice_pwd = talk_base::CreateRandomString(ICE_PWD_LENGTH);
+    desc->ice_ufrag = rtc::CreateRandomString(ICE_UFRAG_LENGTH);
+    desc->ice_pwd = rtc::CreateRandomString(ICE_PWD_LENGTH);
   } else {
     desc->ice_ufrag = current_description->ice_ufrag;
     desc->ice_pwd = current_description->ice_pwd;
@@ -86,7 +86,7 @@ TransportDescription* TransportDescriptionFactory::CreateAnswer(
     const TransportDescription* current_description) const {
   // A NULL offer is treated as a GICE transport description.
   // TODO(juberti): Figure out why we get NULL offers, and fix this upstream.
-  talk_base::scoped_ptr<TransportDescription> desc(new TransportDescription());
+  rtc::scoped_ptr<TransportDescription> desc(new TransportDescription());
 
   // Figure out which ICE variant to negotiate; prefer RFC 5245 ICE, but fall
   // back to G-ICE if needed. Note that we never create a hybrid answer, since
@@ -114,8 +114,8 @@ TransportDescription* TransportDescriptionFactory::CreateAnswer(
   // Generate the ICE credentials if we don't already have them or ice is
   // being restarted.
   if (!current_description || options.ice_restart) {
-    desc->ice_ufrag = talk_base::CreateRandomString(ICE_UFRAG_LENGTH);
-    desc->ice_pwd = talk_base::CreateRandomString(ICE_PWD_LENGTH);
+    desc->ice_ufrag = rtc::CreateRandomString(ICE_UFRAG_LENGTH);
+    desc->ice_pwd = rtc::CreateRandomString(ICE_PWD_LENGTH);
   } else {
     desc->ice_ufrag = current_description->ice_ufrag;
     desc->ice_pwd = current_description->ice_pwd;
@@ -161,7 +161,7 @@ bool TransportDescriptionFactory::SetSecurityInfo(
   }
 
   desc->identity_fingerprint.reset(
-      talk_base::SSLFingerprint::Create(digest_alg, identity_));
+      rtc::SSLFingerprint::Create(digest_alg, identity_));
   if (!desc->identity_fingerprint.get()) {
     LOG(LS_ERROR) << "Failed to create identity fingerprint, alg="
                   << digest_alg;
diff --git a/p2p/base/transportdescriptionfactory.h b/p2p/base/transportdescriptionfactory.h
index 53dd238..84f25ac 100644
--- a/p2p/base/transportdescriptionfactory.h
+++ b/p2p/base/transportdescriptionfactory.h
@@ -30,7 +30,7 @@
 
 #include "talk/p2p/base/transportdescription.h"
 
-namespace talk_base {
+namespace rtc {
 class SSLIdentity;
 }
 
@@ -51,14 +51,14 @@ class TransportDescriptionFactory {
   TransportDescriptionFactory();
   SecurePolicy secure() const { return secure_; }
   // The identity to use when setting up DTLS.
-  talk_base::SSLIdentity* identity() const { return identity_; }
+  rtc::SSLIdentity* identity() const { return identity_; }
 
   // Specifies the transport protocol to be use.
   void set_protocol(TransportProtocol protocol) { protocol_ = protocol; }
   // Specifies the transport security policy to use.
   void set_secure(SecurePolicy s) { secure_ = s; }
   // Specifies the identity to use (only used when secure is not SEC_DISABLED).
-  void set_identity(talk_base::SSLIdentity* identity) { identity_ = identity; }
+  void set_identity(rtc::SSLIdentity* identity) { identity_ = identity; }
 
   // Creates a transport description suitable for use in an offer.
   TransportDescription* CreateOffer(const TransportOptions& options,
@@ -75,7 +75,7 @@ class TransportDescriptionFactory {
 
   TransportProtocol protocol_;
   SecurePolicy secure_;
-  talk_base::SSLIdentity* identity_;
+  rtc::SSLIdentity* identity_;
 };
 
 }  // namespace cricket
diff --git a/p2p/base/transportdescriptionfactory_unittest.cc b/p2p/base/transportdescriptionfactory_unittest.cc
index 8d9a73f..ade331d 100644
--- a/p2p/base/transportdescriptionfactory_unittest.cc
+++ b/p2p/base/transportdescriptionfactory_unittest.cc
@@ -28,13 +28,13 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/fakesslidentity.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/fakesslidentity.h"
+#include "webrtc/base/gunit.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/transportdescription.h"
 #include "talk/p2p/base/transportdescriptionfactory.h"
 
-using talk_base::scoped_ptr;
+using rtc::scoped_ptr;
 using cricket::TransportDescriptionFactory;
 using cricket::TransportDescription;
 using cricket::TransportOptions;
@@ -42,8 +42,8 @@ using cricket::TransportOptions;
 class TransportDescriptionFactoryTest : public testing::Test {
  public:
   TransportDescriptionFactoryTest()
-      : id1_(new talk_base::FakeSSLIdentity("User1")),
-        id2_(new talk_base::FakeSSLIdentity("User2")) {
+      : id1_(new rtc::FakeSSLIdentity("User1")),
+        id2_(new rtc::FakeSSLIdentity("User2")) {
   }
   void CheckDesc(const TransportDescription* desc, const std::string& type,
                  const std::string& opt, const std::string& ice_ufrag,
@@ -86,22 +86,22 @@ class TransportDescriptionFactoryTest : public testing::Test {
 
     cricket::TransportOptions options;
     // The initial offer / answer exchange.
-    talk_base::scoped_ptr<TransportDescription> offer(f1_.CreateOffer(
+    rtc::scoped_ptr<TransportDescription> offer(f1_.CreateOffer(
         options, NULL));
-    talk_base::scoped_ptr<TransportDescription> answer(
+    rtc::scoped_ptr<TransportDescription> answer(
         f2_.CreateAnswer(offer.get(),
                          options, NULL));
 
     // Create an updated offer where we restart ice.
     options.ice_restart = true;
-    talk_base::scoped_ptr<TransportDescription> restart_offer(f1_.CreateOffer(
+    rtc::scoped_ptr<TransportDescription> restart_offer(f1_.CreateOffer(
         options, offer.get()));
 
     VerifyUfragAndPasswordChanged(dtls, offer.get(), restart_offer.get());
 
     // Create a new answer. The transport ufrag and password is changed since
     // |options.ice_restart == true|
-    talk_base::scoped_ptr<TransportDescription> restart_answer(
+    rtc::scoped_ptr<TransportDescription> restart_answer(
         f2_.CreateAnswer(restart_offer.get(), options, answer.get()));
     ASSERT_TRUE(restart_answer.get() != NULL);
 
@@ -129,8 +129,8 @@ class TransportDescriptionFactoryTest : public testing::Test {
  protected:
   TransportDescriptionFactory f1_;
   TransportDescriptionFactory f2_;
-  scoped_ptr<talk_base::SSLIdentity> id1_;
-  scoped_ptr<talk_base::SSLIdentity> id2_;
+  scoped_ptr<rtc::SSLIdentity> id1_;
+  scoped_ptr<rtc::SSLIdentity> id2_;
 };
 
 // Test that in the default case, we generate the expected G-ICE offer.
diff --git a/p2p/base/transportinfo.h b/p2p/base/transportinfo.h
index ad8b6a2..aab022c 100644
--- a/p2p/base/transportinfo.h
+++ b/p2p/base/transportinfo.h
@@ -31,7 +31,7 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/helpers.h"
+#include "webrtc/base/helpers.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/transportdescription.h"
diff --git a/p2p/base/turnport.cc b/p2p/base/turnport.cc
index de0875a..7255a2b 100644
--- a/p2p/base/turnport.cc
+++ b/p2p/base/turnport.cc
@@ -29,13 +29,13 @@
 
 #include <functional>
 
-#include "talk/base/asyncpacketsocket.h"
-#include "talk/base/byteorder.h"
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/nethelpers.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/asyncpacketsocket.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/nethelpers.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/p2p/base/common.h"
 #include "talk/p2p/base/stun.h"
 
@@ -99,7 +99,7 @@ class TurnCreatePermissionRequest : public StunRequest,
                                     public sigslot::has_slots<> {
  public:
   TurnCreatePermissionRequest(TurnPort* port, TurnEntry* entry,
-                              const talk_base::SocketAddress& ext_addr);
+                              const rtc::SocketAddress& ext_addr);
   virtual void Prepare(StunMessage* request);
   virtual void OnResponse(StunMessage* response);
   virtual void OnErrorResponse(StunMessage* response);
@@ -110,14 +110,14 @@ class TurnCreatePermissionRequest : public StunRequest,
 
   TurnPort* port_;
   TurnEntry* entry_;
-  talk_base::SocketAddress ext_addr_;
+  rtc::SocketAddress ext_addr_;
 };
 
 class TurnChannelBindRequest : public StunRequest,
                                public sigslot::has_slots<> {
  public:
   TurnChannelBindRequest(TurnPort* port, TurnEntry* entry, int channel_id,
-                         const talk_base::SocketAddress& ext_addr);
+                         const rtc::SocketAddress& ext_addr);
   virtual void Prepare(StunMessage* request);
   virtual void OnResponse(StunMessage* response);
   virtual void OnErrorResponse(StunMessage* response);
@@ -129,7 +129,7 @@ class TurnChannelBindRequest : public StunRequest,
   TurnPort* port_;
   TurnEntry* entry_;
   int channel_id_;
-  talk_base::SocketAddress ext_addr_;
+  rtc::SocketAddress ext_addr_;
 };
 
 // Manages a "connection" to a remote destination. We will attempt to bring up
@@ -138,12 +138,12 @@ class TurnEntry : public sigslot::has_slots<> {
  public:
   enum BindState { STATE_UNBOUND, STATE_BINDING, STATE_BOUND };
   TurnEntry(TurnPort* port, int channel_id,
-            const talk_base::SocketAddress& ext_addr);
+            const rtc::SocketAddress& ext_addr);
 
   TurnPort* port() { return port_; }
 
   int channel_id() const { return channel_id_; }
-  const talk_base::SocketAddress& address() const { return ext_addr_; }
+  const rtc::SocketAddress& address() const { return ext_addr_; }
   BindState state() const { return state_; }
 
   // Helper methods to send permission and channel bind requests.
@@ -152,7 +152,7 @@ class TurnEntry : public sigslot::has_slots<> {
   // Sends a packet to the given destination address.
   // This will wrap the packet in STUN if necessary.
   int Send(const void* data, size_t size, bool payload,
-           const talk_base::PacketOptions& options);
+           const rtc::PacketOptions& options);
 
   void OnCreatePermissionSuccess();
   void OnCreatePermissionError(StunMessage* response, int code);
@@ -164,14 +164,14 @@ class TurnEntry : public sigslot::has_slots<> {
  private:
   TurnPort* port_;
   int channel_id_;
-  talk_base::SocketAddress ext_addr_;
+  rtc::SocketAddress ext_addr_;
   BindState state_;
 };
 
-TurnPort::TurnPort(talk_base::Thread* thread,
-                   talk_base::PacketSocketFactory* factory,
-                   talk_base::Network* network,
-                   talk_base::AsyncPacketSocket* socket,
+TurnPort::TurnPort(rtc::Thread* thread,
+                   rtc::PacketSocketFactory* factory,
+                   rtc::Network* network,
+                   rtc::AsyncPacketSocket* socket,
                    const std::string& username,
                    const std::string& password,
                    const ProtocolAddress& server_address,
@@ -191,10 +191,10 @@ TurnPort::TurnPort(talk_base::Thread* thread,
   request_manager_.SignalSendPacket.connect(this, &TurnPort::OnSendStunPacket);
 }
 
-TurnPort::TurnPort(talk_base::Thread* thread,
-                   talk_base::PacketSocketFactory* factory,
-                   talk_base::Network* network,
-                   const talk_base::IPAddress& ip,
+TurnPort::TurnPort(rtc::Thread* thread,
+                   rtc::PacketSocketFactory* factory,
+                   rtc::Network* network,
+                   const rtc::IPAddress& ip,
                    int min_port, int max_port,
                    const std::string& username,
                    const std::string& password,
@@ -269,16 +269,16 @@ void TurnPort::PrepareAddress() {
 bool TurnPort::CreateTurnClientSocket() {
   if (server_address_.proto == PROTO_UDP && !SharedSocket()) {
     socket_ = socket_factory()->CreateUdpSocket(
-        talk_base::SocketAddress(ip(), 0), min_port(), max_port());
+        rtc::SocketAddress(ip(), 0), min_port(), max_port());
   } else if (server_address_.proto == PROTO_TCP) {
     ASSERT(!SharedSocket());
-    int opts = talk_base::PacketSocketFactory::OPT_STUN;
+    int opts = rtc::PacketSocketFactory::OPT_STUN;
     // If secure bit is enabled in server address, use TLS over TCP.
     if (server_address_.secure) {
-      opts |= talk_base::PacketSocketFactory::OPT_TLS;
+      opts |= rtc::PacketSocketFactory::OPT_TLS;
     }
     socket_ = socket_factory()->CreateClientTcpSocket(
-        talk_base::SocketAddress(ip(), 0), server_address_.address,
+        rtc::SocketAddress(ip(), 0), server_address_.address,
         proxy(), user_agent(), opts);
   }
 
@@ -307,7 +307,7 @@ bool TurnPort::CreateTurnClientSocket() {
   return true;
 }
 
-void TurnPort::OnSocketConnect(talk_base::AsyncPacketSocket* socket) {
+void TurnPort::OnSocketConnect(rtc::AsyncPacketSocket* socket) {
   ASSERT(server_address_.proto == PROTO_TCP);
   // Do not use this port if the socket bound to a different address than
   // the one we asked for. This is seen in Chrome, where TCP sockets cannot be
@@ -329,7 +329,7 @@ void TurnPort::OnSocketConnect(talk_base::AsyncPacketSocket* socket) {
   SendRequest(new TurnAllocateRequest(this), 0);
 }
 
-void TurnPort::OnSocketClose(talk_base::AsyncPacketSocket* socket, int error) {
+void TurnPort::OnSocketClose(rtc::AsyncPacketSocket* socket, int error) {
   LOG_J(LS_WARNING, this) << "Connection with server failed, error=" << error;
   if (!connected_) {
     OnAllocateError();
@@ -364,7 +364,7 @@ Connection* TurnPort::CreateConnection(const Candidate& address,
   return NULL;
 }
 
-int TurnPort::SetOption(talk_base::Socket::Option opt, int value) {
+int TurnPort::SetOption(rtc::Socket::Option opt, int value) {
   if (!socket_) {
     // If socket is not created yet, these options will be applied during socket
     // creation.
@@ -374,7 +374,7 @@ int TurnPort::SetOption(talk_base::Socket::Option opt, int value) {
   return socket_->SetOption(opt, value);
 }
 
-int TurnPort::GetOption(talk_base::Socket::Option opt, int* value) {
+int TurnPort::GetOption(rtc::Socket::Option opt, int* value) {
   if (!socket_) {
     SocketOptionsMap::const_iterator it = socket_options_.find(opt);
     if (it == socket_options_.end()) {
@@ -392,8 +392,8 @@ int TurnPort::GetError() {
 }
 
 int TurnPort::SendTo(const void* data, size_t size,
-                     const talk_base::SocketAddress& addr,
-                     const talk_base::PacketOptions& options,
+                     const rtc::SocketAddress& addr,
+                     const rtc::PacketOptions& options,
                      bool payload) {
   // Try to find an entry for this specific address; we should have one.
   TurnEntry* entry = FindEntry(addr);
@@ -419,9 +419,9 @@ int TurnPort::SendTo(const void* data, size_t size,
 }
 
 void TurnPort::OnReadPacket(
-    talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    rtc::AsyncPacketSocket* socket, const char* data, size_t size,
+    const rtc::SocketAddress& remote_addr,
+    const rtc::PacketTime& packet_time) {
   ASSERT(socket == socket_);
   ASSERT(remote_addr == server_address_.address);
 
@@ -434,7 +434,7 @@ void TurnPort::OnReadPacket(
   // Check the message type, to see if is a Channel Data message.
   // The message will either be channel data, a TURN data indication, or
   // a response to a previous request.
-  uint16 msg_type = talk_base::GetBE16(data);
+  uint16 msg_type = rtc::GetBE16(data);
   if (IsTurnChannelData(msg_type)) {
     HandleChannelData(msg_type, data, size, packet_time);
   } else if (msg_type == TURN_DATA_INDICATION) {
@@ -452,13 +452,13 @@ void TurnPort::OnReadPacket(
   }
 }
 
-void TurnPort::OnReadyToSend(talk_base::AsyncPacketSocket* socket) {
+void TurnPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
   if (connected_) {
     Port::OnReadyToSend();
   }
 }
 
-void TurnPort::ResolveTurnAddress(const talk_base::SocketAddress& address) {
+void TurnPort::ResolveTurnAddress(const rtc::SocketAddress& address) {
   if (resolver_)
     return;
 
@@ -467,7 +467,7 @@ void TurnPort::ResolveTurnAddress(const talk_base::SocketAddress& address) {
   resolver_->Start(address);
 }
 
-void TurnPort::OnResolveResult(talk_base::AsyncResolverInterface* resolver) {
+void TurnPort::OnResolveResult(rtc::AsyncResolverInterface* resolver) {
   ASSERT(resolver == resolver_);
   // If DNS resolve is failed when trying to connect to the server using TCP,
   // one of the reason could be due to DNS queries blocked by firewall.
@@ -482,7 +482,7 @@ void TurnPort::OnResolveResult(talk_base::AsyncResolverInterface* resolver) {
 
   // Copy the original server address in |resolved_address|. For TLS based
   // sockets we need hostname along with resolved address.
-  talk_base::SocketAddress resolved_address = server_address_.address;
+  rtc::SocketAddress resolved_address = server_address_.address;
   if (resolver_->GetError() != 0 ||
       !resolver_->GetResolvedAddress(ip().family(), &resolved_address)) {
     LOG_J(LS_WARNING, this) << "TURN host lookup received error "
@@ -501,14 +501,14 @@ void TurnPort::OnResolveResult(talk_base::AsyncResolverInterface* resolver) {
 
 void TurnPort::OnSendStunPacket(const void* data, size_t size,
                                 StunRequest* request) {
-  talk_base::PacketOptions options(DefaultDscpValue());
+  rtc::PacketOptions options(DefaultDscpValue());
   if (Send(data, size, options) < 0) {
     LOG_J(LS_ERROR, this) << "Failed to send TURN message, err="
                           << socket_->GetError();
   }
 }
 
-void TurnPort::OnStunAddress(const talk_base::SocketAddress& address) {
+void TurnPort::OnStunAddress(const rtc::SocketAddress& address) {
   // STUN Port will discover STUN candidate, as it's supplied with first TURN
   // server address.
   // Why not using this address? - P2PTransportChannel will start creating
@@ -518,8 +518,8 @@ void TurnPort::OnStunAddress(const talk_base::SocketAddress& address) {
   // handle to UDPPort to pass back the address.
 }
 
-void TurnPort::OnAllocateSuccess(const talk_base::SocketAddress& address,
-                                 const talk_base::SocketAddress& stun_address) {
+void TurnPort::OnAllocateSuccess(const rtc::SocketAddress& address,
+                                 const rtc::SocketAddress& stun_address) {
   connected_ = true;
   // For relayed candidate, Base is the candidate itself.
   AddAddress(address,  // Candidate address.
@@ -539,7 +539,7 @@ void TurnPort::OnAllocateError() {
   thread()->Post(this, MSG_ERROR);
 }
 
-void TurnPort::OnMessage(talk_base::Message* message) {
+void TurnPort::OnMessage(rtc::Message* message) {
   if (message->message_id == MSG_ERROR) {
     SignalPortError(this);
     return;
@@ -553,9 +553,9 @@ void TurnPort::OnAllocateRequestTimeout() {
 }
 
 void TurnPort::HandleDataIndication(const char* data, size_t size,
-                                    const talk_base::PacketTime& packet_time) {
+                                    const rtc::PacketTime& packet_time) {
   // Read in the message, and process according to RFC5766, Section 10.4.
-  talk_base::ByteBuffer buf(data, size);
+  rtc::ByteBuffer buf(data, size);
   TurnMessage msg;
   if (!msg.Read(&buf)) {
     LOG_J(LS_WARNING, this) << "Received invalid TURN data indication";
@@ -580,7 +580,7 @@ void TurnPort::HandleDataIndication(const char* data, size_t size,
   }
 
   // Verify that the data came from somewhere we think we have a permission for.
-  talk_base::SocketAddress ext_addr(addr_attr->GetAddress());
+  rtc::SocketAddress ext_addr(addr_attr->GetAddress());
   if (!HasPermission(ext_addr.ipaddr())) {
     LOG_J(LS_WARNING, this) << "Received TURN data indication with invalid "
                             << "peer address, addr="
@@ -594,7 +594,7 @@ void TurnPort::HandleDataIndication(const char* data, size_t size,
 
 void TurnPort::HandleChannelData(int channel_id, const char* data,
                                  size_t size,
-                                 const talk_base::PacketTime& packet_time) {
+                                 const rtc::PacketTime& packet_time) {
   // Read the message, and process according to RFC5766, Section 11.6.
   //    0                   1                   2                   3
   //    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -610,7 +610,7 @@ void TurnPort::HandleChannelData(int channel_id, const char* data,
   //   +-------------------------------+
 
   // Extract header fields from the message.
-  uint16 len = talk_base::GetBE16(data + 2);
+  uint16 len = rtc::GetBE16(data + 2);
   if (len > size - TURN_CHANNEL_HEADER_SIZE) {
     LOG_J(LS_WARNING, this) << "Received TURN channel data message with "
                             << "incorrect length, len=" << len;
@@ -630,8 +630,8 @@ void TurnPort::HandleChannelData(int channel_id, const char* data,
 }
 
 void TurnPort::DispatchPacket(const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    ProtocolType proto, const talk_base::PacketTime& packet_time) {
+    const rtc::SocketAddress& remote_addr,
+    ProtocolType proto, const rtc::PacketTime& packet_time) {
   if (Connection* conn = GetConnection(remote_addr)) {
     conn->OnReadPacket(data, size, packet_time);
   } else {
@@ -668,7 +668,7 @@ void TurnPort::AddRequestAuthInfo(StunMessage* msg) {
 }
 
 int TurnPort::Send(const void* data, size_t len,
-                   const talk_base::PacketOptions& options) {
+                   const rtc::PacketOptions& options) {
   return socket_->SendTo(data, len, server_address_.address, options);
 }
 
@@ -701,18 +701,18 @@ bool TurnPort::UpdateNonce(StunMessage* response) {
   return true;
 }
 
-static bool MatchesIP(TurnEntry* e, talk_base::IPAddress ipaddr) {
+static bool MatchesIP(TurnEntry* e, rtc::IPAddress ipaddr) {
   return e->address().ipaddr() == ipaddr;
 }
-bool TurnPort::HasPermission(const talk_base::IPAddress& ipaddr) const {
+bool TurnPort::HasPermission(const rtc::IPAddress& ipaddr) const {
   return (std::find_if(entries_.begin(), entries_.end(),
       std::bind2nd(std::ptr_fun(MatchesIP), ipaddr)) != entries_.end());
 }
 
-static bool MatchesAddress(TurnEntry* e, talk_base::SocketAddress addr) {
+static bool MatchesAddress(TurnEntry* e, rtc::SocketAddress addr) {
   return e->address() == addr;
 }
-TurnEntry* TurnPort::FindEntry(const talk_base::SocketAddress& addr) const {
+TurnEntry* TurnPort::FindEntry(const rtc::SocketAddress& addr) const {
   EntryList::const_iterator it = std::find_if(entries_.begin(), entries_.end(),
       std::bind2nd(std::ptr_fun(MatchesAddress), addr));
   return (it != entries_.end()) ? *it : NULL;
@@ -727,14 +727,14 @@ TurnEntry* TurnPort::FindEntry(int channel_id) const {
   return (it != entries_.end()) ? *it : NULL;
 }
 
-TurnEntry* TurnPort::CreateEntry(const talk_base::SocketAddress& addr) {
+TurnEntry* TurnPort::CreateEntry(const rtc::SocketAddress& addr) {
   ASSERT(FindEntry(addr) == NULL);
   TurnEntry* entry = new TurnEntry(this, next_channel_number_++, addr);
   entries_.push_back(entry);
   return entry;
 }
 
-void TurnPort::DestroyEntry(const talk_base::SocketAddress& addr) {
+void TurnPort::DestroyEntry(const rtc::SocketAddress& addr) {
   TurnEntry* entry = FindEntry(addr);
   ASSERT(entry != NULL);
   entry->SignalDestroyed(entry);
@@ -893,7 +893,7 @@ void TurnRefreshRequest::OnTimeout() {
 
 TurnCreatePermissionRequest::TurnCreatePermissionRequest(
     TurnPort* port, TurnEntry* entry,
-    const talk_base::SocketAddress& ext_addr)
+    const rtc::SocketAddress& ext_addr)
     : StunRequest(new TurnMessage()),
       port_(port),
       entry_(entry),
@@ -934,7 +934,7 @@ void TurnCreatePermissionRequest::OnEntryDestroyed(TurnEntry* entry) {
 
 TurnChannelBindRequest::TurnChannelBindRequest(
     TurnPort* port, TurnEntry* entry,
-    int channel_id, const talk_base::SocketAddress& ext_addr)
+    int channel_id, const rtc::SocketAddress& ext_addr)
     : StunRequest(new TurnMessage()),
       port_(port),
       entry_(entry),
@@ -982,7 +982,7 @@ void TurnChannelBindRequest::OnEntryDestroyed(TurnEntry* entry) {
 }
 
 TurnEntry::TurnEntry(TurnPort* port, int channel_id,
-                     const talk_base::SocketAddress& ext_addr)
+                     const rtc::SocketAddress& ext_addr)
     : port_(port),
       channel_id_(channel_id),
       ext_addr_(ext_addr),
@@ -1002,14 +1002,14 @@ void TurnEntry::SendChannelBindRequest(int delay) {
 }
 
 int TurnEntry::Send(const void* data, size_t size, bool payload,
-                    const talk_base::PacketOptions& options) {
-  talk_base::ByteBuffer buf;
+                    const rtc::PacketOptions& options) {
+  rtc::ByteBuffer buf;
   if (state_ != STATE_BOUND) {
     // If we haven't bound the channel yet, we have to use a Send Indication.
     TurnMessage msg;
     msg.SetType(TURN_SEND_INDICATION);
     msg.SetTransactionID(
-        talk_base::CreateRandomString(kStunTransactionIdLength));
+        rtc::CreateRandomString(kStunTransactionIdLength));
     VERIFY(msg.AddAttribute(new StunXorAddressAttribute(
         STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_)));
     VERIFY(msg.AddAttribute(new StunByteStringAttribute(
diff --git a/p2p/base/turnport.h b/p2p/base/turnport.h
index 456644a..d58e75d 100644
--- a/p2p/base/turnport.h
+++ b/p2p/base/turnport.h
@@ -32,11 +32,11 @@
 #include <string>
 #include <list>
 
-#include "talk/base/asyncpacketsocket.h"
+#include "webrtc/base/asyncpacketsocket.h"
 #include "talk/p2p/base/port.h"
 #include "talk/p2p/client/basicportallocator.h"
 
-namespace talk_base {
+namespace rtc {
 class AsyncResolver;
 class SignalThread;
 }
@@ -49,10 +49,10 @@ class TurnEntry;
 
 class TurnPort : public Port {
  public:
-  static TurnPort* Create(talk_base::Thread* thread,
-                          talk_base::PacketSocketFactory* factory,
-                          talk_base::Network* network,
-                          talk_base::AsyncPacketSocket* socket,
+  static TurnPort* Create(rtc::Thread* thread,
+                          rtc::PacketSocketFactory* factory,
+                          rtc::Network* network,
+                          rtc::AsyncPacketSocket* socket,
                           const std::string& username,  // ice username.
                           const std::string& password,  // ice password.
                           const ProtocolAddress& server_address,
@@ -63,10 +63,10 @@ class TurnPort : public Port {
                         credentials, server_priority);
   }
 
-  static TurnPort* Create(talk_base::Thread* thread,
-                          talk_base::PacketSocketFactory* factory,
-                          talk_base::Network* network,
-                          const talk_base::IPAddress& ip,
+  static TurnPort* Create(rtc::Thread* thread,
+                          rtc::PacketSocketFactory* factory,
+                          rtc::Network* network,
+                          const rtc::IPAddress& ip,
                           int min_port, int max_port,
                           const std::string& username,  // ice username.
                           const std::string& password,  // ice password.
@@ -89,29 +89,29 @@ class TurnPort : public Port {
   virtual Connection* CreateConnection(
       const Candidate& c, PortInterface::CandidateOrigin origin);
   virtual int SendTo(const void* data, size_t size,
-                     const talk_base::SocketAddress& addr,
-                     const talk_base::PacketOptions& options,
+                     const rtc::SocketAddress& addr,
+                     const rtc::PacketOptions& options,
                      bool payload);
-  virtual int SetOption(talk_base::Socket::Option opt, int value);
-  virtual int GetOption(talk_base::Socket::Option opt, int* value);
+  virtual int SetOption(rtc::Socket::Option opt, int value);
+  virtual int GetOption(rtc::Socket::Option opt, int* value);
   virtual int GetError();
 
   virtual bool HandleIncomingPacket(
-      talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      const talk_base::PacketTime& packet_time) {
+      rtc::AsyncPacketSocket* socket, const char* data, size_t size,
+      const rtc::SocketAddress& remote_addr,
+      const rtc::PacketTime& packet_time) {
     OnReadPacket(socket, data, size, remote_addr, packet_time);
     return true;
   }
-  virtual void OnReadPacket(talk_base::AsyncPacketSocket* socket,
+  virtual void OnReadPacket(rtc::AsyncPacketSocket* socket,
                             const char* data, size_t size,
-                            const talk_base::SocketAddress& remote_addr,
-                            const talk_base::PacketTime& packet_time);
+                            const rtc::SocketAddress& remote_addr,
+                            const rtc::PacketTime& packet_time);
 
-  virtual void OnReadyToSend(talk_base::AsyncPacketSocket* socket);
+  virtual void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 
-  void OnSocketConnect(talk_base::AsyncPacketSocket* socket);
-  void OnSocketClose(talk_base::AsyncPacketSocket* socket, int error);
+  void OnSocketConnect(rtc::AsyncPacketSocket* socket);
+  void OnSocketClose(rtc::AsyncPacketSocket* socket, int error);
 
 
   const std::string& hash() const { return hash_; }
@@ -123,28 +123,28 @@ class TurnPort : public Port {
   // Parameters are port, server address and resolved server address.
   // This signal will be sent only if server address is resolved successfully.
   sigslot::signal3<TurnPort*,
-                   const talk_base::SocketAddress&,
-                   const talk_base::SocketAddress&> SignalResolvedServerAddress;
+                   const rtc::SocketAddress&,
+                   const rtc::SocketAddress&> SignalResolvedServerAddress;
 
   // This signal is only for testing purpose.
-  sigslot::signal3<TurnPort*, const talk_base::SocketAddress&, int>
+  sigslot::signal3<TurnPort*, const rtc::SocketAddress&, int>
       SignalCreatePermissionResult;
 
  protected:
-  TurnPort(talk_base::Thread* thread,
-           talk_base::PacketSocketFactory* factory,
-           talk_base::Network* network,
-           talk_base::AsyncPacketSocket* socket,
+  TurnPort(rtc::Thread* thread,
+           rtc::PacketSocketFactory* factory,
+           rtc::Network* network,
+           rtc::AsyncPacketSocket* socket,
            const std::string& username,
            const std::string& password,
            const ProtocolAddress& server_address,
            const RelayCredentials& credentials,
            int server_priority);
 
-  TurnPort(talk_base::Thread* thread,
-           talk_base::PacketSocketFactory* factory,
-           talk_base::Network* network,
-           const talk_base::IPAddress& ip,
+  TurnPort(rtc::Thread* thread,
+           rtc::PacketSocketFactory* factory,
+           rtc::Network* network,
+           const rtc::IPAddress& ip,
            int min_port, int max_port,
            const std::string& username,
            const std::string& password,
@@ -156,9 +156,9 @@ class TurnPort : public Port {
   enum { MSG_ERROR = MSG_FIRST_AVAILABLE };
 
   typedef std::list<TurnEntry*> EntryList;
-  typedef std::map<talk_base::Socket::Option, int> SocketOptionsMap;
+  typedef std::map<rtc::Socket::Option, int> SocketOptionsMap;
 
-  virtual void OnMessage(talk_base::Message* pmsg);
+  virtual void OnMessage(rtc::Message* pmsg);
 
   bool CreateTurnClientSocket();
 
@@ -170,47 +170,47 @@ class TurnPort : public Port {
     }
   }
 
-  void ResolveTurnAddress(const talk_base::SocketAddress& address);
-  void OnResolveResult(talk_base::AsyncResolverInterface* resolver);
+  void ResolveTurnAddress(const rtc::SocketAddress& address);
+  void OnResolveResult(rtc::AsyncResolverInterface* resolver);
 
   void AddRequestAuthInfo(StunMessage* msg);
   void OnSendStunPacket(const void* data, size_t size, StunRequest* request);
   // Stun address from allocate success response.
   // Currently used only for testing.
-  void OnStunAddress(const talk_base::SocketAddress& address);
-  void OnAllocateSuccess(const talk_base::SocketAddress& address,
-                         const talk_base::SocketAddress& stun_address);
+  void OnStunAddress(const rtc::SocketAddress& address);
+  void OnAllocateSuccess(const rtc::SocketAddress& address,
+                         const rtc::SocketAddress& stun_address);
   void OnAllocateError();
   void OnAllocateRequestTimeout();
 
   void HandleDataIndication(const char* data, size_t size,
-                            const talk_base::PacketTime& packet_time);
+                            const rtc::PacketTime& packet_time);
   void HandleChannelData(int channel_id, const char* data, size_t size,
-                         const talk_base::PacketTime& packet_time);
+                         const rtc::PacketTime& packet_time);
   void DispatchPacket(const char* data, size_t size,
-      const talk_base::SocketAddress& remote_addr,
-      ProtocolType proto, const talk_base::PacketTime& packet_time);
+      const rtc::SocketAddress& remote_addr,
+      ProtocolType proto, const rtc::PacketTime& packet_time);
 
   bool ScheduleRefresh(int lifetime);
   void SendRequest(StunRequest* request, int delay);
   int Send(const void* data, size_t size,
-           const talk_base::PacketOptions& options);
+           const rtc::PacketOptions& options);
   void UpdateHash();
   bool UpdateNonce(StunMessage* response);
 
-  bool HasPermission(const talk_base::IPAddress& ipaddr) const;
-  TurnEntry* FindEntry(const talk_base::SocketAddress& address) const;
+  bool HasPermission(const rtc::IPAddress& ipaddr) const;
+  TurnEntry* FindEntry(const rtc::SocketAddress& address) const;
   TurnEntry* FindEntry(int channel_id) const;
-  TurnEntry* CreateEntry(const talk_base::SocketAddress& address);
-  void DestroyEntry(const talk_base::SocketAddress& address);
+  TurnEntry* CreateEntry(const rtc::SocketAddress& address);
+  void DestroyEntry(const rtc::SocketAddress& address);
   void OnConnectionDestroyed(Connection* conn);
 
   ProtocolAddress server_address_;
   RelayCredentials credentials_;
 
-  talk_base::AsyncPacketSocket* socket_;
+  rtc::AsyncPacketSocket* socket_;
   SocketOptionsMap socket_options_;
-  talk_base::AsyncResolverInterface* resolver_;
+  rtc::AsyncResolverInterface* resolver_;
   int error_;
 
   StunRequestManager request_manager_;
diff --git a/p2p/base/turnport_unittest.cc b/p2p/base/turnport_unittest.cc
index cc6d283..99bd598 100644
--- a/p2p/base/turnport_unittest.cc
+++ b/p2p/base/turnport_unittest.cc
@@ -28,19 +28,19 @@
 #include <dirent.h>
 #endif
 
-#include "talk/base/asynctcpsocket.h"
-#include "talk/base/buffer.h"
-#include "talk/base/dscp.h"
-#include "talk/base/firewallsocketserver.h"
-#include "talk/base/logging.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/thread.h"
-#include "talk/base/virtualsocketserver.h"
+#include "webrtc/base/asynctcpsocket.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/dscp.h"
+#include "webrtc/base/firewallsocketserver.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/virtualsocketserver.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/tcpport.h"
@@ -48,7 +48,7 @@
 #include "talk/p2p/base/turnport.h"
 #include "talk/p2p/base/udpport.h"
 
-using talk_base::SocketAddress;
+using rtc::SocketAddress;
 using cricket::Connection;
 using cricket::Port;
 using cricket::PortInterface;
@@ -103,15 +103,15 @@ static int GetFDCount() {
 
 class TurnPortTest : public testing::Test,
                      public sigslot::has_slots<>,
-                     public talk_base::MessageHandler {
+                     public rtc::MessageHandler {
  public:
   TurnPortTest()
-      : main_(talk_base::Thread::Current()),
-        pss_(new talk_base::PhysicalSocketServer),
-        ss_(new talk_base::VirtualSocketServer(pss_.get())),
+      : main_(rtc::Thread::Current()),
+        pss_(new rtc::PhysicalSocketServer),
+        ss_(new rtc::VirtualSocketServer(pss_.get())),
         ss_scope_(ss_.get()),
-        network_("unittest", "unittest", talk_base::IPAddress(INADDR_ANY), 32),
-        socket_factory_(talk_base::Thread::Current()),
+        network_("unittest", "unittest", rtc::IPAddress(INADDR_ANY), 32),
+        socket_factory_(rtc::Thread::Current()),
         turn_server_(main_, kTurnUdpIntAddr, kTurnUdpExtAddr),
         turn_ready_(false),
         turn_error_(false),
@@ -119,18 +119,18 @@ class TurnPortTest : public testing::Test,
         turn_create_permission_success_(false),
         udp_ready_(false),
         test_finish_(false) {
-    network_.AddIP(talk_base::IPAddress(INADDR_ANY));
+    network_.AddIP(rtc::IPAddress(INADDR_ANY));
   }
 
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
-  virtual void OnMessage(talk_base::Message* msg) {
+  virtual void OnMessage(rtc::Message* msg) {
     ASSERT(msg->message_id == MSG_TESTFINISH);
     if (msg->message_id == MSG_TESTFINISH)
       test_finish_ = true;
@@ -156,25 +156,25 @@ class TurnPortTest : public testing::Test,
     }
   }
   void OnTurnReadPacket(Connection* conn, const char* data, size_t size,
-                        const talk_base::PacketTime& packet_time) {
-    turn_packets_.push_back(talk_base::Buffer(data, size));
+                        const rtc::PacketTime& packet_time) {
+    turn_packets_.push_back(rtc::Buffer(data, size));
   }
   void OnUdpPortComplete(Port* port) {
     udp_ready_ = true;
   }
   void OnUdpReadPacket(Connection* conn, const char* data, size_t size,
-                       const talk_base::PacketTime& packet_time) {
-    udp_packets_.push_back(talk_base::Buffer(data, size));
+                       const rtc::PacketTime& packet_time) {
+    udp_packets_.push_back(rtc::Buffer(data, size));
   }
-  void OnSocketReadPacket(talk_base::AsyncPacketSocket* socket,
+  void OnSocketReadPacket(rtc::AsyncPacketSocket* socket,
                           const char* data, size_t size,
-                          const talk_base::SocketAddress& remote_addr,
-                          const talk_base::PacketTime& packet_time) {
+                          const rtc::SocketAddress& remote_addr,
+                          const rtc::PacketTime& packet_time) {
     turn_port_->HandleIncomingPacket(socket, data, size, remote_addr,
                                      packet_time);
   }
-  talk_base::AsyncSocket* CreateServerSocket(const SocketAddress addr) {
-    talk_base::AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_STREAM);
+  rtc::AsyncSocket* CreateServerSocket(const SocketAddress addr) {
+    rtc::AsyncSocket* socket = ss_->CreateAsyncSocket(SOCK_STREAM);
     EXPECT_GE(socket->Bind(addr), 0);
     EXPECT_GE(socket->Listen(5), 0);
     return socket;
@@ -185,7 +185,7 @@ class TurnPortTest : public testing::Test,
                       const cricket::ProtocolAddress& server_address) {
     CreateTurnPort(kLocalAddr1, username, password, server_address);
   }
-  void CreateTurnPort(const talk_base::SocketAddress& local_address,
+  void CreateTurnPort(const rtc::SocketAddress& local_address,
                       const std::string& username,
                       const std::string& password,
                       const cricket::ProtocolAddress& server_address) {
@@ -209,7 +209,7 @@ class TurnPortTest : public testing::Test,
     ASSERT(server_address.proto == cricket::PROTO_UDP);
 
     socket_.reset(socket_factory_.CreateUdpSocket(
-        talk_base::SocketAddress(kLocalAddr1.ipaddr(), 0), 0, 0));
+        rtc::SocketAddress(kLocalAddr1.ipaddr(), 0), 0, 0));
     ASSERT_TRUE(socket_ != NULL);
     socket_->SignalReadPacket.connect(this, &TurnPortTest::OnSocketReadPacket);
 
@@ -330,31 +330,31 @@ class TurnPortTest : public testing::Test,
   }
 
  protected:
-  talk_base::Thread* main_;
-  talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
-  talk_base::scoped_ptr<talk_base::VirtualSocketServer> ss_;
-  talk_base::SocketServerScope ss_scope_;
-  talk_base::Network network_;
-  talk_base::BasicPacketSocketFactory socket_factory_;
-  talk_base::scoped_ptr<talk_base::AsyncPacketSocket> socket_;
+  rtc::Thread* main_;
+  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
+  rtc::scoped_ptr<rtc::VirtualSocketServer> ss_;
+  rtc::SocketServerScope ss_scope_;
+  rtc::Network network_;
+  rtc::BasicPacketSocketFactory socket_factory_;
+  rtc::scoped_ptr<rtc::AsyncPacketSocket> socket_;
   cricket::TestTurnServer turn_server_;
-  talk_base::scoped_ptr<TurnPort> turn_port_;
-  talk_base::scoped_ptr<UDPPort> udp_port_;
+  rtc::scoped_ptr<TurnPort> turn_port_;
+  rtc::scoped_ptr<UDPPort> udp_port_;
   bool turn_ready_;
   bool turn_error_;
   bool turn_unknown_address_;
   bool turn_create_permission_success_;
   bool udp_ready_;
   bool test_finish_;
-  std::vector<talk_base::Buffer> turn_packets_;
-  std::vector<talk_base::Buffer> udp_packets_;
-  talk_base::PacketOptions options;
+  std::vector<rtc::Buffer> turn_packets_;
+  std::vector<rtc::Buffer> udp_packets_;
+  rtc::PacketOptions options;
 };
 
 // Do a normal TURN allocation.
 TEST_F(TurnPortTest, TestTurnAllocate) {
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
-  EXPECT_EQ(0, turn_port_->SetOption(talk_base::Socket::OPT_SNDBUF, 10*1024));
+  EXPECT_EQ(0, turn_port_->SetOption(rtc::Socket::OPT_SNDBUF, 10*1024));
   turn_port_->PrepareAddress();
   EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
   ASSERT_EQ(1U, turn_port_->Candidates().size());
@@ -367,7 +367,7 @@ TEST_F(TurnPortTest, TestTurnAllocate) {
 TEST_F(TurnPortTest, TestTurnTcpAllocate) {
   turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
-  EXPECT_EQ(0, turn_port_->SetOption(talk_base::Socket::OPT_SNDBUF, 10*1024));
+  EXPECT_EQ(0, turn_port_->SetOption(rtc::Socket::OPT_SNDBUF, 10*1024));
   turn_port_->PrepareAddress();
   EXPECT_TRUE_WAIT(turn_ready_, kTimeout);
   ASSERT_EQ(1U, turn_port_->Candidates().size());
@@ -381,7 +381,7 @@ TEST_F(TurnPortTest, TestTurnTcpAllocate) {
 TEST_F(TurnPortTest, TestTurnTcpOnAddressResolveFailure) {
   turn_server_.AddInternalSocket(kTurnTcpIntAddr, cricket::PROTO_TCP);
   CreateTurnPort(kTurnUsername, kTurnPassword, cricket::ProtocolAddress(
-      talk_base::SocketAddress("www.webrtc-blah-blah.com", 3478),
+      rtc::SocketAddress("www.webrtc-blah-blah.com", 3478),
       cricket::PROTO_TCP));
   turn_port_->PrepareAddress();
   EXPECT_TRUE_WAIT(turn_error_, kTimeout);
@@ -395,7 +395,7 @@ TEST_F(TurnPortTest, TestTurnTcpOnAddressResolveFailure) {
 // and return allocate failure.
 TEST_F(TurnPortTest, TestTurnUdpOnAdressResolveFailure) {
   CreateTurnPort(kTurnUsername, kTurnPassword, cricket::ProtocolAddress(
-      talk_base::SocketAddress("www.webrtc-blah-blah.com", 3478),
+      rtc::SocketAddress("www.webrtc-blah-blah.com", 3478),
       cricket::PROTO_UDP));
   turn_port_->PrepareAddress();
   EXPECT_TRUE_WAIT(turn_error_, kTimeout);
@@ -503,13 +503,13 @@ TEST_F(TurnPortTest, TestResolverShutdown) {
   int last_fd_count = GetFDCount();
   // Need to supply unresolved address to kick off resolver.
   CreateTurnPort(kLocalIPv6Addr, kTurnUsername, kTurnPassword,
-                 cricket::ProtocolAddress(talk_base::SocketAddress(
+                 cricket::ProtocolAddress(rtc::SocketAddress(
                     "stun.l.google.com", 3478), cricket::PROTO_UDP));
   turn_port_->PrepareAddress();
   ASSERT_TRUE_WAIT(turn_error_, kTimeout);
   EXPECT_TRUE(turn_port_->Candidates().empty());
   turn_port_.reset();
-  talk_base::Thread::Current()->Post(this, MSG_TESTFINISH);
+  rtc::Thread::Current()->Post(this, MSG_TESTFINISH);
   // Waiting for above message to be processed.
   ASSERT_TRUE_WAIT(test_finish_, kTimeout);
   EXPECT_EQ(last_fd_count, GetFDCount());
diff --git a/p2p/base/turnserver.cc b/p2p/base/turnserver.cc
index 4d7f39e..a6cafe0 100644
--- a/p2p/base/turnserver.cc
+++ b/p2p/base/turnserver.cc
@@ -27,13 +27,13 @@
 
 #include "talk/p2p/base/turnserver.h"
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/messagedigest.h"
-#include "talk/base/socketadapters.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/messagedigest.h"
+#include "webrtc/base/socketadapters.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/asyncstuntcpsocket.h"
 #include "talk/p2p/base/common.h"
 #include "talk/p2p/base/packetsocketfactory.h"
@@ -72,12 +72,12 @@ enum {
 // handles TURN messages (via HandleTurnMessage) and channel data messages
 // (via HandleChannelData) for this allocation when received by the server.
 // The object self-deletes and informs the server if its lifetime timer expires.
-class TurnServer::Allocation : public talk_base::MessageHandler,
+class TurnServer::Allocation : public rtc::MessageHandler,
                                public sigslot::has_slots<> {
  public:
   Allocation(TurnServer* server_,
-             talk_base::Thread* thread, const Connection& conn,
-             talk_base::AsyncPacketSocket* server_socket,
+             rtc::Thread* thread, const Connection& conn,
+             rtc::AsyncPacketSocket* server_socket,
              const std::string& key);
   virtual ~Allocation();
 
@@ -105,33 +105,33 @@ class TurnServer::Allocation : public talk_base::MessageHandler,
   void HandleCreatePermissionRequest(const TurnMessage* msg);
   void HandleChannelBindRequest(const TurnMessage* msg);
 
-  void OnExternalPacket(talk_base::AsyncPacketSocket* socket,
+  void OnExternalPacket(rtc::AsyncPacketSocket* socket,
                         const char* data, size_t size,
-                        const talk_base::SocketAddress& addr,
-                        const talk_base::PacketTime& packet_time);
+                        const rtc::SocketAddress& addr,
+                        const rtc::PacketTime& packet_time);
 
   static int ComputeLifetime(const TurnMessage* msg);
-  bool HasPermission(const talk_base::IPAddress& addr);
-  void AddPermission(const talk_base::IPAddress& addr);
-  Permission* FindPermission(const talk_base::IPAddress& addr) const;
+  bool HasPermission(const rtc::IPAddress& addr);
+  void AddPermission(const rtc::IPAddress& addr);
+  Permission* FindPermission(const rtc::IPAddress& addr) const;
   Channel* FindChannel(int channel_id) const;
-  Channel* FindChannel(const talk_base::SocketAddress& addr) const;
+  Channel* FindChannel(const rtc::SocketAddress& addr) const;
 
   void SendResponse(TurnMessage* msg);
   void SendBadRequestResponse(const TurnMessage* req);
   void SendErrorResponse(const TurnMessage* req, int code,
                          const std::string& reason);
   void SendExternal(const void* data, size_t size,
-                    const talk_base::SocketAddress& peer);
+                    const rtc::SocketAddress& peer);
 
   void OnPermissionDestroyed(Permission* perm);
   void OnChannelDestroyed(Channel* channel);
-  virtual void OnMessage(talk_base::Message* msg);
+  virtual void OnMessage(rtc::Message* msg);
 
   TurnServer* server_;
-  talk_base::Thread* thread_;
+  rtc::Thread* thread_;
   Connection conn_;
-  talk_base::scoped_ptr<talk_base::AsyncPacketSocket> external_socket_;
+  rtc::scoped_ptr<rtc::AsyncPacketSocket> external_socket_;
   std::string key_;
   std::string transaction_id_;
   std::string username_;
@@ -143,44 +143,44 @@ class TurnServer::Allocation : public talk_base::MessageHandler,
 // Encapsulates a TURN permission.
 // The object is created when a create permission request is received by an
 // allocation, and self-deletes when its lifetime timer expires.
-class TurnServer::Permission : public talk_base::MessageHandler {
+class TurnServer::Permission : public rtc::MessageHandler {
  public:
-  Permission(talk_base::Thread* thread, const talk_base::IPAddress& peer);
+  Permission(rtc::Thread* thread, const rtc::IPAddress& peer);
   ~Permission();
 
-  const talk_base::IPAddress& peer() const { return peer_; }
+  const rtc::IPAddress& peer() const { return peer_; }
   void Refresh();
 
   sigslot::signal1<Permission*> SignalDestroyed;
 
  private:
-  virtual void OnMessage(talk_base::Message* msg);
+  virtual void OnMessage(rtc::Message* msg);
 
-  talk_base::Thread* thread_;
-  talk_base::IPAddress peer_;
+  rtc::Thread* thread_;
+  rtc::IPAddress peer_;
 };
 
 // Encapsulates a TURN channel binding.
 // The object is created when a channel bind request is received by an
 // allocation, and self-deletes when its lifetime timer expires.
-class TurnServer::Channel : public talk_base::MessageHandler {
+class TurnServer::Channel : public rtc::MessageHandler {
  public:
-  Channel(talk_base::Thread* thread, int id,
-                     const talk_base::SocketAddress& peer);
+  Channel(rtc::Thread* thread, int id,
+                     const rtc::SocketAddress& peer);
   ~Channel();
 
   int id() const { return id_; }
-  const talk_base::SocketAddress& peer() const { return peer_; }
+  const rtc::SocketAddress& peer() const { return peer_; }
   void Refresh();
 
   sigslot::signal1<Channel*> SignalDestroyed;
 
  private:
-  virtual void OnMessage(talk_base::Message* msg);
+  virtual void OnMessage(rtc::Message* msg);
 
-  talk_base::Thread* thread_;
+  rtc::Thread* thread_;
   int id_;
-  talk_base::SocketAddress peer_;
+  rtc::SocketAddress peer_;
 };
 
 static bool InitResponse(const StunMessage* req, StunMessage* resp) {
@@ -204,9 +204,9 @@ static bool InitErrorResponse(const StunMessage* req, int code,
   return true;
 }
 
-TurnServer::TurnServer(talk_base::Thread* thread)
+TurnServer::TurnServer(rtc::Thread* thread)
     : thread_(thread),
-      nonce_key_(talk_base::CreateRandomString(kNonceKeySize)),
+      nonce_key_(rtc::CreateRandomString(kNonceKeySize)),
       auth_hook_(NULL),
       enable_otu_nonce_(false) {
 }
@@ -219,25 +219,25 @@ TurnServer::~TurnServer() {
 
   for (InternalSocketMap::iterator it = server_sockets_.begin();
        it != server_sockets_.end(); ++it) {
-    talk_base::AsyncPacketSocket* socket = it->first;
+    rtc::AsyncPacketSocket* socket = it->first;
     delete socket;
   }
 
   for (ServerSocketMap::iterator it = server_listen_sockets_.begin();
        it != server_listen_sockets_.end(); ++it) {
-    talk_base::AsyncSocket* socket = it->first;
+    rtc::AsyncSocket* socket = it->first;
     delete socket;
   }
 }
 
-void TurnServer::AddInternalSocket(talk_base::AsyncPacketSocket* socket,
+void TurnServer::AddInternalSocket(rtc::AsyncPacketSocket* socket,
                                    ProtocolType proto) {
   ASSERT(server_sockets_.end() == server_sockets_.find(socket));
   server_sockets_[socket] = proto;
   socket->SignalReadPacket.connect(this, &TurnServer::OnInternalPacket);
 }
 
-void TurnServer::AddInternalServerSocket(talk_base::AsyncSocket* socket,
+void TurnServer::AddInternalServerSocket(rtc::AsyncSocket* socket,
                                          ProtocolType proto) {
   ASSERT(server_listen_sockets_.end() ==
       server_listen_sockets_.find(socket));
@@ -246,21 +246,21 @@ void TurnServer::AddInternalServerSocket(talk_base::AsyncSocket* socket,
 }
 
 void TurnServer::SetExternalSocketFactory(
-    talk_base::PacketSocketFactory* factory,
-    const talk_base::SocketAddress& external_addr) {
+    rtc::PacketSocketFactory* factory,
+    const rtc::SocketAddress& external_addr) {
   external_socket_factory_.reset(factory);
   external_addr_ = external_addr;
 }
 
-void TurnServer::OnNewInternalConnection(talk_base::AsyncSocket* socket) {
+void TurnServer::OnNewInternalConnection(rtc::AsyncSocket* socket) {
   ASSERT(server_listen_sockets_.find(socket) != server_listen_sockets_.end());
   AcceptConnection(socket);
 }
 
-void TurnServer::AcceptConnection(talk_base::AsyncSocket* server_socket) {
+void TurnServer::AcceptConnection(rtc::AsyncSocket* server_socket) {
   // Check if someone is trying to connect to us.
-  talk_base::SocketAddress accept_addr;
-  talk_base::AsyncSocket* accepted_socket = server_socket->Accept(&accept_addr);
+  rtc::SocketAddress accept_addr;
+  rtc::AsyncSocket* accepted_socket = server_socket->Accept(&accept_addr);
   if (accepted_socket != NULL) {
     ProtocolType proto = server_listen_sockets_[server_socket];
     cricket::AsyncStunTCPSocket* tcp_socket =
@@ -272,15 +272,15 @@ void TurnServer::AcceptConnection(talk_base::AsyncSocket* server_socket) {
   }
 }
 
-void TurnServer::OnInternalSocketClose(talk_base::AsyncPacketSocket* socket,
+void TurnServer::OnInternalSocketClose(rtc::AsyncPacketSocket* socket,
                                        int err) {
   DestroyInternalSocket(socket);
 }
 
-void TurnServer::OnInternalPacket(talk_base::AsyncPacketSocket* socket,
+void TurnServer::OnInternalPacket(rtc::AsyncPacketSocket* socket,
                                   const char* data, size_t size,
-                                  const talk_base::SocketAddress& addr,
-                                  const talk_base::PacketTime& packet_time) {
+                                  const rtc::SocketAddress& addr,
+                                  const rtc::PacketTime& packet_time) {
   // Fail if the packet is too small to even contain a channel header.
   if (size < TURN_CHANNEL_HEADER_SIZE) {
    return;
@@ -288,7 +288,7 @@ void TurnServer::OnInternalPacket(talk_base::AsyncPacketSocket* socket,
   InternalSocketMap::iterator iter = server_sockets_.find(socket);
   ASSERT(iter != server_sockets_.end());
   Connection conn(addr, iter->second, socket);
-  uint16 msg_type = talk_base::GetBE16(data);
+  uint16 msg_type = rtc::GetBE16(data);
   if (!IsTurnChannelData(msg_type)) {
     // This is a STUN message.
     HandleStunMessage(&conn, data, size);
@@ -304,7 +304,7 @@ void TurnServer::OnInternalPacket(talk_base::AsyncPacketSocket* socket,
 void TurnServer::HandleStunMessage(Connection* conn, const char* data,
                                    size_t size) {
   TurnMessage msg;
-  talk_base::ByteBuffer buf(data, size);
+  rtc::ByteBuffer buf(data, size);
   if (!msg.Read(&buf) || (buf.Length() > 0)) {
     LOG(LS_WARNING) << "Received invalid STUN message";
     return;
@@ -474,10 +474,10 @@ void TurnServer::HandleAllocateRequest(Connection* conn,
 
 std::string TurnServer::GenerateNonce() const {
   // Generate a nonce of the form hex(now + HMAC-MD5(nonce_key_, now))
-  uint32 now = talk_base::Time();
+  uint32 now = rtc::Time();
   std::string input(reinterpret_cast<const char*>(&now), sizeof(now));
-  std::string nonce = talk_base::hex_encode(input.c_str(), input.size());
-  nonce += talk_base::ComputeHmac(talk_base::DIGEST_MD5, nonce_key_, input);
+  std::string nonce = rtc::hex_encode(input.c_str(), input.size());
+  nonce += rtc::ComputeHmac(rtc::DIGEST_MD5, nonce_key_, input);
   ASSERT(nonce.size() == kNonceSize);
   return nonce;
 }
@@ -491,20 +491,20 @@ bool TurnServer::ValidateNonce(const std::string& nonce) const {
   // Decode the timestamp.
   uint32 then;
   char* p = reinterpret_cast<char*>(&then);
-  size_t len = talk_base::hex_decode(p, sizeof(then),
+  size_t len = rtc::hex_decode(p, sizeof(then),
       nonce.substr(0, sizeof(then) * 2));
   if (len != sizeof(then)) {
     return false;
   }
 
   // Verify the HMAC.
-  if (nonce.substr(sizeof(then) * 2) != talk_base::ComputeHmac(
-      talk_base::DIGEST_MD5, nonce_key_, std::string(p, sizeof(then)))) {
+  if (nonce.substr(sizeof(then) * 2) != rtc::ComputeHmac(
+      rtc::DIGEST_MD5, nonce_key_, std::string(p, sizeof(then)))) {
     return false;
   }
 
   // Validate the timestamp.
-  return talk_base::TimeSince(then) < kNonceTimeout;
+  return rtc::TimeSince(then) < kNonceTimeout;
 }
 
 TurnServer::Allocation* TurnServer::FindAllocation(Connection* conn) {
@@ -515,7 +515,7 @@ TurnServer::Allocation* TurnServer::FindAllocation(Connection* conn) {
 TurnServer::Allocation* TurnServer::CreateAllocation(Connection* conn,
                                                      int proto,
                                                      const std::string& key) {
-  talk_base::AsyncPacketSocket* external_socket = (external_socket_factory_) ?
+  rtc::AsyncPacketSocket* external_socket = (external_socket_factory_) ?
       external_socket_factory_->CreateUdpSocket(external_addr_, 0, 0) : NULL;
   if (!external_socket) {
     return NULL;
@@ -552,7 +552,7 @@ void TurnServer::SendErrorResponseWithRealmAndNonce(
 }
 
 void TurnServer::SendStun(Connection* conn, StunMessage* msg) {
-  talk_base::ByteBuffer buf;
+  rtc::ByteBuffer buf;
   // Add a SOFTWARE attribute if one is set.
   if (!software_.empty()) {
     VERIFY(msg->AddAttribute(
@@ -563,14 +563,14 @@ void TurnServer::SendStun(Connection* conn, StunMessage* msg) {
 }
 
 void TurnServer::Send(Connection* conn,
-                      const talk_base::ByteBuffer& buf) {
-  talk_base::PacketOptions options;
+                      const rtc::ByteBuffer& buf) {
+  rtc::PacketOptions options;
   conn->socket()->SendTo(buf.Data(), buf.Length(), conn->src(), options);
 }
 
 void TurnServer::OnAllocationDestroyed(Allocation* allocation) {
   // Removing the internal socket if the connection is not udp.
-  talk_base::AsyncPacketSocket* socket = allocation->conn()->socket();
+  rtc::AsyncPacketSocket* socket = allocation->conn()->socket();
   InternalSocketMap::iterator iter = server_sockets_.find(socket);
   ASSERT(iter != server_sockets_.end());
   // Skip if the socket serving this allocation is UDP, as this will be shared
@@ -584,18 +584,18 @@ void TurnServer::OnAllocationDestroyed(Allocation* allocation) {
     allocations_.erase(it);
 }
 
-void TurnServer::DestroyInternalSocket(talk_base::AsyncPacketSocket* socket) {
+void TurnServer::DestroyInternalSocket(rtc::AsyncPacketSocket* socket) {
   InternalSocketMap::iterator iter = server_sockets_.find(socket);
   if (iter != server_sockets_.end()) {
-    talk_base::AsyncPacketSocket* socket = iter->first;
+    rtc::AsyncPacketSocket* socket = iter->first;
     delete socket;
     server_sockets_.erase(iter);
   }
 }
 
-TurnServer::Connection::Connection(const talk_base::SocketAddress& src,
+TurnServer::Connection::Connection(const rtc::SocketAddress& src,
                                    ProtocolType proto,
-                                   talk_base::AsyncPacketSocket* socket)
+                                   rtc::AsyncPacketSocket* socket)
     : src_(src),
       dst_(socket->GetRemoteAddress()),
       proto_(proto),
@@ -620,9 +620,9 @@ std::string TurnServer::Connection::ToString() const {
 }
 
 TurnServer::Allocation::Allocation(TurnServer* server,
-                                   talk_base::Thread* thread,
+                                   rtc::Thread* thread,
                                    const Connection& conn,
-                                   talk_base::AsyncPacketSocket* socket,
+                                   rtc::AsyncPacketSocket* socket,
                                    const std::string& key)
     : server_(server),
       thread_(thread),
@@ -823,7 +823,7 @@ void TurnServer::Allocation::HandleChannelBindRequest(const TurnMessage* msg) {
 
 void TurnServer::Allocation::HandleChannelData(const char* data, size_t size) {
   // Extract the channel number from the data.
-  uint16 channel_id = talk_base::GetBE16(data);
+  uint16 channel_id = rtc::GetBE16(data);
   Channel* channel = FindChannel(channel_id);
   if (channel) {
     // Send the data to the peer address.
@@ -836,15 +836,15 @@ void TurnServer::Allocation::HandleChannelData(const char* data, size_t size) {
 }
 
 void TurnServer::Allocation::OnExternalPacket(
-    talk_base::AsyncPacketSocket* socket,
+    rtc::AsyncPacketSocket* socket,
     const char* data, size_t size,
-    const talk_base::SocketAddress& addr,
-    const talk_base::PacketTime& packet_time) {
+    const rtc::SocketAddress& addr,
+    const rtc::PacketTime& packet_time) {
   ASSERT(external_socket_.get() == socket);
   Channel* channel = FindChannel(addr);
   if (channel) {
     // There is a channel bound to this address. Send as a channel message.
-    talk_base::ByteBuffer buf;
+    rtc::ByteBuffer buf;
     buf.WriteUInt16(channel->id());
     buf.WriteUInt16(static_cast<uint16>(size));
     buf.WriteBytes(data, size);
@@ -854,7 +854,7 @@ void TurnServer::Allocation::OnExternalPacket(
     TurnMessage msg;
     msg.SetType(TURN_DATA_INDICATION);
     msg.SetTransactionID(
-        talk_base::CreateRandomString(kStunTransactionIdLength));
+        rtc::CreateRandomString(kStunTransactionIdLength));
     VERIFY(msg.AddAttribute(new StunXorAddressAttribute(
         STUN_ATTR_XOR_PEER_ADDRESS, addr)));
     VERIFY(msg.AddAttribute(new StunByteStringAttribute(
@@ -876,11 +876,11 @@ int TurnServer::Allocation::ComputeLifetime(const TurnMessage* msg) {
   return lifetime;
 }
 
-bool TurnServer::Allocation::HasPermission(const talk_base::IPAddress& addr) {
+bool TurnServer::Allocation::HasPermission(const rtc::IPAddress& addr) {
   return (FindPermission(addr) != NULL);
 }
 
-void TurnServer::Allocation::AddPermission(const talk_base::IPAddress& addr) {
+void TurnServer::Allocation::AddPermission(const rtc::IPAddress& addr) {
   Permission* perm = FindPermission(addr);
   if (!perm) {
     perm = new Permission(thread_, addr);
@@ -893,7 +893,7 @@ void TurnServer::Allocation::AddPermission(const talk_base::IPAddress& addr) {
 }
 
 TurnServer::Permission* TurnServer::Allocation::FindPermission(
-    const talk_base::IPAddress& addr) const {
+    const rtc::IPAddress& addr) const {
   for (PermissionList::const_iterator it = perms_.begin();
        it != perms_.end(); ++it) {
     if ((*it)->peer() == addr)
@@ -912,7 +912,7 @@ TurnServer::Channel* TurnServer::Allocation::FindChannel(int channel_id) const {
 }
 
 TurnServer::Channel* TurnServer::Allocation::FindChannel(
-    const talk_base::SocketAddress& addr) const {
+    const rtc::SocketAddress& addr) const {
   for (ChannelList::const_iterator it = channels_.begin();
        it != channels_.end(); ++it) {
     if ((*it)->peer() == addr)
@@ -937,12 +937,12 @@ void TurnServer::Allocation::SendErrorResponse(const TurnMessage* req, int code,
 }
 
 void TurnServer::Allocation::SendExternal(const void* data, size_t size,
-                                  const talk_base::SocketAddress& peer) {
-  talk_base::PacketOptions options;
+                                  const rtc::SocketAddress& peer) {
+  rtc::PacketOptions options;
   external_socket_->SendTo(data, size, peer, options);
 }
 
-void TurnServer::Allocation::OnMessage(talk_base::Message* msg) {
+void TurnServer::Allocation::OnMessage(rtc::Message* msg) {
   ASSERT(msg->message_id == MSG_TIMEOUT);
   SignalDestroyed(this);
   delete this;
@@ -961,8 +961,8 @@ void TurnServer::Allocation::OnChannelDestroyed(Channel* channel) {
   channels_.erase(it);
 }
 
-TurnServer::Permission::Permission(talk_base::Thread* thread,
-                                   const talk_base::IPAddress& peer)
+TurnServer::Permission::Permission(rtc::Thread* thread,
+                                   const rtc::IPAddress& peer)
     : thread_(thread), peer_(peer) {
   Refresh();
 }
@@ -976,14 +976,14 @@ void TurnServer::Permission::Refresh() {
   thread_->PostDelayed(kPermissionTimeout, this, MSG_TIMEOUT);
 }
 
-void TurnServer::Permission::OnMessage(talk_base::Message* msg) {
+void TurnServer::Permission::OnMessage(rtc::Message* msg) {
   ASSERT(msg->message_id == MSG_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
-TurnServer::Channel::Channel(talk_base::Thread* thread, int id,
-                             const talk_base::SocketAddress& peer)
+TurnServer::Channel::Channel(rtc::Thread* thread, int id,
+                             const rtc::SocketAddress& peer)
     : thread_(thread), id_(id), peer_(peer) {
   Refresh();
 }
@@ -997,7 +997,7 @@ void TurnServer::Channel::Refresh() {
   thread_->PostDelayed(kChannelTimeout, this, MSG_TIMEOUT);
 }
 
-void TurnServer::Channel::OnMessage(talk_base::Message* msg) {
+void TurnServer::Channel::OnMessage(rtc::Message* msg) {
   ASSERT(msg->message_id == MSG_TIMEOUT);
   SignalDestroyed(this);
   delete this;
diff --git a/p2p/base/turnserver.h b/p2p/base/turnserver.h
index 2c33cdb..faf41fe 100644
--- a/p2p/base/turnserver.h
+++ b/p2p/base/turnserver.h
@@ -33,13 +33,13 @@
 #include <set>
 #include <string>
 
-#include "talk/base/asyncpacketsocket.h"
-#include "talk/base/messagequeue.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/asyncpacketsocket.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/socketaddress.h"
 #include "talk/p2p/base/portinterface.h"
 
-namespace talk_base {
+namespace rtc {
 class ByteBuffer;
 class PacketSocketFactory;
 class Thread;
@@ -69,7 +69,7 @@ class TurnAuthInterface {
 // Not yet wired up: TCP support.
 class TurnServer : public sigslot::has_slots<> {
  public:
-  explicit TurnServer(talk_base::Thread* thread);
+  explicit TurnServer(rtc::Thread* thread);
   ~TurnServer();
 
   // Gets/sets the realm value to use for the server.
@@ -86,51 +86,51 @@ class TurnServer : public sigslot::has_slots<> {
   void set_enable_otu_nonce(bool enable) { enable_otu_nonce_ = enable; }
 
   // Starts listening for packets from internal clients.
-  void AddInternalSocket(talk_base::AsyncPacketSocket* socket,
+  void AddInternalSocket(rtc::AsyncPacketSocket* socket,
                          ProtocolType proto);
   // Starts listening for the connections on this socket. When someone tries
   // to connect, the connection will be accepted and a new internal socket
   // will be added.
-  void AddInternalServerSocket(talk_base::AsyncSocket* socket,
+  void AddInternalServerSocket(rtc::AsyncSocket* socket,
                                ProtocolType proto);
   // Specifies the factory to use for creating external sockets.
-  void SetExternalSocketFactory(talk_base::PacketSocketFactory* factory,
-                                const talk_base::SocketAddress& address);
+  void SetExternalSocketFactory(rtc::PacketSocketFactory* factory,
+                                const rtc::SocketAddress& address);
 
  private:
   // Encapsulates the client's connection to the server.
   class Connection {
    public:
     Connection() : proto_(PROTO_UDP), socket_(NULL) {}
-    Connection(const talk_base::SocketAddress& src,
+    Connection(const rtc::SocketAddress& src,
                ProtocolType proto,
-               talk_base::AsyncPacketSocket* socket);
-    const talk_base::SocketAddress& src() const { return src_; }
-    talk_base::AsyncPacketSocket* socket() { return socket_; }
+               rtc::AsyncPacketSocket* socket);
+    const rtc::SocketAddress& src() const { return src_; }
+    rtc::AsyncPacketSocket* socket() { return socket_; }
     bool operator==(const Connection& t) const;
     bool operator<(const Connection& t) const;
     std::string ToString() const;
 
    private:
-    talk_base::SocketAddress src_;
-    talk_base::SocketAddress dst_;
+    rtc::SocketAddress src_;
+    rtc::SocketAddress dst_;
     cricket::ProtocolType proto_;
-    talk_base::AsyncPacketSocket* socket_;
+    rtc::AsyncPacketSocket* socket_;
   };
   class Allocation;
   class Permission;
   class Channel;
   typedef std::map<Connection, Allocation*> AllocationMap;
 
-  void OnInternalPacket(talk_base::AsyncPacketSocket* socket, const char* data,
-                        size_t size, const talk_base::SocketAddress& address,
-                        const talk_base::PacketTime& packet_time);
+  void OnInternalPacket(rtc::AsyncPacketSocket* socket, const char* data,
+                        size_t size, const rtc::SocketAddress& address,
+                        const rtc::PacketTime& packet_time);
 
-  void OnNewInternalConnection(talk_base::AsyncSocket* socket);
+  void OnNewInternalConnection(rtc::AsyncSocket* socket);
 
   // Accept connections on this server socket.
-  void AcceptConnection(talk_base::AsyncSocket* server_socket);
-  void OnInternalSocketClose(talk_base::AsyncPacketSocket* socket, int err);
+  void AcceptConnection(rtc::AsyncSocket* server_socket);
+  void OnInternalSocketClose(rtc::AsyncPacketSocket* socket, int err);
 
   void HandleStunMessage(Connection* conn, const char* data, size_t size);
   void HandleBindingRequest(Connection* conn, const StunMessage* msg);
@@ -156,17 +156,17 @@ class TurnServer : public sigslot::has_slots<> {
                                           int code,
                                           const std::string& reason);
   void SendStun(Connection* conn, StunMessage* msg);
-  void Send(Connection* conn, const talk_base::ByteBuffer& buf);
+  void Send(Connection* conn, const rtc::ByteBuffer& buf);
 
   void OnAllocationDestroyed(Allocation* allocation);
-  void DestroyInternalSocket(talk_base::AsyncPacketSocket* socket);
+  void DestroyInternalSocket(rtc::AsyncPacketSocket* socket);
 
-  typedef std::map<talk_base::AsyncPacketSocket*,
+  typedef std::map<rtc::AsyncPacketSocket*,
                    ProtocolType> InternalSocketMap;
-  typedef std::map<talk_base::AsyncSocket*,
+  typedef std::map<rtc::AsyncSocket*,
                    ProtocolType> ServerSocketMap;
 
-  talk_base::Thread* thread_;
+  rtc::Thread* thread_;
   std::string nonce_key_;
   std::string realm_;
   std::string software_;
@@ -176,9 +176,9 @@ class TurnServer : public sigslot::has_slots<> {
   bool enable_otu_nonce_;
   InternalSocketMap server_sockets_;
   ServerSocketMap server_listen_sockets_;
-  talk_base::scoped_ptr<talk_base::PacketSocketFactory>
+  rtc::scoped_ptr<rtc::PacketSocketFactory>
       external_socket_factory_;
-  talk_base::SocketAddress external_addr_;
+  rtc::SocketAddress external_addr_;
   AllocationMap allocations_;
 };
 
diff --git a/p2p/client/autoportallocator.h b/p2p/client/autoportallocator.h
index 4ec324b..c6271d0 100644
--- a/p2p/client/autoportallocator.h
+++ b/p2p/client/autoportallocator.h
@@ -31,7 +31,7 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/p2p/client/httpportallocator.h"
 #include "talk/xmpp/jingleinfotask.h"
 #include "talk/xmpp/xmppclient.h"
@@ -40,7 +40,7 @@
 // It enables the client to traverse Proxy and NAT.
 class AutoPortAllocator : public cricket::HttpPortAllocator {
  public:
-  AutoPortAllocator(talk_base::NetworkManager* network_manager,
+  AutoPortAllocator(rtc::NetworkManager* network_manager,
                     const std::string& user_agent)
       : cricket::HttpPortAllocator(network_manager, user_agent) {
   }
@@ -59,7 +59,7 @@ class AutoPortAllocator : public cricket::HttpPortAllocator {
   void OnJingleInfo(
       const std::string& token,
       const std::vector<std::string>& relay_hosts,
-      const std::vector<talk_base::SocketAddress>& stun_hosts) {
+      const std::vector<rtc::SocketAddress>& stun_hosts) {
     SetRelayToken(token);
     SetStunHosts(stun_hosts);
     SetRelayHosts(relay_hosts);
diff --git a/p2p/client/basicportallocator.cc b/p2p/client/basicportallocator.cc
index 46fbf49..0a3fab1 100644
--- a/p2p/client/basicportallocator.cc
+++ b/p2p/client/basicportallocator.cc
@@ -30,9 +30,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/common.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/common.h"
 #include "talk/p2p/base/port.h"
@@ -42,8 +42,8 @@
 #include "talk/p2p/base/turnport.h"
 #include "talk/p2p/base/udpport.h"
 
-using talk_base::CreateRandomId;
-using talk_base::CreateRandomString;
+using rtc::CreateRandomId;
+using rtc::CreateRandomString;
 
 namespace {
 
@@ -82,7 +82,7 @@ const uint32 DISABLE_ALL_PHASES =
 
 // Performs the allocation of ports, in a sequenced (timed) manner, for a given
 // network and IP address.
-class AllocationSequence : public talk_base::MessageHandler,
+class AllocationSequence : public rtc::MessageHandler,
                            public sigslot::has_slots<> {
  public:
   enum State {
@@ -95,7 +95,7 @@ class AllocationSequence : public talk_base::MessageHandler,
   };
 
   AllocationSequence(BasicPortAllocatorSession* session,
-                     talk_base::Network* network,
+                     rtc::Network* network,
                      PortConfiguration* config,
                      uint32 flags);
   ~AllocationSequence();
@@ -106,7 +106,7 @@ class AllocationSequence : public talk_base::MessageHandler,
 
   // Disables the phases for a new sequence that this one already covers for an
   // equivalent network setup.
-  void DisableEquivalentPhases(talk_base::Network* network,
+  void DisableEquivalentPhases(rtc::Network* network,
       PortConfiguration* config, uint32* flags);
 
   // Starts and stops the sequence.  When started, it will continue allocating
@@ -115,7 +115,7 @@ class AllocationSequence : public talk_base::MessageHandler,
   void Stop();
 
   // MessageHandler
-  void OnMessage(talk_base::Message* msg);
+  void OnMessage(rtc::Message* msg);
 
   void EnableProtocol(ProtocolType proto);
   bool ProtocolEnabled(ProtocolType proto) const;
@@ -141,35 +141,35 @@ class AllocationSequence : public talk_base::MessageHandler,
   void CreateGturnPort(const RelayServerConfig& config);
   void CreateTurnPort(const RelayServerConfig& config);
 
-  void OnReadPacket(talk_base::AsyncPacketSocket* socket,
+  void OnReadPacket(rtc::AsyncPacketSocket* socket,
                     const char* data, size_t size,
-                    const talk_base::SocketAddress& remote_addr,
-                    const talk_base::PacketTime& packet_time);
+                    const rtc::SocketAddress& remote_addr,
+                    const rtc::PacketTime& packet_time);
 
   void OnPortDestroyed(PortInterface* port);
   void OnResolvedTurnServerAddress(
-    TurnPort* port, const talk_base::SocketAddress& server_address,
-    const talk_base::SocketAddress& resolved_server_address);
+    TurnPort* port, const rtc::SocketAddress& server_address,
+    const rtc::SocketAddress& resolved_server_address);
 
   BasicPortAllocatorSession* session_;
-  talk_base::Network* network_;
-  talk_base::IPAddress ip_;
+  rtc::Network* network_;
+  rtc::IPAddress ip_;
   PortConfiguration* config_;
   State state_;
   uint32 flags_;
   ProtocolList protocols_;
-  talk_base::scoped_ptr<talk_base::AsyncPacketSocket> udp_socket_;
+  rtc::scoped_ptr<rtc::AsyncPacketSocket> udp_socket_;
   // There will be only one udp port per AllocationSequence.
   UDPPort* udp_port_;
   // Keeping a map for turn ports keyed with server addresses.
-  std::map<talk_base::SocketAddress, Port*> turn_ports_;
+  std::map<rtc::SocketAddress, Port*> turn_ports_;
   int phase_;
 };
 
 // BasicPortAllocator
 BasicPortAllocator::BasicPortAllocator(
-    talk_base::NetworkManager* network_manager,
-    talk_base::PacketSocketFactory* socket_factory)
+    rtc::NetworkManager* network_manager,
+    rtc::PacketSocketFactory* socket_factory)
     : network_manager_(network_manager),
       socket_factory_(socket_factory) {
   ASSERT(socket_factory_ != NULL);
@@ -177,15 +177,15 @@ BasicPortAllocator::BasicPortAllocator(
 }
 
 BasicPortAllocator::BasicPortAllocator(
-    talk_base::NetworkManager* network_manager)
+    rtc::NetworkManager* network_manager)
     : network_manager_(network_manager),
       socket_factory_(NULL) {
   Construct();
 }
 
 BasicPortAllocator::BasicPortAllocator(
-    talk_base::NetworkManager* network_manager,
-    talk_base::PacketSocketFactory* socket_factory,
+    rtc::NetworkManager* network_manager,
+    rtc::PacketSocketFactory* socket_factory,
     const ServerAddresses& stun_servers)
     : network_manager_(network_manager),
       socket_factory_(socket_factory),
@@ -195,11 +195,11 @@ BasicPortAllocator::BasicPortAllocator(
 }
 
 BasicPortAllocator::BasicPortAllocator(
-    talk_base::NetworkManager* network_manager,
+    rtc::NetworkManager* network_manager,
     const ServerAddresses& stun_servers,
-    const talk_base::SocketAddress& relay_address_udp,
-    const talk_base::SocketAddress& relay_address_tcp,
-    const talk_base::SocketAddress& relay_address_ssl)
+    const rtc::SocketAddress& relay_address_udp,
+    const rtc::SocketAddress& relay_address_tcp,
+    const rtc::SocketAddress& relay_address_ssl)
     : network_manager_(network_manager),
       socket_factory_(NULL),
       stun_servers_(stun_servers) {
@@ -275,10 +275,10 @@ BasicPortAllocatorSession::~BasicPortAllocatorSession() {
 }
 
 void BasicPortAllocatorSession::StartGettingPorts() {
-  network_thread_ = talk_base::Thread::Current();
+  network_thread_ = rtc::Thread::Current();
   if (!socket_factory_) {
     owned_socket_factory_.reset(
-        new talk_base::BasicPacketSocketFactory(network_thread_));
+        new rtc::BasicPacketSocketFactory(network_thread_));
     socket_factory_ = owned_socket_factory_.get();
   }
 
@@ -290,7 +290,7 @@ void BasicPortAllocatorSession::StartGettingPorts() {
 }
 
 void BasicPortAllocatorSession::StopGettingPorts() {
-  ASSERT(talk_base::Thread::Current() == network_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   running_ = false;
   network_thread_->Clear(this, MSG_ALLOCATE);
   for (uint32 i = 0; i < sequences_.size(); ++i)
@@ -298,33 +298,33 @@ void BasicPortAllocatorSession::StopGettingPorts() {
   network_thread_->Post(this, MSG_CONFIG_STOP);
 }
 
-void BasicPortAllocatorSession::OnMessage(talk_base::Message *message) {
+void BasicPortAllocatorSession::OnMessage(rtc::Message *message) {
   switch (message->message_id) {
   case MSG_CONFIG_START:
-    ASSERT(talk_base::Thread::Current() == network_thread_);
+    ASSERT(rtc::Thread::Current() == network_thread_);
     GetPortConfigurations();
     break;
 
   case MSG_CONFIG_READY:
-    ASSERT(talk_base::Thread::Current() == network_thread_);
+    ASSERT(rtc::Thread::Current() == network_thread_);
     OnConfigReady(static_cast<PortConfiguration*>(message->pdata));
     break;
 
   case MSG_ALLOCATE:
-    ASSERT(talk_base::Thread::Current() == network_thread_);
+    ASSERT(rtc::Thread::Current() == network_thread_);
     OnAllocate();
     break;
 
   case MSG_SHAKE:
-    ASSERT(talk_base::Thread::Current() == network_thread_);
+    ASSERT(rtc::Thread::Current() == network_thread_);
     OnShake();
     break;
   case MSG_SEQUENCEOBJECTS_CREATED:
-    ASSERT(talk_base::Thread::Current() == network_thread_);
+    ASSERT(rtc::Thread::Current() == network_thread_);
     OnAllocationSequenceObjectsCreated();
     break;
   case MSG_CONFIG_STOP:
-    ASSERT(talk_base::Thread::Current() == network_thread_);
+    ASSERT(rtc::Thread::Current() == network_thread_);
     OnConfigStop();
     break;
   default:
@@ -356,7 +356,7 @@ void BasicPortAllocatorSession::OnConfigReady(PortConfiguration* config) {
 }
 
 void BasicPortAllocatorSession::OnConfigStop() {
-  ASSERT(talk_base::Thread::Current() == network_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
 
   // If any of the allocated ports have not completed the candidates allocation,
   // mark those as error. Since session doesn't need any new candidates
@@ -387,7 +387,7 @@ void BasicPortAllocatorSession::OnConfigStop() {
 }
 
 void BasicPortAllocatorSession::AllocatePorts() {
-  ASSERT(talk_base::Thread::Current() == network_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   network_thread_->Post(this, MSG_ALLOCATE);
 }
 
@@ -402,7 +402,7 @@ void BasicPortAllocatorSession::OnAllocate() {
 // create a new sequence to create the appropriate ports.
 void BasicPortAllocatorSession::DoAllocate() {
   bool done_signal_needed = false;
-  std::vector<talk_base::Network*> networks;
+  std::vector<rtc::Network*> networks;
   allocator_->network_manager()->GetNetworks(&networks);
   if (networks.empty()) {
     LOG(LS_WARNING) << "Machine has no networks; no ports will be allocated";
@@ -472,7 +472,7 @@ void BasicPortAllocatorSession::OnNetworksChanged() {
 }
 
 void BasicPortAllocatorSession::DisableEquivalentPhases(
-    talk_base::Network* network, PortConfiguration* config, uint32* flags) {
+    rtc::Network* network, PortConfiguration* config, uint32* flags) {
   for (uint32 i = 0; i < sequences_.size() &&
       (*flags & DISABLE_ALL_PHASES) != DISABLE_ALL_PHASES; ++i) {
     sequences_[i]->DisableEquivalentPhases(network, config, flags);
@@ -489,7 +489,7 @@ void BasicPortAllocatorSession::AddAllocatedPort(Port* port,
   port->set_content_name(content_name());
   port->set_component(component_);
   port->set_generation(generation());
-  if (allocator_->proxy().type != talk_base::PROXY_NONE)
+  if (allocator_->proxy().type != rtc::PROXY_NONE)
     port->set_proxy(allocator_->user_agent(), allocator_->proxy());
   port->set_send_retransmit_count_attribute((allocator_->flags() &
       PORTALLOCATOR_ENABLE_STUN_RETRANSMIT_ATTRIBUTE) != 0);
@@ -519,7 +519,7 @@ void BasicPortAllocatorSession::OnAllocationSequenceObjectsCreated() {
 
 void BasicPortAllocatorSession::OnCandidateReady(
     Port* port, const Candidate& c) {
-  ASSERT(talk_base::Thread::Current() == network_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   PortData* data = FindPort(port);
   ASSERT(data != NULL);
   // Discarding any candidate signal if port allocation status is
@@ -549,7 +549,7 @@ void BasicPortAllocatorSession::OnCandidateReady(
 }
 
 void BasicPortAllocatorSession::OnPortComplete(Port* port) {
-  ASSERT(talk_base::Thread::Current() == network_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   PortData* data = FindPort(port);
   ASSERT(data != NULL);
 
@@ -564,7 +564,7 @@ void BasicPortAllocatorSession::OnPortComplete(Port* port) {
 }
 
 void BasicPortAllocatorSession::OnPortError(Port* port) {
-  ASSERT(talk_base::Thread::Current() == network_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   PortData* data = FindPort(port);
   ASSERT(data != NULL);
   // We might have already given up on this port and stopped it.
@@ -636,7 +636,7 @@ void BasicPortAllocatorSession::MaybeSignalCandidatesAllocationDone() {
 
 void BasicPortAllocatorSession::OnPortDestroyed(
     PortInterface* port) {
-  ASSERT(talk_base::Thread::Current() == network_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   for (std::vector<PortData>::iterator iter = ports_.begin();
        iter != ports_.end(); ++iter) {
     if (port == iter->port()) {
@@ -693,7 +693,7 @@ BasicPortAllocatorSession::PortData* BasicPortAllocatorSession::FindPort(
 // AllocationSequence
 
 AllocationSequence::AllocationSequence(BasicPortAllocatorSession* session,
-                                       talk_base::Network* network,
+                                       rtc::Network* network,
                                        PortConfiguration* config,
                                        uint32 flags)
     : session_(session),
@@ -718,7 +718,7 @@ bool AllocationSequence::Init() {
 
   if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)) {
     udp_socket_.reset(session_->socket_factory()->CreateUdpSocket(
-        talk_base::SocketAddress(ip_, 0), session_->allocator()->min_port(),
+        rtc::SocketAddress(ip_, 0), session_->allocator()->min_port(),
         session_->allocator()->max_port()));
     if (udp_socket_) {
       udp_socket_->SignalReadPacket.connect(
@@ -739,7 +739,7 @@ AllocationSequence::~AllocationSequence() {
   session_->network_thread()->Clear(this);
 }
 
-void AllocationSequence::DisableEquivalentPhases(talk_base::Network* network,
+void AllocationSequence::DisableEquivalentPhases(rtc::Network* network,
     PortConfiguration* config, uint32* flags) {
   if (!((network == network_) && (ip_ == network->ip()))) {
     // Different network setup; nothing is equivalent.
@@ -781,8 +781,8 @@ void AllocationSequence::Stop() {
   }
 }
 
-void AllocationSequence::OnMessage(talk_base::Message* msg) {
-  ASSERT(talk_base::Thread::Current() == session_->network_thread());
+void AllocationSequence::OnMessage(rtc::Message* msg) {
+  ASSERT(rtc::Thread::Current() == session_->network_thread());
   ASSERT(msg->message_id == MSG_ALLOCATION_PHASE);
 
   const char* const PHASE_NAMES[kNumPhases] = {
@@ -1059,15 +1059,15 @@ void AllocationSequence::CreateTurnPort(const RelayServerConfig& config) {
 }
 
 void AllocationSequence::OnReadPacket(
-    talk_base::AsyncPacketSocket* socket, const char* data, size_t size,
-    const talk_base::SocketAddress& remote_addr,
-    const talk_base::PacketTime& packet_time) {
+    rtc::AsyncPacketSocket* socket, const char* data, size_t size,
+    const rtc::SocketAddress& remote_addr,
+    const rtc::PacketTime& packet_time) {
   ASSERT(socket == udp_socket_.get());
   // If the packet is received from one of the TURN server in the config, then
   // pass down the packet to that port, otherwise it will be handed down to
   // the local udp port.
   Port* port = NULL;
-  std::map<talk_base::SocketAddress, Port*>::iterator iter =
+  std::map<rtc::SocketAddress, Port*>::iterator iter =
       turn_ports_.find(remote_addr);
   if (iter != turn_ports_.end()) {
     port = iter->second;
@@ -1084,7 +1084,7 @@ void AllocationSequence::OnPortDestroyed(PortInterface* port) {
   if (udp_port_ == port) {
     udp_port_ = NULL;
   } else {
-    std::map<talk_base::SocketAddress, Port*>::iterator iter;
+    std::map<rtc::SocketAddress, Port*>::iterator iter;
     for (iter = turn_ports_.begin(); iter != turn_ports_.end(); ++iter) {
       if (iter->second == port) {
         turn_ports_.erase(iter);
@@ -1095,9 +1095,9 @@ void AllocationSequence::OnPortDestroyed(PortInterface* port) {
 }
 
 void AllocationSequence::OnResolvedTurnServerAddress(
-    TurnPort* port, const talk_base::SocketAddress& server_address,
-    const talk_base::SocketAddress& resolved_server_address) {
-  std::map<talk_base::SocketAddress, Port*>::iterator iter;
+    TurnPort* port, const rtc::SocketAddress& server_address,
+    const rtc::SocketAddress& resolved_server_address) {
+  std::map<rtc::SocketAddress, Port*>::iterator iter;
   iter = turn_ports_.find(server_address);
   if (iter == turn_ports_.end()) {
     LOG(LS_INFO) << "TurnPort entry is not found in the map.";
@@ -1112,7 +1112,7 @@ void AllocationSequence::OnResolvedTurnServerAddress(
 
 // PortConfiguration
 PortConfiguration::PortConfiguration(
-    const talk_base::SocketAddress& stun_address,
+    const rtc::SocketAddress& stun_address,
     const std::string& username,
     const std::string& password)
     : stun_address(stun_address), username(username), password(password) {
diff --git a/p2p/client/basicportallocator.h b/p2p/client/basicportallocator.h
index aee6135..ca1deab 100644
--- a/p2p/client/basicportallocator.h
+++ b/p2p/client/basicportallocator.h
@@ -31,10 +31,10 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/messagequeue.h"
-#include "talk/base/network.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/network.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/port.h"
 #include "talk/p2p/base/portallocator.h"
 
@@ -64,24 +64,24 @@ struct RelayServerConfig {
 
 class BasicPortAllocator : public PortAllocator {
  public:
-  BasicPortAllocator(talk_base::NetworkManager* network_manager,
-                     talk_base::PacketSocketFactory* socket_factory);
-  explicit BasicPortAllocator(talk_base::NetworkManager* network_manager);
-  BasicPortAllocator(talk_base::NetworkManager* network_manager,
-                     talk_base::PacketSocketFactory* socket_factory,
+  BasicPortAllocator(rtc::NetworkManager* network_manager,
+                     rtc::PacketSocketFactory* socket_factory);
+  explicit BasicPortAllocator(rtc::NetworkManager* network_manager);
+  BasicPortAllocator(rtc::NetworkManager* network_manager,
+                     rtc::PacketSocketFactory* socket_factory,
                      const ServerAddresses& stun_servers);
-  BasicPortAllocator(talk_base::NetworkManager* network_manager,
+  BasicPortAllocator(rtc::NetworkManager* network_manager,
                      const ServerAddresses& stun_servers,
-                     const talk_base::SocketAddress& relay_server_udp,
-                     const talk_base::SocketAddress& relay_server_tcp,
-                     const talk_base::SocketAddress& relay_server_ssl);
+                     const rtc::SocketAddress& relay_server_udp,
+                     const rtc::SocketAddress& relay_server_tcp,
+                     const rtc::SocketAddress& relay_server_ssl);
   virtual ~BasicPortAllocator();
 
-  talk_base::NetworkManager* network_manager() { return network_manager_; }
+  rtc::NetworkManager* network_manager() { return network_manager_; }
 
   // If socket_factory() is set to NULL each PortAllocatorSession
   // creates its own socket factory.
-  talk_base::PacketSocketFactory* socket_factory() { return socket_factory_; }
+  rtc::PacketSocketFactory* socket_factory() { return socket_factory_; }
 
   const ServerAddresses& stun_servers() const {
     return stun_servers_;
@@ -103,8 +103,8 @@ class BasicPortAllocator : public PortAllocator {
  private:
   void Construct();
 
-  talk_base::NetworkManager* network_manager_;
-  talk_base::PacketSocketFactory* socket_factory_;
+  rtc::NetworkManager* network_manager_;
+  rtc::PacketSocketFactory* socket_factory_;
   const ServerAddresses stun_servers_;
   std::vector<RelayServerConfig> relays_;
   bool allow_tcp_listen_;
@@ -114,7 +114,7 @@ struct PortConfiguration;
 class AllocationSequence;
 
 class BasicPortAllocatorSession : public PortAllocatorSession,
-                                  public talk_base::MessageHandler {
+                                  public rtc::MessageHandler {
  public:
   BasicPortAllocatorSession(BasicPortAllocator* allocator,
                             const std::string& content_name,
@@ -124,8 +124,8 @@ class BasicPortAllocatorSession : public PortAllocatorSession,
   ~BasicPortAllocatorSession();
 
   virtual BasicPortAllocator* allocator() { return allocator_; }
-  talk_base::Thread* network_thread() { return network_thread_; }
-  talk_base::PacketSocketFactory* socket_factory() { return socket_factory_; }
+  rtc::Thread* network_thread() { return network_thread_; }
+  rtc::PacketSocketFactory* socket_factory() { return socket_factory_; }
 
   virtual void StartGettingPorts();
   virtual void StopGettingPorts();
@@ -140,7 +140,7 @@ class BasicPortAllocatorSession : public PortAllocatorSession,
   virtual void ConfigReady(PortConfiguration* config);
 
   // MessageHandler.  Can be overriden if message IDs do not conflict.
-  virtual void OnMessage(talk_base::Message *message);
+  virtual void OnMessage(rtc::Message *message);
 
  private:
   class PortData {
@@ -187,7 +187,7 @@ class BasicPortAllocatorSession : public PortAllocatorSession,
   void DoAllocate();
   void OnNetworksChanged();
   void OnAllocationSequenceObjectsCreated();
-  void DisableEquivalentPhases(talk_base::Network* network,
+  void DisableEquivalentPhases(rtc::Network* network,
                                PortConfiguration* config, uint32* flags);
   void AddAllocatedPort(Port* port, AllocationSequence* seq,
                         bool prepare_address);
@@ -202,9 +202,9 @@ class BasicPortAllocatorSession : public PortAllocatorSession,
   PortData* FindPort(Port* port);
 
   BasicPortAllocator* allocator_;
-  talk_base::Thread* network_thread_;
-  talk_base::scoped_ptr<talk_base::PacketSocketFactory> owned_socket_factory_;
-  talk_base::PacketSocketFactory* socket_factory_;
+  rtc::Thread* network_thread_;
+  rtc::scoped_ptr<rtc::PacketSocketFactory> owned_socket_factory_;
+  rtc::PacketSocketFactory* socket_factory_;
   bool allocation_started_;
   bool network_manager_started_;
   bool running_;  // set when StartGetAllPorts is called
@@ -217,9 +217,9 @@ class BasicPortAllocatorSession : public PortAllocatorSession,
 };
 
 // Records configuration information useful in creating ports.
-struct PortConfiguration : public talk_base::MessageData {
+struct PortConfiguration : public rtc::MessageData {
   // TODO(jiayl): remove |stun_address| when Chrome is updated.
-  talk_base::SocketAddress stun_address;
+  rtc::SocketAddress stun_address;
   ServerAddresses stun_servers;
   std::string username;
   std::string password;
@@ -228,7 +228,7 @@ struct PortConfiguration : public talk_base::MessageData {
   RelayList relays;
 
   // TODO(jiayl): remove this ctor when Chrome is updated.
-  PortConfiguration(const talk_base::SocketAddress& stun_address,
+  PortConfiguration(const rtc::SocketAddress& stun_address,
                     const std::string& username,
                     const std::string& password);
 
diff --git a/p2p/client/connectivitychecker.cc b/p2p/client/connectivitychecker.cc
index facb01e..dd8673a 100644
--- a/p2p/client/connectivitychecker.cc
+++ b/p2p/client/connectivitychecker.cc
@@ -5,14 +5,14 @@
 
 #include "talk/p2p/client/connectivitychecker.h"
 
-#include "talk/base/asynchttprequest.h"
-#include "talk/base/autodetectproxy.h"
-#include "talk/base/helpers.h"
-#include "talk/base/httpcommon.h"
-#include "talk/base/httpcommon-inl.h"
-#include "talk/base/logging.h"
-#include "talk/base/proxydetect.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/asynchttprequest.h"
+#include "webrtc/base/autodetectproxy.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/httpcommon.h"
+#include "webrtc/base/httpcommon-inl.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/proxydetect.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/common.h"
@@ -37,7 +37,7 @@ enum {
 
 class TestHttpPortAllocator : public HttpPortAllocator {
  public:
-  TestHttpPortAllocator(talk_base::NetworkManager* network_manager,
+  TestHttpPortAllocator(rtc::NetworkManager* network_manager,
                         const std::string& user_agent,
                         const std::string& relay_token) :
       HttpPortAllocator(network_manager, user_agent) {
@@ -61,9 +61,9 @@ void TestHttpPortAllocatorSession::ConfigReady(PortConfiguration* config) {
 }
 
 void TestHttpPortAllocatorSession::OnRequestDone(
-    talk_base::SignalThread* data) {
-  talk_base::AsyncHttpRequest* request =
-      static_cast<talk_base::AsyncHttpRequest*>(data);
+    rtc::SignalThread* data) {
+  rtc::AsyncHttpRequest* request =
+      static_cast<rtc::AsyncHttpRequest*>(data);
 
   // Tell the checker that the request is complete.
   SignalRequestDone(request);
@@ -73,7 +73,7 @@ void TestHttpPortAllocatorSession::OnRequestDone(
 }
 
 ConnectivityChecker::ConnectivityChecker(
-    talk_base::Thread* worker,
+    rtc::Thread* worker,
     const std::string& jid,
     const std::string& session_id,
     const std::string& user_agent,
@@ -115,13 +115,13 @@ bool ConnectivityChecker::Initialize() {
 }
 
 void ConnectivityChecker::Start() {
-  main_ = talk_base::Thread::Current();
+  main_ = rtc::Thread::Current();
   worker_->Post(this, MSG_START);
   started_ = true;
 }
 
 void ConnectivityChecker::CleanUp() {
-  ASSERT(worker_ == talk_base::Thread::Current());
+  ASSERT(worker_ == rtc::Thread::Current());
   if (proxy_detect_) {
     proxy_detect_->Release();
     proxy_detect_ = NULL;
@@ -137,14 +137,14 @@ void ConnectivityChecker::CleanUp() {
   ports_.clear();
 }
 
-bool ConnectivityChecker::AddNic(const talk_base::IPAddress& ip,
-                                 const talk_base::SocketAddress& proxy_addr) {
+bool ConnectivityChecker::AddNic(const rtc::IPAddress& ip,
+                                 const rtc::SocketAddress& proxy_addr) {
   NicMap::iterator i = nics_.find(NicId(ip, proxy_addr));
   if (i != nics_.end()) {
     // Already have it.
     return false;
   }
-  uint32 now = talk_base::Time();
+  uint32 now = rtc::Time();
   NicInfo info;
   info.ip = ip;
   info.proxy_info = GetProxyInfo();
@@ -153,13 +153,13 @@ bool ConnectivityChecker::AddNic(const talk_base::IPAddress& ip,
   return true;
 }
 
-void ConnectivityChecker::SetProxyInfo(const talk_base::ProxyInfo& proxy_info) {
+void ConnectivityChecker::SetProxyInfo(const rtc::ProxyInfo& proxy_info) {
   port_allocator_->set_proxy(user_agent_, proxy_info);
   AllocatePorts();
 }
 
-talk_base::ProxyInfo ConnectivityChecker::GetProxyInfo() const {
-  talk_base::ProxyInfo proxy_info;
+rtc::ProxyInfo ConnectivityChecker::GetProxyInfo() const {
+  rtc::ProxyInfo proxy_info;
   if (proxy_detect_) {
     proxy_info = proxy_detect_->proxy();
   }
@@ -172,10 +172,10 @@ void ConnectivityChecker::CheckNetworks() {
   network_manager_->StartUpdating();
 }
 
-void ConnectivityChecker::OnMessage(talk_base::Message *msg) {
+void ConnectivityChecker::OnMessage(rtc::Message *msg) {
   switch (msg->message_id) {
     case MSG_START:
-      ASSERT(worker_ == talk_base::Thread::Current());
+      ASSERT(worker_ == rtc::Thread::Current());
       worker_->PostDelayed(timeout_ms_, this, MSG_TIMEOUT);
       CheckNetworks();
       break;
@@ -188,7 +188,7 @@ void ConnectivityChecker::OnMessage(talk_base::Message *msg) {
       main_->Post(this, MSG_SIGNAL_RESULTS);
       break;
     case MSG_SIGNAL_RESULTS:
-      ASSERT(main_ == talk_base::Thread::Current());
+      ASSERT(main_ == rtc::Thread::Current());
       SignalCheckDone(this);
       break;
     default:
@@ -196,32 +196,32 @@ void ConnectivityChecker::OnMessage(talk_base::Message *msg) {
   }
 }
 
-void ConnectivityChecker::OnProxyDetect(talk_base::SignalThread* thread) {
-  ASSERT(worker_ == talk_base::Thread::Current());
-  if (proxy_detect_->proxy().type != talk_base::PROXY_NONE) {
+void ConnectivityChecker::OnProxyDetect(rtc::SignalThread* thread) {
+  ASSERT(worker_ == rtc::Thread::Current());
+  if (proxy_detect_->proxy().type != rtc::PROXY_NONE) {
     SetProxyInfo(proxy_detect_->proxy());
   }
 }
 
-void ConnectivityChecker::OnRequestDone(talk_base::AsyncHttpRequest* request) {
-  ASSERT(worker_ == talk_base::Thread::Current());
+void ConnectivityChecker::OnRequestDone(rtc::AsyncHttpRequest* request) {
+  ASSERT(worker_ == rtc::Thread::Current());
   // Since we don't know what nic were actually used for the http request,
   // for now, just use the first one.
-  std::vector<talk_base::Network*> networks;
+  std::vector<rtc::Network*> networks;
   network_manager_->GetNetworks(&networks);
   if (networks.empty()) {
     LOG(LS_ERROR) << "No networks while registering http start.";
     return;
   }
-  talk_base::ProxyInfo proxy_info = request->proxy();
+  rtc::ProxyInfo proxy_info = request->proxy();
   NicMap::iterator i = nics_.find(NicId(networks[0]->ip(), proxy_info.address));
   if (i != nics_.end()) {
     int port = request->port();
-    uint32 now = talk_base::Time();
+    uint32 now = rtc::Time();
     NicInfo* nic_info = &i->second;
-    if (port == talk_base::HTTP_DEFAULT_PORT) {
+    if (port == rtc::HTTP_DEFAULT_PORT) {
       nic_info->http.rtt = now - nic_info->http.start_time_ms;
-    } else if (port == talk_base::HTTP_SECURE_PORT) {
+    } else if (port == rtc::HTTP_SECURE_PORT) {
       nic_info->https.rtt = now - nic_info->https.start_time_ms;
     } else {
       LOG(LS_ERROR) << "Got response with unknown port: " << port;
@@ -233,8 +233,8 @@ void ConnectivityChecker::OnRequestDone(talk_base::AsyncHttpRequest* request) {
 
 void ConnectivityChecker::OnConfigReady(
     const std::string& username, const std::string& password,
-    const PortConfiguration* config, const talk_base::ProxyInfo& proxy_info) {
-  ASSERT(worker_ == talk_base::Thread::Current());
+    const PortConfiguration* config, const rtc::ProxyInfo& proxy_info) {
+  ASSERT(worker_ == rtc::Thread::Current());
 
   // Since we send requests on both HTTP and HTTPS we will get two
   // configs per nic. Results from the second will overwrite the
@@ -244,10 +244,10 @@ void ConnectivityChecker::OnConfigReady(
 }
 
 void ConnectivityChecker::OnRelayPortComplete(Port* port) {
-  ASSERT(worker_ == talk_base::Thread::Current());
+  ASSERT(worker_ == rtc::Thread::Current());
   RelayPort* relay_port = reinterpret_cast<RelayPort*>(port);
   const ProtocolAddress* address = relay_port->ServerAddress(0);
-  talk_base::IPAddress ip = port->Network()->ip();
+  rtc::IPAddress ip = port->Network()->ip();
   NicMap::iterator i = nics_.find(NicId(ip, port->proxy().address));
   if (i != nics_.end()) {
     // We have it already, add the new information.
@@ -269,7 +269,7 @@ void ConnectivityChecker::OnRelayPortComplete(Port* port) {
       }
       if (connect_info) {
         connect_info->rtt =
-            talk_base::TimeSince(connect_info->start_time_ms);
+            rtc::TimeSince(connect_info->start_time_ms);
       }
     }
   } else {
@@ -278,14 +278,14 @@ void ConnectivityChecker::OnRelayPortComplete(Port* port) {
 }
 
 void ConnectivityChecker::OnStunPortComplete(Port* port) {
-  ASSERT(worker_ == talk_base::Thread::Current());
+  ASSERT(worker_ == rtc::Thread::Current());
   const std::vector<Candidate> candidates = port->Candidates();
   Candidate c = candidates[0];
-  talk_base::IPAddress ip = port->Network()->ip();
+  rtc::IPAddress ip = port->Network()->ip();
   NicMap::iterator i = nics_.find(NicId(ip, port->proxy().address));
   if (i != nics_.end()) {
     // We have it already, add the new information.
-    uint32 now = talk_base::Time();
+    uint32 now = rtc::Time();
     NicInfo* nic_info = &i->second;
     nic_info->external_address = c.address();
 
@@ -298,9 +298,9 @@ void ConnectivityChecker::OnStunPortComplete(Port* port) {
 }
 
 void ConnectivityChecker::OnStunPortError(Port* port) {
-  ASSERT(worker_ == talk_base::Thread::Current());
+  ASSERT(worker_ == rtc::Thread::Current());
   LOG(LS_ERROR) << "Stun address error.";
-  talk_base::IPAddress ip = port->Network()->ip();
+  rtc::IPAddress ip = port->Network()->ip();
   NicMap::iterator i = nics_.find(NicId(ip, port->proxy().address));
   if (i != nics_.end()) {
     // We have it already, add the new information.
@@ -312,13 +312,13 @@ void ConnectivityChecker::OnStunPortError(Port* port) {
 }
 
 void ConnectivityChecker::OnRelayPortError(Port* port) {
-  ASSERT(worker_ == talk_base::Thread::Current());
+  ASSERT(worker_ == rtc::Thread::Current());
   LOG(LS_ERROR) << "Relay address error.";
 }
 
 void ConnectivityChecker::OnNetworksChanged() {
-  ASSERT(worker_ == talk_base::Thread::Current());
-  std::vector<talk_base::Network*> networks;
+  ASSERT(worker_ == rtc::Thread::Current());
+  std::vector<rtc::Network*> networks;
   network_manager_->GetNetworks(&networks);
   if (networks.empty()) {
     LOG(LS_ERROR) << "Machine has no networks; nothing to do";
@@ -328,7 +328,7 @@ void ConnectivityChecker::OnNetworksChanged() {
 }
 
 HttpPortAllocator* ConnectivityChecker::CreatePortAllocator(
-    talk_base::NetworkManager* network_manager,
+    rtc::NetworkManager* network_manager,
     const std::string& user_agent,
     const std::string& relay_token) {
   return new TestHttpPortAllocator(network_manager, user_agent, relay_token);
@@ -336,7 +336,7 @@ HttpPortAllocator* ConnectivityChecker::CreatePortAllocator(
 
 StunPort* ConnectivityChecker::CreateStunPort(
     const std::string& username, const std::string& password,
-    const PortConfiguration* config, talk_base::Network* network) {
+    const PortConfiguration* config, rtc::Network* network) {
   return StunPort::Create(worker_, socket_factory_.get(),
                           network, network->ip(), 0, 0,
                           username, password, config->stun_servers);
@@ -344,7 +344,7 @@ StunPort* ConnectivityChecker::CreateStunPort(
 
 RelayPort* ConnectivityChecker::CreateRelayPort(
     const std::string& username, const std::string& password,
-    const PortConfiguration* config, talk_base::Network* network) {
+    const PortConfiguration* config, rtc::Network* network) {
   return RelayPort::Create(worker_, socket_factory_.get(),
                            network, network->ip(),
                            port_allocator_->min_port(),
@@ -354,9 +354,9 @@ RelayPort* ConnectivityChecker::CreateRelayPort(
 
 void ConnectivityChecker::CreateRelayPorts(
     const std::string& username, const std::string& password,
-    const PortConfiguration* config, const talk_base::ProxyInfo& proxy_info) {
+    const PortConfiguration* config, const rtc::ProxyInfo& proxy_info) {
   PortConfiguration::RelayList::const_iterator relay;
-  std::vector<talk_base::Network*> networks;
+  std::vector<rtc::Network*> networks;
   network_manager_->GetNetworks(&networks);
   if (networks.empty()) {
     LOG(LS_ERROR) << "Machine has no networks; no relay ports created.";
@@ -371,7 +371,7 @@ void ConnectivityChecker::CreateRelayPorts(
         // TODO: Now setting the same start time for all protocols.
         // This might affect accuracy, but since we are mainly looking for
         // connect failures or number that stick out, this is good enough.
-        uint32 now = talk_base::Time();
+        uint32 now = rtc::Time();
         NicInfo* nic_info = &iter->second;
         nic_info->udp.start_time_ms = now;
         nic_info->tcp.start_time_ms = now;
@@ -409,18 +409,18 @@ void ConnectivityChecker::CreateRelayPorts(
 }
 
 void ConnectivityChecker::AllocatePorts() {
-  const std::string username = talk_base::CreateRandomString(ICE_UFRAG_LENGTH);
-  const std::string password = talk_base::CreateRandomString(ICE_PWD_LENGTH);
+  const std::string username = rtc::CreateRandomString(ICE_UFRAG_LENGTH);
+  const std::string password = rtc::CreateRandomString(ICE_PWD_LENGTH);
   ServerAddresses stun_servers;
   stun_servers.insert(stun_address_);
   PortConfiguration config(stun_servers, username, password);
-  std::vector<talk_base::Network*> networks;
+  std::vector<rtc::Network*> networks;
   network_manager_->GetNetworks(&networks);
   if (networks.empty()) {
     LOG(LS_ERROR) << "Machine has no networks; no ports will be allocated";
     return;
   }
-  talk_base::ProxyInfo proxy_info = GetProxyInfo();
+  rtc::ProxyInfo proxy_info = GetProxyInfo();
   bool allocate_relay_ports = false;
   for (uint32 i = 0; i < networks.size(); ++i) {
     if (AddNic(networks[i]->ip(), proxy_info.address)) {
@@ -453,9 +453,9 @@ void ConnectivityChecker::AllocatePorts() {
 void ConnectivityChecker::InitiateProxyDetection() {
   // Only start if we haven't been started before.
   if (!proxy_detect_) {
-    proxy_detect_ = new talk_base::AutoDetectProxy(user_agent_);
-    talk_base::Url<char> host_url("/", "relay.google.com",
-                                  talk_base::HTTP_DEFAULT_PORT);
+    proxy_detect_ = new rtc::AutoDetectProxy(user_agent_);
+    rtc::Url<char> host_url("/", "relay.google.com",
+                                  rtc::HTTP_DEFAULT_PORT);
     host_url.set_secure(true);
     proxy_detect_->set_server_url(host_url.url());
     proxy_detect_->SignalWorkDone.connect(
@@ -471,8 +471,8 @@ void ConnectivityChecker::AllocateRelayPorts() {
           port_allocator_->CreateSessionInternal(
               "connectivity checker test content",
               ICE_CANDIDATE_COMPONENT_RTP,
-              talk_base::CreateRandomString(ICE_UFRAG_LENGTH),
-              talk_base::CreateRandomString(ICE_PWD_LENGTH)));
+              rtc::CreateRandomString(ICE_UFRAG_LENGTH),
+              rtc::CreateRandomString(ICE_PWD_LENGTH)));
   allocator_session->set_proxy(port_allocator_->proxy());
   allocator_session->SignalConfigReady.connect(
       this, &ConnectivityChecker::OnConfigReady);
@@ -480,12 +480,12 @@ void ConnectivityChecker::AllocateRelayPorts() {
       this, &ConnectivityChecker::OnRequestDone);
 
   // Try both http and https.
-  RegisterHttpStart(talk_base::HTTP_SECURE_PORT);
+  RegisterHttpStart(rtc::HTTP_SECURE_PORT);
   allocator_session->SendSessionRequest("relay.l.google.com",
-                                        talk_base::HTTP_SECURE_PORT);
-  RegisterHttpStart(talk_base::HTTP_DEFAULT_PORT);
+                                        rtc::HTTP_SECURE_PORT);
+  RegisterHttpStart(rtc::HTTP_DEFAULT_PORT);
   allocator_session->SendSessionRequest("relay.l.google.com",
-                                        talk_base::HTTP_DEFAULT_PORT);
+                                        rtc::HTTP_DEFAULT_PORT);
 
   sessions_.push_back(allocator_session);
 }
@@ -493,20 +493,20 @@ void ConnectivityChecker::AllocateRelayPorts() {
 void ConnectivityChecker::RegisterHttpStart(int port) {
   // Since we don't know what nic were actually used for the http request,
   // for now, just use the first one.
-  std::vector<talk_base::Network*> networks;
+  std::vector<rtc::Network*> networks;
   network_manager_->GetNetworks(&networks);
   if (networks.empty()) {
     LOG(LS_ERROR) << "No networks while registering http start.";
     return;
   }
-  talk_base::ProxyInfo proxy_info = GetProxyInfo();
+  rtc::ProxyInfo proxy_info = GetProxyInfo();
   NicMap::iterator i = nics_.find(NicId(networks[0]->ip(), proxy_info.address));
   if (i != nics_.end()) {
-    uint32 now = talk_base::Time();
+    uint32 now = rtc::Time();
     NicInfo* nic_info = &i->second;
-    if (port == talk_base::HTTP_DEFAULT_PORT) {
+    if (port == rtc::HTTP_DEFAULT_PORT) {
       nic_info->http.start_time_ms = now;
-    } else if (port == talk_base::HTTP_SECURE_PORT) {
+    } else if (port == rtc::HTTP_SECURE_PORT) {
       nic_info->https.start_time_ms = now;
     } else {
       LOG(LS_ERROR) << "Registering start time for unknown port: " << port;
@@ -516,4 +516,4 @@ void ConnectivityChecker::RegisterHttpStart(int port) {
   }
 }
 
-}  // namespace talk_base
+}  // namespace rtc
diff --git a/p2p/client/connectivitychecker.h b/p2p/client/connectivitychecker.h
index 3f10c57..b4423c4 100644
--- a/p2p/client/connectivitychecker.h
+++ b/p2p/client/connectivitychecker.h
@@ -7,17 +7,17 @@
 #include <map>
 #include <string>
 
-#include "talk/base/network.h"
-#include "talk/base/basictypes.h"
-#include "talk/base/messagehandler.h"
-#include "talk/base/proxyinfo.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/network.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/proxyinfo.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/socketaddress.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/client/httpportallocator.h"
 
-namespace talk_base {
+namespace rtc {
 class AsyncHttpRequest;
 class AutoDetectProxy;
 class BasicPacketSocketFactory;
@@ -60,13 +60,13 @@ struct ConnectInfo {
 
 // Identifier for a network interface and proxy address pair.
 struct NicId {
-  NicId(const talk_base::IPAddress& ip,
-        const talk_base::SocketAddress& proxy_address)
+  NicId(const rtc::IPAddress& ip,
+        const rtc::SocketAddress& proxy_address)
       : ip(ip),
         proxy_address(proxy_address) {
   }
-  talk_base::IPAddress ip;
-  talk_base::SocketAddress proxy_address;
+  rtc::IPAddress ip;
+  rtc::SocketAddress proxy_address;
 };
 
 // Comparator implementation identifying unique network interface and
@@ -93,11 +93,11 @@ class NicIdComparator {
 // Contains information of a network interface and proxy address pair.
 struct NicInfo {
   NicInfo() {}
-  talk_base::IPAddress ip;
-  talk_base::ProxyInfo proxy_info;
-  talk_base::SocketAddress external_address;
+  rtc::IPAddress ip;
+  rtc::ProxyInfo proxy_info;
+  rtc::SocketAddress external_address;
   ServerAddresses stun_server_addresses;
-  talk_base::SocketAddress media_server_address;
+  rtc::SocketAddress media_server_address;
   ConnectInfo stun;
   ConnectInfo http;
   ConnectInfo https;
@@ -119,7 +119,7 @@ class TestHttpPortAllocatorSession : public HttpPortAllocatorSession {
       int component,
       const std::string& ice_ufrag,
       const std::string& ice_pwd,
-      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_token,
       const std::string& user_agent)
@@ -127,30 +127,30 @@ class TestHttpPortAllocatorSession : public HttpPortAllocatorSession {
           allocator, content_name, component, ice_ufrag, ice_pwd, stun_hosts,
           relay_hosts, relay_token, user_agent) {
   }
-  void set_proxy(const talk_base::ProxyInfo& proxy) {
+  void set_proxy(const rtc::ProxyInfo& proxy) {
     proxy_ = proxy;
   }
 
   void ConfigReady(PortConfiguration* config);
 
-  void OnRequestDone(talk_base::SignalThread* data);
+  void OnRequestDone(rtc::SignalThread* data);
 
   sigslot::signal4<const std::string&, const std::string&,
                    const PortConfiguration*,
-                   const talk_base::ProxyInfo&> SignalConfigReady;
-  sigslot::signal1<talk_base::AsyncHttpRequest*> SignalRequestDone;
+                   const rtc::ProxyInfo&> SignalConfigReady;
+  sigslot::signal1<rtc::AsyncHttpRequest*> SignalRequestDone;
 
  private:
-  talk_base::ProxyInfo proxy_;
+  rtc::ProxyInfo proxy_;
 };
 
 // Runs a request/response check on all network interface and proxy
 // address combinations. The check is considered done either when all
 // checks has been successful or when the check times out.
 class ConnectivityChecker
-    : public talk_base::MessageHandler, public sigslot::has_slots<> {
+    : public rtc::MessageHandler, public sigslot::has_slots<> {
  public:
-  ConnectivityChecker(talk_base::Thread* worker,
+  ConnectivityChecker(rtc::Thread* worker,
                       const std::string& jid,
                       const std::string& session_id,
                       const std::string& user_agent,
@@ -163,7 +163,7 @@ class ConnectivityChecker
   virtual void Start();
 
   // MessageHandler implementation.
-  virtual void OnMessage(talk_base::Message *msg);
+  virtual void OnMessage(rtc::Message *msg);
 
   // Instruct checker to stop and wait until that's done.
   // Virtual for gMock.
@@ -179,7 +179,7 @@ class ConnectivityChecker
     timeout_ms_ = timeout;
   }
 
-  void set_stun_address(const talk_base::SocketAddress& stun_address) {
+  void set_stun_address(const rtc::SocketAddress& stun_address) {
     stun_address_ = stun_address;
   }
 
@@ -200,72 +200,72 @@ class ConnectivityChecker
 
  protected:
   // Can be overridden for test.
-  virtual talk_base::NetworkManager* CreateNetworkManager() {
-    return new talk_base::BasicNetworkManager();
+  virtual rtc::NetworkManager* CreateNetworkManager() {
+    return new rtc::BasicNetworkManager();
   }
-  virtual talk_base::BasicPacketSocketFactory* CreateSocketFactory(
-      talk_base::Thread* thread) {
-    return new talk_base::BasicPacketSocketFactory(thread);
+  virtual rtc::BasicPacketSocketFactory* CreateSocketFactory(
+      rtc::Thread* thread) {
+    return new rtc::BasicPacketSocketFactory(thread);
   }
   virtual HttpPortAllocator* CreatePortAllocator(
-      talk_base::NetworkManager* network_manager,
+      rtc::NetworkManager* network_manager,
       const std::string& user_agent,
       const std::string& relay_token);
   virtual StunPort* CreateStunPort(
       const std::string& username, const std::string& password,
-      const PortConfiguration* config, talk_base::Network* network);
+      const PortConfiguration* config, rtc::Network* network);
   virtual RelayPort* CreateRelayPort(
       const std::string& username, const std::string& password,
-      const PortConfiguration* config, talk_base::Network* network);
+      const PortConfiguration* config, rtc::Network* network);
   virtual void InitiateProxyDetection();
-  virtual void SetProxyInfo(const talk_base::ProxyInfo& info);
-  virtual talk_base::ProxyInfo GetProxyInfo() const;
+  virtual void SetProxyInfo(const rtc::ProxyInfo& info);
+  virtual rtc::ProxyInfo GetProxyInfo() const;
 
-  talk_base::Thread* worker() {
+  rtc::Thread* worker() {
     return worker_;
   }
 
  private:
-  bool AddNic(const talk_base::IPAddress& ip,
-              const talk_base::SocketAddress& proxy_address);
+  bool AddNic(const rtc::IPAddress& ip,
+              const rtc::SocketAddress& proxy_address);
   void AllocatePorts();
   void AllocateRelayPorts();
   void CheckNetworks();
   void CreateRelayPorts(
       const std::string& username, const std::string& password,
-      const PortConfiguration* config, const talk_base::ProxyInfo& proxy_info);
+      const PortConfiguration* config, const rtc::ProxyInfo& proxy_info);
 
   // Must be called by the worker thread.
   void CleanUp();
 
-  void OnRequestDone(talk_base::AsyncHttpRequest* request);
+  void OnRequestDone(rtc::AsyncHttpRequest* request);
   void OnRelayPortComplete(Port* port);
   void OnStunPortComplete(Port* port);
   void OnRelayPortError(Port* port);
   void OnStunPortError(Port* port);
   void OnNetworksChanged();
-  void OnProxyDetect(talk_base::SignalThread* thread);
+  void OnProxyDetect(rtc::SignalThread* thread);
   void OnConfigReady(
       const std::string& username, const std::string& password,
-      const PortConfiguration* config, const talk_base::ProxyInfo& proxy);
+      const PortConfiguration* config, const rtc::ProxyInfo& proxy);
   void OnConfigWithProxyReady(const PortConfiguration*);
   void RegisterHttpStart(int port);
-  talk_base::Thread* worker_;
+  rtc::Thread* worker_;
   std::string jid_;
   std::string session_id_;
   std::string user_agent_;
   std::string relay_token_;
   std::string connection_;
-  talk_base::AutoDetectProxy* proxy_detect_;
-  talk_base::scoped_ptr<talk_base::NetworkManager> network_manager_;
-  talk_base::scoped_ptr<talk_base::BasicPacketSocketFactory> socket_factory_;
-  talk_base::scoped_ptr<HttpPortAllocator> port_allocator_;
+  rtc::AutoDetectProxy* proxy_detect_;
+  rtc::scoped_ptr<rtc::NetworkManager> network_manager_;
+  rtc::scoped_ptr<rtc::BasicPacketSocketFactory> socket_factory_;
+  rtc::scoped_ptr<HttpPortAllocator> port_allocator_;
   NicMap nics_;
   std::vector<Port*> ports_;
   std::vector<PortAllocatorSession*> sessions_;
   uint32 timeout_ms_;
-  talk_base::SocketAddress stun_address_;
-  talk_base::Thread* main_;
+  rtc::SocketAddress stun_address_;
+  rtc::Thread* main_;
   bool started_;
 };
 
diff --git a/p2p/client/connectivitychecker_unittest.cc b/p2p/client/connectivitychecker_unittest.cc
index 8d6fa9d..d1a6525 100644
--- a/p2p/client/connectivitychecker_unittest.cc
+++ b/p2p/client/connectivitychecker_unittest.cc
@@ -3,11 +3,11 @@
 
 #include <string>
 
-#include "talk/base/asynchttprequest.h"
-#include "talk/base/gunit.h"
-#include "talk/base/fakenetwork.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/asynchttprequest.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/fakenetwork.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/socketaddress.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/relayport.h"
 #include "talk/p2p/base/stunport.h"
@@ -16,13 +16,13 @@
 
 namespace cricket {
 
-static const talk_base::SocketAddress kClientAddr1("11.11.11.11", 0);
-static const talk_base::SocketAddress kClientAddr2("22.22.22.22", 0);
-static const talk_base::SocketAddress kExternalAddr("33.33.33.33", 3333);
-static const talk_base::SocketAddress kStunAddr("44.44.44.44", 4444);
-static const talk_base::SocketAddress kRelayAddr("55.55.55.55", 5555);
-static const talk_base::SocketAddress kProxyAddr("66.66.66.66", 6666);
-static const talk_base::ProxyType kProxyType = talk_base::PROXY_HTTPS;
+static const rtc::SocketAddress kClientAddr1("11.11.11.11", 0);
+static const rtc::SocketAddress kClientAddr2("22.22.22.22", 0);
+static const rtc::SocketAddress kExternalAddr("33.33.33.33", 3333);
+static const rtc::SocketAddress kStunAddr("44.44.44.44", 4444);
+static const rtc::SocketAddress kRelayAddr("55.55.55.55", 5555);
+static const rtc::SocketAddress kProxyAddr("66.66.66.66", 6666);
+static const rtc::ProxyType kProxyType = rtc::PROXY_HTTPS;
 static const char kRelayHost[] = "relay.google.com";
 static const char kRelayToken[] =
     "CAESFwoOb2phQGdvb2dsZS5jb20Q043h47MmGhBTB1rbfIXkhuarDCZe+xF6";
@@ -42,9 +42,9 @@ static const int kMaxPort = 2000;
 // Fake implementation to mock away real network usage.
 class FakeRelayPort : public RelayPort {
  public:
-  FakeRelayPort(talk_base::Thread* thread,
-                talk_base::PacketSocketFactory* factory,
-                talk_base::Network* network, const talk_base::IPAddress& ip,
+  FakeRelayPort(rtc::Thread* thread,
+                rtc::PacketSocketFactory* factory,
+                rtc::Network* network, const rtc::IPAddress& ip,
                 int min_port, int max_port,
                 const std::string& username, const std::string& password)
       : RelayPort(thread, factory, network, ip, min_port, max_port,
@@ -60,10 +60,10 @@ class FakeRelayPort : public RelayPort {
 // Fake implementation to mock away real network usage.
 class FakeStunPort : public StunPort {
  public:
-  FakeStunPort(talk_base::Thread* thread,
-               talk_base::PacketSocketFactory* factory,
-               talk_base::Network* network,
-               const talk_base::IPAddress& ip,
+  FakeStunPort(rtc::Thread* thread,
+               rtc::PacketSocketFactory* factory,
+               rtc::Network* network,
+               const rtc::IPAddress& ip,
                int min_port, int max_port,
                const std::string& username, const std::string& password,
                const ServerAddresses& server_addr)
@@ -73,7 +73,7 @@ class FakeStunPort : public StunPort {
 
   // Just set external address and signal that we are done.
   virtual void PrepareAddress() {
-    AddAddress(kExternalAddr, kExternalAddr, talk_base::SocketAddress(), "udp",
+    AddAddress(kExternalAddr, kExternalAddr, rtc::SocketAddress(), "udp",
                STUN_PORT_TYPE, ICE_TYPE_PREFERENCE_SRFLX, true);
     SignalPortComplete(this);
   }
@@ -88,7 +88,7 @@ class FakeHttpPortAllocatorSession : public TestHttpPortAllocatorSession {
       const std::string& content_name,
       int component,
       const std::string& ice_ufrag, const std::string& ice_pwd,
-      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_token,
       const std::string& agent)
@@ -108,16 +108,16 @@ class FakeHttpPortAllocatorSession : public TestHttpPortAllocatorSession {
 
   // Pass results to the real implementation.
   void FakeReceiveSessionResponse(const std::string& host, int port) {
-    talk_base::AsyncHttpRequest* response = CreateAsyncHttpResponse(port);
+    rtc::AsyncHttpRequest* response = CreateAsyncHttpResponse(port);
     TestHttpPortAllocatorSession::OnRequestDone(response);
     response->Destroy(true);
   }
 
  private:
   // Helper method for creating a response to a relay session request.
-  talk_base::AsyncHttpRequest* CreateAsyncHttpResponse(int port) {
-    talk_base::AsyncHttpRequest* request =
-        new talk_base::AsyncHttpRequest(kBrowserAgent);
+  rtc::AsyncHttpRequest* CreateAsyncHttpResponse(int port) {
+    rtc::AsyncHttpRequest* request =
+        new rtc::AsyncHttpRequest(kBrowserAgent);
     std::stringstream ss;
     ss << "username=" << kUserName << std::endl
        << "password=" << kPassword << std::endl
@@ -127,10 +127,10 @@ class FakeHttpPortAllocatorSession : public TestHttpPortAllocatorSession {
        << "relay.tcp_port=" << kRelayTcpPort << std::endl
        << "relay.ssltcp_port=" << kRelaySsltcpPort << std::endl;
     request->response().document.reset(
-        new talk_base::MemoryStream(ss.str().c_str()));
+        new rtc::MemoryStream(ss.str().c_str()));
     request->response().set_success();
     request->set_port(port);
-    request->set_secure(port == talk_base::HTTP_SECURE_PORT);
+    request->set_secure(port == rtc::HTTP_SECURE_PORT);
     return request;
   }
 };
@@ -138,7 +138,7 @@ class FakeHttpPortAllocatorSession : public TestHttpPortAllocatorSession {
 // Fake implementation for creating fake http sessions.
 class FakeHttpPortAllocator : public HttpPortAllocator {
  public:
-  FakeHttpPortAllocator(talk_base::NetworkManager* network_manager,
+  FakeHttpPortAllocator(rtc::NetworkManager* network_manager,
                         const std::string& user_agent)
       : HttpPortAllocator(network_manager, user_agent) {
   }
@@ -146,7 +146,7 @@ class FakeHttpPortAllocator : public HttpPortAllocator {
   virtual PortAllocatorSession* CreateSessionInternal(
       const std::string& content_name, int component,
       const std::string& ice_ufrag, const std::string& ice_pwd) {
-    std::vector<talk_base::SocketAddress> stun_hosts;
+    std::vector<rtc::SocketAddress> stun_hosts;
     stun_hosts.push_back(kStunAddr);
     std::vector<std::string> relay_hosts;
     relay_hosts.push_back(kRelayHost);
@@ -164,7 +164,7 @@ class FakeHttpPortAllocator : public HttpPortAllocator {
 
 class ConnectivityCheckerForTest : public ConnectivityChecker {
  public:
-  ConnectivityCheckerForTest(talk_base::Thread* worker,
+  ConnectivityCheckerForTest(rtc::Thread* worker,
                              const std::string& jid,
                              const std::string& session_id,
                              const std::string& user_agent,
@@ -179,7 +179,7 @@ class ConnectivityCheckerForTest : public ConnectivityChecker {
         proxy_initiated_(false) {
   }
 
-  talk_base::FakeNetworkManager* network_manager() const {
+  rtc::FakeNetworkManager* network_manager() const {
     return network_manager_;
   }
 
@@ -189,19 +189,19 @@ class ConnectivityCheckerForTest : public ConnectivityChecker {
 
  protected:
   // Overridden methods for faking a real network.
-  virtual talk_base::NetworkManager* CreateNetworkManager() {
-    network_manager_ = new talk_base::FakeNetworkManager();
+  virtual rtc::NetworkManager* CreateNetworkManager() {
+    network_manager_ = new rtc::FakeNetworkManager();
     return network_manager_;
   }
-  virtual talk_base::BasicPacketSocketFactory* CreateSocketFactory(
-      talk_base::Thread* thread) {
+  virtual rtc::BasicPacketSocketFactory* CreateSocketFactory(
+      rtc::Thread* thread) {
     // Create socket factory, for simplicity, let it run on the current thread.
     socket_factory_ =
-        new talk_base::BasicPacketSocketFactory(talk_base::Thread::Current());
+        new rtc::BasicPacketSocketFactory(rtc::Thread::Current());
     return socket_factory_;
   }
   virtual HttpPortAllocator* CreatePortAllocator(
-      talk_base::NetworkManager* network_manager,
+      rtc::NetworkManager* network_manager,
       const std::string& user_agent,
       const std::string& relay_token) {
     fake_port_allocator_ =
@@ -210,7 +210,7 @@ class ConnectivityCheckerForTest : public ConnectivityChecker {
   }
   virtual StunPort* CreateStunPort(
       const std::string& username, const std::string& password,
-      const PortConfiguration* config, talk_base::Network* network) {
+      const PortConfiguration* config, rtc::Network* network) {
     return new FakeStunPort(worker(), socket_factory_,
                             network, network->ip(),
                             kMinPort, kMaxPort,
@@ -219,7 +219,7 @@ class ConnectivityCheckerForTest : public ConnectivityChecker {
   }
   virtual RelayPort* CreateRelayPort(
       const std::string& username, const std::string& password,
-      const PortConfiguration* config, talk_base::Network* network) {
+      const PortConfiguration* config, rtc::Network* network) {
     return new FakeRelayPort(worker(), socket_factory_,
                              network, network->ip(),
                              kMinPort, kMaxPort,
@@ -234,22 +234,22 @@ class ConnectivityCheckerForTest : public ConnectivityChecker {
     }
   }
 
-  virtual talk_base::ProxyInfo GetProxyInfo() const {
+  virtual rtc::ProxyInfo GetProxyInfo() const {
     return proxy_info_;
   }
 
  private:
-  talk_base::BasicPacketSocketFactory* socket_factory_;
+  rtc::BasicPacketSocketFactory* socket_factory_;
   FakeHttpPortAllocator* fake_port_allocator_;
-  talk_base::FakeNetworkManager* network_manager_;
-  talk_base::ProxyInfo proxy_info_;
+  rtc::FakeNetworkManager* network_manager_;
+  rtc::ProxyInfo proxy_info_;
   bool proxy_initiated_;
 };
 
 class ConnectivityCheckerTest : public testing::Test {
  protected:
   void VerifyNic(const NicInfo& info,
-                 const talk_base::SocketAddress& local_address) {
+                 const rtc::SocketAddress& local_address) {
     // Verify that the external address has been set.
     EXPECT_EQ(kExternalAddr, info.external_address);
 
@@ -283,7 +283,7 @@ class ConnectivityCheckerTest : public testing::Test {
 // combinations of ip/proxy are created and that all protocols are
 // tested on each combination.
 TEST_F(ConnectivityCheckerTest, TestStart) {
-  ConnectivityCheckerForTest connectivity_checker(talk_base::Thread::Current(),
+  ConnectivityCheckerForTest connectivity_checker(rtc::Thread::Current(),
                                                   kJid,
                                                   kSessionId,
                                                   kBrowserAgent,
@@ -295,7 +295,7 @@ TEST_F(ConnectivityCheckerTest, TestStart) {
   connectivity_checker.network_manager()->AddInterface(kClientAddr2);
 
   connectivity_checker.Start();
-  talk_base::Thread::Current()->ProcessMessages(1000);
+  rtc::Thread::Current()->ProcessMessages(1000);
 
   NicMap nics = connectivity_checker.GetResults();
 
@@ -304,7 +304,7 @@ TEST_F(ConnectivityCheckerTest, TestStart) {
   EXPECT_EQ(4U, nics.size());
 
   // First verify interfaces without proxy.
-  talk_base::SocketAddress nilAddress;
+  rtc::SocketAddress nilAddress;
 
   // First lookup the address of the first nic combined with no proxy.
   NicMap::iterator i = nics.find(NicId(kClientAddr1.ipaddr(), nilAddress));
@@ -333,7 +333,7 @@ TEST_F(ConnectivityCheckerTest, TestStart) {
 // Tests that nothing bad happens if thera are no network interfaces
 // available to check.
 TEST_F(ConnectivityCheckerTest, TestStartNoNetwork) {
-  ConnectivityCheckerForTest connectivity_checker(talk_base::Thread::Current(),
+  ConnectivityCheckerForTest connectivity_checker(rtc::Thread::Current(),
                                                   kJid,
                                                   kSessionId,
                                                   kBrowserAgent,
@@ -341,7 +341,7 @@ TEST_F(ConnectivityCheckerTest, TestStartNoNetwork) {
                                                   kConnection);
   connectivity_checker.Initialize();
   connectivity_checker.Start();
-  talk_base::Thread::Current()->ProcessMessages(1000);
+  rtc::Thread::Current()->ProcessMessages(1000);
 
   NicMap nics = connectivity_checker.GetResults();
 
diff --git a/p2p/client/fakeportallocator.h b/p2p/client/fakeportallocator.h
index 5375e50..d54f644 100644
--- a/p2p/client/fakeportallocator.h
+++ b/p2p/client/fakeportallocator.h
@@ -6,12 +6,12 @@
 #define TALK_P2P_CLIENT_FAKEPORTALLOCATOR_H_
 
 #include <string>
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/portallocator.h"
 #include "talk/p2p/base/udpport.h"
 
-namespace talk_base {
+namespace rtc {
 class SocketFactory;
 class Thread;
 }
@@ -20,8 +20,8 @@ namespace cricket {
 
 class FakePortAllocatorSession : public PortAllocatorSession {
  public:
-  FakePortAllocatorSession(talk_base::Thread* worker_thread,
-                           talk_base::PacketSocketFactory* factory,
+  FakePortAllocatorSession(rtc::Thread* worker_thread,
+                           rtc::PacketSocketFactory* factory,
                            const std::string& content_name,
                            int component,
                            const std::string& ice_ufrag,
@@ -31,10 +31,10 @@ class FakePortAllocatorSession : public PortAllocatorSession {
         worker_thread_(worker_thread),
         factory_(factory),
         network_("network", "unittest",
-                 talk_base::IPAddress(INADDR_LOOPBACK), 8),
+                 rtc::IPAddress(INADDR_LOOPBACK), 8),
         port_(), running_(false),
         port_config_count_(0) {
-    network_.AddIP(talk_base::IPAddress(INADDR_LOOPBACK));
+    network_.AddIP(rtc::IPAddress(INADDR_LOOPBACK));
   }
 
   virtual void StartGettingPorts() {
@@ -67,21 +67,21 @@ class FakePortAllocatorSession : public PortAllocatorSession {
   }
 
  private:
-  talk_base::Thread* worker_thread_;
-  talk_base::PacketSocketFactory* factory_;
-  talk_base::Network network_;
-  talk_base::scoped_ptr<cricket::Port> port_;
+  rtc::Thread* worker_thread_;
+  rtc::PacketSocketFactory* factory_;
+  rtc::Network network_;
+  rtc::scoped_ptr<cricket::Port> port_;
   bool running_;
   int port_config_count_;
 };
 
 class FakePortAllocator : public cricket::PortAllocator {
  public:
-  FakePortAllocator(talk_base::Thread* worker_thread,
-                    talk_base::PacketSocketFactory* factory)
+  FakePortAllocator(rtc::Thread* worker_thread,
+                    rtc::PacketSocketFactory* factory)
       : worker_thread_(worker_thread), factory_(factory) {
     if (factory_ == NULL) {
-      owned_factory_.reset(new talk_base::BasicPacketSocketFactory(
+      owned_factory_.reset(new rtc::BasicPacketSocketFactory(
           worker_thread_));
       factory_ = owned_factory_.get();
     }
@@ -97,9 +97,9 @@ class FakePortAllocator : public cricket::PortAllocator {
   }
 
  private:
-  talk_base::Thread* worker_thread_;
-  talk_base::PacketSocketFactory* factory_;
-  talk_base::scoped_ptr<talk_base::BasicPacketSocketFactory> owned_factory_;
+  rtc::Thread* worker_thread_;
+  rtc::PacketSocketFactory* factory_;
+  rtc::scoped_ptr<rtc::BasicPacketSocketFactory> owned_factory_;
 };
 
 }  // namespace cricket
diff --git a/p2p/client/httpportallocator.cc b/p2p/client/httpportallocator.cc
index 1529770..31c9b51 100644
--- a/p2p/client/httpportallocator.cc
+++ b/p2p/client/httpportallocator.cc
@@ -30,14 +30,14 @@
 #include <algorithm>
 #include <map>
 
-#include "talk/base/asynchttprequest.h"
-#include "talk/base/basicdefs.h"
-#include "talk/base/common.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/nethelpers.h"
-#include "talk/base/signalthread.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/asynchttprequest.h"
+#include "webrtc/base/basicdefs.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/nethelpers.h"
+#include "webrtc/base/signalthread.h"
+#include "webrtc/base/stringencode.h"
 
 namespace {
 
@@ -95,22 +95,22 @@ const int HttpPortAllocatorBase::kNumRetries = 5;
 const char HttpPortAllocatorBase::kCreateSessionURL[] = "/create_session";
 
 HttpPortAllocatorBase::HttpPortAllocatorBase(
-    talk_base::NetworkManager* network_manager,
-    talk_base::PacketSocketFactory* socket_factory,
+    rtc::NetworkManager* network_manager,
+    rtc::PacketSocketFactory* socket_factory,
     const std::string &user_agent)
     : BasicPortAllocator(network_manager, socket_factory), agent_(user_agent) {
   relay_hosts_.push_back("relay.google.com");
   stun_hosts_.push_back(
-      talk_base::SocketAddress("stun.l.google.com", 19302));
+      rtc::SocketAddress("stun.l.google.com", 19302));
 }
 
 HttpPortAllocatorBase::HttpPortAllocatorBase(
-    talk_base::NetworkManager* network_manager,
+    rtc::NetworkManager* network_manager,
     const std::string &user_agent)
     : BasicPortAllocator(network_manager), agent_(user_agent) {
   relay_hosts_.push_back("relay.google.com");
   stun_hosts_.push_back(
-      talk_base::SocketAddress("stun.l.google.com", 19302));
+      rtc::SocketAddress("stun.l.google.com", 19302));
 }
 
 HttpPortAllocatorBase::~HttpPortAllocatorBase() {
@@ -124,7 +124,7 @@ HttpPortAllocatorSessionBase::HttpPortAllocatorSessionBase(
     int component,
     const std::string& ice_ufrag,
     const std::string& ice_pwd,
-    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_token,
     const std::string& user_agent)
@@ -143,7 +143,7 @@ void HttpPortAllocatorSessionBase::GetPortConfigurations() {
   // configs will have unresolved stun ips and will be discarded by the
   // AllocationSequence.
   ServerAddresses hosts;
-  for (std::vector<talk_base::SocketAddress>::iterator it = stun_hosts_.begin();
+  for (std::vector<rtc::SocketAddress>::iterator it = stun_hosts_.begin();
       it != stun_hosts_.end(); ++it) {
     hosts.insert(*it);
   }
@@ -180,7 +180,7 @@ void HttpPortAllocatorSessionBase::TryCreateRelaySession() {
     LOG(LS_WARNING) << "No relay auth token found.";
   }
 
-  SendSessionRequest(host, talk_base::HTTP_SECURE_PORT);
+  SendSessionRequest(host, rtc::HTTP_SECURE_PORT);
 }
 
 std::string HttpPortAllocatorSessionBase::GetSessionRequestUrl() {
@@ -188,8 +188,8 @@ std::string HttpPortAllocatorSessionBase::GetSessionRequestUrl() {
   if (allocator()->flags() & PORTALLOCATOR_ENABLE_SHARED_UFRAG) {
     ASSERT(!username().empty());
     ASSERT(!password().empty());
-    url = url + "?username=" + talk_base::s_url_encode(username()) +
-        "&password=" + talk_base::s_url_encode(password());
+    url = url + "?username=" + rtc::s_url_encode(username()) +
+        "&password=" + rtc::s_url_encode(password());
   }
   return url;
 }
@@ -213,7 +213,7 @@ void HttpPortAllocatorSessionBase::ReceiveSessionResponse(
   std::string relay_ssltcp_port = map["relay.ssltcp_port"];
 
   ServerAddresses hosts;
-  for (std::vector<talk_base::SocketAddress>::iterator it = stun_hosts_.begin();
+  for (std::vector<rtc::SocketAddress>::iterator it = stun_hosts_.begin();
       it != stun_hosts_.end(); ++it) {
     hosts.insert(*it);
   }
@@ -224,15 +224,15 @@ void HttpPortAllocatorSessionBase::ReceiveSessionResponse(
 
   RelayServerConfig relay_config(RELAY_GTURN);
   if (!relay_udp_port.empty()) {
-    talk_base::SocketAddress address(relay_ip, atoi(relay_udp_port.c_str()));
+    rtc::SocketAddress address(relay_ip, atoi(relay_udp_port.c_str()));
     relay_config.ports.push_back(ProtocolAddress(address, PROTO_UDP));
   }
   if (!relay_tcp_port.empty()) {
-    talk_base::SocketAddress address(relay_ip, atoi(relay_tcp_port.c_str()));
+    rtc::SocketAddress address(relay_ip, atoi(relay_tcp_port.c_str()));
     relay_config.ports.push_back(ProtocolAddress(address, PROTO_TCP));
   }
   if (!relay_ssltcp_port.empty()) {
-    talk_base::SocketAddress address(relay_ip, atoi(relay_ssltcp_port.c_str()));
+    rtc::SocketAddress address(relay_ip, atoi(relay_ssltcp_port.c_str()));
     relay_config.ports.push_back(ProtocolAddress(address, PROTO_SSLTCP));
   }
   config->AddRelay(relay_config);
@@ -242,14 +242,14 @@ void HttpPortAllocatorSessionBase::ReceiveSessionResponse(
 // HttpPortAllocator
 
 HttpPortAllocator::HttpPortAllocator(
-    talk_base::NetworkManager* network_manager,
-    talk_base::PacketSocketFactory* socket_factory,
+    rtc::NetworkManager* network_manager,
+    rtc::PacketSocketFactory* socket_factory,
     const std::string &user_agent)
     : HttpPortAllocatorBase(network_manager, socket_factory, user_agent) {
 }
 
 HttpPortAllocator::HttpPortAllocator(
-    talk_base::NetworkManager* network_manager,
+    rtc::NetworkManager* network_manager,
     const std::string &user_agent)
     : HttpPortAllocatorBase(network_manager, user_agent) {
 }
@@ -273,7 +273,7 @@ HttpPortAllocatorSession::HttpPortAllocatorSession(
     int component,
     const std::string& ice_ufrag,
     const std::string& ice_pwd,
-    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 std::string& agent)
@@ -283,7 +283,7 @@ HttpPortAllocatorSession::HttpPortAllocatorSession(
 }
 
 HttpPortAllocatorSession::~HttpPortAllocatorSession() {
-  for (std::list<talk_base::AsyncHttpRequest*>::iterator it = requests_.begin();
+  for (std::list<rtc::AsyncHttpRequest*>::iterator it = requests_.begin();
        it != requests_.end(); ++it) {
     (*it)->Destroy(true);
   }
@@ -292,15 +292,15 @@ HttpPortAllocatorSession::~HttpPortAllocatorSession() {
 void HttpPortAllocatorSession::SendSessionRequest(const std::string& host,
                                                   int port) {
   // Initiate an HTTP request to create a session through the chosen host.
-  talk_base::AsyncHttpRequest* request =
-      new talk_base::AsyncHttpRequest(user_agent());
+  rtc::AsyncHttpRequest* request =
+      new rtc::AsyncHttpRequest(user_agent());
   request->SignalWorkDone.connect(this,
       &HttpPortAllocatorSession::OnRequestDone);
 
-  request->set_secure(port == talk_base::HTTP_SECURE_PORT);
+  request->set_secure(port == rtc::HTTP_SECURE_PORT);
   request->set_proxy(allocator()->proxy());
-  request->response().document.reset(new talk_base::MemoryStream);
-  request->request().verb = talk_base::HV_GET;
+  request->response().document.reset(new rtc::MemoryStream);
+  request->request().verb = rtc::HV_GET;
   request->request().path = GetSessionRequestUrl();
   request->request().addHeader("X-Talk-Google-Relay-Auth", relay_token(), true);
   request->request().addHeader("X-Stream-Type", "video_rtp", true);
@@ -312,12 +312,12 @@ void HttpPortAllocatorSession::SendSessionRequest(const std::string& host,
   requests_.push_back(request);
 }
 
-void HttpPortAllocatorSession::OnRequestDone(talk_base::SignalThread* data) {
-  talk_base::AsyncHttpRequest* request =
-      static_cast<talk_base::AsyncHttpRequest*>(data);
+void HttpPortAllocatorSession::OnRequestDone(rtc::SignalThread* data) {
+  rtc::AsyncHttpRequest* request =
+      static_cast<rtc::AsyncHttpRequest*>(data);
 
   // Remove the request from the list of active requests.
-  std::list<talk_base::AsyncHttpRequest*>::iterator it =
+  std::list<rtc::AsyncHttpRequest*>::iterator it =
       std::find(requests_.begin(), requests_.end(), request);
   if (it != requests_.end()) {
     requests_.erase(it);
@@ -331,8 +331,8 @@ void HttpPortAllocatorSession::OnRequestDone(talk_base::SignalThread* data) {
   }
   LOG(LS_INFO) << "HTTPPortAllocator: request succeeded";
 
-  talk_base::MemoryStream* stream =
-      static_cast<talk_base::MemoryStream*>(request->response().document.get());
+  rtc::MemoryStream* stream =
+      static_cast<rtc::MemoryStream*>(request->response().document.get());
   stream->Rewind();
   size_t length;
   stream->GetSize(&length);
diff --git a/p2p/client/httpportallocator.h b/p2p/client/httpportallocator.h
index a0ef3b7..7ace943 100644
--- a/p2p/client/httpportallocator.h
+++ b/p2p/client/httpportallocator.h
@@ -36,7 +36,7 @@
 
 class HttpPortAllocatorTest_TestSessionRequestUrl_Test;
 
-namespace talk_base {
+namespace rtc {
 class AsyncHttpRequest;
 class SignalThread;
 }
@@ -51,10 +51,10 @@ class HttpPortAllocatorBase : public BasicPortAllocator {
   // Records the URL that we will GET in order to create a session.
   static const char kCreateSessionURL[];
 
-  HttpPortAllocatorBase(talk_base::NetworkManager* network_manager,
+  HttpPortAllocatorBase(rtc::NetworkManager* network_manager,
                         const std::string& user_agent);
-  HttpPortAllocatorBase(talk_base::NetworkManager* network_manager,
-                        talk_base::PacketSocketFactory* socket_factory,
+  HttpPortAllocatorBase(rtc::NetworkManager* network_manager,
+                        rtc::PacketSocketFactory* socket_factory,
                         const std::string& user_agent);
   virtual ~HttpPortAllocatorBase();
 
@@ -66,7 +66,7 @@ class HttpPortAllocatorBase : public BasicPortAllocator {
       const std::string& ice_ufrag,
       const std::string& ice_pwd) = 0;
 
-  void SetStunHosts(const std::vector<talk_base::SocketAddress>& hosts) {
+  void SetStunHosts(const std::vector<rtc::SocketAddress>& hosts) {
     if (!hosts.empty()) {
       stun_hosts_ = hosts;
     }
@@ -78,7 +78,7 @@ class HttpPortAllocatorBase : public BasicPortAllocator {
   }
   void SetRelayToken(const std::string& relay) { relay_token_ = relay; }
 
-  const std::vector<talk_base::SocketAddress>& stun_hosts() const {
+  const std::vector<rtc::SocketAddress>& stun_hosts() const {
     return stun_hosts_;
   }
 
@@ -95,7 +95,7 @@ class HttpPortAllocatorBase : public BasicPortAllocator {
   }
 
  private:
-  std::vector<talk_base::SocketAddress> stun_hosts_;
+  std::vector<rtc::SocketAddress> stun_hosts_;
   std::vector<std::string> relay_hosts_;
   std::string relay_token_;
   std::string agent_;
@@ -111,7 +111,7 @@ class HttpPortAllocatorSessionBase : public BasicPortAllocatorSession {
       int component,
       const std::string& ice_ufrag,
       const std::string& ice_pwd,
-      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 std::string& agent);
@@ -141,7 +141,7 @@ class HttpPortAllocatorSessionBase : public BasicPortAllocatorSession {
 
  private:
   std::vector<std::string> relay_hosts_;
-  std::vector<talk_base::SocketAddress> stun_hosts_;
+  std::vector<rtc::SocketAddress> stun_hosts_;
   std::string relay_token_;
   std::string agent_;
   int attempts_;
@@ -149,10 +149,10 @@ class HttpPortAllocatorSessionBase : public BasicPortAllocatorSession {
 
 class HttpPortAllocator : public HttpPortAllocatorBase {
  public:
-  HttpPortAllocator(talk_base::NetworkManager* network_manager,
+  HttpPortAllocator(rtc::NetworkManager* network_manager,
                     const std::string& user_agent);
-  HttpPortAllocator(talk_base::NetworkManager* network_manager,
-                    talk_base::PacketSocketFactory* socket_factory,
+  HttpPortAllocator(rtc::NetworkManager* network_manager,
+                    rtc::PacketSocketFactory* socket_factory,
                     const std::string& user_agent);
   virtual ~HttpPortAllocator();
   virtual PortAllocatorSession* CreateSessionInternal(
@@ -169,7 +169,7 @@ class HttpPortAllocatorSession : public HttpPortAllocatorSessionBase {
       int component,
       const std::string& ice_ufrag,
       const std::string& ice_pwd,
-      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 std::string& agent);
@@ -179,10 +179,10 @@ class HttpPortAllocatorSession : public HttpPortAllocatorSessionBase {
 
  protected:
   // Protected for diagnostics.
-  virtual void OnRequestDone(talk_base::SignalThread* request);
+  virtual void OnRequestDone(rtc::SignalThread* request);
 
  private:
-  std::list<talk_base::AsyncHttpRequest*> requests_;
+  std::list<rtc::AsyncHttpRequest*> requests_;
 };
 
 }  // namespace cricket
diff --git a/p2p/client/portallocator_unittest.cc b/p2p/client/portallocator_unittest.cc
index 760d168..bddf0c3 100644
--- a/p2p/client/portallocator_unittest.cc
+++ b/p2p/client/portallocator_unittest.cc
@@ -25,19 +25,19 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/fakenetwork.h"
-#include "talk/base/firewallsocketserver.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/natserver.h"
-#include "talk/base/natsocketfactory.h"
-#include "talk/base/network.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/thread.h"
-#include "talk/base/virtualsocketserver.h"
+#include "webrtc/base/fakenetwork.h"
+#include "webrtc/base/firewallsocketserver.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/natserver.h"
+#include "webrtc/base/natsocketfactory.h"
+#include "webrtc/base/network.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/virtualsocketserver.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/p2ptransportchannel.h"
@@ -49,14 +49,14 @@
 #include "talk/p2p/client/httpportallocator.h"
 
 using cricket::ServerAddresses;
-using talk_base::SocketAddress;
-using talk_base::Thread;
+using rtc::SocketAddress;
+using rtc::Thread;
 
 static const SocketAddress kClientAddr("11.11.11.11", 0);
 static const SocketAddress kClientIPv6Addr(
     "2401:fa00:4:1000:be30:5bff:fee5:c3", 0);
 static const SocketAddress kClientAddr2("22.22.22.22", 0);
-static const SocketAddress kNatAddr("77.77.77.77", talk_base::NAT_SERVER_PORT);
+static const SocketAddress kNatAddr("77.77.77.77", rtc::NAT_SERVER_PORT);
 static const SocketAddress kRemoteClientAddr("22.22.22.22", 0);
 static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
 static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000);
@@ -97,17 +97,17 @@ std::ostream& operator<<(std::ostream& os, const cricket::Candidate& c) {
 class PortAllocatorTest : public testing::Test, public sigslot::has_slots<> {
  public:
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   PortAllocatorTest()
-      : pss_(new talk_base::PhysicalSocketServer),
-        vss_(new talk_base::VirtualSocketServer(pss_.get())),
-        fss_(new talk_base::FirewallSocketServer(vss_.get())),
+      : pss_(new rtc::PhysicalSocketServer),
+        vss_(new rtc::VirtualSocketServer(pss_.get())),
+        fss_(new rtc::FirewallSocketServer(vss_.get())),
         ss_scope_(fss_.get()),
         nat_factory_(vss_.get(), kNatAddr),
         nat_socket_factory_(&nat_factory_),
@@ -132,9 +132,9 @@ class PortAllocatorTest : public testing::Test, public sigslot::has_slots<> {
   bool SetPortRange(int min_port, int max_port) {
     return allocator_->SetPortRange(min_port, max_port);
   }
-  talk_base::NATServer* CreateNatServer(const SocketAddress& addr,
-                                        talk_base::NATType type) {
-    return new talk_base::NATServer(type, vss_.get(), addr, vss_.get(), addr);
+  rtc::NATServer* CreateNatServer(const SocketAddress& addr,
+                                        rtc::NATType type) {
+    return new rtc::NATServer(type, vss_.get(), addr, vss_.get(), addr);
   }
 
   bool CreateSession(int component) {
@@ -185,7 +185,7 @@ class PortAllocatorTest : public testing::Test, public sigslot::has_slots<> {
         ((addr.port() == 0 && (c.address().port() != 0)) ||
         (c.address().port() == addr.port())));
   }
-  static bool CheckPort(const talk_base::SocketAddress& addr,
+  static bool CheckPort(const rtc::SocketAddress& addr,
                         int min_port, int max_port) {
     return (addr.port() >= min_port && addr.port() <= max_port);
   }
@@ -207,10 +207,10 @@ class PortAllocatorTest : public testing::Test, public sigslot::has_slots<> {
       int send_buffer_size;
       if (expected == -1) {
         EXPECT_EQ(SOCKET_ERROR,
-                  (*it)->GetOption(talk_base::Socket::OPT_SNDBUF,
+                  (*it)->GetOption(rtc::Socket::OPT_SNDBUF,
                                    &send_buffer_size));
       } else {
-        EXPECT_EQ(0, (*it)->GetOption(talk_base::Socket::OPT_SNDBUF,
+        EXPECT_EQ(0, (*it)->GetOption(rtc::Socket::OPT_SNDBUF,
                                       &send_buffer_size));
         ASSERT_EQ(expected, send_buffer_size);
       }
@@ -249,18 +249,18 @@ class PortAllocatorTest : public testing::Test, public sigslot::has_slots<> {
     return false;
   }
 
-  talk_base::scoped_ptr<talk_base::PhysicalSocketServer> pss_;
-  talk_base::scoped_ptr<talk_base::VirtualSocketServer> vss_;
-  talk_base::scoped_ptr<talk_base::FirewallSocketServer> fss_;
-  talk_base::SocketServerScope ss_scope_;
-  talk_base::NATSocketFactory nat_factory_;
-  talk_base::BasicPacketSocketFactory nat_socket_factory_;
+  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
+  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
+  rtc::scoped_ptr<rtc::FirewallSocketServer> fss_;
+  rtc::SocketServerScope ss_scope_;
+  rtc::NATSocketFactory nat_factory_;
+  rtc::BasicPacketSocketFactory nat_socket_factory_;
   cricket::TestStunServer stun_server_;
   cricket::TestRelayServer relay_server_;
   cricket::TestTurnServer turn_server_;
-  talk_base::FakeNetworkManager network_manager_;
-  talk_base::scoped_ptr<cricket::BasicPortAllocator> allocator_;
-  talk_base::scoped_ptr<cricket::PortAllocatorSession> session_;
+  rtc::FakeNetworkManager network_manager_;
+  rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
+  rtc::scoped_ptr<cricket::PortAllocatorSession> session_;
   std::vector<cricket::PortInterface*> ports_;
   std::vector<cricket::Candidate> candidates_;
   bool candidate_allocation_done_;
@@ -292,7 +292,7 @@ TEST_F(PortAllocatorTest, TestNoNetworkInterface) {
   // called OnAllocate multiple times. In old behavior it's called every 250ms.
   // When there are no network interfaces, each execution of OnAllocate will
   // result in SignalCandidatesAllocationDone signal.
-  talk_base::Thread::Current()->ProcessMessages(1000);
+  rtc::Thread::Current()->ProcessMessages(1000);
   EXPECT_TRUE(candidate_allocation_done_);
   EXPECT_EQ(0U, candidates_.size());
 }
@@ -408,7 +408,7 @@ TEST_F(PortAllocatorTest, TestGetAllPortsPortRange) {
 TEST_F(PortAllocatorTest, TestGetAllPortsNoAdapters) {
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
-  talk_base::Thread::Current()->ProcessMessages(100);
+  rtc::Thread::Current()->ProcessMessages(100);
   // Without network adapter, we should not get any candidate.
   EXPECT_EQ(0U, candidates_.size());
   EXPECT_TRUE(candidate_allocation_done_);
@@ -424,7 +424,7 @@ TEST_F(PortAllocatorTest, TestDisableAllPorts) {
                       cricket::PORTALLOCATOR_DISABLE_RELAY |
                       cricket::PORTALLOCATOR_DISABLE_TCP);
   session_->StartGettingPorts();
-  talk_base::Thread::Current()->ProcessMessages(100);
+  rtc::Thread::Current()->ProcessMessages(100);
   EXPECT_EQ(0U, candidates_.size());
   EXPECT_TRUE(candidate_allocation_done_);
 }
@@ -491,7 +491,7 @@ TEST_F(PortAllocatorTest, TestGetAllPortsNoSockets) {
 
 // Testing STUN timeout.
 TEST_F(PortAllocatorTest, TestGetAllPortsNoUdpAllowed) {
-  fss_->AddRule(false, talk_base::FP_UDP, talk_base::FD_ANY, kClientAddr);
+  fss_->AddRule(false, rtc::FP_UDP, rtc::FD_ANY, kClientAddr);
   AddInterface(kClientAddr);
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
@@ -550,9 +550,9 @@ TEST_F(PortAllocatorTest, TestBasicMuxFeatures) {
   AddInterface(kClientAddr);
   allocator().set_flags(cricket::PORTALLOCATOR_ENABLE_BUNDLE);
   // Session ID - session1.
-  talk_base::scoped_ptr<cricket::PortAllocatorSession> session1(
+  rtc::scoped_ptr<cricket::PortAllocatorSession> session1(
       CreateSession("session1", cricket::ICE_CANDIDATE_COMPONENT_RTP));
-  talk_base::scoped_ptr<cricket::PortAllocatorSession> session2(
+  rtc::scoped_ptr<cricket::PortAllocatorSession> session2(
       CreateSession("session1", cricket::ICE_CANDIDATE_COMPONENT_RTCP));
   session1->StartGettingPorts();
   session2->StartGettingPorts();
@@ -560,7 +560,7 @@ TEST_F(PortAllocatorTest, TestBasicMuxFeatures) {
   ASSERT_EQ_WAIT(14U, candidates_.size(), kDefaultAllocationTimeout);
   EXPECT_EQ(8U, ports_.size());
 
-  talk_base::scoped_ptr<cricket::PortAllocatorSession> session3(
+  rtc::scoped_ptr<cricket::PortAllocatorSession> session3(
       CreateSession("session1", cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session3->StartGettingPorts();
   // Already allocated candidates and ports will be sent to the newly
@@ -577,7 +577,7 @@ TEST_F(PortAllocatorTest, TestBundleIceRestart) {
   AddInterface(kClientAddr);
   allocator().set_flags(cricket::PORTALLOCATOR_ENABLE_BUNDLE);
   // Session ID - session1.
-  talk_base::scoped_ptr<cricket::PortAllocatorSession> session1(
+  rtc::scoped_ptr<cricket::PortAllocatorSession> session1(
       CreateSession("session1", kContentName,
                     cricket::ICE_CANDIDATE_COMPONENT_RTP,
                     kIceUfrag0, kIcePwd0));
@@ -586,7 +586,7 @@ TEST_F(PortAllocatorTest, TestBundleIceRestart) {
   EXPECT_EQ(4U, ports_.size());
 
   // Allocate a different session with sid |session1| and different ice_ufrag.
-  talk_base::scoped_ptr<cricket::PortAllocatorSession> session2(
+  rtc::scoped_ptr<cricket::PortAllocatorSession> session2(
       CreateSession("session1", kContentName,
                     cricket::ICE_CANDIDATE_COMPONENT_RTP,
                     "TestIceUfrag", kIcePwd0));
@@ -601,7 +601,7 @@ TEST_F(PortAllocatorTest, TestBundleIceRestart) {
 
   // Allocating a different session with sid |session1| and
   // different ice_pwd.
-  talk_base::scoped_ptr<cricket::PortAllocatorSession> session3(
+  rtc::scoped_ptr<cricket::PortAllocatorSession> session3(
       CreateSession("session1", kContentName,
                     cricket::ICE_CANDIDATE_COMPONENT_RTP,
                     kIceUfrag0, "TestIcePwd"));
@@ -614,7 +614,7 @@ TEST_F(PortAllocatorTest, TestBundleIceRestart) {
   EXPECT_NE(candidates_[8].address(), candidates_[15].address());
 
   // Allocating a session with by changing both ice_ufrag and ice_pwd.
-  talk_base::scoped_ptr<cricket::PortAllocatorSession> session4(
+  rtc::scoped_ptr<cricket::PortAllocatorSession> session4(
       CreateSession("session1", kContentName,
                     cricket::ICE_CANDIDATE_COMPONENT_RTP,
                     "TestIceUfrag", "TestIcePwd"));
@@ -698,8 +698,8 @@ TEST_F(PortAllocatorTest, TestSharedSocketWithoutNat) {
 // local candidates as client behind a nat.
 TEST_F(PortAllocatorTest, TestSharedSocketWithNat) {
   AddInterface(kClientAddr);
-  talk_base::scoped_ptr<talk_base::NATServer> nat_server(
-      CreateNatServer(kNatAddr, talk_base::NAT_OPEN_CONE));
+  rtc::scoped_ptr<rtc::NATServer> nat_server(
+      CreateNatServer(kNatAddr, rtc::NAT_OPEN_CONE));
   ServerAddresses stun_servers;
   stun_servers.insert(kStunAddr);
   allocator_.reset(new cricket::BasicPortAllocator(
@@ -716,7 +716,7 @@ TEST_F(PortAllocatorTest, TestSharedSocketWithNat) {
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr);
   EXPECT_PRED5(CheckCandidate, candidates_[1],
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp",
-      talk_base::SocketAddress(kNatAddr.ipaddr(), 0));
+      rtc::SocketAddress(kNatAddr.ipaddr(), 0));
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
   EXPECT_EQ(3U, candidates_.size());
 }
@@ -750,10 +750,10 @@ TEST_F(PortAllocatorTest, TestSharedSocketWithoutNatUsingTurn) {
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr);
   EXPECT_PRED5(CheckCandidate, candidates_[1],
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp",
-      talk_base::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+      rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
   EXPECT_PRED5(CheckCandidate, candidates_[2],
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp",
-      talk_base::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+      rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
   EXPECT_EQ(3U, candidates_.size());
 }
@@ -761,7 +761,7 @@ TEST_F(PortAllocatorTest, TestSharedSocketWithoutNatUsingTurn) {
 // Testing DNS resolve for the TURN server, this will test AllocationSequence
 // handling the unresolved address signal from TurnPort.
 TEST_F(PortAllocatorTest, TestSharedSocketWithServerAddressResolve) {
-  turn_server_.AddInternalSocket(talk_base::SocketAddress("127.0.0.1", 3478),
+  turn_server_.AddInternalSocket(rtc::SocketAddress("127.0.0.1", 3478),
                                  cricket::PROTO_UDP);
   AddInterface(kClientAddr);
   allocator_.reset(new cricket::BasicPortAllocator(&network_manager_));
@@ -769,7 +769,7 @@ TEST_F(PortAllocatorTest, TestSharedSocketWithServerAddressResolve) {
   cricket::RelayCredentials credentials(kTurnUsername, kTurnPassword);
   relay_server.credentials = credentials;
   relay_server.ports.push_back(cricket::ProtocolAddress(
-      talk_base::SocketAddress("localhost", 3478),
+      rtc::SocketAddress("localhost", 3478),
       cricket::PROTO_UDP, false));
   allocator_->AddRelay(relay_server);
 
@@ -790,8 +790,8 @@ TEST_F(PortAllocatorTest, TestSharedSocketWithServerAddressResolve) {
 // stun and turn candidates.
 TEST_F(PortAllocatorTest, TestSharedSocketWithNatUsingTurn) {
   AddInterface(kClientAddr);
-  talk_base::scoped_ptr<talk_base::NATServer> nat_server(
-      CreateNatServer(kNatAddr, talk_base::NAT_OPEN_CONE));
+  rtc::scoped_ptr<rtc::NATServer> nat_server(
+      CreateNatServer(kNatAddr, rtc::NAT_OPEN_CONE));
   ServerAddresses stun_servers;
   stun_servers.insert(kStunAddr);
   allocator_.reset(new cricket::BasicPortAllocator(
@@ -818,10 +818,10 @@ TEST_F(PortAllocatorTest, TestSharedSocketWithNatUsingTurn) {
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "local", "udp", kClientAddr);
   EXPECT_PRED5(CheckCandidate, candidates_[1],
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "stun", "udp",
-      talk_base::SocketAddress(kNatAddr.ipaddr(), 0));
+      rtc::SocketAddress(kNatAddr.ipaddr(), 0));
   EXPECT_PRED5(CheckCandidate, candidates_[2],
       cricket::ICE_CANDIDATE_COMPONENT_RTP, "relay", "udp",
-      talk_base::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
+      rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0));
   EXPECT_TRUE_WAIT(candidate_allocation_done_, kDefaultAllocationTimeout);
   EXPECT_EQ(3U, candidates_.size());
   // Local port will be created first and then TURN port.
@@ -838,7 +838,7 @@ TEST_F(PortAllocatorTest, TestSharedSocketNoUdpAllowed) {
                         cricket::PORTALLOCATOR_DISABLE_TCP |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG |
                         cricket::PORTALLOCATOR_ENABLE_SHARED_SOCKET);
-  fss_->AddRule(false, talk_base::FP_UDP, talk_base::FD_ANY, kClientAddr);
+  fss_->AddRule(false, rtc::FP_UDP, rtc::FD_ANY, kClientAddr);
   AddInterface(kClientAddr);
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
@@ -884,13 +884,13 @@ TEST_F(PortAllocatorTest, TestEnableIPv6Addresses) {
 // Test that the httpportallocator correctly maintains its lists of stun and
 // relay servers, by never allowing an empty list.
 TEST(HttpPortAllocatorTest, TestHttpPortAllocatorHostLists) {
-  talk_base::FakeNetworkManager network_manager;
+  rtc::FakeNetworkManager network_manager;
   cricket::HttpPortAllocator alloc(&network_manager, "unit test agent");
   EXPECT_EQ(1U, alloc.relay_hosts().size());
   EXPECT_EQ(1U, alloc.stun_hosts().size());
 
   std::vector<std::string> relay_servers;
-  std::vector<talk_base::SocketAddress> stun_servers;
+  std::vector<rtc::SocketAddress> stun_servers;
 
   alloc.SetRelayHosts(relay_servers);
   alloc.SetStunHosts(stun_servers);
@@ -900,9 +900,9 @@ TEST(HttpPortAllocatorTest, TestHttpPortAllocatorHostLists) {
   relay_servers.push_back("1.unittest.corp.google.com");
   relay_servers.push_back("2.unittest.corp.google.com");
   stun_servers.push_back(
-      talk_base::SocketAddress("1.unittest.corp.google.com", 0));
+      rtc::SocketAddress("1.unittest.corp.google.com", 0));
   stun_servers.push_back(
-      talk_base::SocketAddress("2.unittest.corp.google.com", 0));
+      rtc::SocketAddress("2.unittest.corp.google.com", 0));
 
   alloc.SetRelayHosts(relay_servers);
   alloc.SetStunHosts(stun_servers);
@@ -912,12 +912,12 @@ TEST(HttpPortAllocatorTest, TestHttpPortAllocatorHostLists) {
 
 // Test that the HttpPortAllocator uses correct URL to create sessions.
 TEST(HttpPortAllocatorTest, TestSessionRequestUrl) {
-  talk_base::FakeNetworkManager network_manager;
+  rtc::FakeNetworkManager network_manager;
   cricket::HttpPortAllocator alloc(&network_manager, "unit test agent");
 
   // Disable PORTALLOCATOR_ENABLE_SHARED_UFRAG.
   alloc.set_flags(alloc.flags() & ~cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG);
-  talk_base::scoped_ptr<cricket::HttpPortAllocatorSessionBase> session(
+  rtc::scoped_ptr<cricket::HttpPortAllocatorSessionBase> session(
       static_cast<cricket::HttpPortAllocatorSession*>(
           alloc.CreateSessionInternal(
               "test content", 0, kIceUfrag0, kIcePwd0)));
@@ -932,19 +932,19 @@ TEST(HttpPortAllocatorTest, TestSessionRequestUrl) {
   url = session->GetSessionRequestUrl();
   LOG(LS_INFO) << "url: " << url;
   std::vector<std::string> parts;
-  talk_base::split(url, '?', &parts);
+  rtc::split(url, '?', &parts);
   ASSERT_EQ(2U, parts.size());
 
   std::vector<std::string> args_parts;
-  talk_base::split(parts[1], '&', &args_parts);
+  rtc::split(parts[1], '&', &args_parts);
 
   std::map<std::string, std::string> args;
   for (std::vector<std::string>::iterator it = args_parts.begin();
        it != args_parts.end(); ++it) {
     std::vector<std::string> parts;
-    talk_base::split(*it, '=', &parts);
+    rtc::split(*it, '=', &parts);
     ASSERT_EQ(2U, parts.size());
-    args[talk_base::s_url_decode(parts[0])] = talk_base::s_url_decode(parts[1]);
+    args[rtc::s_url_decode(parts[0])] = rtc::s_url_decode(parts[1]);
   }
 
   EXPECT_EQ(kIceUfrag0, args["username"]);
diff --git a/p2p/client/sessionsendtask.h b/p2p/client/sessionsendtask.h
index 6c7508a..208386e 100644
--- a/p2p/client/sessionsendtask.h
+++ b/p2p/client/sessionsendtask.h
@@ -28,7 +28,7 @@
 #ifndef TALK_P2P_CLIENT_SESSIONSENDTASK_H_
 #define TALK_P2P_CLIENT_SESSIONSENDTASK_H_
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/xmppclient.h"
 #include "talk/xmpp/xmppengine.h"
@@ -137,7 +137,7 @@ class SessionSendTask : public buzz::XmppTask {
 
  private:
   SessionManager *session_manager_;
-  talk_base::scoped_ptr<buzz::XmlElement> stanza_;
+  rtc::scoped_ptr<buzz::XmlElement> stanza_;
 };
 
 }
diff --git a/p2p/client/socketmonitor.cc b/p2p/client/socketmonitor.cc
index e0c75d4..1924c70 100644
--- a/p2p/client/socketmonitor.cc
+++ b/p2p/client/socketmonitor.cc
@@ -27,7 +27,7 @@
 
 #include "talk/p2p/client/socketmonitor.h"
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 
 namespace cricket {
 
@@ -39,8 +39,8 @@ enum {
 };
 
 SocketMonitor::SocketMonitor(TransportChannel* channel,
-                             talk_base::Thread* worker_thread,
-                             talk_base::Thread* monitor_thread) {
+                             rtc::Thread* worker_thread,
+                             rtc::Thread* monitor_thread) {
   channel_ = channel;
   channel_thread_ = worker_thread;
   monitoring_thread_ = monitor_thread;
@@ -63,11 +63,11 @@ void SocketMonitor::Stop() {
   channel_thread_->Post(this, MSG_MONITOR_STOP);
 }
 
-void SocketMonitor::OnMessage(talk_base::Message *message) {
-  talk_base::CritScope cs(&crit_);
+void SocketMonitor::OnMessage(rtc::Message *message) {
+  rtc::CritScope cs(&crit_);
   switch (message->message_id) {
     case MSG_MONITOR_START:
-      ASSERT(talk_base::Thread::Current() == channel_thread_);
+      ASSERT(rtc::Thread::Current() == channel_thread_);
       if (!monitoring_) {
         monitoring_ = true;
         PollSocket(true);
@@ -75,7 +75,7 @@ void SocketMonitor::OnMessage(talk_base::Message *message) {
       break;
 
     case MSG_MONITOR_STOP:
-      ASSERT(talk_base::Thread::Current() == channel_thread_);
+      ASSERT(rtc::Thread::Current() == channel_thread_);
       if (monitoring_) {
         monitoring_ = false;
         channel_thread_->Clear(this);
@@ -83,12 +83,12 @@ void SocketMonitor::OnMessage(talk_base::Message *message) {
       break;
 
     case MSG_MONITOR_POLL:
-      ASSERT(talk_base::Thread::Current() == channel_thread_);
+      ASSERT(rtc::Thread::Current() == channel_thread_);
       PollSocket(true);
       break;
 
     case MSG_MONITOR_SIGNAL: {
-      ASSERT(talk_base::Thread::Current() == monitoring_thread_);
+      ASSERT(rtc::Thread::Current() == monitoring_thread_);
       std::vector<ConnectionInfo> infos = connection_infos_;
       crit_.Leave();
       SignalUpdate(this, infos);
@@ -99,8 +99,8 @@ void SocketMonitor::OnMessage(talk_base::Message *message) {
 }
 
 void SocketMonitor::PollSocket(bool poll) {
-  ASSERT(talk_base::Thread::Current() == channel_thread_);
-  talk_base::CritScope cs(&crit_);
+  ASSERT(rtc::Thread::Current() == channel_thread_);
+  rtc::CritScope cs(&crit_);
 
   // Gather connection infos
   channel_->GetStats(&connection_infos_);
diff --git a/p2p/client/socketmonitor.h b/p2p/client/socketmonitor.h
index f24ad66..dd540c8 100644
--- a/p2p/client/socketmonitor.h
+++ b/p2p/client/socketmonitor.h
@@ -30,38 +30,38 @@
 
 #include <vector>
 
-#include "talk/base/criticalsection.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/transportchannel.h"
 
 namespace cricket {
 
-class SocketMonitor : public talk_base::MessageHandler,
+class SocketMonitor : public rtc::MessageHandler,
                       public sigslot::has_slots<> {
  public:
   SocketMonitor(TransportChannel* channel,
-                talk_base::Thread* worker_thread,
-                talk_base::Thread* monitor_thread);
+                rtc::Thread* worker_thread,
+                rtc::Thread* monitor_thread);
   ~SocketMonitor();
 
   void Start(int cms);
   void Stop();
 
-  talk_base::Thread* monitor_thread() { return monitoring_thread_; }
+  rtc::Thread* monitor_thread() { return monitoring_thread_; }
 
   sigslot::signal2<SocketMonitor*,
                    const std::vector<ConnectionInfo>&> SignalUpdate;
 
  protected:
-  void OnMessage(talk_base::Message* message);
+  void OnMessage(rtc::Message* message);
   void PollSocket(bool poll);
 
   std::vector<ConnectionInfo> connection_infos_;
   TransportChannel* channel_;
-  talk_base::Thread* channel_thread_;
-  talk_base::Thread* monitoring_thread_;
-  talk_base::CriticalSection crit_;
+  rtc::Thread* channel_thread_;
+  rtc::Thread* monitoring_thread_;
+  rtc::CriticalSection crit_;
   uint32 rate_;
   bool monitoring_;
 };