(Auto)update libjingle 72097588-> 72159069

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

29 files changed, 222 insertions, 222 deletions

diff --git a/examples/call/call_main.cc b/examples/call/call_main.cc
index 33d5385..b6168b3 100644
--- a/examples/call/call_main.cc
+++ b/examples/call/call_main.cc
@@ -33,15 +33,15 @@
 #include <iostream>
 #include <vector>
 
-#include "talk/base/flags.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/flags.h"
+#include "webrtc/base/logging.h"
 #ifdef OSX
-#include "talk/base/maccocoasocketserver.h"
+#include "webrtc/base/maccocoasocketserver.h"
 #endif
-#include "talk/base/pathutils.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/stream.h"
-#include "talk/base/win32socketserver.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/win32socketserver.h"
 #include "talk/examples/call/callclient.h"
 #include "talk/examples/call/console.h"
 #include "talk/examples/call/mediaenginefactory.h"
@@ -257,9 +257,9 @@ int main(int argc, char **argv) {
       "Enable roster messages printed in console.");
 
   // parse options
-  FlagList::SetFlagsFromCommandLine(&argc, argv, true);
+  rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
   if (FLAG_help) {
-    FlagList::Print(NULL, false);
+    rtc::FlagList::Print(NULL, false);
     return 0;
   }
 
@@ -283,19 +283,19 @@ int main(int argc, char **argv) {
   bool render = FLAG_render;
   std::string data_channel = FLAG_datachannel;
   bool multisession_enabled = FLAG_multisession;
-  talk_base::SSLIdentity* ssl_identity = NULL;
+  rtc::SSLIdentity* ssl_identity = NULL;
   bool show_roster_messages = FLAG_roster;
 
   // Set up debugging.
   if (debug) {
-    talk_base::LogMessage::LogToDebug(talk_base::LS_VERBOSE);
+    rtc::LogMessage::LogToDebug(rtc::LS_VERBOSE);
   }
 
   if (!log.empty()) {
-    talk_base::StreamInterface* stream =
-        talk_base::Filesystem::OpenFile(log, "a");
+    rtc::StreamInterface* stream =
+        rtc::Filesystem::OpenFile(log, "a");
     if (stream) {
-      talk_base::LogMessage::LogToStream(stream, talk_base::LS_VERBOSE);
+      rtc::LogMessage::LogToStream(stream, rtc::LS_VERBOSE);
     } else {
       Print(("Cannot open debug log " + log + "\n").c_str());
       return 1;
@@ -307,12 +307,12 @@ int main(int argc, char **argv) {
   }
 
   // Set up the crypto subsystem.
-  talk_base::InitializeSSL();
+  rtc::InitializeSSL();
 
   // Parse username and password, if present.
   buzz::Jid jid;
   std::string username;
-  talk_base::InsecureCryptStringImpl pass;
+  rtc::InsecureCryptStringImpl pass;
   if (argc > 1) {
     username = argv[1];
     if (argc > 2) {
@@ -364,7 +364,7 @@ int main(int argc, char **argv) {
     xcs.set_use_tls(buzz::TLS_DISABLED);
     xcs.set_test_server_domain("google.com");
   }
-  xcs.set_pass(talk_base::CryptString(pass));
+  xcs.set_pass(rtc::CryptString(pass));
   if (!oauth_token.empty()) {
     xcs.set_auth_token(buzz::AUTH_MECHANISM_OAUTH2, oauth_token);
   }
@@ -381,7 +381,7 @@ int main(int argc, char **argv) {
     port = atoi(server.substr(colon + 1).c_str());
   }
 
-  xcs.set_server(talk_base::SocketAddress(host, port));
+  xcs.set_server(rtc::SocketAddress(host, port));
 
   // Decide on the signaling and crypto settings.
   cricket::SignalingProtocol signaling_protocol = cricket::PROTOCOL_HYBRID;
@@ -428,7 +428,7 @@ int main(int argc, char **argv) {
     return 1;
   }
   if (dtls_policy != cricket::SEC_DISABLED) {
-    ssl_identity = talk_base::SSLIdentity::Generate(jid.Str());
+    ssl_identity = rtc::SSLIdentity::Generate(jid.Str());
     if (!ssl_identity) {
       Print("Failed to generate identity for DTLS.\n");
       return 1;
@@ -441,13 +441,13 @@ int main(int argc, char **argv) {
 
 #if WIN32
   // Need to pump messages on our main thread on Windows.
-  talk_base::Win32Thread w32_thread;
-  talk_base::ThreadManager::Instance()->SetCurrentThread(&w32_thread);
+  rtc::Win32Thread w32_thread;
+  rtc::ThreadManager::Instance()->SetCurrentThread(&w32_thread);
 #endif
-  talk_base::Thread* main_thread = talk_base::Thread::Current();
+  rtc::Thread* main_thread = rtc::Thread::Current();
 #ifdef OSX
-  talk_base::MacCocoaSocketServer ss;
-  talk_base::SocketServerScope ss_scope(&ss);
+  rtc::MacCocoaSocketServer ss;
+  rtc::SocketServerScope ss_scope(&ss);
 #endif
 
   buzz::XmppPump pump;
diff --git a/examples/call/call_unittest.cc b/examples/call/call_unittest.cc
index d95f1dd..524726d 100644
--- a/examples/call/call_unittest.cc
+++ b/examples/call/call_unittest.cc
@@ -27,11 +27,11 @@
 
 // Main function for all unit tests in talk/examples/call
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "testing/base/public/gunit.h"
 
 int main(int argc, char **argv) {
-  talk_base::LogMessage::LogToDebug(talk_base::LogMessage::NO_LOGGING);
+  rtc::LogMessage::LogToDebug(rtc::LogMessage::NO_LOGGING);
   testing::ParseGUnitFlags(&argc, argv);
   return RUN_ALL_TESTS();
 }
diff --git a/examples/call/callclient.cc b/examples/call/callclient.cc
index c691db3..7d1cd80 100644
--- a/examples/call/callclient.cc
+++ b/examples/call/callclient.cc
@@ -29,14 +29,14 @@
 
 #include <string>
 
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/network.h"
-#include "talk/base/socketaddress.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
-#include "talk/base/windowpickerfactory.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/network.h"
+#include "webrtc/base/socketaddress.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/windowpickerfactory.h"
 #include "talk/examples/call/console.h"
 #include "talk/examples/call/friendinvitesendtask.h"
 #include "talk/examples/call/muc.h"
@@ -94,7 +94,7 @@ std::string GetWord(const std::vector<std::string>& words,
 
 int GetInt(const std::vector<std::string>& words, size_t index, int def) {
   int val;
-  if (words.size() > index && talk_base::FromString(words[index], &val)) {
+  if (words.size() > index && rtc::FromString(words[index], &val)) {
     return val;
   } else {
     return def;
@@ -251,7 +251,7 @@ void CallClient::ParseLine(const std::string& line) {
         console_->PrintLine("Can't screencast twice.  Unscreencast first.");
       } else {
         std::string streamid = "screencast";
-        screencast_ssrc_ = talk_base::CreateRandomId();
+        screencast_ssrc_ = rtc::CreateRandomId();
         int fps = GetInt(words, 1, 5);  // Default to 5 fps.
 
         cricket::ScreencastId screencastid;
@@ -478,7 +478,7 @@ void CallClient::OnStateChange(buzz::XmppEngine::State state) {
 }
 
 void CallClient::InitMedia() {
-  worker_thread_ = new talk_base::Thread();
+  worker_thread_ = new rtc::Thread();
   // The worker thread must be started here since initialization of
   // the ChannelManager will generate messages that need to be
   // dispatched by it.
@@ -486,15 +486,15 @@ void CallClient::InitMedia() {
 
   // TODO: It looks like we are leaking many objects. E.g.
   // |network_manager_| is never deleted.
-  network_manager_ = new talk_base::BasicNetworkManager();
+  network_manager_ = new rtc::BasicNetworkManager();
 
   // TODO: Decide if the relay address should be specified here.
-  talk_base::SocketAddress stun_addr("stun.l.google.com", 19302);
+  rtc::SocketAddress stun_addr("stun.l.google.com", 19302);
   cricket::ServerAddresses stun_servers;
   stun_servers.insert(stun_addr);
   port_allocator_ =  new cricket::BasicPortAllocator(
-      network_manager_, stun_servers, talk_base::SocketAddress(),
-      talk_base::SocketAddress(), talk_base::SocketAddress());
+      network_manager_, stun_servers, rtc::SocketAddress(),
+      rtc::SocketAddress(), rtc::SocketAddress());
 
   if (portallocator_flags_ != 0) {
     port_allocator_->set_flags(portallocator_flags_);
@@ -685,7 +685,7 @@ void CallClient::InitPresence() {
 
 void CallClient::StartXmppPing() {
   buzz::PingTask* ping = new buzz::PingTask(
-      xmpp_client_, talk_base::Thread::Current(),
+      xmpp_client_, rtc::Thread::Current(),
       kPingPeriodMillis, kPingTimeoutMillis);
   ping->SignalTimeout.connect(this, &CallClient::OnPingTimeout);
   ping->Start();
@@ -741,7 +741,7 @@ void CallClient::PrintRoster() {
 void CallClient::SendChat(const std::string& to, const std::string msg) {
   buzz::XmlElement* stanza = new buzz::XmlElement(buzz::QN_MESSAGE);
   stanza->AddAttr(buzz::QN_TO, to);
-  stanza->AddAttr(buzz::QN_ID, talk_base::CreateRandomString(16));
+  stanza->AddAttr(buzz::QN_ID, rtc::CreateRandomString(16));
   stanza->AddAttr(buzz::QN_TYPE, "chat");
   buzz::XmlElement* body = new buzz::XmlElement(buzz::QN_BODY);
   body->SetBodyText(msg);
@@ -781,7 +781,7 @@ void CallClient::SendData(const std::string& streamid,
 
   cricket::SendDataParams params;
   params.ssrc = stream.first_ssrc();
-  talk_base::Buffer payload(text.data(), text.length());
+  rtc::Buffer payload(text.data(), text.length());
   cricket::SendDataResult result;
   bool sent = call_->SendData(session, params, payload, &result);
   if (!sent) {
@@ -856,7 +856,7 @@ bool CallClient::FindJid(const std::string& name, buzz::Jid* found_jid,
 
 void CallClient::OnDataReceived(cricket::Call*,
                                 const cricket::ReceiveDataParams& params,
-                                const talk_base::Buffer& payload) {
+                                const rtc::Buffer& payload) {
   // TODO(mylesj): Support receiving data on sessions other than the first.
   cricket::Session* session = GetFirstSession();
   if (!session)
@@ -1106,7 +1106,7 @@ void CallClient::Reject() {
 }
 
 void CallClient::Quit() {
-  talk_base::Thread::Current()->Quit();
+  rtc::Thread::Current()->Quit();
 }
 
 void CallClient::SetNick(const std::string& muc_nick) {
@@ -1564,7 +1564,7 @@ buzz::Jid CallClient::GenerateRandomMucJid() {
     }
   }
 
-  talk_base::sprintfn(guid_room,
+  rtc::sprintfn(guid_room,
                       ARRAY_SIZE(guid_room),
                       "private-chat-%s@%s",
                       guid,
@@ -1574,19 +1574,19 @@ buzz::Jid CallClient::GenerateRandomMucJid() {
 
 bool CallClient::SelectFirstDesktopScreencastId(
     cricket::ScreencastId* screencastid) {
-  if (!talk_base::WindowPickerFactory::IsSupported()) {
+  if (!rtc::WindowPickerFactory::IsSupported()) {
     LOG(LS_WARNING) << "Window picker not suported on this OS.";
     return false;
   }
 
-  talk_base::WindowPicker* picker =
-      talk_base::WindowPickerFactory::CreateWindowPicker();
+  rtc::WindowPicker* picker =
+      rtc::WindowPickerFactory::CreateWindowPicker();
   if (!picker) {
     LOG(LS_WARNING) << "Could not create a window picker.";
     return false;
   }
 
-  talk_base::DesktopDescriptionList desktops;
+  rtc::DesktopDescriptionList desktops;
   if (!picker->GetDesktopList(&desktops) || desktops.empty()) {
     LOG(LS_WARNING) << "Could not get a list of desktops.";
     return false;
diff --git a/examples/call/callclient.h b/examples/call/callclient.h
index 39a5b11..f25b9f5 100644
--- a/examples/call/callclient.h
+++ b/examples/call/callclient.h
@@ -32,8 +32,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sslidentity.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sslidentity.h"
 #include "talk/examples/call/console.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/p2p/base/session.h"
@@ -62,10 +62,10 @@ struct AvailableMediaEntry;
 struct MucRoomInfo;
 }  // namespace buzz
 
-namespace talk_base {
+namespace rtc {
 class Thread;
 class NetworkManager;
-}  // namespace talk_base
+}  // namespace rtc
 
 namespace cricket {
 class PortAllocator;
@@ -166,7 +166,7 @@ class CallClient: public sigslot::has_slots<> {
     sdes_policy_ = sdes_policy;
     dtls_policy_ = dtls_policy;
   }
-  void SetSslIdentity(talk_base::SSLIdentity* identity) {
+  void SetSslIdentity(rtc::SSLIdentity* identity) {
     ssl_identity_.reset(identity);
   }
 
@@ -242,7 +242,7 @@ class CallClient: public sigslot::has_slots<> {
                          const buzz::XmlElement* stanza);
   void OnDataReceived(cricket::Call*,
                       const cricket::ReceiveDataParams& params,
-                      const talk_base::Buffer& payload);
+                      const rtc::Buffer& payload);
   buzz::Jid GenerateRandomMucJid();
 
   // Depending on |enable|, render (or don't) all the streams in |session|.
@@ -303,8 +303,8 @@ class CallClient: public sigslot::has_slots<> {
 
   Console *console_;
   buzz::XmppClient* xmpp_client_;
-  talk_base::Thread* worker_thread_;
-  talk_base::NetworkManager* network_manager_;
+  rtc::Thread* worker_thread_;
+  rtc::NetworkManager* network_manager_;
   cricket::PortAllocator* port_allocator_;
   cricket::SessionManager* session_manager_;
   cricket::SessionManagerTask* session_manager_task_;
@@ -343,7 +343,7 @@ class CallClient: public sigslot::has_slots<> {
   cricket::TransportProtocol transport_protocol_;
   cricket::SecurePolicy sdes_policy_;
   cricket::SecurePolicy dtls_policy_;
-  talk_base::scoped_ptr<talk_base::SSLIdentity> ssl_identity_;
+  rtc::scoped_ptr<rtc::SSLIdentity> ssl_identity_;
   std::string last_sent_to_;
 
   bool show_roster_messages_;
diff --git a/examples/call/callclient_unittest.cc b/examples/call/callclient_unittest.cc
index b0e9d89..6268917 100644
--- a/examples/call/callclient_unittest.cc
+++ b/examples/call/callclient_unittest.cc
@@ -27,7 +27,7 @@
 
 // Unit tests for CallClient
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/examples/call/callclient.h"
 #include "talk/media/base/filemediaengine.h"
 #include "talk/media/base/mediaengine.h"
diff --git a/examples/call/console.cc b/examples/call/console.cc
index 647601e..e3ed4f8 100644
--- a/examples/call/console.cc
+++ b/examples/call/console.cc
@@ -35,9 +35,9 @@
 #include <unistd.h>
 #endif  // POSIX
 
-#include "talk/base/logging.h"
-#include "talk/base/messagequeue.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/examples/call/console.h"
 #include "talk/examples/call/callclient.h"
 
@@ -45,7 +45,7 @@
 static void DoNothing(int unused) {}
 #endif
 
-Console::Console(talk_base::Thread *thread, CallClient *client) :
+Console::Console(rtc::Thread *thread, CallClient *client) :
   client_(client),
   client_thread_(thread),
   stopped_(false) {}
@@ -64,7 +64,7 @@ void Console::Start() {
     LOG(LS_WARNING) << "Already started";
     return;
   }
-  console_thread_.reset(new talk_base::Thread());
+  console_thread_.reset(new rtc::Thread());
   console_thread_->Start();
   console_thread_->Post(this, MSG_START);
 }
@@ -140,11 +140,11 @@ void Console::RunConsole() {
   char input_buffer[128];
   while (fgets(input_buffer, sizeof(input_buffer), stdin) != NULL) {
     client_thread_->Post(this, MSG_INPUT,
-        new talk_base::TypedMessageData<std::string>(input_buffer));
+        new rtc::TypedMessageData<std::string>(input_buffer));
   }
 }
 
-void Console::OnMessage(talk_base::Message *msg) {
+void Console::OnMessage(rtc::Message *msg) {
   switch (msg->message_id) {
     case MSG_START:
 #ifdef POSIX
@@ -161,8 +161,8 @@ void Console::OnMessage(talk_base::Message *msg) {
       RunConsole();
       break;
     case MSG_INPUT:
-      talk_base::TypedMessageData<std::string> *data =
-          static_cast<talk_base::TypedMessageData<std::string>*>(msg->pdata);
+      rtc::TypedMessageData<std::string> *data =
+          static_cast<rtc::TypedMessageData<std::string>*>(msg->pdata);
       client_->ParseLine(data->data());
       break;
   }
diff --git a/examples/call/console.h b/examples/call/console.h
index f0f36e3..00b35a0 100644
--- a/examples/call/console.h
+++ b/examples/call/console.h
@@ -30,15 +30,15 @@
 
 #include <stdio.h>
 
-#include "talk/base/thread.h"
-#include "talk/base/messagequeue.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/scoped_ptr.h"
 
 class CallClient;
 
-class Console : public talk_base::MessageHandler {
+class Console : public rtc::MessageHandler {
  public:
-  Console(talk_base::Thread *thread, CallClient *client);
+  Console(rtc::Thread *thread, CallClient *client);
   ~Console();
 
   // Starts reading lines from the console and giving them to the CallClient.
@@ -46,7 +46,7 @@ class Console : public talk_base::MessageHandler {
   // Stops reading lines. Cannot be restarted.
   void Stop();
 
-  virtual void OnMessage(talk_base::Message *msg);
+  virtual void OnMessage(rtc::Message *msg);
 
   void PrintLine(const char* format, ...);
 
@@ -62,8 +62,8 @@ class Console : public talk_base::MessageHandler {
   void ParseLine(std::string &str);
 
   CallClient *client_;
-  talk_base::Thread *client_thread_;
-  talk_base::scoped_ptr<talk_base::Thread> console_thread_;
+  rtc::Thread *client_thread_;
+  rtc::scoped_ptr<rtc::Thread> console_thread_;
   bool stopped_;
 };
 
diff --git a/examples/call/mediaenginefactory.cc b/examples/call/mediaenginefactory.cc
index 983345d..472a880 100644
--- a/examples/call/mediaenginefactory.cc
+++ b/examples/call/mediaenginefactory.cc
@@ -27,7 +27,7 @@
 
 #include "talk/examples/call/mediaenginefactory.h"
 
-#include "talk/base/stringutils.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/filemediaengine.h"
 #include "talk/media/base/mediaengine.h"
diff --git a/examples/call/mucinviterecvtask.h b/examples/call/mucinviterecvtask.h
index 24f05e0..4ec06d0 100644
--- a/examples/call/mucinviterecvtask.h
+++ b/examples/call/mucinviterecvtask.h
@@ -30,7 +30,7 @@
 
 #include <vector>
 
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmpp/xmppengine.h"
 #include "talk/xmpp/xmpptask.h"
 
diff --git a/examples/call/presencepushtask.cc b/examples/call/presencepushtask.cc
index af02b1f..31ccc32 100644
--- a/examples/call/presencepushtask.cc
+++ b/examples/call/presencepushtask.cc
@@ -27,7 +27,7 @@
 
 #include "talk/examples/call/presencepushtask.h"
 
-#include "talk/base/stringencode.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/examples/call/muc.h"
 #include "talk/xmpp/constants.h"
 
@@ -153,7 +153,7 @@ void PresencePushTask::FillStatus(const Jid& from, const XmlElement* stanza,
     const XmlElement * priority = stanza->FirstNamed(QN_PRIORITY);
     if (priority != NULL) {
       int pri;
-      if (talk_base::FromString(priority->BodyText(), &pri)) {
+      if (rtc::FromString(priority->BodyText(), &pri)) {
         s->set_priority(pri);
       }
     }
diff --git a/examples/call/presencepushtask.h b/examples/call/presencepushtask.h
index 9cd1b42..5a080d3 100644
--- a/examples/call/presencepushtask.h
+++ b/examples/call/presencepushtask.h
@@ -33,7 +33,7 @@
 #include "talk/xmpp/xmppengine.h"
 #include "talk/xmpp/xmpptask.h"
 #include "talk/xmpp/presencestatus.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/examples/call/callclient.h"
 
 namespace buzz {
diff --git a/examples/login/login_main.cc b/examples/login/login_main.cc
index 5c5d1d7..55243aa 100644
--- a/examples/login/login_main.cc
+++ b/examples/login/login_main.cc
@@ -29,7 +29,7 @@
 
 #include <iostream>
 
-#include "talk/base/thread.h"
+#include "webrtc/base/thread.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/xmppclientsettings.h"
 #include "talk/xmpp/xmppengine.h"
@@ -54,7 +54,7 @@ int main(int argc, char **argv) {
   xcs.set_use_tls(buzz::TLS_DISABLED);
   xcs.set_auth_token(buzz::AUTH_MECHANISM_OAUTH2,
                      auth_token.c_str());
-  xcs.set_server(talk_base::SocketAddress("talk.google.com", 5222));
+  xcs.set_server(rtc::SocketAddress("talk.google.com", 5222));
   thread.Login(xcs);
 
   // Use main thread for console input
diff --git a/examples/peerconnection/client/conductor.cc b/examples/peerconnection/client/conductor.cc
index bbab3d0..64026c5 100644
--- a/examples/peerconnection/client/conductor.cc
+++ b/examples/peerconnection/client/conductor.cc
@@ -30,9 +30,9 @@
 #include <utility>
 
 #include "talk/app/webrtc/videosourceinterface.h"
-#include "talk/base/common.h"
-#include "talk/base/json.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/json.h"
+#include "webrtc/base/logging.h"
 #include "talk/examples/peerconnection/client/defaults.h"
 #include "talk/media/devices/devicemanager.h"
 
@@ -50,7 +50,7 @@ class DummySetSessionDescriptionObserver
  public:
   static DummySetSessionDescriptionObserver* Create() {
     return
-        new talk_base::RefCountedObject<DummySetSessionDescriptionObserver>();
+        new rtc::RefCountedObject<DummySetSessionDescriptionObserver>();
   }
   virtual void OnSuccess() {
     LOG(INFO) << __FUNCTION__;
@@ -272,7 +272,7 @@ void Conductor::OnMessageFromPeer(int peer_id, const std::string& message) {
       LOG(WARNING) << "Can't parse received message.";
       return;
     }
-    talk_base::scoped_ptr<webrtc::IceCandidateInterface> candidate(
+    rtc::scoped_ptr<webrtc::IceCandidateInterface> candidate(
         webrtc::CreateIceCandidate(sdp_mid, sdp_mlineindex, sdp));
     if (!candidate.get()) {
       LOG(WARNING) << "Can't parse received candidate message.";
@@ -332,7 +332,7 @@ void Conductor::ConnectToPeer(int peer_id) {
 }
 
 cricket::VideoCapturer* Conductor::OpenVideoCaptureDevice() {
-  talk_base::scoped_ptr<cricket::DeviceManagerInterface> dev_manager(
+  rtc::scoped_ptr<cricket::DeviceManagerInterface> dev_manager(
       cricket::DeviceManagerFactory::Create());
   if (!dev_manager->Init()) {
     LOG(LS_ERROR) << "Can't create device manager";
@@ -357,18 +357,18 @@ void Conductor::AddStreams() {
   if (active_streams_.find(kStreamLabel) != active_streams_.end())
     return;  // Already added.
 
-  talk_base::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+  rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
       peer_connection_factory_->CreateAudioTrack(
           kAudioLabel, peer_connection_factory_->CreateAudioSource(NULL)));
 
-  talk_base::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+  rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
       peer_connection_factory_->CreateVideoTrack(
           kVideoLabel,
           peer_connection_factory_->CreateVideoSource(OpenVideoCaptureDevice(),
                                                       NULL)));
   main_wnd_->StartLocalRenderer(video_track);
 
-  talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream =
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
       peer_connection_factory_->CreateLocalMediaStream(kStreamLabel);
 
   stream->AddTrack(audio_track);
@@ -377,7 +377,7 @@ void Conductor::AddStreams() {
     LOG(LS_ERROR) << "Adding stream to PeerConnection failed";
   }
   typedef std::pair<std::string,
-                    talk_base::scoped_refptr<webrtc::MediaStreamInterface> >
+                    rtc::scoped_refptr<webrtc::MediaStreamInterface> >
       MediaStreamPair;
   active_streams_.insert(MediaStreamPair(stream->label(), stream));
   main_wnd_->SwitchToStreamingUI();
diff --git a/examples/peerconnection/client/conductor.h b/examples/peerconnection/client/conductor.h
index f9fb393..93b0779 100644
--- a/examples/peerconnection/client/conductor.h
+++ b/examples/peerconnection/client/conductor.h
@@ -38,7 +38,7 @@
 #include "talk/examples/peerconnection/client/peer_connection_client.h"
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 
 namespace webrtc {
 class VideoCaptureModule;
@@ -130,13 +130,13 @@ class Conductor
   void SendMessage(const std::string& json_object);
 
   int peer_id_;
-  talk_base::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
-  talk_base::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+  rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
+  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
       peer_connection_factory_;
   PeerConnectionClient* client_;
   MainWindow* main_wnd_;
   std::deque<std::string*> pending_messages_;
-  std::map<std::string, talk_base::scoped_refptr<webrtc::MediaStreamInterface> >
+  std::map<std::string, rtc::scoped_refptr<webrtc::MediaStreamInterface> >
       active_streams_;
   std::string server_;
 };
diff --git a/examples/peerconnection/client/defaults.cc b/examples/peerconnection/client/defaults.cc
index 40f3dd1..15252c6 100644
--- a/examples/peerconnection/client/defaults.cc
+++ b/examples/peerconnection/client/defaults.cc
@@ -36,7 +36,7 @@
 #include <unistd.h>
 #endif
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 
 const char kAudioLabel[] = "audio_label";
 const char kVideoLabel[] = "video_label";
diff --git a/examples/peerconnection/client/defaults.h b/examples/peerconnection/client/defaults.h
index f646149..5834f34 100644
--- a/examples/peerconnection/client/defaults.h
+++ b/examples/peerconnection/client/defaults.h
@@ -31,7 +31,7 @@
 
 #include <string>
 
-#include "talk/base/basictypes.h"
+#include "webrtc/base/basictypes.h"
 
 extern const char kAudioLabel[];
 extern const char kVideoLabel[];
diff --git a/examples/peerconnection/client/flagdefs.h b/examples/peerconnection/client/flagdefs.h
index c135bbb..3d3edca 100644
--- a/examples/peerconnection/client/flagdefs.h
+++ b/examples/peerconnection/client/flagdefs.h
@@ -29,7 +29,7 @@
 #define TALK_EXAMPLES_PEERCONNECTION_CLIENT_FLAGDEFS_H_
 #pragma once
 
-#include "talk/base/flags.h"
+#include "webrtc/base/flags.h"
 
 extern const uint16 kDefaultServerPort;  // From defaults.[h|cc]
 
diff --git a/examples/peerconnection/client/linux/main.cc b/examples/peerconnection/client/linux/main.cc
index 4ef81cd..67fd33d 100644
--- a/examples/peerconnection/client/linux/main.cc
+++ b/examples/peerconnection/client/linux/main.cc
@@ -32,12 +32,12 @@
 #include "talk/examples/peerconnection/client/linux/main_wnd.h"
 #include "talk/examples/peerconnection/client/peer_connection_client.h"
 
-#include "talk/base/ssladapter.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/thread.h"
 
-class CustomSocketServer : public talk_base::PhysicalSocketServer {
+class CustomSocketServer : public rtc::PhysicalSocketServer {
  public:
-  CustomSocketServer(talk_base::Thread* thread, GtkMainWnd* wnd)
+  CustomSocketServer(rtc::Thread* thread, GtkMainWnd* wnd)
       : thread_(thread), wnd_(wnd), conductor_(NULL), client_(NULL) {}
   virtual ~CustomSocketServer() {}
 
@@ -58,12 +58,12 @@ class CustomSocketServer : public talk_base::PhysicalSocketServer {
         client_ != NULL && !client_->is_connected()) {
       thread_->Quit();
     }
-    return talk_base::PhysicalSocketServer::Wait(0/*cms == -1 ? 1 : cms*/,
+    return rtc::PhysicalSocketServer::Wait(0/*cms == -1 ? 1 : cms*/,
                                                  process_io);
   }
 
  protected:
-  talk_base::Thread* thread_;
+  rtc::Thread* thread_;
   GtkMainWnd* wnd_;
   Conductor* conductor_;
   PeerConnectionClient* client_;
@@ -74,9 +74,9 @@ int main(int argc, char* argv[]) {
   g_type_init();
   g_thread_init(NULL);
 
-  FlagList::SetFlagsFromCommandLine(&argc, argv, true);
+  rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
   if (FLAG_help) {
-    FlagList::Print(NULL, false);
+    rtc::FlagList::Print(NULL, false);
     return 0;
   }
 
@@ -90,16 +90,16 @@ int main(int argc, char* argv[]) {
   GtkMainWnd wnd(FLAG_server, FLAG_port, FLAG_autoconnect, FLAG_autocall);
   wnd.Create();
 
-  talk_base::AutoThread auto_thread;
-  talk_base::Thread* thread = talk_base::Thread::Current();
+  rtc::AutoThread auto_thread;
+  rtc::Thread* thread = rtc::Thread::Current();
   CustomSocketServer socket_server(thread, &wnd);
   thread->set_socketserver(&socket_server);
 
-  talk_base::InitializeSSL();
+  rtc::InitializeSSL();
   // Must be constructed after we set the socketserver.
   PeerConnectionClient client;
-  talk_base::scoped_refptr<Conductor> conductor(
-      new talk_base::RefCountedObject<Conductor>(&client, &wnd));
+  rtc::scoped_refptr<Conductor> conductor(
+      new rtc::RefCountedObject<Conductor>(&client, &wnd));
   socket_server.set_client(&client);
   socket_server.set_conductor(conductor);
 
@@ -113,7 +113,7 @@ int main(int argc, char* argv[]) {
   //while (gtk_events_pending()) {
   //  gtk_main_iteration();
   //}
-  talk_base::CleanupSSL();
+  rtc::CleanupSSL();
   return 0;
 }
 
diff --git a/examples/peerconnection/client/linux/main_wnd.cc b/examples/peerconnection/client/linux/main_wnd.cc
index 0a2e1f6..55f3649 100644
--- a/examples/peerconnection/client/linux/main_wnd.cc
+++ b/examples/peerconnection/client/linux/main_wnd.cc
@@ -33,11 +33,11 @@
 #include <stddef.h>
 
 #include "talk/examples/peerconnection/client/defaults.h"
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringutils.h"
 
-using talk_base::sprintfn;
+using rtc::sprintfn;
 
 namespace {
 
diff --git a/examples/peerconnection/client/linux/main_wnd.h b/examples/peerconnection/client/linux/main_wnd.h
index 5a44640..6e45333 100644
--- a/examples/peerconnection/client/linux/main_wnd.h
+++ b/examples/peerconnection/client/linux/main_wnd.h
@@ -110,11 +110,11 @@ class GtkMainWnd : public MainWindow {
     }
 
    protected:
-    talk_base::scoped_ptr<uint8[]> image_;
+    rtc::scoped_ptr<uint8[]> image_;
     int width_;
     int height_;
     GtkMainWnd* main_wnd_;
-    talk_base::scoped_refptr<webrtc::VideoTrackInterface> rendered_track_;
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> rendered_track_;
   };
 
  protected:
@@ -129,9 +129,9 @@ class GtkMainWnd : public MainWindow {
   std::string port_;
   bool autoconnect_;
   bool autocall_;
-  talk_base::scoped_ptr<VideoRenderer> local_renderer_;
-  talk_base::scoped_ptr<VideoRenderer> remote_renderer_;
-  talk_base::scoped_ptr<uint8> draw_buffer_;
+  rtc::scoped_ptr<VideoRenderer> local_renderer_;
+  rtc::scoped_ptr<VideoRenderer> remote_renderer_;
+  rtc::scoped_ptr<uint8> draw_buffer_;
   int draw_buffer_size_;
 };
 
diff --git a/examples/peerconnection/client/main.cc b/examples/peerconnection/client/main.cc
index 765dfaa..34fadfa 100644
--- a/examples/peerconnection/client/main.cc
+++ b/examples/peerconnection/client/main.cc
@@ -29,24 +29,24 @@
 #include "talk/examples/peerconnection/client/flagdefs.h"
 #include "talk/examples/peerconnection/client/main_wnd.h"
 #include "talk/examples/peerconnection/client/peer_connection_client.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/win32socketinit.h"
-#include "talk/base/win32socketserver.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/win32socketinit.h"
+#include "webrtc/base/win32socketserver.h"
 
 
 int PASCAL wWinMain(HINSTANCE instance, HINSTANCE prev_instance,
                     wchar_t* cmd_line, int cmd_show) {
-  talk_base::EnsureWinsockInit();
-  talk_base::Win32Thread w32_thread;
-  talk_base::ThreadManager::Instance()->SetCurrentThread(&w32_thread);
+  rtc::EnsureWinsockInit();
+  rtc::Win32Thread w32_thread;
+  rtc::ThreadManager::Instance()->SetCurrentThread(&w32_thread);
 
-  WindowsCommandLineArguments win_args;
+  rtc::WindowsCommandLineArguments win_args;
   int argc = win_args.argc();
   char **argv = win_args.argv();
 
-  FlagList::SetFlagsFromCommandLine(&argc, argv, true);
+  rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
   if (FLAG_help) {
-    FlagList::Print(NULL, false);
+    rtc::FlagList::Print(NULL, false);
     return 0;
   }
 
@@ -63,10 +63,10 @@ int PASCAL wWinMain(HINSTANCE instance, HINSTANCE prev_instance,
     return -1;
   }
 
-  talk_base::InitializeSSL();
+  rtc::InitializeSSL();
   PeerConnectionClient client;
-  talk_base::scoped_refptr<Conductor> conductor(
-        new talk_base::RefCountedObject<Conductor>(&client, &wnd));
+  rtc::scoped_refptr<Conductor> conductor(
+        new rtc::RefCountedObject<Conductor>(&client, &wnd));
 
   // Main loop.
   MSG msg;
@@ -88,6 +88,6 @@ int PASCAL wWinMain(HINSTANCE instance, HINSTANCE prev_instance,
     }
   }
 
-  talk_base::CleanupSSL();
+  rtc::CleanupSSL();
   return 0;
 }
diff --git a/examples/peerconnection/client/main_wnd.cc b/examples/peerconnection/client/main_wnd.cc
index cef1da7..2296c42 100644
--- a/examples/peerconnection/client/main_wnd.cc
+++ b/examples/peerconnection/client/main_wnd.cc
@@ -29,14 +29,14 @@
 
 #include <math.h>
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
 #include "talk/examples/peerconnection/client/defaults.h"
 
 ATOM MainWnd::wnd_class_ = 0;
 const wchar_t MainWnd::kClassName[] = L"WebRTC_MainWnd";
 
-using talk_base::sprintfn;
+using rtc::sprintfn;
 
 namespace {
 
diff --git a/examples/peerconnection/client/main_wnd.h b/examples/peerconnection/client/main_wnd.h
index 77da9f6..e87153a 100644
--- a/examples/peerconnection/client/main_wnd.h
+++ b/examples/peerconnection/client/main_wnd.h
@@ -33,7 +33,7 @@
 #include <string>
 
 #include "talk/app/webrtc/mediastreaminterface.h"
-#include "talk/base/win32.h"
+#include "webrtc/base/win32.h"
 #include "talk/examples/peerconnection/client/peer_connection_client.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/videocommon.h"
@@ -147,9 +147,9 @@ class MainWnd : public MainWindow {
 
     HWND wnd_;
     BITMAPINFO bmi_;
-    talk_base::scoped_ptr<uint8[]> image_;
+    rtc::scoped_ptr<uint8[]> image_;
     CRITICAL_SECTION buffer_lock_;
-    talk_base::scoped_refptr<webrtc::VideoTrackInterface> rendered_track_;
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> rendered_track_;
   };
 
   // A little helper class to make sure we always to proper locking and
@@ -192,8 +192,8 @@ class MainWnd : public MainWindow {
   void HandleTabbing();
 
  private:
-  talk_base::scoped_ptr<VideoRenderer> local_renderer_;
-  talk_base::scoped_ptr<VideoRenderer> remote_renderer_;
+  rtc::scoped_ptr<VideoRenderer> local_renderer_;
+  rtc::scoped_ptr<VideoRenderer> remote_renderer_;
   UI ui_;
   HWND wnd_;
   DWORD ui_thread_id_;
diff --git a/examples/peerconnection/client/peer_connection_client.cc b/examples/peerconnection/client/peer_connection_client.cc
index 9cdaedc..e5bef05 100644
--- a/examples/peerconnection/client/peer_connection_client.cc
+++ b/examples/peerconnection/client/peer_connection_client.cc
@@ -28,16 +28,16 @@
 #include "talk/examples/peerconnection/client/peer_connection_client.h"
 
 #include "talk/examples/peerconnection/client/defaults.h"
-#include "talk/base/common.h"
-#include "talk/base/nethelpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/nethelpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringutils.h"
 
 #ifdef WIN32
-#include "talk/base/win32socketserver.h"
+#include "webrtc/base/win32socketserver.h"
 #endif
 
-using talk_base::sprintfn;
+using rtc::sprintfn;
 
 namespace {
 
@@ -46,13 +46,13 @@ const char kByeMessage[] = "BYE";
 // Delay between server connection retries, in milliseconds
 const int kReconnectDelay = 2000;
 
-talk_base::AsyncSocket* CreateClientSocket(int family) {
+rtc::AsyncSocket* CreateClientSocket(int family) {
 #ifdef WIN32
-  talk_base::Win32Socket* sock = new talk_base::Win32Socket();
+  rtc::Win32Socket* sock = new rtc::Win32Socket();
   sock->CreateT(family, SOCK_STREAM);
   return sock;
 #elif defined(POSIX)
-  talk_base::Thread* thread = talk_base::Thread::Current();
+  rtc::Thread* thread = rtc::Thread::Current();
   ASSERT(thread != NULL);
   return thread->socketserver()->CreateAsyncSocket(family, SOCK_STREAM);
 #else
@@ -133,7 +133,7 @@ void PeerConnectionClient::Connect(const std::string& server, int port,
 
   if (server_address_.IsUnresolved()) {
     state_ = RESOLVING;
-    resolver_ = new talk_base::AsyncResolver();
+    resolver_ = new rtc::AsyncResolver();
     resolver_->SignalDone.connect(this, &PeerConnectionClient::OnResolveResult);
     resolver_->Start(server_address_);
   } else {
@@ -142,7 +142,7 @@ void PeerConnectionClient::Connect(const std::string& server, int port,
 }
 
 void PeerConnectionClient::OnResolveResult(
-    talk_base::AsyncResolverInterface* resolver) {
+    rtc::AsyncResolverInterface* resolver) {
   if (resolver_->GetError() != 0) {
     callback_->OnServerConnectionFailure();
     resolver_->Destroy(false);
@@ -176,7 +176,7 @@ bool PeerConnectionClient::SendToPeer(int peer_id, const std::string& message) {
     return false;
 
   ASSERT(is_connected());
-  ASSERT(control_socket_->GetState() == talk_base::Socket::CS_CLOSED);
+  ASSERT(control_socket_->GetState() == rtc::Socket::CS_CLOSED);
   if (!is_connected() || peer_id == -1)
     return false;
 
@@ -198,17 +198,17 @@ bool PeerConnectionClient::SendHangUp(int peer_id) {
 
 bool PeerConnectionClient::IsSendingMessage() {
   return state_ == CONNECTED &&
-         control_socket_->GetState() != talk_base::Socket::CS_CLOSED;
+         control_socket_->GetState() != rtc::Socket::CS_CLOSED;
 }
 
 bool PeerConnectionClient::SignOut() {
   if (state_ == NOT_CONNECTED || state_ == SIGNING_OUT)
     return true;
 
-  if (hanging_get_->GetState() != talk_base::Socket::CS_CLOSED)
+  if (hanging_get_->GetState() != rtc::Socket::CS_CLOSED)
     hanging_get_->Close();
 
-  if (control_socket_->GetState() == talk_base::Socket::CS_CLOSED) {
+  if (control_socket_->GetState() == rtc::Socket::CS_CLOSED) {
     state_ = SIGNING_OUT;
 
     if (my_id_ != -1) {
@@ -242,7 +242,7 @@ void PeerConnectionClient::Close() {
 }
 
 bool PeerConnectionClient::ConnectControlSocket() {
-  ASSERT(control_socket_->GetState() == talk_base::Socket::CS_CLOSED);
+  ASSERT(control_socket_->GetState() == rtc::Socket::CS_CLOSED);
   int err = control_socket_->Connect(server_address_);
   if (err == SOCKET_ERROR) {
     Close();
@@ -251,22 +251,22 @@ bool PeerConnectionClient::ConnectControlSocket() {
   return true;
 }
 
-void PeerConnectionClient::OnConnect(talk_base::AsyncSocket* socket) {
+void PeerConnectionClient::OnConnect(rtc::AsyncSocket* socket) {
   ASSERT(!onconnect_data_.empty());
   size_t sent = socket->Send(onconnect_data_.c_str(), onconnect_data_.length());
   ASSERT(sent == onconnect_data_.length());
-  UNUSED(sent);
+  RTC_UNUSED(sent);
   onconnect_data_.clear();
 }
 
-void PeerConnectionClient::OnHangingGetConnect(talk_base::AsyncSocket* socket) {
+void PeerConnectionClient::OnHangingGetConnect(rtc::AsyncSocket* socket) {
   char buffer[1024];
   sprintfn(buffer, sizeof(buffer),
            "GET /wait?peer_id=%i HTTP/1.0\r\n\r\n", my_id_);
   int len = static_cast<int>(strlen(buffer));
   int sent = socket->Send(buffer, len);
   ASSERT(sent == len);
-  UNUSED2(sent, len);
+  RTC_UNUSED2(sent, len);
 }
 
 void PeerConnectionClient::OnMessageFromPeer(int peer_id,
@@ -308,7 +308,7 @@ bool PeerConnectionClient::GetHeaderValue(const std::string& data, size_t eoh,
   return false;
 }
 
-bool PeerConnectionClient::ReadIntoBuffer(talk_base::AsyncSocket* socket,
+bool PeerConnectionClient::ReadIntoBuffer(rtc::AsyncSocket* socket,
                                           std::string* data,
                                           size_t* content_length) {
   char buffer[0xffff];
@@ -346,7 +346,7 @@ bool PeerConnectionClient::ReadIntoBuffer(talk_base::AsyncSocket* socket,
   return ret;
 }
 
-void PeerConnectionClient::OnRead(talk_base::AsyncSocket* socket) {
+void PeerConnectionClient::OnRead(rtc::AsyncSocket* socket) {
   size_t content_length = 0;
   if (ReadIntoBuffer(socket, &control_data_, &content_length)) {
     size_t peer_id = 0, eoh = 0;
@@ -390,14 +390,14 @@ void PeerConnectionClient::OnRead(talk_base::AsyncSocket* socket) {
     control_data_.clear();
 
     if (state_ == SIGNING_IN) {
-      ASSERT(hanging_get_->GetState() == talk_base::Socket::CS_CLOSED);
+      ASSERT(hanging_get_->GetState() == rtc::Socket::CS_CLOSED);
       state_ = CONNECTED;
       hanging_get_->Connect(server_address_);
     }
   }
 }
 
-void PeerConnectionClient::OnHangingGetRead(talk_base::AsyncSocket* socket) {
+void PeerConnectionClient::OnHangingGetRead(rtc::AsyncSocket* socket) {
   LOG(INFO) << __FUNCTION__;
   size_t content_length = 0;
   if (ReadIntoBuffer(socket, &notification_data_, &content_length)) {
@@ -434,7 +434,7 @@ void PeerConnectionClient::OnHangingGetRead(talk_base::AsyncSocket* socket) {
     notification_data_.clear();
   }
 
-  if (hanging_get_->GetState() == talk_base::Socket::CS_CLOSED &&
+  if (hanging_get_->GetState() == rtc::Socket::CS_CLOSED &&
       state_ == CONNECTED) {
     hanging_get_->Connect(server_address_);
   }
@@ -496,7 +496,7 @@ bool PeerConnectionClient::ParseServerResponse(const std::string& response,
   return true;
 }
 
-void PeerConnectionClient::OnClose(talk_base::AsyncSocket* socket, int err) {
+void PeerConnectionClient::OnClose(rtc::AsyncSocket* socket, int err) {
   LOG(INFO) << __FUNCTION__;
 
   socket->Close();
@@ -517,7 +517,7 @@ void PeerConnectionClient::OnClose(talk_base::AsyncSocket* socket, int err) {
   } else {
     if (socket == control_socket_.get()) {
       LOG(WARNING) << "Connection refused; retrying in 2 seconds";
-      talk_base::Thread::Current()->PostDelayed(kReconnectDelay, this, 0);
+      rtc::Thread::Current()->PostDelayed(kReconnectDelay, this, 0);
     } else {
       Close();
       callback_->OnDisconnected();
@@ -525,7 +525,7 @@ void PeerConnectionClient::OnClose(talk_base::AsyncSocket* socket, int err) {
   }
 }
 
-void PeerConnectionClient::OnMessage(talk_base::Message* msg) {
+void PeerConnectionClient::OnMessage(rtc::Message* msg) {
   // ignore msg; there is currently only one supported message ("retry")
   DoConnect();
 }
diff --git a/examples/peerconnection/client/peer_connection_client.h b/examples/peerconnection/client/peer_connection_client.h
index 43fee34..3187895 100644
--- a/examples/peerconnection/client/peer_connection_client.h
+++ b/examples/peerconnection/client/peer_connection_client.h
@@ -32,11 +32,11 @@
 #include <map>
 #include <string>
 
-#include "talk/base/nethelpers.h"
-#include "talk/base/signalthread.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/nethelpers.h"
+#include "webrtc/base/signalthread.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/scoped_ptr.h"
 
 typedef std::map<int, std::string> Peers;
 
@@ -54,7 +54,7 @@ struct PeerConnectionClientObserver {
 };
 
 class PeerConnectionClient : public sigslot::has_slots<>,
-                             public talk_base::MessageHandler {
+                             public rtc::MessageHandler {
  public:
   enum State {
     NOT_CONNECTED,
@@ -84,15 +84,15 @@ class PeerConnectionClient : public sigslot::has_slots<>,
   bool SignOut();
 
   // implements the MessageHandler interface
-  void OnMessage(talk_base::Message* msg);
+  void OnMessage(rtc::Message* msg);
 
  protected:
   void DoConnect();
   void Close();
   void InitSocketSignals();
   bool ConnectControlSocket();
-  void OnConnect(talk_base::AsyncSocket* socket);
-  void OnHangingGetConnect(talk_base::AsyncSocket* socket);
+  void OnConnect(rtc::AsyncSocket* socket);
+  void OnHangingGetConnect(rtc::AsyncSocket* socket);
   void OnMessageFromPeer(int peer_id, const std::string& message);
 
   // Quick and dirty support for parsing HTTP header values.
@@ -103,12 +103,12 @@ class PeerConnectionClient : public sigslot::has_slots<>,
                       const char* header_pattern, std::string* value);
 
   // Returns true if the whole response has been read.
-  bool ReadIntoBuffer(talk_base::AsyncSocket* socket, std::string* data,
+  bool ReadIntoBuffer(rtc::AsyncSocket* socket, std::string* data,
                       size_t* content_length);
 
-  void OnRead(talk_base::AsyncSocket* socket);
+  void OnRead(rtc::AsyncSocket* socket);
 
-  void OnHangingGetRead(talk_base::AsyncSocket* socket);
+  void OnHangingGetRead(rtc::AsyncSocket* socket);
 
   // Parses a single line entry in the form "<name>,<id>,<connected>"
   bool ParseEntry(const std::string& entry, std::string* name, int* id,
@@ -119,15 +119,15 @@ class PeerConnectionClient : public sigslot::has_slots<>,
   bool ParseServerResponse(const std::string& response, size_t content_length,
                            size_t* peer_id, size_t* eoh);
 
-  void OnClose(talk_base::AsyncSocket* socket, int err);
+  void OnClose(rtc::AsyncSocket* socket, int err);
 
-  void OnResolveResult(talk_base::AsyncResolverInterface* resolver);
+  void OnResolveResult(rtc::AsyncResolverInterface* resolver);
 
   PeerConnectionClientObserver* callback_;
-  talk_base::SocketAddress server_address_;
-  talk_base::AsyncResolver* resolver_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> control_socket_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> hanging_get_;
+  rtc::SocketAddress server_address_;
+  rtc::AsyncResolver* resolver_;
+  rtc::scoped_ptr<rtc::AsyncSocket> control_socket_;
+  rtc::scoped_ptr<rtc::AsyncSocket> hanging_get_;
   std::string onconnect_data_;
   std::string control_data_;
   std::string notification_data_;
diff --git a/examples/peerconnection/server/main.cc b/examples/peerconnection/server/main.cc
index 40ede93..9be3bbe 100644
--- a/examples/peerconnection/server/main.cc
+++ b/examples/peerconnection/server/main.cc
@@ -31,7 +31,7 @@
 
 #include <vector>
 
-#include "talk/base/flags.h"
+#include "webrtc/base/flags.h"
 #include "talk/examples/peerconnection/server/data_socket.h"
 #include "talk/examples/peerconnection/server/peer_channel.h"
 #include "talk/examples/peerconnection/server/utils.h"
@@ -67,9 +67,9 @@ void HandleBrowserRequest(DataSocket* ds, bool* quit) {
 }
 
 int main(int argc, char** argv) {
-  FlagList::SetFlagsFromCommandLine(&argc, argv, true);
+  rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
   if (FLAG_help) {
-    FlagList::Print(NULL, false);
+    rtc::FlagList::Print(NULL, false);
     return 0;
   }
 
diff --git a/examples/relayserver/relayserver_main.cc b/examples/relayserver/relayserver_main.cc
index 11e8a5b..d9dde66 100644
--- a/examples/relayserver/relayserver_main.cc
+++ b/examples/relayserver/relayserver_main.cc
@@ -27,8 +27,8 @@
 
 #include <iostream>  // NOLINT
 
-#include "talk/base/thread.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/p2p/base/relayserver.h"
 
 int main(int argc, char **argv) {
@@ -38,30 +38,30 @@ int main(int argc, char **argv) {
     return 1;
   }
 
-  talk_base::SocketAddress int_addr;
+  rtc::SocketAddress int_addr;
   if (!int_addr.FromString(argv[1])) {
     std::cerr << "Unable to parse IP address: " << argv[1];
     return 1;
   }
 
-  talk_base::SocketAddress ext_addr;
+  rtc::SocketAddress ext_addr;
   if (!ext_addr.FromString(argv[2])) {
     std::cerr << "Unable to parse IP address: " << argv[2];
     return 1;
   }
 
-  talk_base::Thread *pthMain = talk_base::Thread::Current();
+  rtc::Thread *pthMain = rtc::Thread::Current();
 
-  talk_base::scoped_ptr<talk_base::AsyncUDPSocket> int_socket(
-      talk_base::AsyncUDPSocket::Create(pthMain->socketserver(), int_addr));
+  rtc::scoped_ptr<rtc::AsyncUDPSocket> int_socket(
+      rtc::AsyncUDPSocket::Create(pthMain->socketserver(), int_addr));
   if (!int_socket) {
     std::cerr << "Failed to create a UDP socket bound at"
               << int_addr.ToString() << std::endl;
     return 1;
   }
 
-  talk_base::scoped_ptr<talk_base::AsyncUDPSocket> ext_socket(
-      talk_base::AsyncUDPSocket::Create(pthMain->socketserver(), ext_addr));
+  rtc::scoped_ptr<rtc::AsyncUDPSocket> ext_socket(
+      rtc::AsyncUDPSocket::Create(pthMain->socketserver(), ext_addr));
   if (!ext_socket) {
     std::cerr << "Failed to create a UDP socket bound at"
               << ext_addr.ToString() << std::endl;
diff --git a/examples/stunserver/stunserver_main.cc b/examples/stunserver/stunserver_main.cc
index 4467944..3ac2ea6 100644
--- a/examples/stunserver/stunserver_main.cc
+++ b/examples/stunserver/stunserver_main.cc
@@ -31,7 +31,7 @@
 
 #include <iostream>
 
-#include "talk/base/thread.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/stunserver.h"
 
 using namespace cricket;
@@ -42,16 +42,16 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
-  talk_base::SocketAddress server_addr;
+  rtc::SocketAddress server_addr;
   if (!server_addr.FromString(argv[1])) {
     std::cerr << "Unable to parse IP address: " << argv[1];
     return 1;
   }
 
-  talk_base::Thread *pthMain = talk_base::Thread::Current();
+  rtc::Thread *pthMain = rtc::Thread::Current();
 
-  talk_base::AsyncUDPSocket* server_socket =
-      talk_base::AsyncUDPSocket::Create(pthMain->socketserver(), server_addr);
+  rtc::AsyncUDPSocket* server_socket =
+      rtc::AsyncUDPSocket::Create(pthMain->socketserver(), server_addr);
   if (!server_socket) {
     std::cerr << "Failed to create a UDP socket" << std::endl;
     return 1;
diff --git a/examples/turnserver/turnserver_main.cc b/examples/turnserver/turnserver_main.cc
index d40fede..a32f42c 100644
--- a/examples/turnserver/turnserver_main.cc
+++ b/examples/turnserver/turnserver_main.cc
@@ -27,10 +27,10 @@
 
 #include <iostream>  // NOLINT
 
-#include "talk/base/asyncudpsocket.h"
-#include "talk/base/optionsfile.h"
-#include "talk/base/thread.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/asyncudpsocket.h"
+#include "webrtc/base/optionsfile.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/base/turnserver.h"
 
@@ -49,13 +49,13 @@ class TurnFileAuth : public cricket::TurnAuthInterface {
     bool ret = file_.GetStringValue(username, &hex);
     if (ret) {
       char buf[32];
-      size_t len = talk_base::hex_decode(buf, sizeof(buf), hex);
+      size_t len = rtc::hex_decode(buf, sizeof(buf), hex);
       *key = std::string(buf, len);
     }
     return ret;
   }
  private:
-  talk_base::OptionsFile file_;
+  rtc::OptionsFile file_;
 };
 
 int main(int argc, char **argv) {
@@ -65,21 +65,21 @@ int main(int argc, char **argv) {
     return 1;
   }
 
-  talk_base::SocketAddress int_addr;
+  rtc::SocketAddress int_addr;
   if (!int_addr.FromString(argv[1])) {
     std::cerr << "Unable to parse IP address: " << argv[1] << std::endl;
     return 1;
   }
 
-  talk_base::IPAddress ext_addr;
+  rtc::IPAddress ext_addr;
   if (!IPFromString(argv[2], &ext_addr)) {
     std::cerr << "Unable to parse IP address: " << argv[2] << std::endl;
     return 1;
   }
 
-  talk_base::Thread* main = talk_base::Thread::Current();
-  talk_base::AsyncUDPSocket* int_socket =
-      talk_base::AsyncUDPSocket::Create(main->socketserver(), int_addr);
+  rtc::Thread* main = rtc::Thread::Current();
+  rtc::AsyncUDPSocket* int_socket =
+      rtc::AsyncUDPSocket::Create(main->socketserver(), int_addr);
   if (!int_socket) {
     std::cerr << "Failed to create a UDP socket bound at"
               << int_addr.ToString() << std::endl;
@@ -92,8 +92,8 @@ int main(int argc, char **argv) {
   server.set_software(kSoftware);
   server.set_auth_hook(&auth);
   server.AddInternalSocket(int_socket, cricket::PROTO_UDP);
-  server.SetExternalSocketFactory(new talk_base::BasicPacketSocketFactory(),
-                                  talk_base::SocketAddress(ext_addr, 0));
+  server.SetExternalSocketFactory(new rtc::BasicPacketSocketFactory(),
+                                  rtc::SocketAddress(ext_addr, 0));
 
   std::cout << "Listening internally at " << int_addr.ToString() << std::endl;