diff --git a/talk/app/webrtc/audiotrack.cc b/talk/app/webrtc/audiotrack.cc
index a8d45baaca..5ac9b96668 100644
--- a/talk/app/webrtc/audiotrack.cc
+++ b/talk/app/webrtc/audiotrack.cc
@@ -42,10 +42,10 @@ std::string AudioTrack::kind() const {
   return kAudioTrackKind;
 }
 
-talk_base::scoped_refptr<AudioTrack> AudioTrack::Create(
+rtc::scoped_refptr<AudioTrack> AudioTrack::Create(
     const std::string& id, AudioSourceInterface* source) {
-  talk_base::RefCountedObject<AudioTrack>* track =
-      new talk_base::RefCountedObject<AudioTrack>(id, source);
+  rtc::RefCountedObject<AudioTrack>* track =
+      new rtc::RefCountedObject<AudioTrack>(id, source);
   return track;
 }
 
diff --git a/talk/app/webrtc/audiotrack.h b/talk/app/webrtc/audiotrack.h
index 2f96527f64..f0094d35b5 100644
--- a/talk/app/webrtc/audiotrack.h
+++ b/talk/app/webrtc/audiotrack.h
@@ -31,14 +31,14 @@
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/mediastreamtrack.h"
 #include "talk/app/webrtc/notifier.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/scoped_ref_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 
 namespace webrtc {
 
 class AudioTrack : public MediaStreamTrack<AudioTrackInterface> {
  public:
-  static talk_base::scoped_refptr<AudioTrack> Create(
+  static rtc::scoped_refptr<AudioTrack> Create(
       const std::string& id, AudioSourceInterface* source);
 
   // AudioTrackInterface implementation.
@@ -49,7 +49,7 @@ class AudioTrack : public MediaStreamTrack<AudioTrackInterface> {
   virtual void AddSink(AudioTrackSinkInterface* sink) OVERRIDE {}
   virtual void RemoveSink(AudioTrackSinkInterface* sink) OVERRIDE {}
   virtual bool GetSignalLevel(int* level) OVERRIDE { return false; }
-  virtual talk_base::scoped_refptr<AudioProcessorInterface> GetAudioProcessor()
+  virtual rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor()
       OVERRIDE { return NULL; }
   virtual cricket::AudioRenderer* GetRenderer() OVERRIDE {
     return NULL;
@@ -62,7 +62,7 @@ class AudioTrack : public MediaStreamTrack<AudioTrackInterface> {
   AudioTrack(const std::string& label, AudioSourceInterface* audio_source);
 
  private:
-  talk_base::scoped_refptr<AudioSourceInterface> audio_source_;
+  rtc::scoped_refptr<AudioSourceInterface> audio_source_;
 };
 
 }  // namespace webrtc
diff --git a/talk/app/webrtc/audiotrackrenderer.cc b/talk/app/webrtc/audiotrackrenderer.cc
index 92d3449ac8..c812697bd4 100644
--- a/talk/app/webrtc/audiotrackrenderer.cc
+++ b/talk/app/webrtc/audiotrackrenderer.cc
@@ -26,7 +26,7 @@
  */
 
 #include "talk/app/webrtc/audiotrackrenderer.h"
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 
 namespace webrtc {
 
diff --git a/talk/app/webrtc/audiotrackrenderer.h b/talk/app/webrtc/audiotrackrenderer.h
index a4c58c4fc0..4a9bf6e767 100644
--- a/talk/app/webrtc/audiotrackrenderer.h
+++ b/talk/app/webrtc/audiotrackrenderer.h
@@ -28,7 +28,7 @@
 #ifndef TALK_APP_WEBRTC_AUDIOTRACKRENDERER_H_
 #define TALK_APP_WEBRTC_AUDIOTRACKRENDERER_H_
 
-#include "talk/base/thread.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/audiorenderer.h"
 
 namespace webrtc {
diff --git a/talk/app/webrtc/datachannel.cc b/talk/app/webrtc/datachannel.cc
index d98f8be802..952f5bfb6e 100644
--- a/talk/app/webrtc/datachannel.cc
+++ b/talk/app/webrtc/datachannel.cc
@@ -30,8 +30,8 @@
 
 #include "talk/app/webrtc/mediastreamprovider.h"
 #include "talk/app/webrtc/sctputils.h"
-#include "talk/base/logging.h"
-#include "talk/base/refcount.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/refcount.h"
 
 namespace webrtc {
 
@@ -86,13 +86,13 @@ void DataChannel::PacketQueue::Swap(PacketQueue* other) {
   other->packets_.swap(packets_);
 }
 
-talk_base::scoped_refptr<DataChannel> DataChannel::Create(
+rtc::scoped_refptr<DataChannel> DataChannel::Create(
     DataChannelProviderInterface* provider,
     cricket::DataChannelType dct,
     const std::string& label,
     const InternalDataChannelInit& config) {
-  talk_base::scoped_refptr<DataChannel> channel(
-      new talk_base::RefCountedObject<DataChannel>(provider, dct, label));
+  rtc::scoped_refptr<DataChannel> channel(
+      new rtc::RefCountedObject<DataChannel>(provider, dct, label));
   if (!channel->Init(config)) {
     return NULL;
   }
@@ -151,7 +151,7 @@ bool DataChannel::Init(const InternalDataChannelInit& config) {
     // Chrome glue and WebKit) are not wired up properly until after this
     // function returns.
     if (provider_->ReadyToSendData()) {
-      talk_base::Thread::Current()->Post(this, MSG_CHANNELREADY, NULL);
+      rtc::Thread::Current()->Post(this, MSG_CHANNELREADY, NULL);
     }
   }
 
@@ -271,7 +271,7 @@ void DataChannel::SetSendSsrc(uint32 send_ssrc) {
   UpdateState();
 }
 
-void DataChannel::OnMessage(talk_base::Message* msg) {
+void DataChannel::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_CHANNELREADY:
       OnChannelReady(true);
@@ -288,7 +288,7 @@ void DataChannel::OnDataEngineClose() {
 
 void DataChannel::OnDataReceived(cricket::DataChannel* channel,
                                  const cricket::ReceiveDataParams& params,
-                                 const talk_base::Buffer& payload) {
+                                 const rtc::Buffer& payload) {
   uint32 expected_ssrc =
       (data_channel_type_ == cricket::DCT_RTP) ? receive_ssrc_ : config_.id;
   if (params.ssrc != expected_ssrc) {
@@ -325,7 +325,7 @@ void DataChannel::OnDataReceived(cricket::DataChannel* channel,
   waiting_for_open_ack_ = false;
 
   bool binary = (params.type == cricket::DMT_BINARY);
-  talk_base::scoped_ptr<DataBuffer> buffer(new DataBuffer(payload, binary));
+  rtc::scoped_ptr<DataBuffer> buffer(new DataBuffer(payload, binary));
   if (was_ever_writable_ && observer_) {
     observer_->OnMessage(*buffer.get());
   } else {
@@ -355,7 +355,7 @@ void DataChannel::OnChannelReady(bool writable) {
     was_ever_writable_ = true;
 
     if (data_channel_type_ == cricket::DCT_SCTP) {
-      talk_base::Buffer payload;
+      rtc::Buffer payload;
 
       if (config_.open_handshake_role == InternalDataChannelInit::kOpener) {
         WriteDataChannelOpenMessage(label_, config_, &payload);
@@ -452,7 +452,7 @@ void DataChannel::DeliverQueuedReceivedData() {
   }
 
   while (!queued_received_data_.Empty()) {
-    talk_base::scoped_ptr<DataBuffer> buffer(queued_received_data_.Front());
+    rtc::scoped_ptr<DataBuffer> buffer(queued_received_data_.Front());
     observer_->OnMessage(*buffer);
     queued_received_data_.Pop();
   }
@@ -465,7 +465,7 @@ void DataChannel::SendQueuedDataMessages() {
   packet_buffer.Swap(&queued_send_data_);
 
   while (!packet_buffer.Empty()) {
-    talk_base::scoped_ptr<DataBuffer> buffer(packet_buffer.Front());
+    rtc::scoped_ptr<DataBuffer> buffer(packet_buffer.Front());
     SendDataMessage(*buffer);
     packet_buffer.Pop();
   }
@@ -520,17 +520,17 @@ void DataChannel::SendQueuedControlMessages() {
   control_packets.Swap(&queued_control_data_);
 
   while (!control_packets.Empty()) {
-    talk_base::scoped_ptr<DataBuffer> buf(control_packets.Front());
+    rtc::scoped_ptr<DataBuffer> buf(control_packets.Front());
     SendControlMessage(buf->data);
     control_packets.Pop();
   }
 }
 
-void DataChannel::QueueControlMessage(const talk_base::Buffer& buffer) {
+void DataChannel::QueueControlMessage(const rtc::Buffer& buffer) {
   queued_control_data_.Push(new DataBuffer(buffer, true));
 }
 
-bool DataChannel::SendControlMessage(const talk_base::Buffer& buffer) {
+bool DataChannel::SendControlMessage(const rtc::Buffer& buffer) {
   bool is_open_message =
       (config_.open_handshake_role == InternalDataChannelInit::kOpener);
 
diff --git a/talk/app/webrtc/datachannel.h b/talk/app/webrtc/datachannel.h
index 0510f7e887..184ad91b88 100644
--- a/talk/app/webrtc/datachannel.h
+++ b/talk/app/webrtc/datachannel.h
@@ -33,9 +33,9 @@
 
 #include "talk/app/webrtc/datachannelinterface.h"
 #include "talk/app/webrtc/proxy.h"
-#include "talk/base/messagehandler.h"
-#include "talk/base/scoped_ref_ptr.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/session/media/channel.h"
 
@@ -47,7 +47,7 @@ class DataChannelProviderInterface {
  public:
   // Sends the data to the transport.
   virtual bool SendData(const cricket::SendDataParams& params,
-                        const talk_base::Buffer& payload,
+                        const rtc::Buffer& payload,
                         cricket::SendDataResult* result) = 0;
   // Connects to the transport signals.
   virtual bool ConnectDataChannel(DataChannel* data_channel) = 0;
@@ -100,9 +100,9 @@ struct InternalDataChannelInit : public DataChannelInit {
 //          SSRC==0.
 class DataChannel : public DataChannelInterface,
                     public sigslot::has_slots<>,
-                    public talk_base::MessageHandler {
+                    public rtc::MessageHandler {
  public:
-  static talk_base::scoped_refptr<DataChannel> Create(
+  static rtc::scoped_refptr<DataChannel> Create(
       DataChannelProviderInterface* provider,
       cricket::DataChannelType dct,
       const std::string& label,
@@ -128,8 +128,8 @@ class DataChannel : public DataChannelInterface,
   virtual DataState state() const { return state_; }
   virtual bool Send(const DataBuffer& buffer);
 
-  // talk_base::MessageHandler override.
-  virtual void OnMessage(talk_base::Message* msg);
+  // rtc::MessageHandler override.
+  virtual void OnMessage(rtc::Message* msg);
 
   // Called if the underlying data engine is closing.
   void OnDataEngineClose();
@@ -142,7 +142,7 @@ class DataChannel : public DataChannelInterface,
   // Sigslots from cricket::DataChannel
   void OnDataReceived(cricket::DataChannel* channel,
                       const cricket::ReceiveDataParams& params,
-                      const talk_base::Buffer& payload);
+                      const rtc::Buffer& payload);
 
   // The remote peer request that this channel should be closed.
   void RemotePeerRequestClose();
@@ -217,8 +217,8 @@ class DataChannel : public DataChannelInterface,
   bool QueueSendDataMessage(const DataBuffer& buffer);
 
   void SendQueuedControlMessages();
-  void QueueControlMessage(const talk_base::Buffer& buffer);
-  bool SendControlMessage(const talk_base::Buffer& buffer);
+  void QueueControlMessage(const rtc::Buffer& buffer);
+  bool SendControlMessage(const rtc::Buffer& buffer);
 
   std::string label_;
   InternalDataChannelInit config_;
@@ -242,7 +242,7 @@ class DataChannel : public DataChannelInterface,
 
 class DataChannelFactory {
  public:
-  virtual talk_base::scoped_refptr<DataChannel> CreateDataChannel(
+  virtual rtc::scoped_refptr<DataChannel> CreateDataChannel(
       const std::string& label,
       const InternalDataChannelInit* config) = 0;
 
diff --git a/talk/app/webrtc/datachannel_unittest.cc b/talk/app/webrtc/datachannel_unittest.cc
index ef4d26f924..84a6935358 100644
--- a/talk/app/webrtc/datachannel_unittest.cc
+++ b/talk/app/webrtc/datachannel_unittest.cc
@@ -28,7 +28,7 @@
 #include "talk/app/webrtc/datachannel.h"
 #include "talk/app/webrtc/sctputils.h"
 #include "talk/app/webrtc/test/fakedatachannelprovider.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 
 using webrtc::DataChannel;
 
@@ -86,14 +86,14 @@ class SctpDataChannelTest : public testing::Test {
 
   webrtc::InternalDataChannelInit init_;
   FakeDataChannelProvider provider_;
-  talk_base::scoped_ptr<FakeDataChannelObserver> observer_;
-  talk_base::scoped_refptr<DataChannel> webrtc_data_channel_;
+  rtc::scoped_ptr<FakeDataChannelObserver> observer_;
+  rtc::scoped_refptr<DataChannel> webrtc_data_channel_;
 };
 
 // Verifies that the data channel is connected to the transport after creation.
 TEST_F(SctpDataChannelTest, ConnectedToTransportOnCreated) {
   provider_.set_transport_available(true);
-  talk_base::scoped_refptr<DataChannel> dc = DataChannel::Create(
+  rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", init_);
 
   EXPECT_TRUE(provider_.IsConnected(dc.get()));
@@ -190,7 +190,7 @@ TEST_F(SctpDataChannelTest, LateCreatedChannelTransitionToOpen) {
   SetChannelReady();
   webrtc::InternalDataChannelInit init;
   init.id = 1;
-  talk_base::scoped_refptr<DataChannel> dc = DataChannel::Create(
+  rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", init);
   EXPECT_EQ(webrtc::DataChannelInterface::kConnecting, dc->state());
   EXPECT_TRUE_WAIT(webrtc::DataChannelInterface::kOpen == dc->state(),
@@ -204,7 +204,7 @@ TEST_F(SctpDataChannelTest, SendUnorderedAfterReceivesOpenAck) {
   webrtc::InternalDataChannelInit init;
   init.id = 1;
   init.ordered = false;
-  talk_base::scoped_refptr<DataChannel> dc = DataChannel::Create(
+  rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", init);
 
   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
@@ -218,7 +218,7 @@ TEST_F(SctpDataChannelTest, SendUnorderedAfterReceivesOpenAck) {
   cricket::ReceiveDataParams params;
   params.ssrc = init.id;
   params.type = cricket::DMT_CONTROL;
-  talk_base::Buffer payload;
+  rtc::Buffer payload;
   webrtc::WriteDataChannelOpenAckMessage(&payload);
   dc->OnDataReceived(NULL, params, payload);
 
@@ -234,7 +234,7 @@ TEST_F(SctpDataChannelTest, SendUnorderedAfterReceiveData) {
   webrtc::InternalDataChannelInit init;
   init.id = 1;
   init.ordered = false;
-  talk_base::scoped_refptr<DataChannel> dc = DataChannel::Create(
+  rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", init);
 
   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
@@ -299,7 +299,7 @@ TEST_F(SctpDataChannelTest, NoMsgSentIfNegotiatedAndNotFromOpenMsg) {
   config.open_handshake_role = webrtc::InternalDataChannelInit::kNone;
 
   SetChannelReady();
-  talk_base::scoped_refptr<DataChannel> dc = DataChannel::Create(
+  rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", config);
 
   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
@@ -315,7 +315,7 @@ TEST_F(SctpDataChannelTest, OpenAckSentIfCreatedFromOpenMessage) {
   config.open_handshake_role = webrtc::InternalDataChannelInit::kAcker;
 
   SetChannelReady();
-  talk_base::scoped_refptr<DataChannel> dc = DataChannel::Create(
+  rtc::scoped_refptr<DataChannel> dc = DataChannel::Create(
       &provider_, cricket::DCT_SCTP, "test1", config);
 
   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
@@ -342,7 +342,7 @@ TEST_F(SctpDataChannelTest, ClosedWhenSendBufferFull) {
   SetChannelReady();
 
   const size_t buffer_size = 1024;
-  talk_base::Buffer buffer;
+  rtc::Buffer buffer;
   buffer.SetLength(buffer_size);
   memset(buffer.data(), 0, buffer_size);
 
@@ -396,7 +396,7 @@ TEST_F(SctpDataChannelTest, RemotePeerRequestClose) {
 TEST_F(SctpDataChannelTest, ClosedWhenReceivedBufferFull) {
   SetChannelReady();
   const size_t buffer_size = 1024;
-  talk_base::Buffer buffer;
+  rtc::Buffer buffer;
   buffer.SetLength(buffer_size);
   memset(buffer.data(), 0, buffer_size);
 
diff --git a/talk/app/webrtc/datachannelinterface.h b/talk/app/webrtc/datachannelinterface.h
index 57fe200cfe..5684cc2428 100644
--- a/talk/app/webrtc/datachannelinterface.h
+++ b/talk/app/webrtc/datachannelinterface.h
@@ -33,9 +33,9 @@
 
 #include <string>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/buffer.h"
-#include "talk/base/refcount.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/refcount.h"
 
 
 namespace webrtc {
@@ -66,7 +66,7 @@ struct DataChannelInit {
 };
 
 struct DataBuffer {
-  DataBuffer(const talk_base::Buffer& data, bool binary)
+  DataBuffer(const rtc::Buffer& data, bool binary)
       : data(data),
         binary(binary) {
   }
@@ -77,7 +77,7 @@ struct DataBuffer {
   }
   size_t size() const { return data.length(); }
 
-  talk_base::Buffer data;
+  rtc::Buffer data;
   // Indicates if the received data contains UTF-8 or binary data.
   // Note that the upper layers are left to verify the UTF-8 encoding.
   // TODO(jiayl): prefer to use an enum instead of a bool.
@@ -95,7 +95,7 @@ class DataChannelObserver {
   virtual ~DataChannelObserver() {}
 };
 
-class DataChannelInterface : public talk_base::RefCountInterface {
+class DataChannelInterface : public rtc::RefCountInterface {
  public:
   // Keep in sync with DataChannel.java:State and
   // RTCDataChannel.h:RTCDataChannelState.
diff --git a/talk/app/webrtc/dtmfsender.cc b/talk/app/webrtc/dtmfsender.cc
index 6556acdbb8..4eade1610e 100644
--- a/talk/app/webrtc/dtmfsender.cc
+++ b/talk/app/webrtc/dtmfsender.cc
@@ -31,8 +31,8 @@
 
 #include <string>
 
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 
 namespace webrtc {
 
@@ -75,21 +75,21 @@ bool GetDtmfCode(char tone, int* code) {
   return true;
 }
 
-talk_base::scoped_refptr<DtmfSender> DtmfSender::Create(
+rtc::scoped_refptr<DtmfSender> DtmfSender::Create(
     AudioTrackInterface* track,
-    talk_base::Thread* signaling_thread,
+    rtc::Thread* signaling_thread,
     DtmfProviderInterface* provider) {
   if (!track || !signaling_thread) {
     return NULL;
   }
-  talk_base::scoped_refptr<DtmfSender> dtmf_sender(
-      new talk_base::RefCountedObject<DtmfSender>(track, signaling_thread,
+  rtc::scoped_refptr<DtmfSender> dtmf_sender(
+      new rtc::RefCountedObject<DtmfSender>(track, signaling_thread,
                                                   provider));
   return dtmf_sender;
 }
 
 DtmfSender::DtmfSender(AudioTrackInterface* track,
-                       talk_base::Thread* signaling_thread,
+                       rtc::Thread* signaling_thread,
                        DtmfProviderInterface* provider)
     : track_(track),
       observer_(NULL),
@@ -176,7 +176,7 @@ int DtmfSender::inter_tone_gap() const {
   return inter_tone_gap_;
 }
 
-void DtmfSender::OnMessage(talk_base::Message* msg) {
+void DtmfSender::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_DO_INSERT_DTMF: {
       DoInsertDtmf();
diff --git a/talk/app/webrtc/dtmfsender.h b/talk/app/webrtc/dtmfsender.h
index f2bebdeb5a..e875d3ab2c 100644
--- a/talk/app/webrtc/dtmfsender.h
+++ b/talk/app/webrtc/dtmfsender.h
@@ -33,15 +33,15 @@
 #include "talk/app/webrtc/dtmfsenderinterface.h"
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/proxy.h"
-#include "talk/base/common.h"
-#include "talk/base/messagehandler.h"
-#include "talk/base/refcount.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/refcount.h"
 
 // DtmfSender is the native implementation of the RTCDTMFSender defined by
 // the WebRTC W3C Editor's Draft.
 // http://dev.w3.org/2011/webrtc/editor/webrtc.html
 
-namespace talk_base {
+namespace rtc {
 class Thread;
 }
 
@@ -70,11 +70,11 @@ class DtmfProviderInterface {
 class DtmfSender
     : public DtmfSenderInterface,
       public sigslot::has_slots<>,
-      public talk_base::MessageHandler {
+      public rtc::MessageHandler {
  public:
-  static talk_base::scoped_refptr<DtmfSender> Create(
+  static rtc::scoped_refptr<DtmfSender> Create(
       AudioTrackInterface* track,
-      talk_base::Thread* signaling_thread,
+      rtc::Thread* signaling_thread,
       DtmfProviderInterface* provider);
 
   // Implements DtmfSenderInterface.
@@ -90,7 +90,7 @@ class DtmfSender
 
  protected:
   DtmfSender(AudioTrackInterface* track,
-             talk_base::Thread* signaling_thread,
+             rtc::Thread* signaling_thread,
              DtmfProviderInterface* provider);
   virtual ~DtmfSender();
 
@@ -98,7 +98,7 @@ class DtmfSender
   DtmfSender();
 
   // Implements MessageHandler.
-  virtual void OnMessage(talk_base::Message* msg);
+  virtual void OnMessage(rtc::Message* msg);
 
   // The DTMF sending task.
   void DoInsertDtmf();
@@ -107,9 +107,9 @@ class DtmfSender
 
   void StopSending();
 
-  talk_base::scoped_refptr<AudioTrackInterface> track_;
+  rtc::scoped_refptr<AudioTrackInterface> track_;
   DtmfSenderObserverInterface* observer_;
-  talk_base::Thread* signaling_thread_;
+  rtc::Thread* signaling_thread_;
   DtmfProviderInterface* provider_;
   std::string tones_;
   int duration_;
diff --git a/talk/app/webrtc/dtmfsender_unittest.cc b/talk/app/webrtc/dtmfsender_unittest.cc
index a4835054ad..c5b19cc9d5 100644
--- a/talk/app/webrtc/dtmfsender_unittest.cc
+++ b/talk/app/webrtc/dtmfsender_unittest.cc
@@ -32,9 +32,9 @@
 #include <vector>
 
 #include "talk/app/webrtc/audiotrack.h"
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/timeutils.h"
 
 using webrtc::AudioTrackInterface;
 using webrtc::AudioTrack;
@@ -97,12 +97,12 @@ class FakeDtmfProvider : public DtmfProviderInterface {
   virtual bool InsertDtmf(const std::string& track_label,
                           int code, int duration) OVERRIDE {
     int gap = 0;
-    // TODO(ronghuawu): Make the timer (basically the talk_base::TimeNanos)
+    // TODO(ronghuawu): Make the timer (basically the rtc::TimeNanos)
     // mockable and use a fake timer in the unit tests.
     if (last_insert_dtmf_call_ > 0) {
-      gap = static_cast<int>(talk_base::Time() - last_insert_dtmf_call_);
+      gap = static_cast<int>(rtc::Time() - last_insert_dtmf_call_);
     }
-    last_insert_dtmf_call_ = talk_base::Time();
+    last_insert_dtmf_call_ = rtc::Time();
 
     LOG(LS_VERBOSE) << "FakeDtmfProvider::InsertDtmf code=" << code
                     << " duration=" << duration
@@ -139,10 +139,10 @@ class DtmfSenderTest : public testing::Test {
  protected:
   DtmfSenderTest()
       : track_(AudioTrack::Create(kTestAudioLabel, NULL)),
-        observer_(new talk_base::RefCountedObject<FakeDtmfObserver>()),
+        observer_(new rtc::RefCountedObject<FakeDtmfObserver>()),
         provider_(new FakeDtmfProvider()) {
     provider_->AddCanInsertDtmfTrack(kTestAudioLabel);
-    dtmf_ = DtmfSender::Create(track_, talk_base::Thread::Current(),
+    dtmf_ = DtmfSender::Create(track_, rtc::Thread::Current(),
                                provider_.get());
     dtmf_->RegisterObserver(observer_.get());
   }
@@ -229,10 +229,10 @@ class DtmfSenderTest : public testing::Test {
     }
   }
 
-  talk_base::scoped_refptr<AudioTrackInterface> track_;
-  talk_base::scoped_ptr<FakeDtmfObserver> observer_;
-  talk_base::scoped_ptr<FakeDtmfProvider> provider_;
-  talk_base::scoped_refptr<DtmfSender> dtmf_;
+  rtc::scoped_refptr<AudioTrackInterface> track_;
+  rtc::scoped_ptr<FakeDtmfObserver> observer_;
+  rtc::scoped_ptr<FakeDtmfProvider> provider_;
+  rtc::scoped_refptr<DtmfSender> dtmf_;
 };
 
 TEST_F(DtmfSenderTest, CanInsertDtmf) {
diff --git a/talk/app/webrtc/dtmfsenderinterface.h b/talk/app/webrtc/dtmfsenderinterface.h
index 46f39245db..93b4543ef7 100644
--- a/talk/app/webrtc/dtmfsenderinterface.h
+++ b/talk/app/webrtc/dtmfsenderinterface.h
@@ -31,8 +31,8 @@
 #include <string>
 
 #include "talk/app/webrtc/mediastreaminterface.h"
-#include "talk/base/common.h"
-#include "talk/base/refcount.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/refcount.h"
 
 // This file contains interfaces for DtmfSender.
 
@@ -53,7 +53,7 @@ class DtmfSenderObserverInterface {
 
 // The interface of native implementation of the RTCDTMFSender defined by the
 // WebRTC W3C Editor's Draft.
-class DtmfSenderInterface : public talk_base::RefCountInterface {
+class DtmfSenderInterface : public rtc::RefCountInterface {
  public:
   virtual void RegisterObserver(DtmfSenderObserverInterface* observer) = 0;
   virtual void UnregisterObserver() = 0;
diff --git a/talk/app/webrtc/fakeportallocatorfactory.h b/talk/app/webrtc/fakeportallocatorfactory.h
index c1727ae5cd..eee98b06f7 100644
--- a/talk/app/webrtc/fakeportallocatorfactory.h
+++ b/talk/app/webrtc/fakeportallocatorfactory.h
@@ -39,8 +39,8 @@ namespace webrtc {
 class FakePortAllocatorFactory : public PortAllocatorFactoryInterface {
  public:
   static FakePortAllocatorFactory* Create() {
-    talk_base::RefCountedObject<FakePortAllocatorFactory>* allocator =
-          new talk_base::RefCountedObject<FakePortAllocatorFactory>();
+    rtc::RefCountedObject<FakePortAllocatorFactory>* allocator =
+          new rtc::RefCountedObject<FakePortAllocatorFactory>();
     return allocator;
   }
 
@@ -49,7 +49,7 @@ class FakePortAllocatorFactory : public PortAllocatorFactoryInterface {
       const std::vector<TurnConfiguration>& turn_configurations) {
     stun_configs_ = stun_configurations;
     turn_configs_ = turn_configurations;
-    return new cricket::FakePortAllocator(talk_base::Thread::Current(), NULL);
+    return new cricket::FakePortAllocator(rtc::Thread::Current(), NULL);
   }
 
   const std::vector<StunConfiguration>& stun_configs() const {
diff --git a/talk/app/webrtc/java/jni/peerconnection_jni.cc b/talk/app/webrtc/java/jni/peerconnection_jni.cc
index a3181a582b..fadbc8a82b 100644
--- a/talk/app/webrtc/java/jni/peerconnection_jni.cc
+++ b/talk/app/webrtc/java/jni/peerconnection_jni.cc
@@ -66,10 +66,10 @@
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
 #include "talk/app/webrtc/videosourceinterface.h"
-#include "talk/base/bind.h"
-#include "talk/base/logging.h"
-#include "talk/base/messagequeue.h"
-#include "talk/base/ssladapter.h"
+#include "webrtc/base/bind.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/ssladapter.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videorenderer.h"
 #include "talk/media/devices/videorendererfactory.h"
@@ -98,10 +98,10 @@ using webrtc::VideoCodec;
 #endif
 
 using icu::UnicodeString;
-using talk_base::Bind;
-using talk_base::Thread;
-using talk_base::ThreadManager;
-using talk_base::scoped_ptr;
+using rtc::Bind;
+using rtc::Thread;
+using rtc::ThreadManager;
+using rtc::scoped_ptr;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrackInterface;
 using webrtc::AudioTrackVector;
@@ -1177,7 +1177,7 @@ enum { kMediaCodecPollMs = 10 };
 // MediaCodecVideoEncoder is created, operated, and destroyed on a single
 // thread, currently the libjingle Worker thread.
 class MediaCodecVideoEncoder : public webrtc::VideoEncoder,
-                               public talk_base::MessageHandler {
+                               public rtc::MessageHandler {
  public:
   virtual ~MediaCodecVideoEncoder();
   explicit MediaCodecVideoEncoder(JNIEnv* jni);
@@ -1198,8 +1198,8 @@ class MediaCodecVideoEncoder : public webrtc::VideoEncoder,
                                        int /* rtt */) OVERRIDE;
   virtual int32_t SetRates(uint32_t new_bit_rate, uint32_t frame_rate) OVERRIDE;
 
-  // talk_base::MessageHandler implementation.
-  virtual void OnMessage(talk_base::Message* msg) OVERRIDE;
+  // rtc::MessageHandler implementation.
+  virtual void OnMessage(rtc::Message* msg) OVERRIDE;
 
  private:
   // CHECK-fail if not running on |codec_thread_|.
@@ -1401,7 +1401,7 @@ int32_t MediaCodecVideoEncoder::SetRates(uint32_t new_bit_rate,
            frame_rate));
 }
 
-void MediaCodecVideoEncoder::OnMessage(talk_base::Message* msg) {
+void MediaCodecVideoEncoder::OnMessage(rtc::Message* msg) {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
@@ -1639,7 +1639,7 @@ int32_t MediaCodecVideoEncoder::SetRatesOnCodecThread(uint32_t new_bit_rate,
 }
 
 void MediaCodecVideoEncoder::ResetParameters(JNIEnv* jni) {
-  talk_base::MessageQueueManager::Clear(this);
+  rtc::MessageQueueManager::Clear(this);
   width_ = 0;
   height_ = 0;
   yuv_size_ = 0;
@@ -1818,7 +1818,7 @@ void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
 }
 
 class MediaCodecVideoDecoder : public webrtc::VideoDecoder,
-                               public talk_base::MessageHandler {
+                               public rtc::MessageHandler {
  public:
   explicit MediaCodecVideoDecoder(JNIEnv* jni);
   virtual ~MediaCodecVideoDecoder();
@@ -1838,8 +1838,8 @@ class MediaCodecVideoDecoder : public webrtc::VideoDecoder,
   virtual int32_t Release() OVERRIDE;
 
   virtual int32_t Reset() OVERRIDE;
-  // talk_base::MessageHandler implementation.
-  virtual void OnMessage(talk_base::Message* msg) OVERRIDE;
+  // rtc::MessageHandler implementation.
+  virtual void OnMessage(rtc::Message* msg) OVERRIDE;
 
  private:
   // CHECK-fail if not running on |codec_thread_|.
@@ -2196,7 +2196,7 @@ int32_t MediaCodecVideoDecoder::Reset() {
   return InitDecode(&codec_, 1);
 }
 
-void MediaCodecVideoDecoder::OnMessage(talk_base::Message* msg) {
+void MediaCodecVideoDecoder::OnMessage(rtc::Message* msg) {
 }
 
 class MediaCodecVideoDecoderFactory
@@ -2256,7 +2256,7 @@ extern "C" jint JNIEXPORT JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
 
   CHECK(!pthread_once(&g_jni_ptr_once, &CreateJNIPtrKey), "pthread_once");
 
-  CHECK(talk_base::InitializeSSL(), "Failed to InitializeSSL()");
+  CHECK(rtc::InitializeSSL(), "Failed to InitializeSSL()");
 
   JNIEnv* jni;
   if (jvm->GetEnv(reinterpret_cast<void**>(&jni), JNI_VERSION_1_6) != JNI_OK)
@@ -2270,7 +2270,7 @@ extern "C" void JNIEXPORT JNICALL JNI_OnUnLoad(JavaVM *jvm, void *reserved) {
   g_class_reference_holder->FreeReferences(AttachCurrentThreadIfNeeded());
   delete g_class_reference_holder;
   g_class_reference_holder = NULL;
-  CHECK(talk_base::CleanupSSL(), "Failed to CleanupSSL()");
+  CHECK(rtc::CleanupSSL(), "Failed to CleanupSSL()");
   g_jvm = NULL;
 }
 
@@ -2319,7 +2319,7 @@ JOW(jboolean, DataChannel_sendNative)(JNIEnv* jni, jobject j_dc,
                                       jbyteArray data, jboolean binary) {
   jbyte* bytes = jni->GetByteArrayElements(data, NULL);
   bool ret = ExtractNativeDC(jni, j_dc)->Send(DataBuffer(
-      talk_base::Buffer(bytes, jni->GetArrayLength(data)),
+      rtc::Buffer(bytes, jni->GetArrayLength(data)),
       binary));
   jni->ReleaseByteArrayElements(data, bytes, JNI_ABORT);
   return ret;
@@ -2348,7 +2348,7 @@ JOW(void, Logging_nativeEnableTracing)(
     }
 #endif
   }
-  talk_base::LogMessage::LogToDebug(nativeSeverity);
+  rtc::LogMessage::LogToDebug(nativeSeverity);
 }
 
 JOW(void, PeerConnection_freePeerConnection)(JNIEnv*, jclass, jlong j_p) {
@@ -2458,9 +2458,9 @@ JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnectionFactory)(
   // talk/ assumes pretty widely that the current Thread is ThreadManager'd, but
   // ThreadManager only WrapCurrentThread()s the thread where it is first
   // created.  Since the semantics around when auto-wrapping happens in
-  // talk/base/ are convoluted, we simply wrap here to avoid having to think
+  // webrtc/base/ are convoluted, we simply wrap here to avoid having to think
   // about ramifications of auto-wrapping there.
-  talk_base::ThreadManager::Instance()->WrapCurrentThread();
+  rtc::ThreadManager::Instance()->WrapCurrentThread();
   webrtc::Trace::CreateTrace();
   Thread* worker_thread = new Thread();
   worker_thread->SetName("worker_thread", NULL);
@@ -2474,7 +2474,7 @@ JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnectionFactory)(
   encoder_factory.reset(new MediaCodecVideoEncoderFactory());
   decoder_factory.reset(new MediaCodecVideoDecoderFactory());
 #endif
-  talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       webrtc::CreatePeerConnectionFactory(worker_thread,
                                           signaling_thread,
                                           NULL,
@@ -2496,9 +2496,9 @@ static PeerConnectionFactoryInterface* factoryFromJava(jlong j_p) {
 
 JOW(jlong, PeerConnectionFactory_nativeCreateLocalMediaStream)(
     JNIEnv* jni, jclass, jlong native_factory, jstring label) {
-  talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
-  talk_base::scoped_refptr<MediaStreamInterface> stream(
+  rtc::scoped_refptr<MediaStreamInterface> stream(
       factory->CreateLocalMediaStream(JavaToStdString(jni, label)));
   return (jlong)stream.release();
 }
@@ -2508,9 +2508,9 @@ JOW(jlong, PeerConnectionFactory_nativeCreateVideoSource)(
     jobject j_constraints) {
   scoped_ptr<ConstraintsWrapper> constraints(
       new ConstraintsWrapper(jni, j_constraints));
-  talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
-  talk_base::scoped_refptr<VideoSourceInterface> source(
+  rtc::scoped_refptr<VideoSourceInterface> source(
       factory->CreateVideoSource(
           reinterpret_cast<cricket::VideoCapturer*>(native_capturer),
           constraints.get()));
@@ -2520,9 +2520,9 @@ JOW(jlong, PeerConnectionFactory_nativeCreateVideoSource)(
 JOW(jlong, PeerConnectionFactory_nativeCreateVideoTrack)(
     JNIEnv* jni, jclass, jlong native_factory, jstring id,
     jlong native_source) {
-  talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
-  talk_base::scoped_refptr<VideoTrackInterface> track(
+  rtc::scoped_refptr<VideoTrackInterface> track(
       factory->CreateVideoTrack(
           JavaToStdString(jni, id),
           reinterpret_cast<VideoSourceInterface*>(native_source)));
@@ -2533,9 +2533,9 @@ JOW(jlong, PeerConnectionFactory_nativeCreateAudioSource)(
     JNIEnv* jni, jclass, jlong native_factory, jobject j_constraints) {
   scoped_ptr<ConstraintsWrapper> constraints(
       new ConstraintsWrapper(jni, j_constraints));
-  talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
-  talk_base::scoped_refptr<AudioSourceInterface> source(
+  rtc::scoped_refptr<AudioSourceInterface> source(
       factory->CreateAudioSource(constraints.get()));
   return (jlong)source.release();
 }
@@ -2543,9 +2543,9 @@ JOW(jlong, PeerConnectionFactory_nativeCreateAudioSource)(
 JOW(jlong, PeerConnectionFactory_nativeCreateAudioTrack)(
     JNIEnv* jni, jclass, jlong native_factory, jstring id,
     jlong native_source) {
-  talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
-  talk_base::scoped_refptr<AudioTrackInterface> track(factory->CreateAudioTrack(
+  rtc::scoped_refptr<AudioTrackInterface> track(factory->CreateAudioTrack(
       JavaToStdString(jni, id),
       reinterpret_cast<AudioSourceInterface*>(native_source)));
   return (jlong)track.release();
@@ -2592,24 +2592,24 @@ static void JavaIceServersToJsepIceServers(
 JOW(jlong, PeerConnectionFactory_nativeCreatePeerConnection)(
     JNIEnv *jni, jclass, jlong factory, jobject j_ice_servers,
     jobject j_constraints, jlong observer_p) {
-  talk_base::scoped_refptr<PeerConnectionFactoryInterface> f(
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> f(
       reinterpret_cast<PeerConnectionFactoryInterface*>(
           factoryFromJava(factory)));
   PeerConnectionInterface::IceServers servers;
   JavaIceServersToJsepIceServers(jni, j_ice_servers, &servers);
   PCOJava* observer = reinterpret_cast<PCOJava*>(observer_p);
   observer->SetConstraints(new ConstraintsWrapper(jni, j_constraints));
-  talk_base::scoped_refptr<PeerConnectionInterface> pc(f->CreatePeerConnection(
+  rtc::scoped_refptr<PeerConnectionInterface> pc(f->CreatePeerConnection(
       servers, observer->constraints(), NULL, NULL, observer));
   return (jlong)pc.release();
 }
 
-static talk_base::scoped_refptr<PeerConnectionInterface> ExtractNativePC(
+static rtc::scoped_refptr<PeerConnectionInterface> ExtractNativePC(
     JNIEnv* jni, jobject j_pc) {
   jfieldID native_pc_id = GetFieldID(jni,
       GetObjectClass(jni, j_pc), "nativePeerConnection", "J");
   jlong j_p = GetLongField(jni, j_pc, native_pc_id);
-  return talk_base::scoped_refptr<PeerConnectionInterface>(
+  return rtc::scoped_refptr<PeerConnectionInterface>(
       reinterpret_cast<PeerConnectionInterface*>(j_p));
 }
 
@@ -2628,7 +2628,7 @@ JOW(jobject, PeerConnection_getRemoteDescription)(JNIEnv* jni, jobject j_pc) {
 JOW(jobject, PeerConnection_createDataChannel)(
     JNIEnv* jni, jobject j_pc, jstring j_label, jobject j_init) {
   DataChannelInit init = JavaDataChannelInitToNative(jni, j_init);
-  talk_base::scoped_refptr<DataChannelInterface> channel(
+  rtc::scoped_refptr<DataChannelInterface> channel(
       ExtractNativePC(jni, j_pc)->CreateDataChannel(
           JavaToStdString(jni, j_label), &init));
   // Mustn't pass channel.get() directly through NewObject to avoid reading its
@@ -2652,8 +2652,8 @@ JOW(void, PeerConnection_createOffer)(
     JNIEnv* jni, jobject j_pc, jobject j_observer, jobject j_constraints) {
   ConstraintsWrapper* constraints =
       new ConstraintsWrapper(jni, j_constraints);
-  talk_base::scoped_refptr<CreateSdpObserverWrapper> observer(
-      new talk_base::RefCountedObject<CreateSdpObserverWrapper>(
+  rtc::scoped_refptr<CreateSdpObserverWrapper> observer(
+      new rtc::RefCountedObject<CreateSdpObserverWrapper>(
           jni, j_observer, constraints));
   ExtractNativePC(jni, j_pc)->CreateOffer(observer, constraints);
 }
@@ -2662,8 +2662,8 @@ JOW(void, PeerConnection_createAnswer)(
     JNIEnv* jni, jobject j_pc, jobject j_observer, jobject j_constraints) {
   ConstraintsWrapper* constraints =
       new ConstraintsWrapper(jni, j_constraints);
-  talk_base::scoped_refptr<CreateSdpObserverWrapper> observer(
-      new talk_base::RefCountedObject<CreateSdpObserverWrapper>(
+  rtc::scoped_refptr<CreateSdpObserverWrapper> observer(
+      new rtc::RefCountedObject<CreateSdpObserverWrapper>(
           jni, j_observer, constraints));
   ExtractNativePC(jni, j_pc)->CreateAnswer(observer, constraints);
 }
@@ -2695,8 +2695,8 @@ static SessionDescriptionInterface* JavaSdpToNativeSdp(
 JOW(void, PeerConnection_setLocalDescription)(
     JNIEnv* jni, jobject j_pc,
     jobject j_observer, jobject j_sdp) {
-  talk_base::scoped_refptr<SetSdpObserverWrapper> observer(
-      new talk_base::RefCountedObject<SetSdpObserverWrapper>(
+  rtc::scoped_refptr<SetSdpObserverWrapper> observer(
+      new rtc::RefCountedObject<SetSdpObserverWrapper>(
           jni, j_observer, reinterpret_cast<ConstraintsWrapper*>(NULL)));
   ExtractNativePC(jni, j_pc)->SetLocalDescription(
       observer, JavaSdpToNativeSdp(jni, j_sdp));
@@ -2705,8 +2705,8 @@ JOW(void, PeerConnection_setLocalDescription)(
 JOW(void, PeerConnection_setRemoteDescription)(
     JNIEnv* jni, jobject j_pc,
     jobject j_observer, jobject j_sdp) {
-  talk_base::scoped_refptr<SetSdpObserverWrapper> observer(
-      new talk_base::RefCountedObject<SetSdpObserverWrapper>(
+  rtc::scoped_refptr<SetSdpObserverWrapper> observer(
+      new rtc::RefCountedObject<SetSdpObserverWrapper>(
           jni, j_observer, reinterpret_cast<ConstraintsWrapper*>(NULL)));
   ExtractNativePC(jni, j_pc)->SetRemoteDescription(
       observer, JavaSdpToNativeSdp(jni, j_sdp));
@@ -2748,8 +2748,8 @@ JOW(void, PeerConnection_nativeRemoveLocalStream)(
 
 JOW(bool, PeerConnection_nativeGetStats)(
     JNIEnv* jni, jobject j_pc, jobject j_observer, jlong native_track) {
-  talk_base::scoped_refptr<StatsObserverWrapper> observer(
-      new talk_base::RefCountedObject<StatsObserverWrapper>(jni, j_observer));
+  rtc::scoped_refptr<StatsObserverWrapper> observer(
+      new rtc::RefCountedObject<StatsObserverWrapper>(jni, j_observer));
   return ExtractNativePC(jni, j_pc)->GetStats(
       observer,
       reinterpret_cast<MediaStreamTrackInterface*>(native_track),
@@ -2780,7 +2780,7 @@ JOW(void, PeerConnection_close)(JNIEnv* jni, jobject j_pc) {
 }
 
 JOW(jobject, MediaSource_nativeState)(JNIEnv* jni, jclass, jlong j_p) {
-  talk_base::scoped_refptr<MediaSourceInterface> p(
+  rtc::scoped_refptr<MediaSourceInterface> p(
       reinterpret_cast<MediaSourceInterface*>(j_p));
   return JavaEnumFromIndex(jni, "MediaSource$State", p->state());
 }
diff --git a/talk/app/webrtc/java/src/org/webrtc/Logging.java b/talk/app/webrtc/java/src/org/webrtc/Logging.java
index 8b23dafb20..b8d6c6ed04 100644
--- a/talk/app/webrtc/java/src/org/webrtc/Logging.java
+++ b/talk/app/webrtc/java/src/org/webrtc/Logging.java
@@ -59,7 +59,7 @@ public class Logging {
     }
   };
 
-  // Keep in sync with talk/base/logging.h:LoggingSeverity.
+  // Keep in sync with webrtc/base/logging.h:LoggingSeverity.
   public enum Severity {
     LS_SENSITIVE, LS_VERBOSE, LS_INFO, LS_WARNING, LS_ERROR,
   };
diff --git a/talk/app/webrtc/jsep.h b/talk/app/webrtc/jsep.h
index 5f28fc8858..e748da198c 100644
--- a/talk/app/webrtc/jsep.h
+++ b/talk/app/webrtc/jsep.h
@@ -33,8 +33,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/refcount.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/refcount.h"
 
 namespace cricket {
 class SessionDescription;
@@ -138,7 +138,7 @@ SessionDescriptionInterface* CreateSessionDescription(const std::string& type,
                                                       SdpParseError* error);
 
 // Jsep CreateOffer and CreateAnswer callback interface.
-class CreateSessionDescriptionObserver : public talk_base::RefCountInterface {
+class CreateSessionDescriptionObserver : public rtc::RefCountInterface {
  public:
   // The implementation of the CreateSessionDescriptionObserver takes
   // the ownership of the |desc|.
@@ -150,7 +150,7 @@ class CreateSessionDescriptionObserver : public talk_base::RefCountInterface {
 };
 
 // Jsep SetLocalDescription and SetRemoteDescription callback interface.
-class SetSessionDescriptionObserver : public talk_base::RefCountInterface {
+class SetSessionDescriptionObserver : public rtc::RefCountInterface {
  public:
   virtual void OnSuccess() = 0;
   virtual void OnFailure(const std::string& error) = 0;
diff --git a/talk/app/webrtc/jsepicecandidate.cc b/talk/app/webrtc/jsepicecandidate.cc
index 13cc812736..755403e376 100644
--- a/talk/app/webrtc/jsepicecandidate.cc
+++ b/talk/app/webrtc/jsepicecandidate.cc
@@ -30,7 +30,7 @@
 #include <vector>
 
 #include "talk/app/webrtc/webrtcsdp.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/stringencode.h"
 
 namespace webrtc {
 
diff --git a/talk/app/webrtc/jsepicecandidate.h b/talk/app/webrtc/jsepicecandidate.h
index 54de950e92..3463c828a3 100644
--- a/talk/app/webrtc/jsepicecandidate.h
+++ b/talk/app/webrtc/jsepicecandidate.h
@@ -33,7 +33,7 @@
 #include <string>
 
 #include "talk/app/webrtc/jsep.h"
-#include "talk/base/constructormagic.h"
+#include "webrtc/base/constructormagic.h"
 #include "talk/p2p/base/candidate.h"
 
 namespace webrtc {
diff --git a/talk/app/webrtc/jsepsessiondescription.cc b/talk/app/webrtc/jsepsessiondescription.cc
index 13604b468e..eb42392938 100644
--- a/talk/app/webrtc/jsepsessiondescription.cc
+++ b/talk/app/webrtc/jsepsessiondescription.cc
@@ -27,10 +27,10 @@
 #include "talk/app/webrtc/jsepsessiondescription.h"
 
 #include "talk/app/webrtc/webrtcsdp.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/session/media/mediasession.h"
 
-using talk_base::scoped_ptr;
+using rtc::scoped_ptr;
 using cricket::SessionDescription;
 
 namespace webrtc {
diff --git a/talk/app/webrtc/jsepsessiondescription.h b/talk/app/webrtc/jsepsessiondescription.h
index 7ca7a22429..07d13a3442 100644
--- a/talk/app/webrtc/jsepsessiondescription.h
+++ b/talk/app/webrtc/jsepsessiondescription.h
@@ -35,7 +35,7 @@
 
 #include "talk/app/webrtc/jsep.h"
 #include "talk/app/webrtc/jsepicecandidate.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 
 namespace cricket {
 class SessionDescription;
@@ -89,7 +89,7 @@ class JsepSessionDescription : public SessionDescriptionInterface {
   static const int kDefaultVideoCodecPreference;
 
  private:
-  talk_base::scoped_ptr<cricket::SessionDescription> description_;
+  rtc::scoped_ptr<cricket::SessionDescription> description_;
   std::string session_id_;
   std::string session_version_;
   std::string type_;
diff --git a/talk/app/webrtc/jsepsessiondescription_unittest.cc b/talk/app/webrtc/jsepsessiondescription_unittest.cc
index 55eb3d5392..12db9d4adc 100644
--- a/talk/app/webrtc/jsepsessiondescription_unittest.cc
+++ b/talk/app/webrtc/jsepsessiondescription_unittest.cc
@@ -29,11 +29,11 @@
 
 #include "talk/app/webrtc/jsepicecandidate.h"
 #include "talk/app/webrtc/jsepsessiondescription.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/sessiondescription.h"
@@ -44,7 +44,7 @@ using webrtc::IceCandidateInterface;
 using webrtc::JsepIceCandidate;
 using webrtc::JsepSessionDescription;
 using webrtc::SessionDescriptionInterface;
-using talk_base::scoped_ptr;
+using rtc::scoped_ptr;
 
 static const char kCandidateUfrag[] = "ufrag";
 static const char kCandidatePwd[] = "pwd";
@@ -98,24 +98,24 @@ static cricket::SessionDescription* CreateCricketSessionDescription() {
 class JsepSessionDescriptionTest : public testing::Test {
  protected:
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   virtual void SetUp() {
     int port = 1234;
-    talk_base::SocketAddress address("127.0.0.1", port++);
+    rtc::SocketAddress address("127.0.0.1", port++);
     cricket::Candidate candidate("rtp", cricket::ICE_CANDIDATE_COMPONENT_RTP,
                                  "udp", address, 1, "",
                                  "", "local", "eth0", 0, "1");
     candidate_ = candidate;
     const std::string session_id =
-        talk_base::ToString(talk_base::CreateRandomId64());
+        rtc::ToString(rtc::CreateRandomId64());
     const std::string session_version =
-        talk_base::ToString(talk_base::CreateRandomId());
+        rtc::ToString(rtc::CreateRandomId());
     jsep_desc_.reset(new JsepSessionDescription("dummy"));
     ASSERT_TRUE(jsep_desc_->Initialize(CreateCricketSessionDescription(),
         session_id, session_version));
@@ -135,7 +135,7 @@ class JsepSessionDescriptionTest : public testing::Test {
   }
 
   cricket::Candidate candidate_;
-  talk_base::scoped_ptr<JsepSessionDescription> jsep_desc_;
+  rtc::scoped_ptr<JsepSessionDescription> jsep_desc_;
 };
 
 // Test that number_of_mediasections() returns the number of media contents in
diff --git a/talk/app/webrtc/localaudiosource.cc b/talk/app/webrtc/localaudiosource.cc
index ab9ae4fa99..9a37112970 100644
--- a/talk/app/webrtc/localaudiosource.cc
+++ b/talk/app/webrtc/localaudiosource.cc
@@ -53,7 +53,7 @@ bool FromConstraints(const MediaConstraintsInterface::Constraints& constraints,
   for (iter = constraints.begin(); iter != constraints.end(); ++iter) {
     bool value = false;
 
-    if (!talk_base::FromString(iter->value, &value)) {
+    if (!rtc::FromString(iter->value, &value)) {
       success = false;
       continue;
     }
@@ -87,11 +87,11 @@ bool FromConstraints(const MediaConstraintsInterface::Constraints& constraints,
 
 }  // namespace
 
-talk_base::scoped_refptr<LocalAudioSource> LocalAudioSource::Create(
+rtc::scoped_refptr<LocalAudioSource> LocalAudioSource::Create(
     const PeerConnectionFactoryInterface::Options& options,
     const MediaConstraintsInterface* constraints) {
-  talk_base::scoped_refptr<LocalAudioSource> source(
-      new talk_base::RefCountedObject<LocalAudioSource>());
+  rtc::scoped_refptr<LocalAudioSource> source(
+      new rtc::RefCountedObject<LocalAudioSource>());
   source->Initialize(options, constraints);
   return source;
 }
diff --git a/talk/app/webrtc/localaudiosource.h b/talk/app/webrtc/localaudiosource.h
index fb769ed621..84fa763c58 100644
--- a/talk/app/webrtc/localaudiosource.h
+++ b/talk/app/webrtc/localaudiosource.h
@@ -31,7 +31,7 @@
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/notifier.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/mediachannel.h"
 
 // LocalAudioSource implements AudioSourceInterface.
@@ -44,7 +44,7 @@ class MediaConstraintsInterface;
 class LocalAudioSource : public Notifier<AudioSourceInterface> {
  public:
   // Creates an instance of LocalAudioSource.
-  static talk_base::scoped_refptr<LocalAudioSource> Create(
+  static rtc::scoped_refptr<LocalAudioSource> Create(
       const PeerConnectionFactoryInterface::Options& options,
       const MediaConstraintsInterface* constraints);
 
diff --git a/talk/app/webrtc/localaudiosource_unittest.cc b/talk/app/webrtc/localaudiosource_unittest.cc
index f8880e0f69..3a14bec58d 100644
--- a/talk/app/webrtc/localaudiosource_unittest.cc
+++ b/talk/app/webrtc/localaudiosource_unittest.cc
@@ -31,7 +31,7 @@
 #include <vector>
 
 #include "talk/app/webrtc/test/fakeconstraints.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakevideorenderer.h"
 #include "talk/media/devices/fakedevicemanager.h"
@@ -52,7 +52,7 @@ TEST(LocalAudioSourceTest, SetValidOptions) {
   constraints.AddMandatory(MediaConstraintsInterface::kNoiseSuppression, false);
   constraints.AddOptional(MediaConstraintsInterface::kHighpassFilter, true);
 
-  talk_base::scoped_refptr<LocalAudioSource> source =
+  rtc::scoped_refptr<LocalAudioSource> source =
       LocalAudioSource::Create(PeerConnectionFactoryInterface::Options(),
                                &constraints);
 
@@ -73,7 +73,7 @@ TEST(LocalAudioSourceTest, SetValidOptions) {
 
 TEST(LocalAudioSourceTest, OptionNotSet) {
   webrtc::FakeConstraints constraints;
-  talk_base::scoped_refptr<LocalAudioSource> source =
+  rtc::scoped_refptr<LocalAudioSource> source =
       LocalAudioSource::Create(PeerConnectionFactoryInterface::Options(),
                                &constraints);
   bool value;
@@ -85,7 +85,7 @@ TEST(LocalAudioSourceTest, MandatoryOverridesOptional) {
   constraints.AddMandatory(MediaConstraintsInterface::kEchoCancellation, false);
   constraints.AddOptional(MediaConstraintsInterface::kEchoCancellation, true);
 
-  talk_base::scoped_refptr<LocalAudioSource> source =
+  rtc::scoped_refptr<LocalAudioSource> source =
       LocalAudioSource::Create(PeerConnectionFactoryInterface::Options(),
                                &constraints);
 
@@ -99,7 +99,7 @@ TEST(LocalAudioSourceTest, InvalidOptional) {
   constraints.AddOptional(MediaConstraintsInterface::kHighpassFilter, false);
   constraints.AddOptional("invalidKey", false);
 
-  talk_base::scoped_refptr<LocalAudioSource> source =
+  rtc::scoped_refptr<LocalAudioSource> source =
       LocalAudioSource::Create(PeerConnectionFactoryInterface::Options(),
                                &constraints);
 
@@ -114,7 +114,7 @@ TEST(LocalAudioSourceTest, InvalidMandatory) {
   constraints.AddMandatory(MediaConstraintsInterface::kHighpassFilter, false);
   constraints.AddMandatory("invalidKey", false);
 
-  talk_base::scoped_refptr<LocalAudioSource> source =
+  rtc::scoped_refptr<LocalAudioSource> source =
       LocalAudioSource::Create(PeerConnectionFactoryInterface::Options(),
                                &constraints);
 
diff --git a/talk/app/webrtc/mediaconstraintsinterface.cc b/talk/app/webrtc/mediaconstraintsinterface.cc
index c38369581c..874ce64a71 100644
--- a/talk/app/webrtc/mediaconstraintsinterface.cc
+++ b/talk/app/webrtc/mediaconstraintsinterface.cc
@@ -27,7 +27,7 @@
 
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
 
-#include "talk/base/stringencode.h"
+#include "webrtc/base/stringencode.h"
 
 namespace webrtc {
 
@@ -153,10 +153,10 @@ bool FindConstraint(const MediaConstraintsInterface* constraints,
   if (constraints->GetMandatory().FindFirst(key, &string_value)) {
     if (mandatory_constraints)
       ++*mandatory_constraints;
-    return talk_base::FromString(string_value, value);
+    return rtc::FromString(string_value, value);
   }
   if (constraints->GetOptional().FindFirst(key, &string_value)) {
-    return talk_base::FromString(string_value, value);
+    return rtc::FromString(string_value, value);
   }
   return false;
 }
diff --git a/talk/app/webrtc/mediastream.cc b/talk/app/webrtc/mediastream.cc
index aad8e85f82..2bd5b53aaa 100644
--- a/talk/app/webrtc/mediastream.cc
+++ b/talk/app/webrtc/mediastream.cc
@@ -26,7 +26,7 @@
  */
 
 #include "talk/app/webrtc/mediastream.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 
 namespace webrtc {
 
@@ -42,10 +42,10 @@ static typename V::iterator FindTrack(V* vector,
   return it;
 };
 
-talk_base::scoped_refptr<MediaStream> MediaStream::Create(
+rtc::scoped_refptr<MediaStream> MediaStream::Create(
     const std::string& label) {
-  talk_base::RefCountedObject<MediaStream>* stream =
-      new talk_base::RefCountedObject<MediaStream>(label);
+  rtc::RefCountedObject<MediaStream>* stream =
+      new rtc::RefCountedObject<MediaStream>(label);
   return stream;
 }
 
@@ -69,7 +69,7 @@ bool MediaStream::RemoveTrack(VideoTrackInterface* track) {
   return RemoveTrack<VideoTrackVector>(&video_tracks_, track);
 }
 
-talk_base::scoped_refptr<AudioTrackInterface>
+rtc::scoped_refptr<AudioTrackInterface>
 MediaStream::FindAudioTrack(const std::string& track_id) {
   AudioTrackVector::iterator it = FindTrack(&audio_tracks_, track_id);
   if (it == audio_tracks_.end())
@@ -77,7 +77,7 @@ MediaStream::FindAudioTrack(const std::string& track_id) {
   return *it;
 }
 
-talk_base::scoped_refptr<VideoTrackInterface>
+rtc::scoped_refptr<VideoTrackInterface>
 MediaStream::FindVideoTrack(const std::string& track_id) {
   VideoTrackVector::iterator it = FindTrack(&video_tracks_, track_id);
   if (it == video_tracks_.end())
diff --git a/talk/app/webrtc/mediastream.h b/talk/app/webrtc/mediastream.h
index e5ac6ebee9..c8e0bcc621 100644
--- a/talk/app/webrtc/mediastream.h
+++ b/talk/app/webrtc/mediastream.h
@@ -40,7 +40,7 @@ namespace webrtc {
 
 class MediaStream : public Notifier<MediaStreamInterface> {
  public:
-  static talk_base::scoped_refptr<MediaStream> Create(const std::string& label);
+  static rtc::scoped_refptr<MediaStream> Create(const std::string& label);
 
   virtual std::string label() const OVERRIDE { return label_; }
 
@@ -48,9 +48,9 @@ class MediaStream : public Notifier<MediaStreamInterface> {
   virtual bool AddTrack(VideoTrackInterface* track) OVERRIDE;
   virtual bool RemoveTrack(AudioTrackInterface* track) OVERRIDE;
   virtual bool RemoveTrack(VideoTrackInterface* track) OVERRIDE;
-  virtual talk_base::scoped_refptr<AudioTrackInterface>
+  virtual rtc::scoped_refptr<AudioTrackInterface>
       FindAudioTrack(const std::string& track_id);
-  virtual talk_base::scoped_refptr<VideoTrackInterface>
+  virtual rtc::scoped_refptr<VideoTrackInterface>
       FindVideoTrack(const std::string& track_id);
 
   virtual AudioTrackVector GetAudioTracks() OVERRIDE { return audio_tracks_; }
diff --git a/talk/app/webrtc/mediastream_unittest.cc b/talk/app/webrtc/mediastream_unittest.cc
index 113242faf5..4711e9cba0 100644
--- a/talk/app/webrtc/mediastream_unittest.cc
+++ b/talk/app/webrtc/mediastream_unittest.cc
@@ -30,9 +30,9 @@
 #include "talk/app/webrtc/audiotrack.h"
 #include "talk/app/webrtc/mediastream.h"
 #include "talk/app/webrtc/videotrack.h"
-#include "talk/base/refcount.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/gunit.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -40,7 +40,7 @@ static const char kStreamLabel1[] = "local_stream_1";
 static const char kVideoTrackId[] = "dummy_video_cam_1";
 static const char kAudioTrackId[] = "dummy_microphone_1";
 
-using talk_base::scoped_refptr;
+using rtc::scoped_refptr;
 using ::testing::Exactly;
 
 namespace webrtc {
diff --git a/talk/app/webrtc/mediastreamhandler.cc b/talk/app/webrtc/mediastreamhandler.cc
index ca28cf4973..57aa4f5daa 100644
--- a/talk/app/webrtc/mediastreamhandler.cc
+++ b/talk/app/webrtc/mediastreamhandler.cc
@@ -59,7 +59,7 @@ void TrackHandler::OnChanged() {
 LocalAudioSinkAdapter::LocalAudioSinkAdapter() : sink_(NULL) {}
 
 LocalAudioSinkAdapter::~LocalAudioSinkAdapter() {
-  talk_base::CritScope lock(&lock_);
+  rtc::CritScope lock(&lock_);
   if (sink_)
     sink_->OnClose();
 }
@@ -69,7 +69,7 @@ void LocalAudioSinkAdapter::OnData(const void* audio_data,
                                    int sample_rate,
                                    int number_of_channels,
                                    int number_of_frames) {
-  talk_base::CritScope lock(&lock_);
+  rtc::CritScope lock(&lock_);
   if (sink_) {
     sink_->OnData(audio_data, bits_per_sample, sample_rate,
                   number_of_channels, number_of_frames);
@@ -77,7 +77,7 @@ void LocalAudioSinkAdapter::OnData(const void* audio_data,
 }
 
 void LocalAudioSinkAdapter::SetSink(cricket::AudioRenderer::Sink* sink) {
-  talk_base::CritScope lock(&lock_);
+  rtc::CritScope lock(&lock_);
   ASSERT(!sink || !sink_);
   sink_ = sink;
 }
diff --git a/talk/app/webrtc/mediastreamhandler.h b/talk/app/webrtc/mediastreamhandler.h
index 53afd55628..63864ced6d 100644
--- a/talk/app/webrtc/mediastreamhandler.h
+++ b/talk/app/webrtc/mediastreamhandler.h
@@ -39,7 +39,7 @@
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/mediastreamprovider.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/audiorenderer.h"
 
 namespace webrtc {
@@ -62,7 +62,7 @@ class TrackHandler : public ObserverInterface {
   virtual void OnEnabledChanged() = 0;
 
  private:
-  talk_base::scoped_refptr<MediaStreamTrackInterface> track_;
+  rtc::scoped_refptr<MediaStreamTrackInterface> track_;
   uint32 ssrc_;
   MediaStreamTrackInterface::TrackState state_;
   bool enabled_;
@@ -87,7 +87,7 @@ class LocalAudioSinkAdapter : public AudioTrackSinkInterface,
 
   cricket::AudioRenderer::Sink* sink_;
   // Critical section protecting |sink_|.
-  talk_base::CriticalSection lock_;
+  rtc::CriticalSection lock_;
 };
 
 // LocalAudioTrackHandler listen to events on a local AudioTrack instance
@@ -112,7 +112,7 @@ class LocalAudioTrackHandler : public TrackHandler {
 
   // Used to pass the data callback from the |audio_track_| to the other
   // end of cricket::AudioRenderer.
-  talk_base::scoped_ptr<LocalAudioSinkAdapter> sink_adapter_;
+  rtc::scoped_ptr<LocalAudioSinkAdapter> sink_adapter_;
 };
 
 // RemoteAudioTrackHandler listen to events on a remote AudioTrack instance
@@ -196,7 +196,7 @@ class MediaStreamHandler : public ObserverInterface {
 
  protected:
   TrackHandler* FindTrackHandler(MediaStreamTrackInterface* track);
-  talk_base::scoped_refptr<MediaStreamInterface> stream_;
+  rtc::scoped_refptr<MediaStreamInterface> stream_;
   AudioProviderInterface* audio_provider_;
   VideoProviderInterface* video_provider_;
   typedef std::vector<TrackHandler*> TrackHandlers;
diff --git a/talk/app/webrtc/mediastreamhandler_unittest.cc b/talk/app/webrtc/mediastreamhandler_unittest.cc
index 9a53f35561..772708660b 100644
--- a/talk/app/webrtc/mediastreamhandler_unittest.cc
+++ b/talk/app/webrtc/mediastreamhandler_unittest.cc
@@ -35,7 +35,7 @@
 #include "talk/app/webrtc/streamcollection.h"
 #include "talk/app/webrtc/videosource.h"
 #include "talk/app/webrtc/videotrack.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/base/mediachannel.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -79,8 +79,8 @@ class MockVideoProvider : public VideoProviderInterface {
 
 class FakeVideoSource : public Notifier<VideoSourceInterface> {
  public:
-  static talk_base::scoped_refptr<FakeVideoSource> Create() {
-    return new talk_base::RefCountedObject<FakeVideoSource>();
+  static rtc::scoped_refptr<FakeVideoSource> Create() {
+    return new rtc::RefCountedObject<FakeVideoSource>();
   }
   virtual cricket::VideoCapturer* GetVideoCapturer() {
     return &fake_capturer_;
@@ -109,7 +109,7 @@ class MediaStreamHandlerTest : public testing::Test {
 
   virtual void SetUp() {
     stream_ = MediaStream::Create(kStreamLabel1);
-    talk_base::scoped_refptr<VideoSourceInterface> source(
+    rtc::scoped_refptr<VideoSourceInterface> source(
         FakeVideoSource::Create());
     video_track_ = VideoTrack::Create(kVideoTrackId, source);
     EXPECT_TRUE(stream_->AddTrack(video_track_));
@@ -175,9 +175,9 @@ class MediaStreamHandlerTest : public testing::Test {
   MockAudioProvider audio_provider_;
   MockVideoProvider video_provider_;
   MediaStreamHandlerContainer handlers_;
-  talk_base::scoped_refptr<MediaStreamInterface> stream_;
-  talk_base::scoped_refptr<VideoTrackInterface> video_track_;
-  talk_base::scoped_refptr<AudioTrackInterface> audio_track_;
+  rtc::scoped_refptr<MediaStreamInterface> stream_;
+  rtc::scoped_refptr<VideoTrackInterface> video_track_;
+  rtc::scoped_refptr<AudioTrackInterface> audio_track_;
 };
 
 // Test that |audio_provider_| is notified when an audio track is associated
diff --git a/talk/app/webrtc/mediastreaminterface.h b/talk/app/webrtc/mediastreaminterface.h
index a3439c59c4..5d6c659f97 100644
--- a/talk/app/webrtc/mediastreaminterface.h
+++ b/talk/app/webrtc/mediastreaminterface.h
@@ -37,9 +37,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/refcount.h"
-#include "talk/base/scoped_ref_ptr.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 
 namespace cricket {
 
@@ -73,7 +73,7 @@ class NotifierInterface {
 // provide media. A source can be shared with multiple tracks.
 // TODO(perkj): Implement sources for local and remote audio tracks and
 // remote video tracks.
-class MediaSourceInterface : public talk_base::RefCountInterface,
+class MediaSourceInterface : public rtc::RefCountInterface,
                              public NotifierInterface {
  public:
   enum SourceState {
@@ -90,7 +90,7 @@ class MediaSourceInterface : public talk_base::RefCountInterface,
 };
 
 // Information about a track.
-class MediaStreamTrackInterface : public talk_base::RefCountInterface,
+class MediaStreamTrackInterface : public rtc::RefCountInterface,
                                   public NotifierInterface {
  public:
   enum TrackState {
@@ -176,7 +176,7 @@ class AudioTrackSinkInterface {
 
 // Interface of the audio processor used by the audio track to collect
 // statistics.
-class AudioProcessorInterface : public talk_base::RefCountInterface {
+class AudioProcessorInterface : public rtc::RefCountInterface {
  public:
   struct AudioProcessorStats {
     AudioProcessorStats() : typing_noise_detected(false),
@@ -220,7 +220,7 @@ class AudioTrackInterface : public MediaStreamTrackInterface {
   // Get the audio processor used by the audio track. Return NULL if the track
   // does not have any processor.
   // TODO(xians): Make the interface pure virtual.
-  virtual talk_base::scoped_refptr<AudioProcessorInterface>
+  virtual rtc::scoped_refptr<AudioProcessorInterface>
       GetAudioProcessor() { return NULL; }
 
   // Get a pointer to the audio renderer of this AudioTrack.
@@ -233,21 +233,21 @@ class AudioTrackInterface : public MediaStreamTrackInterface {
   virtual ~AudioTrackInterface() {}
 };
 
-typedef std::vector<talk_base::scoped_refptr<AudioTrackInterface> >
+typedef std::vector<rtc::scoped_refptr<AudioTrackInterface> >
     AudioTrackVector;
-typedef std::vector<talk_base::scoped_refptr<VideoTrackInterface> >
+typedef std::vector<rtc::scoped_refptr<VideoTrackInterface> >
     VideoTrackVector;
 
-class MediaStreamInterface : public talk_base::RefCountInterface,
+class MediaStreamInterface : public rtc::RefCountInterface,
                              public NotifierInterface {
  public:
   virtual std::string label() const = 0;
 
   virtual AudioTrackVector GetAudioTracks() = 0;
   virtual VideoTrackVector GetVideoTracks() = 0;
-  virtual talk_base::scoped_refptr<AudioTrackInterface>
+  virtual rtc::scoped_refptr<AudioTrackInterface>
       FindAudioTrack(const std::string& track_id) = 0;
-  virtual talk_base::scoped_refptr<VideoTrackInterface>
+  virtual rtc::scoped_refptr<VideoTrackInterface>
       FindVideoTrack(const std::string& track_id) = 0;
 
   virtual bool AddTrack(AudioTrackInterface* track) = 0;
diff --git a/talk/app/webrtc/mediastreamproxy.h b/talk/app/webrtc/mediastreamproxy.h
index 7d018d5eae..484690e11c 100644
--- a/talk/app/webrtc/mediastreamproxy.h
+++ b/talk/app/webrtc/mediastreamproxy.h
@@ -37,9 +37,9 @@ BEGIN_PROXY_MAP(MediaStream)
   PROXY_CONSTMETHOD0(std::string, label)
   PROXY_METHOD0(AudioTrackVector, GetAudioTracks)
   PROXY_METHOD0(VideoTrackVector, GetVideoTracks)
-  PROXY_METHOD1(talk_base::scoped_refptr<AudioTrackInterface>,
+  PROXY_METHOD1(rtc::scoped_refptr<AudioTrackInterface>,
                 FindAudioTrack, const std::string&)
-  PROXY_METHOD1(talk_base::scoped_refptr<VideoTrackInterface>,
+  PROXY_METHOD1(rtc::scoped_refptr<VideoTrackInterface>,
                 FindVideoTrack, const std::string&)
   PROXY_METHOD1(bool, AddTrack, AudioTrackInterface*)
   PROXY_METHOD1(bool, AddTrack, VideoTrackInterface*)
diff --git a/talk/app/webrtc/mediastreamsignaling.cc b/talk/app/webrtc/mediastreamsignaling.cc
index ad3c01aed4..2d30cc2280 100644
--- a/talk/app/webrtc/mediastreamsignaling.cc
+++ b/talk/app/webrtc/mediastreamsignaling.cc
@@ -38,8 +38,8 @@
 #include "talk/app/webrtc/sctputils.h"
 #include "talk/app/webrtc/videosource.h"
 #include "talk/app/webrtc/videotrack.h"
-#include "talk/base/bytebuffer.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/sctp/sctpdataengine.h"
 
 static const char kDefaultStreamLabel[] = "default";
@@ -48,8 +48,8 @@ static const char kDefaultVideoTrackLabel[] = "defaultv0";
 
 namespace webrtc {
 
-using talk_base::scoped_ptr;
-using talk_base::scoped_refptr;
+using rtc::scoped_ptr;
+using rtc::scoped_refptr;
 
 static bool ParseConstraints(
     const MediaConstraintsInterface* constraints,
@@ -130,13 +130,13 @@ static bool MediaContentDirectionHasSend(cricket::MediaContentDirection dir) {
 // Factory class for creating remote MediaStreams and MediaStreamTracks.
 class RemoteMediaStreamFactory {
  public:
-  explicit RemoteMediaStreamFactory(talk_base::Thread* signaling_thread,
+  explicit RemoteMediaStreamFactory(rtc::Thread* signaling_thread,
                                     cricket::ChannelManager* channel_manager)
       : signaling_thread_(signaling_thread),
         channel_manager_(channel_manager) {
   }
 
-  talk_base::scoped_refptr<MediaStreamInterface> CreateMediaStream(
+  rtc::scoped_refptr<MediaStreamInterface> CreateMediaStream(
       const std::string& stream_label) {
     return MediaStreamProxy::Create(
         signaling_thread_, MediaStream::Create(stream_label));
@@ -160,7 +160,7 @@ class RemoteMediaStreamFactory {
   template <typename TI, typename T, typename TP, typename S>
   TI* AddTrack(MediaStreamInterface* stream, const std::string& track_id,
                S* source) {
-    talk_base::scoped_refptr<TI> track(
+    rtc::scoped_refptr<TI> track(
         TP::Create(signaling_thread_, T::Create(track_id, source)));
     track->set_state(webrtc::MediaStreamTrackInterface::kLive);
     if (stream->AddTrack(track)) {
@@ -169,12 +169,12 @@ class RemoteMediaStreamFactory {
     return NULL;
   }
 
-  talk_base::Thread* signaling_thread_;
+  rtc::Thread* signaling_thread_;
   cricket::ChannelManager* channel_manager_;
 };
 
 MediaStreamSignaling::MediaStreamSignaling(
-    talk_base::Thread* signaling_thread,
+    rtc::Thread* signaling_thread,
     MediaStreamSignalingObserver* stream_observer,
     cricket::ChannelManager* channel_manager)
     : signaling_thread_(signaling_thread),
@@ -210,8 +210,8 @@ bool MediaStreamSignaling::IsSctpSidAvailable(int sid) const {
 // SSL_CLIENT, the allocated id starts from 0 and takes even numbers; otherwise,
 // the id starts from 1 and takes odd numbers. Returns false if no id can be
 // allocated.
-bool MediaStreamSignaling::AllocateSctpSid(talk_base::SSLRole role, int* sid) {
-  int& last_id = (role == talk_base::SSL_CLIENT) ?
+bool MediaStreamSignaling::AllocateSctpSid(rtc::SSLRole role, int* sid) {
+  int& last_id = (role == rtc::SSL_CLIENT) ?
       last_allocated_sctp_even_sid_ : last_allocated_sctp_odd_sid_;
 
   do {
@@ -250,7 +250,7 @@ bool MediaStreamSignaling::AddDataChannel(DataChannel* data_channel) {
 
 bool MediaStreamSignaling::AddDataChannelFromOpenMessage(
     const cricket::ReceiveDataParams& params,
-    const talk_base::Buffer& payload) {
+    const rtc::Buffer& payload) {
   if (!data_channel_factory_) {
     LOG(LS_WARNING) << "Remote peer requested a DataChannel but DataChannels "
                     << "are not supported.";
@@ -285,9 +285,9 @@ void MediaStreamSignaling::RemoveSctpDataChannel(int sid) {
     if ((*iter)->id() == sid) {
       sctp_data_channels_.erase(iter);
 
-      if (talk_base::IsEven(sid) && sid <= last_allocated_sctp_even_sid_) {
+      if (rtc::IsEven(sid) && sid <= last_allocated_sctp_even_sid_) {
         last_allocated_sctp_even_sid_ = sid - 2;
-      } else if (talk_base::IsOdd(sid) && sid <= last_allocated_sctp_odd_sid_) {
+      } else if (rtc::IsOdd(sid) && sid <= last_allocated_sctp_odd_sid_) {
         last_allocated_sctp_odd_sid_ = sid - 2;
       }
       return;
@@ -398,7 +398,7 @@ bool MediaStreamSignaling::GetOptionsForAnswer(
 void MediaStreamSignaling::OnRemoteDescriptionChanged(
     const SessionDescriptionInterface* desc) {
   const cricket::SessionDescription* remote_desc = desc->description();
-  talk_base::scoped_refptr<StreamCollection> new_streams(
+  rtc::scoped_refptr<StreamCollection> new_streams(
       StreamCollection::Create());
 
   // Find all audio rtp streams and create corresponding remote AudioTracks
@@ -433,7 +433,7 @@ void MediaStreamSignaling::OnRemoteDescriptionChanged(
     const cricket::DataContentDescription* data_desc =
         static_cast<const cricket::DataContentDescription*>(
             data_content->description);
-    if (talk_base::starts_with(
+    if (rtc::starts_with(
             data_desc->protocol().data(), cricket::kMediaProtocolRtpPrefix)) {
       UpdateRemoteRtpDataChannels(data_desc->streams());
     }
@@ -488,7 +488,7 @@ void MediaStreamSignaling::OnLocalDescriptionChanged(
     const cricket::DataContentDescription* data_desc =
         static_cast<const cricket::DataContentDescription*>(
             data_content->description);
-    if (talk_base::starts_with(
+    if (rtc::starts_with(
             data_desc->protocol().data(), cricket::kMediaProtocolRtpPrefix)) {
       UpdateLocalRtpDataChannels(data_desc->streams());
     }
@@ -599,7 +599,7 @@ void MediaStreamSignaling::UpdateRemoteStreamsList(
     const std::string& track_id = it->id;
     uint32 ssrc = it->first_ssrc();
 
-    talk_base::scoped_refptr<MediaStreamInterface> stream =
+    rtc::scoped_refptr<MediaStreamInterface> stream =
         remote_streams_->find(stream_label);
     if (!stream) {
       // This is a new MediaStream. Create a new remote MediaStream.
@@ -643,7 +643,7 @@ void MediaStreamSignaling::OnRemoteTrackRemoved(
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
-    talk_base::scoped_refptr<AudioTrackInterface> audio_track =
+    rtc::scoped_refptr<AudioTrackInterface> audio_track =
         stream->FindAudioTrack(track_id);
     if (audio_track) {
       audio_track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
@@ -651,7 +651,7 @@ void MediaStreamSignaling::OnRemoteTrackRemoved(
       stream_observer_->OnRemoveRemoteAudioTrack(stream, audio_track);
     }
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
-    talk_base::scoped_refptr<VideoTrackInterface> video_track =
+    rtc::scoped_refptr<VideoTrackInterface> video_track =
         stream->FindVideoTrack(track_id);
     if (video_track) {
       video_track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
@@ -898,7 +898,7 @@ void MediaStreamSignaling::UpdateRemoteRtpDataChannels(
     // The data channel label is either the mslabel or the SSRC if the mslabel
     // does not exist. Ex a=ssrc:444330170 mslabel:test1.
     std::string label = it->sync_label.empty() ?
-        talk_base::ToString(it->first_ssrc()) : it->sync_label;
+        rtc::ToString(it->first_ssrc()) : it->sync_label;
     RtpDataChannels::iterator data_channel_it =
         rtp_data_channels_.find(label);
     if (data_channel_it == rtp_data_channels_.end()) {
@@ -963,7 +963,7 @@ void MediaStreamSignaling::OnDataTransportCreatedForSctp() {
   }
 }
 
-void MediaStreamSignaling::OnDtlsRoleReadyForSctp(talk_base::SSLRole role) {
+void MediaStreamSignaling::OnDtlsRoleReadyForSctp(rtc::SSLRole role) {
   SctpDataChannels::iterator it = sctp_data_channels_.begin();
   for (; it != sctp_data_channels_.end(); ++it) {
     if ((*it)->id() < 0) {
diff --git a/talk/app/webrtc/mediastreamsignaling.h b/talk/app/webrtc/mediastreamsignaling.h
index 7378166160..ac8a02a951 100644
--- a/talk/app/webrtc/mediastreamsignaling.h
+++ b/talk/app/webrtc/mediastreamsignaling.h
@@ -36,13 +36,13 @@
 #include "talk/app/webrtc/mediastream.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
 #include "talk/app/webrtc/streamcollection.h"
-#include "talk/base/scoped_ref_ptr.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/session/media/mediasession.h"
 
-namespace talk_base {
+namespace rtc {
 class Thread;
-}  // namespace talk_base
+}  // namespace rtc
 
 namespace webrtc {
 
@@ -160,7 +160,7 @@ class MediaStreamSignalingObserver {
 
 class MediaStreamSignaling : public sigslot::has_slots<> {
  public:
-  MediaStreamSignaling(talk_base::Thread* signaling_thread,
+  MediaStreamSignaling(rtc::Thread* signaling_thread,
                        MediaStreamSignalingObserver* stream_observer,
                        cricket::ChannelManager* channel_manager);
   virtual ~MediaStreamSignaling();
@@ -180,7 +180,7 @@ class MediaStreamSignaling : public sigslot::has_slots<> {
 
   // Gets the first available SCTP id that is not assigned to any existing
   // data channels.
-  bool AllocateSctpSid(talk_base::SSLRole role, int* sid);
+  bool AllocateSctpSid(rtc::SSLRole role, int* sid);
 
   // Adds |local_stream| to the collection of known MediaStreams that will be
   // offered in a SessionDescription.
@@ -197,7 +197,7 @@ class MediaStreamSignaling : public sigslot::has_slots<> {
   bool AddDataChannel(DataChannel* data_channel);
   // After we receive an OPEN message, create a data channel and add it.
   bool AddDataChannelFromOpenMessage(const cricket::ReceiveDataParams& params,
-                                     const talk_base::Buffer& payload);
+                                     const rtc::Buffer& payload);
   void RemoveSctpDataChannel(int sid);
 
   // Returns a MediaSessionOptions struct with options decided by |constraints|,
@@ -249,7 +249,7 @@ class MediaStreamSignaling : public sigslot::has_slots<> {
     return remote_streams_.get();
   }
   void OnDataTransportCreatedForSctp();
-  void OnDtlsRoleReadyForSctp(talk_base::SSLRole role);
+  void OnDtlsRoleReadyForSctp(rtc::SSLRole role);
   void OnRemoteSctpDataChannelClosed(uint32 sid);
 
  private:
@@ -376,13 +376,13 @@ class MediaStreamSignaling : public sigslot::has_slots<> {
   int FindDataChannelBySid(int sid) const;
 
   RemotePeerInfo remote_info_;
-  talk_base::Thread* signaling_thread_;
+  rtc::Thread* signaling_thread_;
   DataChannelFactory* data_channel_factory_;
   cricket::MediaSessionOptions options_;
   MediaStreamSignalingObserver* stream_observer_;
-  talk_base::scoped_refptr<StreamCollection> local_streams_;
-  talk_base::scoped_refptr<StreamCollection> remote_streams_;
-  talk_base::scoped_ptr<RemoteMediaStreamFactory> remote_stream_factory_;
+  rtc::scoped_refptr<StreamCollection> local_streams_;
+  rtc::scoped_refptr<StreamCollection> remote_streams_;
+  rtc::scoped_ptr<RemoteMediaStreamFactory> remote_stream_factory_;
 
   TrackInfos remote_audio_tracks_;
   TrackInfos remote_video_tracks_;
@@ -392,9 +392,9 @@ class MediaStreamSignaling : public sigslot::has_slots<> {
   int last_allocated_sctp_even_sid_;
   int last_allocated_sctp_odd_sid_;
 
-  typedef std::map<std::string, talk_base::scoped_refptr<DataChannel> >
+  typedef std::map<std::string, rtc::scoped_refptr<DataChannel> >
       RtpDataChannels;
-  typedef std::vector<talk_base::scoped_refptr<DataChannel> > SctpDataChannels;
+  typedef std::vector<rtc::scoped_refptr<DataChannel> > SctpDataChannels;
 
   RtpDataChannels rtp_data_channels_;
   SctpDataChannels sctp_data_channels_;
diff --git a/talk/app/webrtc/mediastreamsignaling_unittest.cc b/talk/app/webrtc/mediastreamsignaling_unittest.cc
index 47034f6f51..259f4c05fa 100644
--- a/talk/app/webrtc/mediastreamsignaling_unittest.cc
+++ b/talk/app/webrtc/mediastreamsignaling_unittest.cc
@@ -36,10 +36,10 @@
 #include "talk/app/webrtc/test/fakeconstraints.h"
 #include "talk/app/webrtc/test/fakedatachannelprovider.h"
 #include "talk/app/webrtc/videotrack.h"
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/devices/fakedevicemanager.h"
 #include "talk/p2p/base/constants.h"
@@ -261,7 +261,7 @@ class FakeDataChannelFactory : public webrtc::DataChannelFactory {
                          cricket::DataChannelType dct)
       : provider_(provider), type_(dct) {}
 
-  virtual talk_base::scoped_refptr<webrtc::DataChannel> CreateDataChannel(
+  virtual rtc::scoped_refptr<webrtc::DataChannel> CreateDataChannel(
       const std::string& label,
       const webrtc::InternalDataChannelInit* config) {
     last_init_ = *config;
@@ -449,14 +449,14 @@ class MockSignalingObserver : public webrtc::MediaStreamSignalingObserver {
   TrackInfos local_audio_tracks_;
   TrackInfos local_video_tracks_;
 
-  talk_base::scoped_refptr<StreamCollection> remote_media_streams_;
+  rtc::scoped_refptr<StreamCollection> remote_media_streams_;
 };
 
 class MediaStreamSignalingForTest : public webrtc::MediaStreamSignaling {
  public:
   MediaStreamSignalingForTest(MockSignalingObserver* observer,
                               cricket::ChannelManager* channel_manager)
-      : webrtc::MediaStreamSignaling(talk_base::Thread::Current(), observer,
+      : webrtc::MediaStreamSignaling(rtc::Thread::Current(), observer,
                                      channel_manager) {
   };
 
@@ -473,7 +473,7 @@ class MediaStreamSignalingTest: public testing::Test {
     channel_manager_.reset(
         new cricket::ChannelManager(new cricket::FakeMediaEngine(),
                                     new cricket::FakeDeviceManager(),
-                                    talk_base::Thread::Current()));
+                                    rtc::Thread::Current()));
     signaling_.reset(new MediaStreamSignalingForTest(observer_.get(),
                                                      channel_manager_.get()));
     data_channel_provider_.reset(new FakeDataChannelProvider());
@@ -483,22 +483,22 @@ class MediaStreamSignalingTest: public testing::Test {
   // CreateStreamCollection(1) creates a collection that
   // correspond to kSdpString1.
   // CreateStreamCollection(2) correspond to kSdpString2.
-  talk_base::scoped_refptr<StreamCollection>
+  rtc::scoped_refptr<StreamCollection>
   CreateStreamCollection(int number_of_streams) {
-    talk_base::scoped_refptr<StreamCollection> local_collection(
+    rtc::scoped_refptr<StreamCollection> local_collection(
         StreamCollection::Create());
 
     for (int i = 0; i < number_of_streams; ++i) {
-      talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
           webrtc::MediaStream::Create(kStreams[i]));
 
       // Add a local audio track.
-      talk_base::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+      rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
           webrtc::AudioTrack::Create(kAudioTracks[i], NULL));
       stream->AddTrack(audio_track);
 
       // Add a local video track.
-      talk_base::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+      rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
           webrtc::VideoTrack::Create(kVideoTracks[i], NULL));
       stream->AddTrack(video_track);
 
@@ -525,7 +525,7 @@ class MediaStreamSignalingTest: public testing::Test {
 
     std::string mediastream_label = kStreams[0];
 
-    talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream(
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
             webrtc::MediaStream::Create(mediastream_label));
     reference_collection_->AddStream(stream);
 
@@ -555,23 +555,23 @@ class MediaStreamSignalingTest: public testing::Test {
 
   void AddAudioTrack(const std::string& track_id,
                      MediaStreamInterface* stream) {
-    talk_base::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+    rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         webrtc::AudioTrack::Create(track_id, NULL));
     ASSERT_TRUE(stream->AddTrack(audio_track));
   }
 
   void AddVideoTrack(const std::string& track_id,
                      MediaStreamInterface* stream) {
-    talk_base::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
         webrtc::VideoTrack::Create(track_id, NULL));
     ASSERT_TRUE(stream->AddTrack(video_track));
   }
 
-  talk_base::scoped_refptr<webrtc::DataChannel> AddDataChannel(
+  rtc::scoped_refptr<webrtc::DataChannel> AddDataChannel(
       cricket::DataChannelType type, const std::string& label, int id) {
     webrtc::InternalDataChannelInit config;
     config.id = id;
-    talk_base::scoped_refptr<webrtc::DataChannel> data_channel(
+    rtc::scoped_refptr<webrtc::DataChannel> data_channel(
         webrtc::DataChannel::Create(
             data_channel_provider_.get(), type, label, config));
     EXPECT_TRUE(data_channel.get() != NULL);
@@ -581,11 +581,11 @@ class MediaStreamSignalingTest: public testing::Test {
 
   // ChannelManager is used by VideoSource, so it should be released after all
   // the video tracks. Put it as the first private variable should ensure that.
-  talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
-  talk_base::scoped_refptr<StreamCollection> reference_collection_;
-  talk_base::scoped_ptr<MockSignalingObserver> observer_;
-  talk_base::scoped_ptr<MediaStreamSignalingForTest> signaling_;
-  talk_base::scoped_ptr<FakeDataChannelProvider> data_channel_provider_;
+  rtc::scoped_ptr<cricket::ChannelManager> channel_manager_;
+  rtc::scoped_refptr<StreamCollection> reference_collection_;
+  rtc::scoped_ptr<MockSignalingObserver> observer_;
+  rtc::scoped_ptr<MediaStreamSignalingForTest> signaling_;
+  rtc::scoped_ptr<FakeDataChannelProvider> data_channel_provider_;
 };
 
 // Test that a MediaSessionOptions is created for an offer if
@@ -686,7 +686,7 @@ TEST_F(MediaStreamSignalingTest, GetMediaSessionOptionsWithBadConstraints) {
 // a MediaStream is sent and later updated with a new track.
 // MediaConstraints are not used.
 TEST_F(MediaStreamSignalingTest, AddTrackToLocalMediaStream) {
-  talk_base::scoped_refptr<StreamCollection> local_streams(
+  rtc::scoped_refptr<StreamCollection> local_streams(
       CreateStreamCollection(1));
   MediaStreamInterface* local_stream = local_streams->at(0);
   EXPECT_TRUE(signaling_->AddLocalStream(local_stream));
@@ -758,13 +758,13 @@ TEST_F(MediaStreamSignalingTest, MediaConstraintsInAnswer) {
 // SDP string is created. In this test the two separate MediaStreams are
 // signaled.
 TEST_F(MediaStreamSignalingTest, UpdateRemoteStreams) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithStream1, NULL));
   EXPECT_TRUE(desc != NULL);
   signaling_->OnRemoteDescriptionChanged(desc.get());
 
-  talk_base::scoped_refptr<StreamCollection> reference(
+  rtc::scoped_refptr<StreamCollection> reference(
       CreateStreamCollection(1));
   EXPECT_TRUE(CompareStreamCollections(signaling_->remote_streams(),
                                        reference.get()));
@@ -780,13 +780,13 @@ TEST_F(MediaStreamSignalingTest, UpdateRemoteStreams) {
 
   // Create a session description based on another SDP with another
   // MediaStream.
-  talk_base::scoped_ptr<SessionDescriptionInterface> update_desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> update_desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWith2Stream, NULL));
   EXPECT_TRUE(update_desc != NULL);
   signaling_->OnRemoteDescriptionChanged(update_desc.get());
 
-  talk_base::scoped_refptr<StreamCollection> reference2(
+  rtc::scoped_refptr<StreamCollection> reference2(
       CreateStreamCollection(2));
   EXPECT_TRUE(CompareStreamCollections(signaling_->remote_streams(),
                                        reference2.get()));
@@ -805,14 +805,14 @@ TEST_F(MediaStreamSignalingTest, UpdateRemoteStreams) {
 // SDP string is created. In this test the same remote MediaStream is signaled
 // but MediaStream tracks are added and removed.
 TEST_F(MediaStreamSignalingTest, AddRemoveTrackFromExistingRemoteMediaStream) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_ms1;
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms1;
   CreateSessionDescriptionAndReference(1, 1, desc_ms1.use());
   signaling_->OnRemoteDescriptionChanged(desc_ms1.get());
   EXPECT_TRUE(CompareStreamCollections(signaling_->remote_streams(),
                                        reference_collection_));
 
   // Add extra audio and video tracks to the same MediaStream.
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_ms1_two_tracks;
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms1_two_tracks;
   CreateSessionDescriptionAndReference(2, 2, desc_ms1_two_tracks.use());
   signaling_->OnRemoteDescriptionChanged(desc_ms1_two_tracks.get());
   EXPECT_TRUE(CompareStreamCollections(signaling_->remote_streams(),
@@ -821,7 +821,7 @@ TEST_F(MediaStreamSignalingTest, AddRemoveTrackFromExistingRemoteMediaStream) {
                                        reference_collection_));
 
   // Remove the extra audio and video tracks again.
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_ms2;
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_ms2;
   CreateSessionDescriptionAndReference(1, 1, desc_ms2.use());
   signaling_->OnRemoteDescriptionChanged(desc_ms2.get());
   EXPECT_TRUE(CompareStreamCollections(signaling_->remote_streams(),
@@ -833,7 +833,7 @@ TEST_F(MediaStreamSignalingTest, AddRemoveTrackFromExistingRemoteMediaStream) {
 // This test that remote tracks are ended if a
 // local session description is set that rejects the media content type.
 TEST_F(MediaStreamSignalingTest, RejectMediaContent) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithStream1, NULL));
   EXPECT_TRUE(desc != NULL);
@@ -844,10 +844,10 @@ TEST_F(MediaStreamSignalingTest, RejectMediaContent) {
   ASSERT_EQ(1u, remote_stream->GetVideoTracks().size());
   ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
 
-  talk_base::scoped_refptr<webrtc::VideoTrackInterface> remote_video =
+  rtc::scoped_refptr<webrtc::VideoTrackInterface> remote_video =
       remote_stream->GetVideoTracks()[0];
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_video->state());
-  talk_base::scoped_refptr<webrtc::AudioTrackInterface> remote_audio =
+  rtc::scoped_refptr<webrtc::AudioTrackInterface> remote_audio =
       remote_stream->GetAudioTracks()[0];
   EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state());
 
@@ -871,7 +871,7 @@ TEST_F(MediaStreamSignalingTest, RejectMediaContent) {
 // of MediaStreamSignaling and then MediaStreamSignaling tries to reject
 // this track.
 TEST_F(MediaStreamSignalingTest, RemoveTrackThenRejectMediaContent) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithStream1, NULL));
   EXPECT_TRUE(desc != NULL);
@@ -899,7 +899,7 @@ TEST_F(MediaStreamSignalingTest, RemoveTrackThenRejectMediaContent) {
 // It also tests that the default stream is updated if a video m-line is added
 // in a subsequent session description.
 TEST_F(MediaStreamSignalingTest, SdpWithoutMsidCreatesDefaultStream) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_audio_only(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_audio_only(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithoutStreamsAudioOnly,
                                        NULL));
@@ -914,7 +914,7 @@ TEST_F(MediaStreamSignalingTest, SdpWithoutMsidCreatesDefaultStream) {
   EXPECT_EQ(0u, remote_stream->GetVideoTracks().size());
   EXPECT_EQ("default", remote_stream->label());
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithoutStreams, NULL));
   ASSERT_TRUE(desc != NULL);
@@ -931,7 +931,7 @@ TEST_F(MediaStreamSignalingTest, SdpWithoutMsidCreatesDefaultStream) {
 // This tests that a default MediaStream is created if a remote session
 // description doesn't contain any streams and media direction is send only.
 TEST_F(MediaStreamSignalingTest, RecvOnlySdpWithoutMsidCreatesDefaultStream) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringSendOnlyWithWithoutStreams,
                                        NULL));
@@ -950,7 +950,7 @@ TEST_F(MediaStreamSignalingTest, RecvOnlySdpWithoutMsidCreatesDefaultStream) {
 // This tests that it won't crash when MediaStreamSignaling tries to remove
 //  a remote track that as already been removed from the mediastream.
 TEST_F(MediaStreamSignalingTest, RemoveAlreadyGoneRemoteStream) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_audio_only(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_audio_only(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithoutStreams,
                                        NULL));
@@ -960,7 +960,7 @@ TEST_F(MediaStreamSignalingTest, RemoveAlreadyGoneRemoteStream) {
   remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
   remote_stream->RemoveTrack(remote_stream->GetVideoTracks()[0]);
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithoutStreams, NULL));
   ASSERT_TRUE(desc != NULL);
@@ -974,7 +974,7 @@ TEST_F(MediaStreamSignalingTest, RemoveAlreadyGoneRemoteStream) {
 // MSID is supported.
 TEST_F(MediaStreamSignalingTest,
        SdpWithoutMsidAndStreamsCreatesDefaultStream) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithoutStreams,
                                        NULL));
@@ -990,7 +990,7 @@ TEST_F(MediaStreamSignalingTest,
 // This tests that a default MediaStream is not created if the remote session
 // description doesn't contain any streams but does support MSID.
 TEST_F(MediaStreamSignalingTest, SdpWitMsidDontCreatesDefaultStream) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_msid_without_streams(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_msid_without_streams(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithMsidWithoutStreams,
                                        NULL));
@@ -1001,18 +1001,18 @@ TEST_F(MediaStreamSignalingTest, SdpWitMsidDontCreatesDefaultStream) {
 // This test that a default MediaStream is not created if a remote session
 // description is updated to not have any MediaStreams.
 TEST_F(MediaStreamSignalingTest, VerifyDefaultStreamIsNotCreated) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithStream1,
                                        NULL));
   ASSERT_TRUE(desc != NULL);
   signaling_->OnRemoteDescriptionChanged(desc.get());
-  talk_base::scoped_refptr<StreamCollection> reference(
+  rtc::scoped_refptr<StreamCollection> reference(
       CreateStreamCollection(1));
   EXPECT_TRUE(CompareStreamCollections(observer_->remote_streams(),
                                        reference.get()));
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_without_streams(
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_without_streams(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithoutStreams,
                                        NULL));
@@ -1024,7 +1024,7 @@ TEST_F(MediaStreamSignalingTest, VerifyDefaultStreamIsNotCreated) {
 // when MediaStreamSignaling::OnLocalDescriptionChanged is called with an
 // updated local session description.
 TEST_F(MediaStreamSignalingTest, LocalDescriptionChanged) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_1;
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_1;
   CreateSessionDescriptionAndReference(2, 2, desc_1.use());
 
   signaling_->AddLocalStream(reference_collection_->at(0));
@@ -1037,7 +1037,7 @@ TEST_F(MediaStreamSignalingTest, LocalDescriptionChanged) {
   observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[1], 4);
 
   // Remove an audio and video track.
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_2;
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_2;
   CreateSessionDescriptionAndReference(1, 1, desc_2.use());
   signaling_->OnLocalDescriptionChanged(desc_2.get());
   EXPECT_EQ(1u, observer_->NumberOfLocalAudioTracks());
@@ -1050,7 +1050,7 @@ TEST_F(MediaStreamSignalingTest, LocalDescriptionChanged) {
 // when MediaStreamSignaling::AddLocalStream is called after
 // MediaStreamSignaling::OnLocalDescriptionChanged is called.
 TEST_F(MediaStreamSignalingTest, AddLocalStreamAfterLocalDescriptionChanged) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_1;
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_1;
   CreateSessionDescriptionAndReference(2, 2, desc_1.use());
 
   signaling_->OnLocalDescriptionChanged(desc_1.get());
@@ -1070,7 +1070,7 @@ TEST_F(MediaStreamSignalingTest, AddLocalStreamAfterLocalDescriptionChanged) {
 // if the ssrc on a local track is changed when
 // MediaStreamSignaling::OnLocalDescriptionChanged is called.
 TEST_F(MediaStreamSignalingTest, ChangeSsrcOnTrackInLocalSessionDescription) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc;
+  rtc::scoped_ptr<SessionDescriptionInterface> desc;
   CreateSessionDescriptionAndReference(1, 1, desc.use());
 
   signaling_->AddLocalStream(reference_collection_->at(0));
@@ -1085,15 +1085,15 @@ TEST_F(MediaStreamSignalingTest, ChangeSsrcOnTrackInLocalSessionDescription) {
   desc->ToString(&sdp);
   std::string ssrc_org = "a=ssrc:1";
   std::string ssrc_to = "a=ssrc:97";
-  talk_base::replace_substrs(ssrc_org.c_str(), ssrc_org.length(),
+  rtc::replace_substrs(ssrc_org.c_str(), ssrc_org.length(),
                              ssrc_to.c_str(), ssrc_to.length(),
                              &sdp);
   ssrc_org = "a=ssrc:2";
   ssrc_to = "a=ssrc:98";
-  talk_base::replace_substrs(ssrc_org.c_str(), ssrc_org.length(),
+  rtc::replace_substrs(ssrc_org.c_str(), ssrc_org.length(),
                              ssrc_to.c_str(), ssrc_to.length(),
                              &sdp);
-  talk_base::scoped_ptr<SessionDescriptionInterface> updated_desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        sdp, NULL));
 
@@ -1108,7 +1108,7 @@ TEST_F(MediaStreamSignalingTest, ChangeSsrcOnTrackInLocalSessionDescription) {
 // if a new session description is set with the same tracks but they are now
 // sent on a another MediaStream.
 TEST_F(MediaStreamSignalingTest, SignalSameTracksInSeparateMediaStream) {
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc;
+  rtc::scoped_ptr<SessionDescriptionInterface> desc;
   CreateSessionDescriptionAndReference(1, 1, desc.use());
 
   signaling_->AddLocalStream(reference_collection_->at(0));
@@ -1122,7 +1122,7 @@ TEST_F(MediaStreamSignalingTest, SignalSameTracksInSeparateMediaStream) {
 
   // Add a new MediaStream but with the same tracks as in the first stream.
   std::string stream_label_1 = kStreams[1];
-  talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
       webrtc::MediaStream::Create(kStreams[1]));
   stream_1->AddTrack(reference_collection_->at(0)->GetVideoTracks()[0]);
   stream_1->AddTrack(reference_collection_->at(0)->GetAudioTracks()[0]);
@@ -1131,10 +1131,10 @@ TEST_F(MediaStreamSignalingTest, SignalSameTracksInSeparateMediaStream) {
   // Replace msid in the original SDP.
   std::string sdp;
   desc->ToString(&sdp);
-  talk_base::replace_substrs(
+  rtc::replace_substrs(
       kStreams[0], strlen(kStreams[0]), kStreams[1], strlen(kStreams[1]), &sdp);
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> updated_desc(
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        sdp, NULL));
 
@@ -1149,13 +1149,13 @@ TEST_F(MediaStreamSignalingTest, SignalSameTracksInSeparateMediaStream) {
 // SSL_SERVER.
 TEST_F(MediaStreamSignalingTest, SctpIdAllocationBasedOnRole) {
   int id;
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_SERVER, &id));
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_SERVER, &id));
   EXPECT_EQ(1, id);
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_CLIENT, &id));
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_CLIENT, &id));
   EXPECT_EQ(0, id);
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_SERVER, &id));
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_SERVER, &id));
   EXPECT_EQ(3, id);
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_CLIENT, &id));
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_CLIENT, &id));
   EXPECT_EQ(2, id);
 }
 
@@ -1165,13 +1165,13 @@ TEST_F(MediaStreamSignalingTest, SctpIdAllocationNoReuse) {
   AddDataChannel(cricket::DCT_SCTP, "a", old_id);
 
   int new_id;
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_SERVER, &new_id));
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_SERVER, &new_id));
   EXPECT_NE(old_id, new_id);
 
   // Creates a DataChannel with id 0.
   old_id = 0;
   AddDataChannel(cricket::DCT_SCTP, "a", old_id);
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_CLIENT, &new_id));
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_CLIENT, &new_id));
   EXPECT_NE(old_id, new_id);
 }
 
@@ -1183,12 +1183,12 @@ TEST_F(MediaStreamSignalingTest, SctpIdReusedForRemovedDataChannel) {
   AddDataChannel(cricket::DCT_SCTP, "a", even_id);
 
   int allocated_id = -1;
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_SERVER,
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_SERVER,
                                           &allocated_id));
   EXPECT_EQ(odd_id + 2, allocated_id);
   AddDataChannel(cricket::DCT_SCTP, "a", allocated_id);
 
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_CLIENT,
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_CLIENT,
                                           &allocated_id));
   EXPECT_EQ(even_id + 2, allocated_id);
   AddDataChannel(cricket::DCT_SCTP, "a", allocated_id);
@@ -1197,20 +1197,20 @@ TEST_F(MediaStreamSignalingTest, SctpIdReusedForRemovedDataChannel) {
   signaling_->RemoveSctpDataChannel(even_id);
 
   // Verifies that removed DataChannel ids are reused.
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_SERVER,
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_SERVER,
                                           &allocated_id));
   EXPECT_EQ(odd_id, allocated_id);
 
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_CLIENT,
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_CLIENT,
                                           &allocated_id));
   EXPECT_EQ(even_id, allocated_id);
 
   // Verifies that used higher DataChannel ids are not reused.
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_SERVER,
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_SERVER,
                                           &allocated_id));
   EXPECT_NE(odd_id + 2, allocated_id);
 
-  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_CLIENT,
+  ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_CLIENT,
                                           &allocated_id));
   EXPECT_NE(even_id + 2, allocated_id);
 
@@ -1221,7 +1221,7 @@ TEST_F(MediaStreamSignalingTest, RtpDuplicatedLabelNotAllowed) {
   AddDataChannel(cricket::DCT_RTP, "a", -1);
 
   webrtc::InternalDataChannelInit config;
-  talk_base::scoped_refptr<webrtc::DataChannel> data_channel =
+  rtc::scoped_refptr<webrtc::DataChannel> data_channel =
       webrtc::DataChannel::Create(
           data_channel_provider_.get(), cricket::DCT_RTP, "a", config);
   ASSERT_TRUE(data_channel.get() != NULL);
@@ -1242,7 +1242,7 @@ TEST_F(MediaStreamSignalingTest, CreateDataChannelFromOpenMessage) {
   signaling_->SetDataChannelFactory(&fake_factory);
   webrtc::DataChannelInit config;
   config.id = 1;
-  talk_base::Buffer payload;
+  rtc::Buffer payload;
   webrtc::WriteDataChannelOpenMessage("a", config, &payload);
   cricket::ReceiveDataParams params;
   params.ssrc = config.id;
@@ -1262,7 +1262,7 @@ TEST_F(MediaStreamSignalingTest, DuplicatedLabelFromOpenMessageAllowed) {
   signaling_->SetDataChannelFactory(&fake_factory);
   webrtc::DataChannelInit config;
   config.id = 0;
-  talk_base::Buffer payload;
+  rtc::Buffer payload;
   webrtc::WriteDataChannelOpenMessage("a", config, &payload);
   cricket::ReceiveDataParams params;
   params.ssrc = config.id;
@@ -1275,7 +1275,7 @@ TEST_F(MediaStreamSignalingTest,
   webrtc::InternalDataChannelInit config;
   config.id = 0;
 
-  talk_base::scoped_refptr<webrtc::DataChannel> data_channel =
+  rtc::scoped_refptr<webrtc::DataChannel> data_channel =
       webrtc::DataChannel::Create(
           data_channel_provider_.get(), cricket::DCT_SCTP, "a", config);
   ASSERT_TRUE(data_channel.get() != NULL);
diff --git a/talk/app/webrtc/mediastreamtrackproxy.h b/talk/app/webrtc/mediastreamtrackproxy.h
index 19750b08ac..56ad1e3cfa 100644
--- a/talk/app/webrtc/mediastreamtrackproxy.h
+++ b/talk/app/webrtc/mediastreamtrackproxy.h
@@ -45,7 +45,7 @@ BEGIN_PROXY_MAP(AudioTrack)
   PROXY_METHOD1(void, AddSink, AudioTrackSinkInterface*)
   PROXY_METHOD1(void, RemoveSink, AudioTrackSinkInterface*)
   PROXY_METHOD1(bool, GetSignalLevel, int*)
-  PROXY_METHOD0(talk_base::scoped_refptr<AudioProcessorInterface>,
+  PROXY_METHOD0(rtc::scoped_refptr<AudioProcessorInterface>,
                 GetAudioProcessor)
   PROXY_METHOD0(cricket::AudioRenderer*, GetRenderer)
 
diff --git a/talk/app/webrtc/notifier.h b/talk/app/webrtc/notifier.h
index eaa0063872..0237ecf3e0 100644
--- a/talk/app/webrtc/notifier.h
+++ b/talk/app/webrtc/notifier.h
@@ -30,7 +30,7 @@
 
 #include <list>
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/app/webrtc/mediastreaminterface.h"
 
 namespace webrtc {
diff --git a/talk/app/webrtc/objc/RTCAudioTrack+Internal.h b/talk/app/webrtc/objc/RTCAudioTrack+Internal.h
index 17d2723247..60e40bf0ff 100644
--- a/talk/app/webrtc/objc/RTCAudioTrack+Internal.h
+++ b/talk/app/webrtc/objc/RTCAudioTrack+Internal.h
@@ -32,6 +32,6 @@
 @interface RTCAudioTrack (Internal)
 
 @property(nonatomic, assign, readonly)
-    talk_base::scoped_refptr<webrtc::AudioTrackInterface> audioTrack;
+    rtc::scoped_refptr<webrtc::AudioTrackInterface> audioTrack;
 
 @end
diff --git a/talk/app/webrtc/objc/RTCAudioTrack.mm b/talk/app/webrtc/objc/RTCAudioTrack.mm
index 2364c2942c..bdc89b5021 100644
--- a/talk/app/webrtc/objc/RTCAudioTrack.mm
+++ b/talk/app/webrtc/objc/RTCAudioTrack.mm
@@ -38,7 +38,7 @@
 
 @implementation RTCAudioTrack (Internal)
 
-- (talk_base::scoped_refptr<webrtc::AudioTrackInterface>)audioTrack {
+- (rtc::scoped_refptr<webrtc::AudioTrackInterface>)audioTrack {
   return static_cast<webrtc::AudioTrackInterface*>(self.mediaTrack.get());
 }
 
diff --git a/talk/app/webrtc/objc/RTCDataChannel+Internal.h b/talk/app/webrtc/objc/RTCDataChannel+Internal.h
index a55089193b..0a8079b3a9 100644
--- a/talk/app/webrtc/objc/RTCDataChannel+Internal.h
+++ b/talk/app/webrtc/objc/RTCDataChannel+Internal.h
@@ -28,7 +28,7 @@
 #import "RTCDataChannel.h"
 
 #include "talk/app/webrtc/datachannelinterface.h"
-#include "talk/base/scoped_ref_ptr.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 
 @interface RTCDataBuffer (Internal)
 
@@ -47,9 +47,9 @@
 @interface RTCDataChannel (Internal)
 
 @property(nonatomic, readonly)
-    talk_base::scoped_refptr<webrtc::DataChannelInterface> dataChannel;
+    rtc::scoped_refptr<webrtc::DataChannelInterface> dataChannel;
 
 - (instancetype)initWithDataChannel:
-        (talk_base::scoped_refptr<webrtc::DataChannelInterface>)dataChannel;
+        (rtc::scoped_refptr<webrtc::DataChannelInterface>)dataChannel;
 
 @end
diff --git a/talk/app/webrtc/objc/RTCDataChannel.mm b/talk/app/webrtc/objc/RTCDataChannel.mm
index 0837940375..2cf8bf8da3 100644
--- a/talk/app/webrtc/objc/RTCDataChannel.mm
+++ b/talk/app/webrtc/objc/RTCDataChannel.mm
@@ -135,13 +135,13 @@ std::string StdStringFromNSString(NSString* nsString) {
 @end
 
 @implementation RTCDataBuffer {
-  talk_base::scoped_ptr<webrtc::DataBuffer> _dataBuffer;
+  rtc::scoped_ptr<webrtc::DataBuffer> _dataBuffer;
 }
 
 - (instancetype)initWithData:(NSData*)data isBinary:(BOOL)isBinary {
   NSAssert(data, @"data cannot be nil");
   if (self = [super init]) {
-    talk_base::Buffer buffer([data bytes], [data length]);
+    rtc::Buffer buffer([data bytes], [data length]);
     _dataBuffer.reset(new webrtc::DataBuffer(buffer, isBinary));
   }
   return self;
@@ -174,8 +174,8 @@ std::string StdStringFromNSString(NSString* nsString) {
 @end
 
 @implementation RTCDataChannel {
-  talk_base::scoped_refptr<webrtc::DataChannelInterface> _dataChannel;
-  talk_base::scoped_ptr<webrtc::RTCDataChannelObserver> _observer;
+  rtc::scoped_refptr<webrtc::DataChannelInterface> _dataChannel;
+  rtc::scoped_ptr<webrtc::RTCDataChannelObserver> _observer;
   BOOL _isObserverRegistered;
 }
 
@@ -256,7 +256,7 @@ std::string StdStringFromNSString(NSString* nsString) {
 @implementation RTCDataChannel (Internal)
 
 - (instancetype)initWithDataChannel:
-                    (talk_base::scoped_refptr<webrtc::DataChannelInterface>)
+                    (rtc::scoped_refptr<webrtc::DataChannelInterface>)
                 dataChannel {
   NSAssert(dataChannel != NULL, @"dataChannel cannot be NULL");
   if (self = [super init]) {
@@ -266,7 +266,7 @@ std::string StdStringFromNSString(NSString* nsString) {
   return self;
 }
 
-- (talk_base::scoped_refptr<webrtc::DataChannelInterface>)dataChannel {
+- (rtc::scoped_refptr<webrtc::DataChannelInterface>)dataChannel {
   return _dataChannel;
 }
 
diff --git a/talk/app/webrtc/objc/RTCI420Frame.mm b/talk/app/webrtc/objc/RTCI420Frame.mm
index eff3102e26..61903bc16e 100644
--- a/talk/app/webrtc/objc/RTCI420Frame.mm
+++ b/talk/app/webrtc/objc/RTCI420Frame.mm
@@ -27,11 +27,11 @@
 
 #import "RTCI420Frame.h"
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/videoframe.h"
 
 @implementation RTCI420Frame {
-  talk_base::scoped_ptr<cricket::VideoFrame> _videoFrame;
+  rtc::scoped_ptr<cricket::VideoFrame> _videoFrame;
 }
 
 - (NSUInteger)width {
diff --git a/talk/app/webrtc/objc/RTCMediaConstraints.mm b/talk/app/webrtc/objc/RTCMediaConstraints.mm
index a1cc5a564e..e44dd593cd 100644
--- a/talk/app/webrtc/objc/RTCMediaConstraints.mm
+++ b/talk/app/webrtc/objc/RTCMediaConstraints.mm
@@ -33,13 +33,13 @@
 
 #import "RTCPair.h"
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 
 // TODO(hughv):  Add accessors for mandatory and optional constraints.
 // TODO(hughv):  Add description.
 
 @implementation RTCMediaConstraints {
-  talk_base::scoped_ptr<webrtc::RTCMediaConstraintsNative> _constraints;
+  rtc::scoped_ptr<webrtc::RTCMediaConstraintsNative> _constraints;
   webrtc::MediaConstraintsInterface::Constraints _mandatory;
   webrtc::MediaConstraintsInterface::Constraints _optional;
 }
diff --git a/talk/app/webrtc/objc/RTCMediaSource+Internal.h b/talk/app/webrtc/objc/RTCMediaSource+Internal.h
index 98f8e9cc25..96341f22ca 100644
--- a/talk/app/webrtc/objc/RTCMediaSource+Internal.h
+++ b/talk/app/webrtc/objc/RTCMediaSource+Internal.h
@@ -32,9 +32,9 @@
 @interface RTCMediaSource (Internal)
 
 @property(nonatomic, assign, readonly)
-    talk_base::scoped_refptr<webrtc::MediaSourceInterface> mediaSource;
+    rtc::scoped_refptr<webrtc::MediaSourceInterface> mediaSource;
 
 - (id)initWithMediaSource:
-        (talk_base::scoped_refptr<webrtc::MediaSourceInterface>)mediaSource;
+        (rtc::scoped_refptr<webrtc::MediaSourceInterface>)mediaSource;
 
 @end
diff --git a/talk/app/webrtc/objc/RTCMediaSource.mm b/talk/app/webrtc/objc/RTCMediaSource.mm
index 28af3ad2e3..b94bf05afe 100644
--- a/talk/app/webrtc/objc/RTCMediaSource.mm
+++ b/talk/app/webrtc/objc/RTCMediaSource.mm
@@ -34,7 +34,7 @@
 #import "RTCEnumConverter.h"
 
 @implementation RTCMediaSource {
-  talk_base::scoped_refptr<webrtc::MediaSourceInterface> _mediaSource;
+  rtc::scoped_refptr<webrtc::MediaSourceInterface> _mediaSource;
 }
 
 - (RTCSourceState)state {
@@ -46,7 +46,7 @@
 @implementation RTCMediaSource (Internal)
 
 - (id)initWithMediaSource:
-        (talk_base::scoped_refptr<webrtc::MediaSourceInterface>)mediaSource {
+        (rtc::scoped_refptr<webrtc::MediaSourceInterface>)mediaSource {
   if (!mediaSource) {
     NSAssert(NO, @"nil arguments not allowed");
     self = nil;
@@ -58,7 +58,7 @@
   return self;
 }
 
-- (talk_base::scoped_refptr<webrtc::MediaSourceInterface>)mediaSource {
+- (rtc::scoped_refptr<webrtc::MediaSourceInterface>)mediaSource {
   return _mediaSource;
 }
 
diff --git a/talk/app/webrtc/objc/RTCMediaStream+Internal.h b/talk/app/webrtc/objc/RTCMediaStream+Internal.h
index 2123c2d8b8..bde7631a63 100644
--- a/talk/app/webrtc/objc/RTCMediaStream+Internal.h
+++ b/talk/app/webrtc/objc/RTCMediaStream+Internal.h
@@ -32,9 +32,9 @@
 @interface RTCMediaStream (Internal)
 
 @property(nonatomic, assign, readonly)
-    talk_base::scoped_refptr<webrtc::MediaStreamInterface> mediaStream;
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> mediaStream;
 
 - (id)initWithMediaStream:
-        (talk_base::scoped_refptr<webrtc::MediaStreamInterface>)mediaStream;
+        (rtc::scoped_refptr<webrtc::MediaStreamInterface>)mediaStream;
 
 @end
diff --git a/talk/app/webrtc/objc/RTCMediaStream.mm b/talk/app/webrtc/objc/RTCMediaStream.mm
index 94e14fc57c..27d20b8aae 100644
--- a/talk/app/webrtc/objc/RTCMediaStream.mm
+++ b/talk/app/webrtc/objc/RTCMediaStream.mm
@@ -40,7 +40,7 @@
 @implementation RTCMediaStream {
   NSMutableArray* _audioTracks;
   NSMutableArray* _videoTracks;
-  talk_base::scoped_refptr<webrtc::MediaStreamInterface> _mediaStream;
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> _mediaStream;
 }
 
 - (NSString*)description {
@@ -105,7 +105,7 @@
 @implementation RTCMediaStream (Internal)
 
 - (id)initWithMediaStream:
-          (talk_base::scoped_refptr<webrtc::MediaStreamInterface>)mediaStream {
+          (rtc::scoped_refptr<webrtc::MediaStreamInterface>)mediaStream {
   if (!mediaStream) {
     NSAssert(NO, @"nil arguments not allowed");
     self = nil;
@@ -120,7 +120,7 @@
     _mediaStream = mediaStream;
 
     for (size_t i = 0; i < audio_tracks.size(); ++i) {
-      talk_base::scoped_refptr<webrtc::AudioTrackInterface> track =
+      rtc::scoped_refptr<webrtc::AudioTrackInterface> track =
           audio_tracks[i];
       RTCAudioTrack* audioTrack =
           [[RTCAudioTrack alloc] initWithMediaTrack:track];
@@ -128,7 +128,7 @@
     }
 
     for (size_t i = 0; i < video_tracks.size(); ++i) {
-      talk_base::scoped_refptr<webrtc::VideoTrackInterface> track =
+      rtc::scoped_refptr<webrtc::VideoTrackInterface> track =
           video_tracks[i];
       RTCVideoTrack* videoTrack =
           [[RTCVideoTrack alloc] initWithMediaTrack:track];
@@ -138,7 +138,7 @@
   return self;
 }
 
-- (talk_base::scoped_refptr<webrtc::MediaStreamInterface>)mediaStream {
+- (rtc::scoped_refptr<webrtc::MediaStreamInterface>)mediaStream {
   return _mediaStream;
 }
 
diff --git a/talk/app/webrtc/objc/RTCMediaStreamTrack+Internal.h b/talk/app/webrtc/objc/RTCMediaStreamTrack+Internal.h
index 9a0cab39b1..d815c79b0a 100644
--- a/talk/app/webrtc/objc/RTCMediaStreamTrack+Internal.h
+++ b/talk/app/webrtc/objc/RTCMediaStreamTrack+Internal.h
@@ -32,9 +32,9 @@
 @interface RTCMediaStreamTrack (Internal)
 
 @property(nonatomic, assign, readonly)
-    talk_base::scoped_refptr<webrtc::MediaStreamTrackInterface> mediaTrack;
+    rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> mediaTrack;
 
 - (id)initWithMediaTrack:
-        (talk_base::scoped_refptr<webrtc::MediaStreamTrackInterface>)mediaTrack;
+        (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)mediaTrack;
 
 @end
diff --git a/talk/app/webrtc/objc/RTCMediaStreamTrack.mm b/talk/app/webrtc/objc/RTCMediaStreamTrack.mm
index 5931312002..a821bcc3f1 100644
--- a/talk/app/webrtc/objc/RTCMediaStreamTrack.mm
+++ b/talk/app/webrtc/objc/RTCMediaStreamTrack.mm
@@ -48,8 +48,8 @@ class RTCMediaStreamTrackObserver : public ObserverInterface {
 }
 
 @implementation RTCMediaStreamTrack {
-  talk_base::scoped_refptr<webrtc::MediaStreamTrackInterface> _mediaTrack;
-  talk_base::scoped_ptr<webrtc::RTCMediaStreamTrackObserver> _observer;
+  rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> _mediaTrack;
+  rtc::scoped_ptr<webrtc::RTCMediaStreamTrackObserver> _observer;
 }
 
 @synthesize label;
@@ -100,7 +100,7 @@ class RTCMediaStreamTrackObserver : public ObserverInterface {
 @implementation RTCMediaStreamTrack (Internal)
 
 - (id)initWithMediaTrack:
-          (talk_base::scoped_refptr<webrtc::MediaStreamTrackInterface>)
+          (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)
       mediaTrack {
   if (!mediaTrack) {
     NSAssert(NO, @"nil arguments not allowed");
@@ -120,7 +120,7 @@ class RTCMediaStreamTrackObserver : public ObserverInterface {
   _mediaTrack->UnregisterObserver(_observer.get());
 }
 
-- (talk_base::scoped_refptr<webrtc::MediaStreamTrackInterface>)mediaTrack {
+- (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)mediaTrack {
   return _mediaTrack;
 }
 
diff --git a/talk/app/webrtc/objc/RTCPeerConnection+Internal.h b/talk/app/webrtc/objc/RTCPeerConnection+Internal.h
index ad1c334a2a..305bd5e987 100644
--- a/talk/app/webrtc/objc/RTCPeerConnection+Internal.h
+++ b/talk/app/webrtc/objc/RTCPeerConnection+Internal.h
@@ -34,7 +34,7 @@
 @interface RTCPeerConnection (Internal)
 
 @property(nonatomic, assign, readonly)
-    talk_base::scoped_refptr<webrtc::PeerConnectionInterface> peerConnection;
+    rtc::scoped_refptr<webrtc::PeerConnectionInterface> peerConnection;
 
 - (instancetype)initWithFactory:(webrtc::PeerConnectionFactoryInterface*)factory
      iceServers:(const webrtc::PeerConnectionInterface::IceServers&)iceServers
diff --git a/talk/app/webrtc/objc/RTCPeerConnection.mm b/talk/app/webrtc/objc/RTCPeerConnection.mm
index 738fb313f4..58c13422cb 100644
--- a/talk/app/webrtc/objc/RTCPeerConnection.mm
+++ b/talk/app/webrtc/objc/RTCPeerConnection.mm
@@ -141,12 +141,12 @@ class RTCStatsObserver : public StatsObserver {
 
 @implementation RTCPeerConnection {
   NSMutableArray* _localStreams;
-  talk_base::scoped_ptr<webrtc::RTCPeerConnectionObserver> _observer;
-  talk_base::scoped_refptr<webrtc::PeerConnectionInterface> _peerConnection;
+  rtc::scoped_ptr<webrtc::RTCPeerConnectionObserver> _observer;
+  rtc::scoped_refptr<webrtc::PeerConnectionInterface> _peerConnection;
 }
 
 - (BOOL)addICECandidate:(RTCICECandidate*)candidate {
-  talk_base::scoped_ptr<const webrtc::IceCandidateInterface> iceCandidate(
+  rtc::scoped_ptr<const webrtc::IceCandidateInterface> iceCandidate(
       candidate.candidate);
   return self.peerConnection->AddIceCandidate(iceCandidate.get());
 }
@@ -165,7 +165,7 @@ class RTCStatsObserver : public StatsObserver {
 - (RTCDataChannel*)createDataChannelWithLabel:(NSString*)label
                                        config:(RTCDataChannelInit*)config {
   std::string labelString([label UTF8String]);
-  talk_base::scoped_refptr<webrtc::DataChannelInterface> dataChannel =
+  rtc::scoped_refptr<webrtc::DataChannelInterface> dataChannel =
       self.peerConnection->CreateDataChannel(labelString,
                                              config.dataChannelInit);
   return [[RTCDataChannel alloc] initWithDataChannel:dataChannel];
@@ -173,16 +173,16 @@ class RTCStatsObserver : public StatsObserver {
 
 - (void)createAnswerWithDelegate:(id<RTCSessionDescriptionDelegate>)delegate
                      constraints:(RTCMediaConstraints*)constraints {
-  talk_base::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
-      observer(new talk_base::RefCountedObject<
+  rtc::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
+      observer(new rtc::RefCountedObject<
           webrtc::RTCCreateSessionDescriptionObserver>(delegate, self));
   self.peerConnection->CreateAnswer(observer, constraints.constraints);
 }
 
 - (void)createOfferWithDelegate:(id<RTCSessionDescriptionDelegate>)delegate
                     constraints:(RTCMediaConstraints*)constraints {
-  talk_base::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
-      observer(new talk_base::RefCountedObject<
+  rtc::scoped_refptr<webrtc::RTCCreateSessionDescriptionObserver>
+      observer(new rtc::RefCountedObject<
           webrtc::RTCCreateSessionDescriptionObserver>(delegate, self));
   self.peerConnection->CreateOffer(observer, constraints.constraints);
 }
@@ -195,8 +195,8 @@ class RTCStatsObserver : public StatsObserver {
 - (void)setLocalDescriptionWithDelegate:
             (id<RTCSessionDescriptionDelegate>)delegate
                      sessionDescription:(RTCSessionDescription*)sdp {
-  talk_base::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
-      new talk_base::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>(
+  rtc::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
+      new rtc::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>(
           delegate, self));
   self.peerConnection->SetLocalDescription(observer, sdp.sessionDescription);
 }
@@ -204,8 +204,8 @@ class RTCStatsObserver : public StatsObserver {
 - (void)setRemoteDescriptionWithDelegate:
             (id<RTCSessionDescriptionDelegate>)delegate
                       sessionDescription:(RTCSessionDescription*)sdp {
-  talk_base::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
-      new talk_base::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>(
+  rtc::scoped_refptr<webrtc::RTCSetSessionDescriptionObserver> observer(
+      new rtc::RefCountedObject<webrtc::RTCSetSessionDescriptionObserver>(
           delegate, self));
   self.peerConnection->SetRemoteDescription(observer, sdp.sessionDescription);
 }
@@ -261,8 +261,8 @@ class RTCStatsObserver : public StatsObserver {
 - (BOOL)getStatsWithDelegate:(id<RTCStatsDelegate>)delegate
             mediaStreamTrack:(RTCMediaStreamTrack*)mediaStreamTrack
             statsOutputLevel:(RTCStatsOutputLevel)statsOutputLevel {
-  talk_base::scoped_refptr<webrtc::RTCStatsObserver> observer(
-      new talk_base::RefCountedObject<webrtc::RTCStatsObserver>(delegate,
+  rtc::scoped_refptr<webrtc::RTCStatsObserver> observer(
+      new rtc::RefCountedObject<webrtc::RTCStatsObserver>(delegate,
                                                                 self));
   webrtc::PeerConnectionInterface::StatsOutputLevel nativeOutputLevel =
       [RTCEnumConverter convertStatsOutputLevelToNative:statsOutputLevel];
@@ -287,7 +287,7 @@ class RTCStatsObserver : public StatsObserver {
   return self;
 }
 
-- (talk_base::scoped_refptr<webrtc::PeerConnectionInterface>)peerConnection {
+- (rtc::scoped_refptr<webrtc::PeerConnectionInterface>)peerConnection {
   return _peerConnection;
 }
 
diff --git a/talk/app/webrtc/objc/RTCPeerConnectionFactory.mm b/talk/app/webrtc/objc/RTCPeerConnectionFactory.mm
index 8ada166d6b..b7d2ce3085 100644
--- a/talk/app/webrtc/objc/RTCPeerConnectionFactory.mm
+++ b/talk/app/webrtc/objc/RTCPeerConnectionFactory.mm
@@ -51,12 +51,12 @@
 #include "talk/app/webrtc/peerconnectioninterface.h"
 #include "talk/app/webrtc/videosourceinterface.h"
 #include "talk/app/webrtc/videotrack.h"
-#include "talk/base/logging.h"
-#include "talk/base/ssladapter.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/ssladapter.h"
 
 @interface RTCPeerConnectionFactory ()
 
-@property(nonatomic, assign) talk_base::scoped_refptr<
+@property(nonatomic, assign) rtc::scoped_refptr<
     webrtc::PeerConnectionFactoryInterface> nativeFactory;
 
 @end
@@ -66,12 +66,12 @@
 @synthesize nativeFactory = _nativeFactory;
 
 + (void)initializeSSL {
-  BOOL initialized = talk_base::InitializeSSL();
+  BOOL initialized = rtc::InitializeSSL();
   NSAssert(initialized, @"Failed to initialize SSL library");
 }
 
 + (void)deinitializeSSL {
-  BOOL deinitialized = talk_base::CleanupSSL();
+  BOOL deinitialized = rtc::CleanupSSL();
   NSAssert(deinitialized, @"Failed to deinitialize SSL library");
 }
 
@@ -80,7 +80,7 @@
     _nativeFactory = webrtc::CreatePeerConnectionFactory();
     NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
     // Uncomment to get sensitive logs emitted (to stderr or logcat).
-    // talk_base::LogMessage::LogToDebug(talk_base::LS_SENSITIVE);
+    // rtc::LogMessage::LogToDebug(rtc::LS_SENSITIVE);
   }
   return self;
 }
@@ -102,7 +102,7 @@
 }
 
 - (RTCMediaStream*)mediaStreamWithLabel:(NSString*)label {
-  talk_base::scoped_refptr<webrtc::MediaStreamInterface> nativeMediaStream =
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> nativeMediaStream =
       self.nativeFactory->CreateLocalMediaStream([label UTF8String]);
   return [[RTCMediaStream alloc] initWithMediaStream:nativeMediaStream];
 }
@@ -112,7 +112,7 @@
   if (!capturer) {
     return nil;
   }
-  talk_base::scoped_refptr<webrtc::VideoSourceInterface> source =
+  rtc::scoped_refptr<webrtc::VideoSourceInterface> source =
       self.nativeFactory->CreateVideoSource([capturer takeNativeCapturer],
                                             constraints.constraints);
   return [[RTCVideoSource alloc] initWithMediaSource:source];
@@ -120,14 +120,14 @@
 
 - (RTCVideoTrack*)videoTrackWithID:(NSString*)videoId
                             source:(RTCVideoSource*)source {
-  talk_base::scoped_refptr<webrtc::VideoTrackInterface> track =
+  rtc::scoped_refptr<webrtc::VideoTrackInterface> track =
       self.nativeFactory->CreateVideoTrack([videoId UTF8String],
                                            source.videoSource);
   return [[RTCVideoTrack alloc] initWithMediaTrack:track];
 }
 
 - (RTCAudioTrack*)audioTrackWithID:(NSString*)audioId {
-  talk_base::scoped_refptr<webrtc::AudioTrackInterface> track =
+  rtc::scoped_refptr<webrtc::AudioTrackInterface> track =
       self.nativeFactory->CreateAudioTrack([audioId UTF8String], NULL);
   return [[RTCAudioTrack alloc] initWithMediaTrack:track];
 }
diff --git a/talk/app/webrtc/objc/RTCVideoCapturer.mm b/talk/app/webrtc/objc/RTCVideoCapturer.mm
index d947f02ade..ea8e7ad13e 100644
--- a/talk/app/webrtc/objc/RTCVideoCapturer.mm
+++ b/talk/app/webrtc/objc/RTCVideoCapturer.mm
@@ -35,12 +35,12 @@
 #include "talk/media/devices/devicemanager.h"
 
 @implementation RTCVideoCapturer {
-  talk_base::scoped_ptr<cricket::VideoCapturer> _capturer;
+  rtc::scoped_ptr<cricket::VideoCapturer> _capturer;
 }
 
 + (RTCVideoCapturer*)capturerWithDeviceName:(NSString*)deviceName {
   const std::string& device_name = std::string([deviceName UTF8String]);
-  talk_base::scoped_ptr<cricket::DeviceManagerInterface> device_manager(
+  rtc::scoped_ptr<cricket::DeviceManagerInterface> device_manager(
       cricket::DeviceManagerFactory::Create());
   bool initialized = device_manager->Init();
   NSAssert(initialized, @"DeviceManager::Init() failed");
@@ -49,7 +49,7 @@
     LOG(LS_ERROR) << "GetVideoCaptureDevice failed";
     return 0;
   }
-  talk_base::scoped_ptr<cricket::VideoCapturer> capturer(
+  rtc::scoped_ptr<cricket::VideoCapturer> capturer(
       device_manager->CreateVideoCapturer(device));
   RTCVideoCapturer* rtcCapturer =
       [[RTCVideoCapturer alloc] initWithCapturer:capturer.release()];
diff --git a/talk/app/webrtc/objc/RTCVideoRenderer.mm b/talk/app/webrtc/objc/RTCVideoRenderer.mm
index 07041819f6..de03a1e8a4 100644
--- a/talk/app/webrtc/objc/RTCVideoRenderer.mm
+++ b/talk/app/webrtc/objc/RTCVideoRenderer.mm
@@ -61,7 +61,7 @@ class RTCVideoRendererAdapter : public VideoRendererInterface {
 }
 
 @implementation RTCVideoRenderer {
-  talk_base::scoped_ptr<webrtc::RTCVideoRendererAdapter> _adapter;
+  rtc::scoped_ptr<webrtc::RTCVideoRendererAdapter> _adapter;
 #if TARGET_OS_IPHONE
   RTCEAGLVideoView* _videoView;
 #endif
diff --git a/talk/app/webrtc/objc/RTCVideoSource+Internal.h b/talk/app/webrtc/objc/RTCVideoSource+Internal.h
index 1d3c4c9f13..962fa43688 100644
--- a/talk/app/webrtc/objc/RTCVideoSource+Internal.h
+++ b/talk/app/webrtc/objc/RTCVideoSource+Internal.h
@@ -32,6 +32,6 @@
 @interface RTCVideoSource (Internal)
 
 @property(nonatomic, assign, readonly)
-    talk_base::scoped_refptr<webrtc::VideoSourceInterface>videoSource;
+    rtc::scoped_refptr<webrtc::VideoSourceInterface>videoSource;
 
 @end
diff --git a/talk/app/webrtc/objc/RTCVideoSource.mm b/talk/app/webrtc/objc/RTCVideoSource.mm
index b4554e08d2..7ad423c523 100644
--- a/talk/app/webrtc/objc/RTCVideoSource.mm
+++ b/talk/app/webrtc/objc/RTCVideoSource.mm
@@ -37,7 +37,7 @@
 
 @implementation RTCVideoSource (Internal)
 
-- (talk_base::scoped_refptr<webrtc::VideoSourceInterface>)videoSource {
+- (rtc::scoped_refptr<webrtc::VideoSourceInterface>)videoSource {
   return static_cast<webrtc::VideoSourceInterface*>(self.mediaSource.get());
 }
 
diff --git a/talk/app/webrtc/objc/RTCVideoTrack+Internal.h b/talk/app/webrtc/objc/RTCVideoTrack+Internal.h
index b5da54bda8..03c8f95a6d 100644
--- a/talk/app/webrtc/objc/RTCVideoTrack+Internal.h
+++ b/talk/app/webrtc/objc/RTCVideoTrack+Internal.h
@@ -35,6 +35,6 @@
 @interface RTCVideoTrack (Internal)
 
 @property(nonatomic, assign, readonly)
-    talk_base::scoped_refptr<webrtc::VideoTrackInterface> videoTrack;
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> videoTrack;
 
 @end
diff --git a/talk/app/webrtc/objc/RTCVideoTrack.mm b/talk/app/webrtc/objc/RTCVideoTrack.mm
index d6c8ed8a4f..beebde0bad 100644
--- a/talk/app/webrtc/objc/RTCVideoTrack.mm
+++ b/talk/app/webrtc/objc/RTCVideoTrack.mm
@@ -39,7 +39,7 @@
 }
 
 - (id)initWithMediaTrack:
-          (talk_base::scoped_refptr<webrtc::MediaStreamTrackInterface>)
+          (rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>)
       mediaTrack {
   if (self = [super initWithMediaTrack:mediaTrack]) {
     _rendererArray = [NSMutableArray array];
@@ -71,7 +71,7 @@
 
 @implementation RTCVideoTrack (Internal)
 
-- (talk_base::scoped_refptr<webrtc::VideoTrackInterface>)videoTrack {
+- (rtc::scoped_refptr<webrtc::VideoTrackInterface>)videoTrack {
   return static_cast<webrtc::VideoTrackInterface*>(self.mediaTrack.get());
 }
 
diff --git a/talk/app/webrtc/objctests/RTCPeerConnectionTest.mm b/talk/app/webrtc/objctests/RTCPeerConnectionTest.mm
index 7a178f39fc..909503ac70 100644
--- a/talk/app/webrtc/objctests/RTCPeerConnectionTest.mm
+++ b/talk/app/webrtc/objctests/RTCPeerConnectionTest.mm
@@ -39,8 +39,8 @@
 #import "RTCVideoRenderer.h"
 #import "RTCVideoTrack.h"
 
-#include "talk/base/gunit.h"
-#include "talk/base/ssladapter.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/ssladapter.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
@@ -299,7 +299,7 @@
 // a TestBase since it's not.
 TEST(RTCPeerConnectionTest, SessionTest) {
   @autoreleasepool {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
     // Since |factory| will own the signaling & worker threads, it's important
     // that it outlive the created PeerConnections since they self-delete on the
     // signaling thread, and if |factory| is freed first then a last refcount on
@@ -312,6 +312,6 @@ TEST(RTCPeerConnectionTest, SessionTest) {
       RTCPeerConnectionTest* pcTest = [[RTCPeerConnectionTest alloc] init];
       [pcTest testCompleteSessionWithFactory:factory];
     }
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 }
diff --git a/talk/app/webrtc/objctests/mac/main.mm b/talk/app/webrtc/objctests/mac/main.mm
index 4995b7f3ac..7af1a2b71d 100644
--- a/talk/app/webrtc/objctests/mac/main.mm
+++ b/talk/app/webrtc/objctests/mac/main.mm
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
diff --git a/talk/app/webrtc/peerconnection.cc b/talk/app/webrtc/peerconnection.cc
index ec2059380e..089da823fa 100644
--- a/talk/app/webrtc/peerconnection.cc
+++ b/talk/app/webrtc/peerconnection.cc
@@ -35,8 +35,8 @@
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
 #include "talk/app/webrtc/mediastreamhandler.h"
 #include "talk/app/webrtc/streamcollection.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/p2p/client/basicportallocator.h"
 #include "talk/session/media/channelmanager.h"
 
@@ -74,22 +74,22 @@ enum {
   MSG_GETSTATS,
 };
 
-struct SetSessionDescriptionMsg : public talk_base::MessageData {
+struct SetSessionDescriptionMsg : public rtc::MessageData {
   explicit SetSessionDescriptionMsg(
       webrtc::SetSessionDescriptionObserver* observer)
       : observer(observer) {
   }
 
-  talk_base::scoped_refptr<webrtc::SetSessionDescriptionObserver> observer;
+  rtc::scoped_refptr<webrtc::SetSessionDescriptionObserver> observer;
   std::string error;
 };
 
-struct GetStatsMsg : public talk_base::MessageData {
+struct GetStatsMsg : public rtc::MessageData {
   explicit GetStatsMsg(webrtc::StatsObserver* observer)
       : observer(observer) {
   }
   webrtc::StatsReports reports;
-  talk_base::scoped_refptr<webrtc::StatsObserver> observer;
+  rtc::scoped_refptr<webrtc::StatsObserver> observer;
 };
 
 // |in_str| should be of format
@@ -136,7 +136,7 @@ bool ParseHostnameAndPortFromString(const std::string& in_str,
       *host = in_str.substr(1, closebracket - 1);
       std::string::size_type colonpos = in_str.find(':', closebracket);
       if (std::string::npos != colonpos) {
-        if (!talk_base::FromString(
+        if (!rtc::FromString(
             in_str.substr(closebracket + 2, std::string::npos), port)) {
           return false;
         }
@@ -148,7 +148,7 @@ bool ParseHostnameAndPortFromString(const std::string& in_str,
     std::string::size_type colonpos = in_str.find(':');
     if (std::string::npos != colonpos) {
       *host = in_str.substr(0, colonpos);
-      if (!talk_base::FromString(
+      if (!rtc::FromString(
           in_str.substr(colonpos + 1, std::string::npos), port)) {
         return false;
       }
@@ -189,12 +189,12 @@ bool ParseIceServers(const PeerConnectionInterface::IceServers& configuration,
     }
     std::vector<std::string> tokens;
     std::string turn_transport_type = kUdpTransportType;
-    talk_base::tokenize(server.uri, '?', &tokens);
+    rtc::tokenize(server.uri, '?', &tokens);
     std::string uri_without_transport = tokens[0];
     // Let's look into transport= param, if it exists.
     if (tokens.size() == kTurnTransportTokensNum) {  // ?transport= is present.
       std::string uri_transport_param = tokens[1];
-      talk_base::tokenize(uri_transport_param, '=', &tokens);
+      rtc::tokenize(uri_transport_param, '=', &tokens);
       if (tokens[0] == kTransport) {
         // As per above grammar transport param will be consist of lower case
         // letters.
@@ -218,10 +218,10 @@ bool ParseIceServers(const PeerConnectionInterface::IceServers& configuration,
 
     // Let's break hostname.
     tokens.clear();
-    talk_base::tokenize(hoststring, '@', &tokens);
+    rtc::tokenize(hoststring, '@', &tokens);
     hoststring = tokens[0];
     if (tokens.size() == kTurnHostTokensNum) {
-      server.username = talk_base::s_url_decode(tokens[0]);
+      server.username = rtc::s_url_decode(tokens[0]);
       hoststring = tokens[1];
     }
 
@@ -253,9 +253,9 @@ bool ParseIceServers(const PeerConnectionInterface::IceServers& configuration,
         if (server.username.empty()) {
           // Turn url example from the spec |url:"turn:user@turn.example.org"|.
           std::vector<std::string> turn_tokens;
-          talk_base::tokenize(address, '@', &turn_tokens);
+          rtc::tokenize(address, '@', &turn_tokens);
           if (turn_tokens.size() == kTurnHostTokensNum) {
-            server.username = talk_base::s_url_decode(turn_tokens[0]);
+            server.username = rtc::s_url_decode(turn_tokens[0]);
             address = turn_tokens[1];
           }
         }
@@ -387,12 +387,12 @@ bool PeerConnection::DoInitialize(
   return true;
 }
 
-talk_base::scoped_refptr<StreamCollectionInterface>
+rtc::scoped_refptr<StreamCollectionInterface>
 PeerConnection::local_streams() {
   return mediastream_signaling_->local_streams();
 }
 
-talk_base::scoped_refptr<StreamCollectionInterface>
+rtc::scoped_refptr<StreamCollectionInterface>
 PeerConnection::remote_streams() {
   return mediastream_signaling_->remote_streams();
 }
@@ -423,7 +423,7 @@ void PeerConnection::RemoveStream(MediaStreamInterface* local_stream) {
   observer_->OnRenegotiationNeeded();
 }
 
-talk_base::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
+rtc::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
     AudioTrackInterface* track) {
   if (!track) {
     LOG(LS_ERROR) << "CreateDtmfSender - track is NULL.";
@@ -434,7 +434,7 @@ talk_base::scoped_refptr<DtmfSenderInterface> PeerConnection::CreateDtmfSender(
     return NULL;
   }
 
-  talk_base::scoped_refptr<DtmfSenderInterface> sender(
+  rtc::scoped_refptr<DtmfSenderInterface> sender(
       DtmfSender::Create(track, signaling_thread(), session_.get()));
   if (!sender.get()) {
     LOG(LS_ERROR) << "CreateDtmfSender failed on DtmfSender::Create.";
@@ -452,7 +452,7 @@ bool PeerConnection::GetStats(StatsObserver* observer,
   }
 
   stats_->UpdateStats(level);
-  talk_base::scoped_ptr<GetStatsMsg> msg(new GetStatsMsg(observer));
+  rtc::scoped_ptr<GetStatsMsg> msg(new GetStatsMsg(observer));
   if (!stats_->GetStats(track, &(msg->reports))) {
     return false;
   }
@@ -478,17 +478,17 @@ PeerConnection::ice_gathering_state() {
   return ice_gathering_state_;
 }
 
-talk_base::scoped_refptr<DataChannelInterface>
+rtc::scoped_refptr<DataChannelInterface>
 PeerConnection::CreateDataChannel(
     const std::string& label,
     const DataChannelInit* config) {
   bool first_datachannel = !mediastream_signaling_->HasDataChannels();
 
-  talk_base::scoped_ptr<InternalDataChannelInit> internal_config;
+  rtc::scoped_ptr<InternalDataChannelInit> internal_config;
   if (config) {
     internal_config.reset(new InternalDataChannelInit(*config));
   }
-  talk_base::scoped_refptr<DataChannelInterface> channel(
+  rtc::scoped_refptr<DataChannelInterface> channel(
       session_->CreateDataChannel(label, internal_config.get()));
   if (!channel.get())
     return NULL;
@@ -588,13 +588,13 @@ bool PeerConnection::UpdateIce(const RTCConfiguration& config) {
       return false;
     }
 
-    std::vector<talk_base::SocketAddress> stun_hosts;
+    std::vector<rtc::SocketAddress> stun_hosts;
     typedef std::vector<StunConfiguration>::const_iterator StunIt;
     for (StunIt stun_it = stuns.begin(); stun_it != stuns.end(); ++stun_it) {
       stun_hosts.push_back(stun_it->server);
     }
 
-    talk_base::SocketAddress stun_addr;
+    rtc::SocketAddress stun_addr;
     if (!stun_hosts.empty()) {
       stun_addr = stun_hosts.front();
       LOG(LS_INFO) << "UpdateIce: StunServer Address: " << stun_addr.ToString();
@@ -684,7 +684,7 @@ void PeerConnection::OnSessionStateChange(cricket::BaseSession* /*session*/,
   }
 }
 
-void PeerConnection::OnMessage(talk_base::Message* msg) {
+void PeerConnection::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_SET_SESSIONDESCRIPTION_SUCCESS: {
       SetSessionDescriptionMsg* param =
diff --git a/talk/app/webrtc/peerconnection.h b/talk/app/webrtc/peerconnection.h
index ebb5dba1c6..bb4e4ebc2a 100644
--- a/talk/app/webrtc/peerconnection.h
+++ b/talk/app/webrtc/peerconnection.h
@@ -36,7 +36,7 @@
 #include "talk/app/webrtc/statscollector.h"
 #include "talk/app/webrtc/streamcollection.h"
 #include "talk/app/webrtc/webrtcsession.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 
 namespace webrtc {
 class MediaStreamHandlerContainer;
@@ -52,7 +52,7 @@ typedef std::vector<PortAllocatorFactoryInterface::TurnConfiguration>
 class PeerConnection : public PeerConnectionInterface,
                        public MediaStreamSignalingObserver,
                        public IceObserver,
-                       public talk_base::MessageHandler,
+                       public rtc::MessageHandler,
                        public sigslot::has_slots<> {
  public:
   explicit PeerConnection(PeerConnectionFactory* factory);
@@ -63,16 +63,16 @@ class PeerConnection : public PeerConnectionInterface,
       PortAllocatorFactoryInterface* allocator_factory,
       DTLSIdentityServiceInterface* dtls_identity_service,
       PeerConnectionObserver* observer);
-  virtual talk_base::scoped_refptr<StreamCollectionInterface> local_streams();
-  virtual talk_base::scoped_refptr<StreamCollectionInterface> remote_streams();
+  virtual rtc::scoped_refptr<StreamCollectionInterface> local_streams();
+  virtual rtc::scoped_refptr<StreamCollectionInterface> remote_streams();
   virtual bool AddStream(MediaStreamInterface* local_stream,
                          const MediaConstraintsInterface* constraints);
   virtual void RemoveStream(MediaStreamInterface* local_stream);
 
-  virtual talk_base::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
+  virtual rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
       AudioTrackInterface* track);
 
-  virtual talk_base::scoped_refptr<DataChannelInterface> CreateDataChannel(
+  virtual rtc::scoped_refptr<DataChannelInterface> CreateDataChannel(
       const std::string& label,
       const DataChannelInit* config);
   virtual bool GetStats(StatsObserver* observer,
@@ -114,7 +114,7 @@ class PeerConnection : public PeerConnectionInterface,
 
  private:
   // Implements MessageHandler.
-  virtual void OnMessage(talk_base::Message* msg);
+  virtual void OnMessage(rtc::Message* msg);
 
   // Implements MediaStreamSignalingObserver.
   virtual void OnAddRemoteStream(MediaStreamInterface* stream) OVERRIDE;
@@ -166,7 +166,7 @@ class PeerConnection : public PeerConnectionInterface,
                     DTLSIdentityServiceInterface* dtls_identity_service,
                     PeerConnectionObserver* observer);
 
-  talk_base::Thread* signaling_thread() const {
+  rtc::Thread* signaling_thread() const {
     return factory_->signaling_thread();
   }
 
@@ -183,7 +183,7 @@ class PeerConnection : public PeerConnectionInterface,
   // However, since the reference counting is done in the
   // PeerConnectionFactoryInteface all instances created using the raw pointer
   // will refer to the same reference count.
-  talk_base::scoped_refptr<PeerConnectionFactory> factory_;
+  rtc::scoped_refptr<PeerConnectionFactory> factory_;
   PeerConnectionObserver* observer_;
   UMAObserver* uma_observer_;
   SignalingState signaling_state_;
@@ -192,11 +192,11 @@ class PeerConnection : public PeerConnectionInterface,
   IceConnectionState ice_connection_state_;
   IceGatheringState ice_gathering_state_;
 
-  talk_base::scoped_ptr<cricket::PortAllocator> port_allocator_;
-  talk_base::scoped_ptr<WebRtcSession> session_;
-  talk_base::scoped_ptr<MediaStreamSignaling> mediastream_signaling_;
-  talk_base::scoped_ptr<MediaStreamHandlerContainer> stream_handler_container_;
-  talk_base::scoped_ptr<StatsCollector> stats_;
+  rtc::scoped_ptr<cricket::PortAllocator> port_allocator_;
+  rtc::scoped_ptr<WebRtcSession> session_;
+  rtc::scoped_ptr<MediaStreamSignaling> mediastream_signaling_;
+  rtc::scoped_ptr<MediaStreamHandlerContainer> stream_handler_container_;
+  rtc::scoped_ptr<StatsCollector> stats_;
 };
 
 }  // namespace webrtc
diff --git a/talk/app/webrtc/peerconnection_unittest.cc b/talk/app/webrtc/peerconnection_unittest.cc
index 0c39297ab2..44009c09aa 100644
--- a/talk/app/webrtc/peerconnection_unittest.cc
+++ b/talk/app/webrtc/peerconnection_unittest.cc
@@ -45,11 +45,11 @@
 #include "talk/app/webrtc/test/fakeperiodicvideocapturer.h"
 #include "talk/app/webrtc/test/mockpeerconnectionobservers.h"
 #include "talk/app/webrtc/videosourceinterface.h"
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/sslstreamadapter.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/webrtc/fakewebrtcvideoengine.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/sessiondescription.h"
@@ -155,9 +155,9 @@ class PeerConnectionTestClientBase
 
   void AddMediaStream(bool audio, bool video) {
     std::string label = kStreamLabelBase +
-        talk_base::ToString<int>(
+        rtc::ToString<int>(
             static_cast<int>(peer_connection_->local_streams()->count()));
-    talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream =
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
         peer_connection_factory_->CreateLocalMediaStream(label);
 
     if (audio && can_receive_audio()) {
@@ -165,11 +165,11 @@ class PeerConnectionTestClientBase
       // Disable highpass filter so that we can get all the test audio frames.
       constraints.AddMandatory(
           MediaConstraintsInterface::kHighpassFilter, false);
-      talk_base::scoped_refptr<webrtc::AudioSourceInterface> source =
+      rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
           peer_connection_factory_->CreateAudioSource(&constraints);
       // TODO(perkj): Test audio source when it is implemented. Currently audio
       // always use the default input.
-      talk_base::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+      rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
           peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase,
                                                      source));
       stream->AddTrack(audio_track);
@@ -236,13 +236,13 @@ class PeerConnectionTestClientBase
   }
   // Verify the CreateDtmfSender interface
   void VerifyDtmf() {
-    talk_base::scoped_ptr<DummyDtmfObserver> observer(new DummyDtmfObserver());
-    talk_base::scoped_refptr<DtmfSenderInterface> dtmf_sender;
+    rtc::scoped_ptr<DummyDtmfObserver> observer(new DummyDtmfObserver());
+    rtc::scoped_refptr<DtmfSenderInterface> dtmf_sender;
 
     // We can't create a DTMF sender with an invalid audio track or a non local
     // track.
     EXPECT_TRUE(peer_connection_->CreateDtmfSender(NULL) == NULL);
-    talk_base::scoped_refptr<webrtc::AudioTrackInterface> non_localtrack(
+    rtc::scoped_refptr<webrtc::AudioTrackInterface> non_localtrack(
         peer_connection_factory_->CreateAudioTrack("dummy_track",
                                                    NULL));
     EXPECT_TRUE(peer_connection_->CreateDtmfSender(non_localtrack) == NULL);
@@ -333,8 +333,8 @@ class PeerConnectionTestClientBase
   }
 
   int GetAudioOutputLevelStats(webrtc::MediaStreamTrackInterface* track) {
-    talk_base::scoped_refptr<MockStatsObserver>
-        observer(new talk_base::RefCountedObject<MockStatsObserver>());
+    rtc::scoped_refptr<MockStatsObserver>
+        observer(new rtc::RefCountedObject<MockStatsObserver>());
     EXPECT_TRUE(peer_connection_->GetStats(
         observer, track, PeerConnectionInterface::kStatsOutputLevelStandard));
     EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs);
@@ -342,8 +342,8 @@ class PeerConnectionTestClientBase
   }
 
   int GetAudioInputLevelStats() {
-    talk_base::scoped_refptr<MockStatsObserver>
-        observer(new talk_base::RefCountedObject<MockStatsObserver>());
+    rtc::scoped_refptr<MockStatsObserver>
+        observer(new rtc::RefCountedObject<MockStatsObserver>());
     EXPECT_TRUE(peer_connection_->GetStats(
         observer, NULL, PeerConnectionInterface::kStatsOutputLevelStandard));
     EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs);
@@ -351,8 +351,8 @@ class PeerConnectionTestClientBase
   }
 
   int GetBytesReceivedStats(webrtc::MediaStreamTrackInterface* track) {
-    talk_base::scoped_refptr<MockStatsObserver>
-    observer(new talk_base::RefCountedObject<MockStatsObserver>());
+    rtc::scoped_refptr<MockStatsObserver>
+    observer(new rtc::RefCountedObject<MockStatsObserver>());
     EXPECT_TRUE(peer_connection_->GetStats(
         observer, track, PeerConnectionInterface::kStatsOutputLevelStandard));
     EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs);
@@ -360,8 +360,8 @@ class PeerConnectionTestClientBase
   }
 
   int GetBytesSentStats(webrtc::MediaStreamTrackInterface* track) {
-    talk_base::scoped_refptr<MockStatsObserver>
-    observer(new talk_base::RefCountedObject<MockStatsObserver>());
+    rtc::scoped_refptr<MockStatsObserver>
+    observer(new rtc::RefCountedObject<MockStatsObserver>());
     EXPECT_TRUE(peer_connection_->GetStats(
         observer, track, PeerConnectionInterface::kStatsOutputLevelStandard));
     EXPECT_TRUE_WAIT(observer->called(), kMaxWaitMs);
@@ -474,7 +474,7 @@ class PeerConnectionTestClientBase
     fake_video_decoder_factory_ = new FakeWebRtcVideoDecoderFactory();
     fake_video_encoder_factory_ = new FakeWebRtcVideoEncoderFactory();
     peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
-        talk_base::Thread::Current(), talk_base::Thread::Current(),
+        rtc::Thread::Current(), rtc::Thread::Current(),
         fake_audio_capture_module_, fake_video_encoder_factory_,
         fake_video_decoder_factory_);
     if (!peer_connection_factory_) {
@@ -484,7 +484,7 @@ class PeerConnectionTestClientBase
                                             constraints);
     return peer_connection_.get() != NULL;
   }
-  virtual talk_base::scoped_refptr<webrtc::PeerConnectionInterface>
+  virtual rtc::scoped_refptr<webrtc::PeerConnectionInterface>
       CreatePeerConnection(webrtc::PortAllocatorFactoryInterface* factory,
                            const MediaConstraintsInterface* constraints) = 0;
   MessageReceiver* signaling_message_receiver() {
@@ -523,13 +523,13 @@ class PeerConnectionTestClientBase
     std::vector<std::string> tones_;
   };
 
-  talk_base::scoped_refptr<webrtc::VideoTrackInterface>
+  rtc::scoped_refptr<webrtc::VideoTrackInterface>
   CreateLocalVideoTrack(const std::string stream_label) {
     // Set max frame rate to 10fps to reduce the risk of the tests to be flaky.
     FakeConstraints source_constraints = video_constraints_;
     source_constraints.SetMandatoryMaxFrameRate(10);
 
-    talk_base::scoped_refptr<webrtc::VideoSourceInterface> source =
+    rtc::scoped_refptr<webrtc::VideoSourceInterface> source =
         peer_connection_factory_->CreateVideoSource(
             new webrtc::FakePeriodicVideoCapturer(),
             &source_constraints);
@@ -543,12 +543,12 @@ class PeerConnectionTestClientBase
   // signaling time constraints and relative complexity of the audio pipeline.
   // This is consistent with the video pipeline that us a a separate thread for
   // encoding and decoding.
-  talk_base::Thread audio_thread_;
+  rtc::Thread audio_thread_;
 
-  talk_base::scoped_refptr<webrtc::PortAllocatorFactoryInterface>
+  rtc::scoped_refptr<webrtc::PortAllocatorFactoryInterface>
       allocator_factory_;
-  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_;
 
   typedef std::pair<std::string, std::string> IceUfragPwdPair;
@@ -556,7 +556,7 @@ class PeerConnectionTestClientBase
   bool expect_ice_restart_;
 
   // Needed to keep track of number of frames send.
-  talk_base::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+  rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
   // Needed to keep track of number of frames received.
   typedef std::map<std::string, webrtc::FakeVideoTrackRenderer*> RenderMap;
   RenderMap fake_video_renderers_;
@@ -590,7 +590,7 @@ class JsepTestClient
     Negotiate(true, true);
   }
   virtual void Negotiate(bool audio, bool video) {
-    talk_base::scoped_ptr<SessionDescriptionInterface> offer;
+    rtc::scoped_ptr<SessionDescriptionInterface> offer;
     EXPECT_TRUE(DoCreateOffer(offer.use()));
 
     if (offer->description()->GetContentByName("audio")) {
@@ -621,7 +621,7 @@ class JsepTestClient
                                  int sdp_mline_index,
                                  const std::string& msg) {
     LOG(INFO) << id() << "ReceiveIceMessage";
-    talk_base::scoped_ptr<webrtc::IceCandidateInterface> candidate(
+    rtc::scoped_ptr<webrtc::IceCandidateInterface> candidate(
         webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, msg, NULL));
     EXPECT_TRUE(pc()->AddIceCandidate(candidate.get()));
   }
@@ -723,7 +723,7 @@ class JsepTestClient
         remove_sdes_(false) {
   }
 
-  virtual talk_base::scoped_refptr<webrtc::PeerConnectionInterface>
+  virtual rtc::scoped_refptr<webrtc::PeerConnectionInterface>
       CreatePeerConnection(webrtc::PortAllocatorFactoryInterface* factory,
                            const MediaConstraintsInterface* constraints) {
     // CreatePeerConnection with IceServers.
@@ -733,7 +733,7 @@ class JsepTestClient
     ice_servers.push_back(ice_server);
 
     FakeIdentityService* dtls_service =
-        talk_base::SSLStreamAdapter::HaveDtlsSrtp() ?
+        rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
             new FakeIdentityService() : NULL;
     return peer_connection_factory()->CreatePeerConnection(
         ice_servers, constraints, factory, dtls_service, this);
@@ -745,10 +745,10 @@ class JsepTestClient
       // If we are not sending any streams ourselves it is time to add some.
       AddMediaStream(true, true);
     }
-    talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+    rtc::scoped_ptr<SessionDescriptionInterface> desc(
          webrtc::CreateSessionDescription("offer", msg, NULL));
     EXPECT_TRUE(DoSetRemoteDescription(desc.release()));
-    talk_base::scoped_ptr<SessionDescriptionInterface> answer;
+    rtc::scoped_ptr<SessionDescriptionInterface> answer;
     EXPECT_TRUE(DoCreateAnswer(answer.use()));
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
@@ -761,15 +761,15 @@ class JsepTestClient
 
   void HandleIncomingAnswer(const std::string& msg) {
     LOG(INFO) << id() << "HandleIncomingAnswer";
-    talk_base::scoped_ptr<SessionDescriptionInterface> desc(
+    rtc::scoped_ptr<SessionDescriptionInterface> desc(
          webrtc::CreateSessionDescription("answer", msg, NULL));
     EXPECT_TRUE(DoSetRemoteDescription(desc.release()));
   }
 
   bool DoCreateOfferAnswer(SessionDescriptionInterface** desc,
                            bool offer) {
-    talk_base::scoped_refptr<MockCreateSessionDescriptionObserver>
-        observer(new talk_base::RefCountedObject<
+    rtc::scoped_refptr<MockCreateSessionDescriptionObserver>
+        observer(new rtc::RefCountedObject<
             MockCreateSessionDescriptionObserver>());
     if (offer) {
       pc()->CreateOffer(observer, &session_description_constraints_);
@@ -793,8 +793,8 @@ class JsepTestClient
   }
 
   bool DoSetLocalDescription(SessionDescriptionInterface* desc) {
-    talk_base::scoped_refptr<MockSetSessionDescriptionObserver>
-            observer(new talk_base::RefCountedObject<
+    rtc::scoped_refptr<MockSetSessionDescriptionObserver>
+            observer(new rtc::RefCountedObject<
                 MockSetSessionDescriptionObserver>());
     LOG(INFO) << id() << "SetLocalDescription ";
     pc()->SetLocalDescription(observer, desc);
@@ -802,7 +802,7 @@ class JsepTestClient
     // EXPECT_TRUE_WAIT, local ice candidates might be sent to the remote peer
     // before the offer which is an error.
     // The reason is that EXPECT_TRUE_WAIT uses
-    // talk_base::Thread::Current()->ProcessMessages(1);
+    // rtc::Thread::Current()->ProcessMessages(1);
     // ProcessMessages waits at least 1ms but processes all messages before
     // returning. Since this test is synchronous and send messages to the remote
     // peer whenever a callback is invoked, this can lead to messages being
@@ -814,8 +814,8 @@ class JsepTestClient
   }
 
   bool DoSetRemoteDescription(SessionDescriptionInterface* desc) {
-    talk_base::scoped_refptr<MockSetSessionDescriptionObserver>
-        observer(new talk_base::RefCountedObject<
+    rtc::scoped_refptr<MockSetSessionDescriptionObserver>
+        observer(new rtc::RefCountedObject<
             MockSetSessionDescriptionObserver>());
     LOG(INFO) << id() << "SetRemoteDescription ";
     pc()->SetRemoteDescription(observer, desc);
@@ -847,8 +847,8 @@ class JsepTestClient
   bool remove_bundle_;  // True if bundle should be removed in received SDP.
   bool remove_sdes_;  // True if a=crypto should be removed in received SDP.
 
-  talk_base::scoped_refptr<DataChannelInterface> data_channel_;
-  talk_base::scoped_ptr<MockDataChannelObserver> data_observer_;
+  rtc::scoped_refptr<DataChannelInterface> data_channel_;
+  rtc::scoped_ptr<MockDataChannelObserver> data_observer_;
 };
 
 template <typename SignalingClass>
@@ -904,7 +904,7 @@ class P2PTestConductor : public testing::Test {
   }
 
   P2PTestConductor() {
-    talk_base::InitializeSSL(NULL);
+    rtc::InitializeSSL(NULL);
   }
   ~P2PTestConductor() {
     if (initiating_client_) {
@@ -913,7 +913,7 @@ class P2PTestConductor : public testing::Test {
     if (receiving_client_) {
       receiving_client_->set_signaling_message_receiver(NULL);
     }
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   bool CreateTestClients() {
@@ -1023,8 +1023,8 @@ class P2PTestConductor : public testing::Test {
   SignalingClass* receiving_client() { return receiving_client_.get(); }
 
  private:
-  talk_base::scoped_ptr<SignalingClass> initiating_client_;
-  talk_base::scoped_ptr<SignalingClass> receiving_client_;
+  rtc::scoped_ptr<SignalingClass> initiating_client_;
+  rtc::scoped_ptr<SignalingClass> receiving_client_;
 };
 typedef P2PTestConductor<JsepTestClient> JsepPeerConnectionP2PTestClient;
 
@@ -1081,7 +1081,7 @@ TEST_F(JsepPeerConnectionP2PTestClient, DISABLED_LocalP2PTest1280By720) {
 // This test sets up a call between two endpoints that are configured to use
 // DTLS key agreement. As a result, DTLS is negotiated and used for transport.
 TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestDtls) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
@@ -1093,7 +1093,7 @@ TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestDtls) {
 // This test sets up a audio call initially and then upgrades to audio/video,
 // using DTLS.
 TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestDtlsRenegotiate) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
@@ -1108,7 +1108,7 @@ TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestDtlsRenegotiate) {
 // DTLS key agreement. The offerer don't support SDES. As a result, DTLS is
 // negotiated and used for transport.
 TEST_F(JsepPeerConnectionP2PTestClient, LocalP2PTestOfferDtlsButNotSdes) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
@@ -1320,7 +1320,7 @@ TEST_F(JsepPeerConnectionP2PTestClient, RegisterDataChannelObserver) {
 
   // Wait a while to allow the sent data to arrive before an observer is
   // registered..
-  talk_base::Thread::Current()->ProcessMessages(100);
+  rtc::Thread::Current()->ProcessMessages(100);
 
   MockDataChannelObserver new_observer(receiving_client()->data_channel());
   EXPECT_EQ_WAIT(data, new_observer.last_message(), kMaxWaitMs);
@@ -1367,7 +1367,7 @@ TEST_F(JsepPeerConnectionP2PTestClient, AddDataChannelAfterRenegotiation) {
 // negotiation is completed without error.
 #ifdef HAVE_SCTP
 TEST_F(JsepPeerConnectionP2PTestClient, CreateOfferWithSctpDataChannel) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints constraints;
   constraints.SetMandatory(
       MediaConstraintsInterface::kEnableDtlsSrtp, true);
diff --git a/talk/app/webrtc/peerconnectionendtoend_unittest.cc b/talk/app/webrtc/peerconnectionendtoend_unittest.cc
index f701e0635f..898478170c 100644
--- a/talk/app/webrtc/peerconnectionendtoend_unittest.cc
+++ b/talk/app/webrtc/peerconnectionendtoend_unittest.cc
@@ -27,12 +27,12 @@
 
 #include "talk/app/webrtc/test/peerconnectiontestwrapper.h"
 #include "talk/app/webrtc/test/mockpeerconnectionobservers.h"
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/sslstreamadapter.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
 
 #define MAYBE_SKIP_TEST(feature)                    \
   if (!(feature())) {                               \
@@ -68,14 +68,14 @@ void InjectAfter(const std::string& line,
                  const std::string& newlines,
                  std::string* message) {
   const std::string tmp = line + newlines;
-  talk_base::replace_substrs(line.c_str(), line.length(),
+  rtc::replace_substrs(line.c_str(), line.length(),
                              tmp.c_str(), tmp.length(), message);
 }
 
 void Replace(const std::string& line,
              const std::string& newlines,
              std::string* message) {
-  talk_base::replace_substrs(line.c_str(), line.length(),
+  rtc::replace_substrs(line.c_str(), line.length(),
                              newlines.c_str(), newlines.length(), message);
 }
 
@@ -126,15 +126,15 @@ class PeerConnectionEndToEndTest
     : public sigslot::has_slots<>,
       public testing::Test {
  public:
-  typedef std::vector<talk_base::scoped_refptr<DataChannelInterface> >
+  typedef std::vector<rtc::scoped_refptr<DataChannelInterface> >
       DataChannelList;
 
   PeerConnectionEndToEndTest()
-      : caller_(new talk_base::RefCountedObject<PeerConnectionTestWrapper>(
+      : caller_(new rtc::RefCountedObject<PeerConnectionTestWrapper>(
                     "caller")),
-        callee_(new talk_base::RefCountedObject<PeerConnectionTestWrapper>(
+        callee_(new rtc::RefCountedObject<PeerConnectionTestWrapper>(
                     "callee")) {
-    talk_base::InitializeSSL(NULL);
+    rtc::InitializeSSL(NULL);
   }
 
   void CreatePcs() {
@@ -222,10 +222,10 @@ class PeerConnectionEndToEndTest
   // Tests that |dc1| and |dc2| can send to and receive from each other.
   void TestDataChannelSendAndReceive(
       DataChannelInterface* dc1, DataChannelInterface* dc2) {
-    talk_base::scoped_ptr<webrtc::MockDataChannelObserver> dc1_observer(
+    rtc::scoped_ptr<webrtc::MockDataChannelObserver> dc1_observer(
         new webrtc::MockDataChannelObserver(dc1));
 
-    talk_base::scoped_ptr<webrtc::MockDataChannelObserver> dc2_observer(
+    rtc::scoped_ptr<webrtc::MockDataChannelObserver> dc2_observer(
         new webrtc::MockDataChannelObserver(dc2));
 
     static const std::string kDummyData = "abcdefg";
@@ -263,12 +263,12 @@ class PeerConnectionEndToEndTest
   }
 
   ~PeerConnectionEndToEndTest() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
  protected:
-  talk_base::scoped_refptr<PeerConnectionTestWrapper> caller_;
-  talk_base::scoped_refptr<PeerConnectionTestWrapper> callee_;
+  rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
+  rtc::scoped_refptr<PeerConnectionTestWrapper> callee_;
   DataChannelList caller_signaled_data_channels_;
   DataChannelList callee_signaled_data_channels_;
 };
@@ -300,14 +300,14 @@ TEST_F(PeerConnectionEndToEndTest, DISABLED_CallWithLegacySdp) {
 // Verifies that a DataChannel created before the negotiation can transition to
 // "OPEN" and transfer data.
 TEST_F(PeerConnectionEndToEndTest, CreateDataChannelBeforeNegotiate) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   CreatePcs();
 
   webrtc::DataChannelInit init;
-  talk_base::scoped_refptr<DataChannelInterface> caller_dc(
+  rtc::scoped_refptr<DataChannelInterface> caller_dc(
       caller_->CreateDataChannel("data", init));
-  talk_base::scoped_refptr<DataChannelInterface> callee_dc(
+  rtc::scoped_refptr<DataChannelInterface> callee_dc(
       callee_->CreateDataChannel("data", init));
 
   Negotiate();
@@ -326,22 +326,22 @@ TEST_F(PeerConnectionEndToEndTest, CreateDataChannelBeforeNegotiate) {
 // Verifies that a DataChannel created after the negotiation can transition to
 // "OPEN" and transfer data.
 TEST_F(PeerConnectionEndToEndTest, CreateDataChannelAfterNegotiate) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   CreatePcs();
 
   webrtc::DataChannelInit init;
 
   // This DataChannel is for creating the data content in the negotiation.
-  talk_base::scoped_refptr<DataChannelInterface> dummy(
+  rtc::scoped_refptr<DataChannelInterface> dummy(
       caller_->CreateDataChannel("data", init));
   Negotiate();
   WaitForConnection();
 
   // Creates new DataChannels after the negotiation and verifies their states.
-  talk_base::scoped_refptr<DataChannelInterface> caller_dc(
+  rtc::scoped_refptr<DataChannelInterface> caller_dc(
       caller_->CreateDataChannel("hello", init));
-  talk_base::scoped_refptr<DataChannelInterface> callee_dc(
+  rtc::scoped_refptr<DataChannelInterface> callee_dc(
       callee_->CreateDataChannel("hello", init));
 
   WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 1);
@@ -356,14 +356,14 @@ TEST_F(PeerConnectionEndToEndTest, CreateDataChannelAfterNegotiate) {
 
 // Verifies that DataChannel IDs are even/odd based on the DTLS roles.
 TEST_F(PeerConnectionEndToEndTest, DataChannelIdAssignment) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   CreatePcs();
 
   webrtc::DataChannelInit init;
-  talk_base::scoped_refptr<DataChannelInterface> caller_dc_1(
+  rtc::scoped_refptr<DataChannelInterface> caller_dc_1(
       caller_->CreateDataChannel("data", init));
-  talk_base::scoped_refptr<DataChannelInterface> callee_dc_1(
+  rtc::scoped_refptr<DataChannelInterface> callee_dc_1(
       callee_->CreateDataChannel("data", init));
 
   Negotiate();
@@ -372,9 +372,9 @@ TEST_F(PeerConnectionEndToEndTest, DataChannelIdAssignment) {
   EXPECT_EQ(1U, caller_dc_1->id() % 2);
   EXPECT_EQ(0U, callee_dc_1->id() % 2);
 
-  talk_base::scoped_refptr<DataChannelInterface> caller_dc_2(
+  rtc::scoped_refptr<DataChannelInterface> caller_dc_2(
       caller_->CreateDataChannel("data", init));
-  talk_base::scoped_refptr<DataChannelInterface> callee_dc_2(
+  rtc::scoped_refptr<DataChannelInterface> callee_dc_2(
       callee_->CreateDataChannel("data", init));
 
   EXPECT_EQ(1U, caller_dc_2->id() % 2);
@@ -385,15 +385,15 @@ TEST_F(PeerConnectionEndToEndTest, DataChannelIdAssignment) {
 // there are multiple DataChannels.
 TEST_F(PeerConnectionEndToEndTest,
        MessageTransferBetweenTwoPairsOfDataChannels) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   CreatePcs();
 
   webrtc::DataChannelInit init;
 
-  talk_base::scoped_refptr<DataChannelInterface> caller_dc_1(
+  rtc::scoped_refptr<DataChannelInterface> caller_dc_1(
       caller_->CreateDataChannel("data", init));
-  talk_base::scoped_refptr<DataChannelInterface> caller_dc_2(
+  rtc::scoped_refptr<DataChannelInterface> caller_dc_2(
       caller_->CreateDataChannel("data", init));
 
   Negotiate();
@@ -401,10 +401,10 @@ TEST_F(PeerConnectionEndToEndTest,
   WaitForDataChannelsToOpen(caller_dc_1, callee_signaled_data_channels_, 0);
   WaitForDataChannelsToOpen(caller_dc_2, callee_signaled_data_channels_, 1);
 
-  talk_base::scoped_ptr<webrtc::MockDataChannelObserver> dc_1_observer(
+  rtc::scoped_ptr<webrtc::MockDataChannelObserver> dc_1_observer(
       new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[0]));
 
-  talk_base::scoped_ptr<webrtc::MockDataChannelObserver> dc_2_observer(
+  rtc::scoped_ptr<webrtc::MockDataChannelObserver> dc_2_observer(
       new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[1]));
 
   const std::string message_1 = "hello 1";
diff --git a/talk/app/webrtc/peerconnectionfactory.cc b/talk/app/webrtc/peerconnectionfactory.cc
index 3628c59053..81d864cba2 100644
--- a/talk/app/webrtc/peerconnectionfactory.cc
+++ b/talk/app/webrtc/peerconnectionfactory.cc
@@ -43,13 +43,13 @@
 #include "talk/media/webrtc/webrtcvideoencoderfactory.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 
-using talk_base::scoped_refptr;
+using rtc::scoped_refptr;
 
 namespace {
 
-typedef talk_base::TypedMessageData<bool> InitMessageData;
+typedef rtc::TypedMessageData<bool> InitMessageData;
 
-struct CreatePeerConnectionParams : public talk_base::MessageData {
+struct CreatePeerConnectionParams : public rtc::MessageData {
   CreatePeerConnectionParams(
       const webrtc::PeerConnectionInterface::RTCConfiguration& configuration,
       const webrtc::MediaConstraintsInterface* constraints,
@@ -70,7 +70,7 @@ struct CreatePeerConnectionParams : public talk_base::MessageData {
   webrtc::PeerConnectionObserver* observer;
 };
 
-struct CreateAudioSourceParams : public talk_base::MessageData {
+struct CreateAudioSourceParams : public rtc::MessageData {
   explicit CreateAudioSourceParams(
       const webrtc::MediaConstraintsInterface* constraints)
       : constraints(constraints) {
@@ -79,7 +79,7 @@ struct CreateAudioSourceParams : public talk_base::MessageData {
   scoped_refptr<webrtc::AudioSourceInterface> source;
 };
 
-struct CreateVideoSourceParams : public talk_base::MessageData {
+struct CreateVideoSourceParams : public rtc::MessageData {
   CreateVideoSourceParams(cricket::VideoCapturer* capturer,
                           const webrtc::MediaConstraintsInterface* constraints)
       : capturer(capturer),
@@ -90,11 +90,11 @@ struct CreateVideoSourceParams : public talk_base::MessageData {
   scoped_refptr<webrtc::VideoSourceInterface> source;
 };
 
-struct StartAecDumpParams : public talk_base::MessageData {
-  explicit StartAecDumpParams(talk_base::PlatformFile aec_dump_file)
+struct StartAecDumpParams : public rtc::MessageData {
+  explicit StartAecDumpParams(rtc::PlatformFile aec_dump_file)
       : aec_dump_file(aec_dump_file) {
   }
-  talk_base::PlatformFile aec_dump_file;
+  rtc::PlatformFile aec_dump_file;
   bool result;
 };
 
@@ -111,10 +111,10 @@ enum {
 
 namespace webrtc {
 
-talk_base::scoped_refptr<PeerConnectionFactoryInterface>
+rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactory() {
-  talk_base::scoped_refptr<PeerConnectionFactory> pc_factory(
-      new talk_base::RefCountedObject<PeerConnectionFactory>());
+  rtc::scoped_refptr<PeerConnectionFactory> pc_factory(
+      new rtc::RefCountedObject<PeerConnectionFactory>());
 
   if (!pc_factory->Initialize()) {
     return NULL;
@@ -122,15 +122,15 @@ CreatePeerConnectionFactory() {
   return pc_factory;
 }
 
-talk_base::scoped_refptr<PeerConnectionFactoryInterface>
+rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactory(
-    talk_base::Thread* worker_thread,
-    talk_base::Thread* signaling_thread,
+    rtc::Thread* worker_thread,
+    rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     cricket::WebRtcVideoDecoderFactory* decoder_factory) {
-  talk_base::scoped_refptr<PeerConnectionFactory> pc_factory(
-      new talk_base::RefCountedObject<PeerConnectionFactory>(worker_thread,
+  rtc::scoped_refptr<PeerConnectionFactory> pc_factory(
+      new rtc::RefCountedObject<PeerConnectionFactory>(worker_thread,
                                                              signaling_thread,
                                                              default_adm,
                                                              encoder_factory,
@@ -143,8 +143,8 @@ CreatePeerConnectionFactory(
 
 PeerConnectionFactory::PeerConnectionFactory()
     : owns_ptrs_(true),
-      signaling_thread_(new talk_base::Thread),
-      worker_thread_(new talk_base::Thread) {
+      signaling_thread_(new rtc::Thread),
+      worker_thread_(new rtc::Thread) {
   bool result = signaling_thread_->Start();
   ASSERT(result);
   result = worker_thread_->Start();
@@ -152,8 +152,8 @@ PeerConnectionFactory::PeerConnectionFactory()
 }
 
 PeerConnectionFactory::PeerConnectionFactory(
-    talk_base::Thread* worker_thread,
-    talk_base::Thread* signaling_thread,
+    rtc::Thread* worker_thread,
+    rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
     cricket::WebRtcVideoDecoderFactory* video_decoder_factory)
@@ -185,7 +185,7 @@ bool PeerConnectionFactory::Initialize() {
   return result.data();
 }
 
-void PeerConnectionFactory::OnMessage(talk_base::Message* msg) {
+void PeerConnectionFactory::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_INIT_FACTORY: {
      InitMessageData* pdata = static_cast<InitMessageData*>(msg->pdata);
@@ -229,7 +229,7 @@ void PeerConnectionFactory::OnMessage(talk_base::Message* msg) {
 }
 
 bool PeerConnectionFactory::Initialize_s() {
-  talk_base::InitRandom(talk_base::Time());
+  rtc::InitRandom(rtc::Time());
 
   allocator_factory_ = PortAllocatorFactory::Create(worker_thread_);
   if (!allocator_factory_)
@@ -260,28 +260,28 @@ void PeerConnectionFactory::Terminate_s() {
   allocator_factory_ = NULL;
 }
 
-talk_base::scoped_refptr<AudioSourceInterface>
+rtc::scoped_refptr<AudioSourceInterface>
 PeerConnectionFactory::CreateAudioSource_s(
     const MediaConstraintsInterface* constraints) {
-  talk_base::scoped_refptr<LocalAudioSource> source(
+  rtc::scoped_refptr<LocalAudioSource> source(
       LocalAudioSource::Create(options_, constraints));
   return source;
 }
 
-talk_base::scoped_refptr<VideoSourceInterface>
+rtc::scoped_refptr<VideoSourceInterface>
 PeerConnectionFactory::CreateVideoSource_s(
     cricket::VideoCapturer* capturer,
     const MediaConstraintsInterface* constraints) {
-  talk_base::scoped_refptr<VideoSource> source(
+  rtc::scoped_refptr<VideoSource> source(
       VideoSource::Create(channel_manager_.get(), capturer, constraints));
   return VideoSourceProxy::Create(signaling_thread_, source);
 }
 
-bool PeerConnectionFactory::StartAecDump_s(talk_base::PlatformFile file) {
+bool PeerConnectionFactory::StartAecDump_s(rtc::PlatformFile file) {
   return channel_manager_->StartAecDump(file);
 }
 
-talk_base::scoped_refptr<PeerConnectionInterface>
+rtc::scoped_refptr<PeerConnectionInterface>
 PeerConnectionFactory::CreatePeerConnection(
     const PeerConnectionInterface::RTCConfiguration& configuration,
     const MediaConstraintsInterface* constraints,
@@ -296,7 +296,7 @@ PeerConnectionFactory::CreatePeerConnection(
   return params.peerconnection;
 }
 
-talk_base::scoped_refptr<PeerConnectionInterface>
+rtc::scoped_refptr<PeerConnectionInterface>
 PeerConnectionFactory::CreatePeerConnection_s(
     const PeerConnectionInterface::RTCConfiguration& configuration,
     const MediaConstraintsInterface* constraints,
@@ -304,8 +304,8 @@ PeerConnectionFactory::CreatePeerConnection_s(
     DTLSIdentityServiceInterface* dtls_identity_service,
     PeerConnectionObserver* observer) {
   ASSERT(allocator_factory || allocator_factory_);
-  talk_base::scoped_refptr<PeerConnection> pc(
-      new talk_base::RefCountedObject<PeerConnection>(this));
+  rtc::scoped_refptr<PeerConnection> pc(
+      new rtc::RefCountedObject<PeerConnection>(this));
   if (!pc->Initialize(
       configuration,
       constraints,
@@ -317,13 +317,13 @@ PeerConnectionFactory::CreatePeerConnection_s(
   return PeerConnectionProxy::Create(signaling_thread(), pc);
 }
 
-talk_base::scoped_refptr<MediaStreamInterface>
+rtc::scoped_refptr<MediaStreamInterface>
 PeerConnectionFactory::CreateLocalMediaStream(const std::string& label) {
   return MediaStreamProxy::Create(signaling_thread_,
                                   MediaStream::Create(label));
 }
 
-talk_base::scoped_refptr<AudioSourceInterface>
+rtc::scoped_refptr<AudioSourceInterface>
 PeerConnectionFactory::CreateAudioSource(
     const MediaConstraintsInterface* constraints) {
   CreateAudioSourceParams params(constraints);
@@ -331,7 +331,7 @@ PeerConnectionFactory::CreateAudioSource(
   return params.source;
 }
 
-talk_base::scoped_refptr<VideoSourceInterface>
+rtc::scoped_refptr<VideoSourceInterface>
 PeerConnectionFactory::CreateVideoSource(
     cricket::VideoCapturer* capturer,
     const MediaConstraintsInterface* constraints) {
@@ -342,24 +342,24 @@ PeerConnectionFactory::CreateVideoSource(
   return params.source;
 }
 
-talk_base::scoped_refptr<VideoTrackInterface>
+rtc::scoped_refptr<VideoTrackInterface>
 PeerConnectionFactory::CreateVideoTrack(
     const std::string& id,
     VideoSourceInterface* source) {
-  talk_base::scoped_refptr<VideoTrackInterface> track(
+  rtc::scoped_refptr<VideoTrackInterface> track(
       VideoTrack::Create(id, source));
   return VideoTrackProxy::Create(signaling_thread_, track);
 }
 
-talk_base::scoped_refptr<AudioTrackInterface>
+rtc::scoped_refptr<AudioTrackInterface>
 PeerConnectionFactory::CreateAudioTrack(const std::string& id,
                                         AudioSourceInterface* source) {
-  talk_base::scoped_refptr<AudioTrackInterface> track(
+  rtc::scoped_refptr<AudioTrackInterface> track(
       AudioTrack::Create(id, source));
   return AudioTrackProxy::Create(signaling_thread_, track);
 }
 
-bool PeerConnectionFactory::StartAecDump(talk_base::PlatformFile file) {
+bool PeerConnectionFactory::StartAecDump(rtc::PlatformFile file) {
   StartAecDumpParams params(file);
   signaling_thread_->Send(this, MSG_START_AEC_DUMP, &params);
   return params.result;
@@ -369,11 +369,11 @@ cricket::ChannelManager* PeerConnectionFactory::channel_manager() {
   return channel_manager_.get();
 }
 
-talk_base::Thread* PeerConnectionFactory::signaling_thread() {
+rtc::Thread* PeerConnectionFactory::signaling_thread() {
   return signaling_thread_;
 }
 
-talk_base::Thread* PeerConnectionFactory::worker_thread() {
+rtc::Thread* PeerConnectionFactory::worker_thread() {
   return worker_thread_;
 }
 
diff --git a/talk/app/webrtc/peerconnectionfactory.h b/talk/app/webrtc/peerconnectionfactory.h
index 633d281140..2cadaaa86e 100644
--- a/talk/app/webrtc/peerconnectionfactory.h
+++ b/talk/app/webrtc/peerconnectionfactory.h
@@ -31,20 +31,20 @@
 
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
 #include "talk/session/media/channelmanager.h"
 
 namespace webrtc {
 
 class PeerConnectionFactory : public PeerConnectionFactoryInterface,
-                              public talk_base::MessageHandler {
+                              public rtc::MessageHandler {
  public:
   virtual void SetOptions(const Options& options) {
     options_ = options;
   }
 
-  virtual talk_base::scoped_refptr<PeerConnectionInterface>
+  virtual rtc::scoped_refptr<PeerConnectionInterface>
       CreatePeerConnection(
           const PeerConnectionInterface::RTCConfiguration& configuration,
           const MediaConstraintsInterface* constraints,
@@ -54,36 +54,36 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface,
 
   bool Initialize();
 
-  virtual talk_base::scoped_refptr<MediaStreamInterface>
+  virtual rtc::scoped_refptr<MediaStreamInterface>
       CreateLocalMediaStream(const std::string& label);
 
-  virtual talk_base::scoped_refptr<AudioSourceInterface> CreateAudioSource(
+  virtual rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource(
       const MediaConstraintsInterface* constraints);
 
-  virtual talk_base::scoped_refptr<VideoSourceInterface> CreateVideoSource(
+  virtual rtc::scoped_refptr<VideoSourceInterface> CreateVideoSource(
       cricket::VideoCapturer* capturer,
       const MediaConstraintsInterface* constraints);
 
-  virtual talk_base::scoped_refptr<VideoTrackInterface>
+  virtual rtc::scoped_refptr<VideoTrackInterface>
       CreateVideoTrack(const std::string& id,
                        VideoSourceInterface* video_source);
 
-  virtual talk_base::scoped_refptr<AudioTrackInterface>
+  virtual rtc::scoped_refptr<AudioTrackInterface>
       CreateAudioTrack(const std::string& id,
                        AudioSourceInterface* audio_source);
 
-  virtual bool StartAecDump(talk_base::PlatformFile file);
+  virtual bool StartAecDump(rtc::PlatformFile file);
 
   virtual cricket::ChannelManager* channel_manager();
-  virtual talk_base::Thread* signaling_thread();
-  virtual talk_base::Thread* worker_thread();
+  virtual rtc::Thread* signaling_thread();
+  virtual rtc::Thread* worker_thread();
   const Options& options() const { return options_; }
 
  protected:
   PeerConnectionFactory();
   PeerConnectionFactory(
-      talk_base::Thread* worker_thread,
-      talk_base::Thread* signaling_thread,
+      rtc::Thread* worker_thread,
+      rtc::Thread* signaling_thread,
       AudioDeviceModule* default_adm,
       cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
       cricket::WebRtcVideoDecoderFactory* video_decoder_factory);
@@ -92,39 +92,39 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface,
  private:
   bool Initialize_s();
   void Terminate_s();
-  talk_base::scoped_refptr<AudioSourceInterface> CreateAudioSource_s(
+  rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource_s(
       const MediaConstraintsInterface* constraints);
-  talk_base::scoped_refptr<VideoSourceInterface> CreateVideoSource_s(
+  rtc::scoped_refptr<VideoSourceInterface> CreateVideoSource_s(
       cricket::VideoCapturer* capturer,
       const MediaConstraintsInterface* constraints);
 
-  talk_base::scoped_refptr<PeerConnectionInterface> CreatePeerConnection_s(
+  rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection_s(
       const PeerConnectionInterface::RTCConfiguration& configuration,
       const MediaConstraintsInterface* constraints,
       PortAllocatorFactoryInterface* allocator_factory,
       DTLSIdentityServiceInterface* dtls_identity_service,
       PeerConnectionObserver* observer);
 
-  bool StartAecDump_s(talk_base::PlatformFile file);
+  bool StartAecDump_s(rtc::PlatformFile file);
 
-  // Implements talk_base::MessageHandler.
-  void OnMessage(talk_base::Message* msg);
+  // Implements rtc::MessageHandler.
+  void OnMessage(rtc::Message* msg);
 
   bool owns_ptrs_;
-  talk_base::Thread* signaling_thread_;
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* signaling_thread_;
+  rtc::Thread* worker_thread_;
   Options options_;
-  talk_base::scoped_refptr<PortAllocatorFactoryInterface> allocator_factory_;
+  rtc::scoped_refptr<PortAllocatorFactoryInterface> allocator_factory_;
   // External Audio device used for audio playback.
-  talk_base::scoped_refptr<AudioDeviceModule> default_adm_;
-  talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
+  rtc::scoped_refptr<AudioDeviceModule> default_adm_;
+  rtc::scoped_ptr<cricket::ChannelManager> channel_manager_;
   // External Video encoder factory. This can be NULL if the client has not
   // injected any. In that case, video engine will use the internal SW encoder.
-  talk_base::scoped_ptr<cricket::WebRtcVideoEncoderFactory>
+  rtc::scoped_ptr<cricket::WebRtcVideoEncoderFactory>
       video_encoder_factory_;
   // External Video decoder factory. This can be NULL if the client has not
   // injected any. In that case, video engine will use the internal SW decoder.
-  talk_base::scoped_ptr<cricket::WebRtcVideoDecoderFactory>
+  rtc::scoped_ptr<cricket::WebRtcVideoDecoderFactory>
       video_decoder_factory_;
 };
 
diff --git a/talk/app/webrtc/peerconnectionfactory_unittest.cc b/talk/app/webrtc/peerconnectionfactory_unittest.cc
index 01f35d940d..a18069e85f 100644
--- a/talk/app/webrtc/peerconnectionfactory_unittest.cc
+++ b/talk/app/webrtc/peerconnectionfactory_unittest.cc
@@ -32,9 +32,9 @@
 #include "talk/app/webrtc/peerconnectionfactory.h"
 #include "talk/app/webrtc/videosourceinterface.h"
 #include "talk/app/webrtc/test/fakevideotrackrenderer.h"
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/webrtc/webrtccommon.h"
 #include "talk/media/webrtc/webrtcvoe.h"
@@ -102,8 +102,8 @@ class NullPeerConnectionObserver : public PeerConnectionObserver {
 
 class PeerConnectionFactoryTest : public testing::Test {
   void SetUp() {
-    factory_ = webrtc::CreatePeerConnectionFactory(talk_base::Thread::Current(),
-                                                   talk_base::Thread::Current(),
+    factory_ = webrtc::CreatePeerConnectionFactory(rtc::Thread::Current(),
+                                                   rtc::Thread::Current(),
                                                    NULL,
                                                    NULL,
                                                    NULL);
@@ -141,21 +141,21 @@ class PeerConnectionFactoryTest : public testing::Test {
     }
   }
 
-  talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory_;
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_;
   NullPeerConnectionObserver observer_;
-  talk_base::scoped_refptr<PortAllocatorFactoryInterface> allocator_factory_;
+  rtc::scoped_refptr<PortAllocatorFactoryInterface> allocator_factory_;
 };
 
 // Verify creation of PeerConnection using internal ADM, video factory and
 // internal libjingle threads.
 TEST(PeerConnectionFactoryTestInternal, CreatePCUsingInternalModules) {
-  talk_base::scoped_refptr<PeerConnectionFactoryInterface> factory(
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       webrtc::CreatePeerConnectionFactory());
 
   NullPeerConnectionObserver observer;
   webrtc::PeerConnectionInterface::IceServers servers;
 
-  talk_base::scoped_refptr<PeerConnectionInterface> pc(
+  rtc::scoped_refptr<PeerConnectionInterface> pc(
       factory->CreatePeerConnection(servers, NULL, NULL, NULL, &observer));
 
   EXPECT_TRUE(pc.get() != NULL);
@@ -174,7 +174,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) {
   ice_server.uri = kTurnIceServerWithTransport;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  talk_base::scoped_refptr<PeerConnectionInterface> pc(
+  rtc::scoped_refptr<PeerConnectionInterface> pc(
       factory_->CreatePeerConnection(config, NULL,
                                      allocator_factory_.get(),
                                      NULL,
@@ -210,7 +210,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersOldSignature) {
   ice_server.uri = kTurnIceServerWithTransport;
   ice_server.password = kTurnPassword;
   ice_servers.push_back(ice_server);
-  talk_base::scoped_refptr<PeerConnectionInterface> pc(
+  rtc::scoped_refptr<PeerConnectionInterface> pc(
       factory_->CreatePeerConnection(ice_servers, NULL,
                                      allocator_factory_.get(),
                                      NULL,
@@ -240,7 +240,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) {
   ice_server.username = kTurnUsername;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  talk_base::scoped_refptr<PeerConnectionInterface> pc(
+  rtc::scoped_refptr<PeerConnectionInterface> pc(
       factory_->CreatePeerConnection(config, NULL,
                                      allocator_factory_.get(),
                                      NULL,
@@ -261,7 +261,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) {
   ice_server.uri = kTurnIceServerWithTransport;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  talk_base::scoped_refptr<PeerConnectionInterface> pc(
+  rtc::scoped_refptr<PeerConnectionInterface> pc(
       factory_->CreatePeerConnection(config, NULL,
                                      allocator_factory_.get(),
                                      NULL,
@@ -286,7 +286,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
   ice_server.uri = kSecureTurnIceServerWithoutTransportAndPortParam;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  talk_base::scoped_refptr<PeerConnectionInterface> pc(
+  rtc::scoped_refptr<PeerConnectionInterface> pc(
       factory_->CreatePeerConnection(config, NULL,
                                      allocator_factory_.get(),
                                      NULL,
@@ -323,7 +323,7 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
   ice_server.uri = kTurnIceServerWithIPv6Address;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  talk_base::scoped_refptr<PeerConnectionInterface> pc(
+  rtc::scoped_refptr<PeerConnectionInterface> pc(
       factory_->CreatePeerConnection(config, NULL,
                                      allocator_factory_.get(),
                                      NULL,
@@ -356,10 +356,10 @@ TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
 TEST_F(PeerConnectionFactoryTest, LocalRendering) {
   cricket::FakeVideoCapturer* capturer = new cricket::FakeVideoCapturer();
   // The source take ownership of |capturer|.
-  talk_base::scoped_refptr<VideoSourceInterface> source(
+  rtc::scoped_refptr<VideoSourceInterface> source(
       factory_->CreateVideoSource(capturer, NULL));
   ASSERT_TRUE(source.get() != NULL);
-  talk_base::scoped_refptr<VideoTrackInterface> track(
+  rtc::scoped_refptr<VideoTrackInterface> track(
       factory_->CreateVideoTrack("testlabel", source));
   ASSERT_TRUE(track.get() != NULL);
   FakeVideoTrackRenderer local_renderer(track);
diff --git a/talk/app/webrtc/peerconnectioninterface.h b/talk/app/webrtc/peerconnectioninterface.h
index ed4033c17d..5c43d3bf7b 100644
--- a/talk/app/webrtc/peerconnectioninterface.h
+++ b/talk/app/webrtc/peerconnectioninterface.h
@@ -77,10 +77,10 @@
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/statstypes.h"
 #include "talk/app/webrtc/umametrics.h"
-#include "talk/base/fileutils.h"
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/socketaddress.h"
 
-namespace talk_base {
+namespace rtc {
 class Thread;
 }
 
@@ -95,7 +95,7 @@ class AudioDeviceModule;
 class MediaConstraintsInterface;
 
 // MediaStream container interface.
-class StreamCollectionInterface : public talk_base::RefCountInterface {
+class StreamCollectionInterface : public rtc::RefCountInterface {
  public:
   // TODO(ronghuawu): Update the function names to c++ style, e.g. find -> Find.
   virtual size_t count() = 0;
@@ -111,7 +111,7 @@ class StreamCollectionInterface : public talk_base::RefCountInterface {
   ~StreamCollectionInterface() {}
 };
 
-class StatsObserver : public talk_base::RefCountInterface {
+class StatsObserver : public rtc::RefCountInterface {
  public:
   virtual void OnComplete(const std::vector<StatsReport>& reports) = 0;
 
@@ -119,7 +119,7 @@ class StatsObserver : public talk_base::RefCountInterface {
   virtual ~StatsObserver() {}
 };
 
-class UMAObserver : public talk_base::RefCountInterface {
+class UMAObserver : public rtc::RefCountInterface {
  public:
   virtual void IncrementCounter(PeerConnectionUMAMetricsCounter type) = 0;
   virtual void AddHistogramSample(PeerConnectionUMAMetricsName type,
@@ -129,7 +129,7 @@ class UMAObserver : public talk_base::RefCountInterface {
   virtual ~UMAObserver() {}
 };
 
-class PeerConnectionInterface : public talk_base::RefCountInterface {
+class PeerConnectionInterface : public rtc::RefCountInterface {
  public:
   // See http://dev.w3.org/2011/webrtc/editor/webrtc.html#state-definitions .
   enum SignalingState {
@@ -202,11 +202,11 @@ class PeerConnectionInterface : public talk_base::RefCountInterface {
   };
 
   // Accessor methods to active local streams.
-  virtual talk_base::scoped_refptr<StreamCollectionInterface>
+  virtual rtc::scoped_refptr<StreamCollectionInterface>
       local_streams() = 0;
 
   // Accessor methods to remote streams.
-  virtual talk_base::scoped_refptr<StreamCollectionInterface>
+  virtual rtc::scoped_refptr<StreamCollectionInterface>
       remote_streams() = 0;
 
   // Add a new MediaStream to be sent on this PeerConnection.
@@ -222,14 +222,14 @@ class PeerConnectionInterface : public talk_base::RefCountInterface {
 
   // Returns pointer to the created DtmfSender on success.
   // Otherwise returns NULL.
-  virtual talk_base::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
+  virtual rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
       AudioTrackInterface* track) = 0;
 
   virtual bool GetStats(StatsObserver* observer,
                         MediaStreamTrackInterface* track,
                         StatsOutputLevel level) = 0;
 
-  virtual talk_base::scoped_refptr<DataChannelInterface> CreateDataChannel(
+  virtual rtc::scoped_refptr<DataChannelInterface> CreateDataChannel(
       const std::string& label,
       const DataChannelInit* config) = 0;
 
@@ -340,13 +340,13 @@ class PeerConnectionObserver {
 
 // Factory class used for creating cricket::PortAllocator that is used
 // for ICE negotiation.
-class PortAllocatorFactoryInterface : public talk_base::RefCountInterface {
+class PortAllocatorFactoryInterface : public rtc::RefCountInterface {
  public:
   struct StunConfiguration {
     StunConfiguration(const std::string& address, int port)
         : server(address, port) {}
     // STUN server address and port.
-    talk_base::SocketAddress server;
+    rtc::SocketAddress server;
   };
 
   struct TurnConfiguration {
@@ -361,7 +361,7 @@ class PortAllocatorFactoryInterface : public talk_base::RefCountInterface {
           password(password),
           transport_type(transport_type),
           secure(secure) {}
-    talk_base::SocketAddress server;
+    rtc::SocketAddress server;
     std::string username;
     std::string password;
     std::string transport_type;
@@ -378,7 +378,7 @@ class PortAllocatorFactoryInterface : public talk_base::RefCountInterface {
 };
 
 // Used to receive callbacks of DTLS identity requests.
-class DTLSIdentityRequestObserver : public talk_base::RefCountInterface {
+class DTLSIdentityRequestObserver : public rtc::RefCountInterface {
  public:
   virtual void OnFailure(int error) = 0;
   virtual void OnSuccess(const std::string& der_cert,
@@ -427,7 +427,7 @@ class DTLSIdentityServiceInterface {
 // CreatePeerConnectionFactory method which accepts threads as input and use the
 // CreatePeerConnection version that takes a PortAllocatorFactoryInterface as
 // argument.
-class PeerConnectionFactoryInterface : public talk_base::RefCountInterface {
+class PeerConnectionFactoryInterface : public rtc::RefCountInterface {
  public:
   class Options {
    public:
@@ -441,7 +441,7 @@ class PeerConnectionFactoryInterface : public talk_base::RefCountInterface {
 
   virtual void SetOptions(const Options& options) = 0;
 
-  virtual talk_base::scoped_refptr<PeerConnectionInterface>
+  virtual rtc::scoped_refptr<PeerConnectionInterface>
       CreatePeerConnection(
           const PeerConnectionInterface::RTCConfiguration& configuration,
           const MediaConstraintsInterface* constraints,
@@ -455,7 +455,7 @@ class PeerConnectionFactoryInterface : public talk_base::RefCountInterface {
   // and not IceServers. RTCConfiguration is made up of ice servers and
   // ice transport type.
   // http://dev.w3.org/2011/webrtc/editor/webrtc.html
-  inline talk_base::scoped_refptr<PeerConnectionInterface>
+  inline rtc::scoped_refptr<PeerConnectionInterface>
       CreatePeerConnection(
           const PeerConnectionInterface::IceServers& configuration,
           const MediaConstraintsInterface* constraints,
@@ -468,29 +468,29 @@ class PeerConnectionFactoryInterface : public talk_base::RefCountInterface {
                                   dtls_identity_service, observer);
   }
 
-  virtual talk_base::scoped_refptr<MediaStreamInterface>
+  virtual rtc::scoped_refptr<MediaStreamInterface>
       CreateLocalMediaStream(const std::string& label) = 0;
 
   // Creates a AudioSourceInterface.
   // |constraints| decides audio processing settings but can be NULL.
-  virtual talk_base::scoped_refptr<AudioSourceInterface> CreateAudioSource(
+  virtual rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource(
       const MediaConstraintsInterface* constraints) = 0;
 
   // Creates a VideoSourceInterface. The new source take ownership of
   // |capturer|. |constraints| decides video resolution and frame rate but can
   // be NULL.
-  virtual talk_base::scoped_refptr<VideoSourceInterface> CreateVideoSource(
+  virtual rtc::scoped_refptr<VideoSourceInterface> CreateVideoSource(
       cricket::VideoCapturer* capturer,
       const MediaConstraintsInterface* constraints) = 0;
 
   // Creates a new local VideoTrack. The same |source| can be used in several
   // tracks.
-  virtual talk_base::scoped_refptr<VideoTrackInterface>
+  virtual rtc::scoped_refptr<VideoTrackInterface>
       CreateVideoTrack(const std::string& label,
                        VideoSourceInterface* source) = 0;
 
   // Creates an new AudioTrack. At the moment |source| can be NULL.
-  virtual talk_base::scoped_refptr<AudioTrackInterface>
+  virtual rtc::scoped_refptr<AudioTrackInterface>
       CreateAudioTrack(const std::string& label,
                        AudioSourceInterface* source) = 0;
 
@@ -499,7 +499,7 @@ class PeerConnectionFactoryInterface : public talk_base::RefCountInterface {
   // the ownerhip. If the operation fails, the file will be closed.
   // TODO(grunell): Remove when Chromium has started to use AEC in each source.
   // http://crbug.com/264611.
-  virtual bool StartAecDump(talk_base::PlatformFile file) = 0;
+  virtual bool StartAecDump(rtc::PlatformFile file) = 0;
 
  protected:
   // Dtor and ctor protected as objects shouldn't be created or deleted via
@@ -509,16 +509,16 @@ class PeerConnectionFactoryInterface : public talk_base::RefCountInterface {
 };
 
 // Create a new instance of PeerConnectionFactoryInterface.
-talk_base::scoped_refptr<PeerConnectionFactoryInterface>
+rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactory();
 
 // Create a new instance of PeerConnectionFactoryInterface.
 // Ownership of |factory|, |default_adm|, and optionally |encoder_factory| and
 // |decoder_factory| transferred to the returned factory.
-talk_base::scoped_refptr<PeerConnectionFactoryInterface>
+rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactory(
-    talk_base::Thread* worker_thread,
-    talk_base::Thread* signaling_thread,
+    rtc::Thread* worker_thread,
+    rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     cricket::WebRtcVideoDecoderFactory* decoder_factory);
diff --git a/talk/app/webrtc/peerconnectioninterface_unittest.cc b/talk/app/webrtc/peerconnectioninterface_unittest.cc
index 2219a061cb..1eef82e127 100644
--- a/talk/app/webrtc/peerconnectioninterface_unittest.cc
+++ b/talk/app/webrtc/peerconnectioninterface_unittest.cc
@@ -36,12 +36,12 @@
 #include "talk/app/webrtc/test/mockpeerconnectionobservers.h"
 #include "talk/app/webrtc/test/testsdpstrings.h"
 #include "talk/app/webrtc/videosource.h"
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/sslstreamadapter.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/sctp/sctpdataengine.h"
 #include "talk/session/media/mediasession.h"
@@ -66,8 +66,8 @@ static const uint32 kTimeout = 5000U;
     return;                                         \
   }
 
-using talk_base::scoped_ptr;
-using talk_base::scoped_refptr;
+using rtc::scoped_ptr;
+using rtc::scoped_refptr;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrackInterface;
 using webrtc::DataBuffer;
@@ -229,15 +229,15 @@ class MockPeerConnectionObserver : public PeerConnectionObserver {
 class PeerConnectionInterfaceTest : public testing::Test {
  protected:
   virtual void SetUp() {
-    talk_base::InitializeSSL(NULL);
+    rtc::InitializeSSL(NULL);
     pc_factory_ = webrtc::CreatePeerConnectionFactory(
-        talk_base::Thread::Current(), talk_base::Thread::Current(), NULL, NULL,
+        rtc::Thread::Current(), rtc::Thread::Current(), NULL, NULL,
         NULL);
     ASSERT_TRUE(pc_factory_.get() != NULL);
   }
 
   virtual void TearDown() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   void CreatePeerConnection() {
@@ -361,8 +361,8 @@ class PeerConnectionInterfaceTest : public testing::Test {
   }
 
   bool DoCreateOfferAnswer(SessionDescriptionInterface** desc, bool offer) {
-    talk_base::scoped_refptr<MockCreateSessionDescriptionObserver>
-        observer(new talk_base::RefCountedObject<
+    rtc::scoped_refptr<MockCreateSessionDescriptionObserver>
+        observer(new rtc::RefCountedObject<
             MockCreateSessionDescriptionObserver>());
     if (offer) {
       pc_->CreateOffer(observer, NULL);
@@ -383,8 +383,8 @@ class PeerConnectionInterfaceTest : public testing::Test {
   }
 
   bool DoSetSessionDescription(SessionDescriptionInterface* desc, bool local) {
-    talk_base::scoped_refptr<MockSetSessionDescriptionObserver>
-        observer(new talk_base::RefCountedObject<
+    rtc::scoped_refptr<MockSetSessionDescriptionObserver>
+        observer(new rtc::RefCountedObject<
             MockSetSessionDescriptionObserver>());
     if (local) {
       pc_->SetLocalDescription(observer, desc);
@@ -407,8 +407,8 @@ class PeerConnectionInterfaceTest : public testing::Test {
   // It does not verify the values in the StatReports since a RTCP packet might
   // be required.
   bool DoGetStats(MediaStreamTrackInterface* track) {
-    talk_base::scoped_refptr<MockStatsObserver> observer(
-        new talk_base::RefCountedObject<MockStatsObserver>());
+    rtc::scoped_refptr<MockStatsObserver> observer(
+        new rtc::RefCountedObject<MockStatsObserver>());
     if (!pc_->GetStats(
         observer, track, PeerConnectionInterface::kStatsOutputLevelStandard))
       return false;
@@ -438,7 +438,7 @@ class PeerConnectionInterfaceTest : public testing::Test {
   }
 
   void CreateOfferAsRemoteDescription() {
-    talk_base::scoped_ptr<SessionDescriptionInterface> offer;
+    rtc::scoped_ptr<SessionDescriptionInterface> offer;
     EXPECT_TRUE(DoCreateOffer(offer.use()));
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
@@ -490,7 +490,7 @@ class PeerConnectionInterfaceTest : public testing::Test {
   }
 
   void CreateOfferAsLocalDescription() {
-    talk_base::scoped_ptr<SessionDescriptionInterface> offer;
+    rtc::scoped_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(offer.use()));
     // TODO(perkj): Currently SetLocalDescription fails if any parameters in an
     // audio codec change, even if the parameter has nothing to do with
@@ -792,9 +792,9 @@ TEST_F(PeerConnectionInterfaceTest, TestDataChannel) {
   scoped_refptr<DataChannelInterface> data2  =
       pc_->CreateDataChannel("test2", NULL);
   ASSERT_TRUE(data1 != NULL);
-  talk_base::scoped_ptr<MockDataChannelObserver> observer1(
+  rtc::scoped_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
-  talk_base::scoped_ptr<MockDataChannelObserver> observer2(
+  rtc::scoped_ptr<MockDataChannelObserver> observer2(
       new MockDataChannelObserver(data2));
 
   EXPECT_EQ(DataChannelInterface::kConnecting, data1->state());
@@ -839,9 +839,9 @@ TEST_F(PeerConnectionInterfaceTest, TestSendBinaryOnRtpDataChannel) {
   scoped_refptr<DataChannelInterface> data2  =
       pc_->CreateDataChannel("test2", NULL);
   ASSERT_TRUE(data1 != NULL);
-  talk_base::scoped_ptr<MockDataChannelObserver> observer1(
+  rtc::scoped_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
-  talk_base::scoped_ptr<MockDataChannelObserver> observer2(
+  rtc::scoped_ptr<MockDataChannelObserver> observer2(
       new MockDataChannelObserver(data2));
 
   EXPECT_EQ(DataChannelInterface::kConnecting, data1->state());
@@ -854,7 +854,7 @@ TEST_F(PeerConnectionInterfaceTest, TestSendBinaryOnRtpDataChannel) {
   EXPECT_EQ(DataChannelInterface::kOpen, data1->state());
   EXPECT_EQ(DataChannelInterface::kOpen, data2->state());
 
-  talk_base::Buffer buffer("test", 4);
+  rtc::Buffer buffer("test", 4);
   EXPECT_FALSE(data1->Send(DataBuffer(buffer, true)));
 }
 
@@ -866,7 +866,7 @@ TEST_F(PeerConnectionInterfaceTest, TestSendOnlyDataChannel) {
   CreatePeerConnection(&constraints);
   scoped_refptr<DataChannelInterface> data1  =
       pc_->CreateDataChannel("test1", NULL);
-  talk_base::scoped_ptr<MockDataChannelObserver> observer1(
+  rtc::scoped_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
 
   CreateOfferReceiveAnswerWithoutSsrc();
@@ -897,7 +897,7 @@ TEST_F(PeerConnectionInterfaceTest, TestReceiveOnlyDataChannel) {
   std::string receive_label = "answer_channel";
   std::string sdp;
   EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
-  talk_base::replace_substrs(offer_label.c_str(), offer_label.length(),
+  rtc::replace_substrs(offer_label.c_str(), offer_label.length(),
                              receive_label.c_str(), receive_label.length(),
                              &sdp);
   CreateAnswerAsRemoteDescription(sdp);
@@ -1048,9 +1048,9 @@ TEST_F(PeerConnectionInterfaceTest, DataChannelCloseWhenPeerConnectionClose) {
   scoped_refptr<DataChannelInterface> data2  =
       pc_->CreateDataChannel("test2", NULL);
   ASSERT_TRUE(data1 != NULL);
-  talk_base::scoped_ptr<MockDataChannelObserver> observer1(
+  rtc::scoped_ptr<MockDataChannelObserver> observer1(
       new MockDataChannelObserver(data1));
-  talk_base::scoped_ptr<MockDataChannelObserver> observer2(
+  rtc::scoped_ptr<MockDataChannelObserver> observer2(
       new MockDataChannelObserver(data2));
 
   CreateOfferReceiveAnswer();
@@ -1091,7 +1091,7 @@ TEST_F(PeerConnectionInterfaceTest, TestRejectDataChannelInAnswer) {
 // FireFox, use it as a remote session description, generate an answer and use
 // the answer as a local description.
 TEST_F(PeerConnectionInterfaceTest, ReceiveFireFoxOffer) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
@@ -1188,7 +1188,7 @@ TEST_F(PeerConnectionInterfaceTest, CloseAndTestMethods) {
   EXPECT_FALSE(pc_->AddStream(local_stream, NULL));
 
   ASSERT_FALSE(local_stream->GetAudioTracks().empty());
-  talk_base::scoped_refptr<webrtc::DtmfSenderInterface> dtmf_sender(
+  rtc::scoped_refptr<webrtc::DtmfSenderInterface> dtmf_sender(
       pc_->CreateDtmfSender(local_stream->GetAudioTracks()[0]));
   EXPECT_TRUE(NULL == dtmf_sender);  // local stream has been removed.
 
@@ -1197,9 +1197,9 @@ TEST_F(PeerConnectionInterfaceTest, CloseAndTestMethods) {
   EXPECT_TRUE(pc_->local_description() != NULL);
   EXPECT_TRUE(pc_->remote_description() != NULL);
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer;
+  rtc::scoped_ptr<SessionDescriptionInterface> offer;
   EXPECT_TRUE(DoCreateOffer(offer.use()));
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer;
+  rtc::scoped_ptr<SessionDescriptionInterface> answer;
   EXPECT_TRUE(DoCreateAnswer(answer.use()));
 
   std::string sdp;
diff --git a/talk/app/webrtc/peerconnectionproxy.h b/talk/app/webrtc/peerconnectionproxy.h
index 74e5012bb1..ed26eb8706 100644
--- a/talk/app/webrtc/peerconnectionproxy.h
+++ b/talk/app/webrtc/peerconnectionproxy.h
@@ -35,19 +35,19 @@ namespace webrtc {
 
 // Define proxy for PeerConnectionInterface.
 BEGIN_PROXY_MAP(PeerConnection)
-  PROXY_METHOD0(talk_base::scoped_refptr<StreamCollectionInterface>,
+  PROXY_METHOD0(rtc::scoped_refptr<StreamCollectionInterface>,
                 local_streams)
-  PROXY_METHOD0(talk_base::scoped_refptr<StreamCollectionInterface>,
+  PROXY_METHOD0(rtc::scoped_refptr<StreamCollectionInterface>,
                 remote_streams)
   PROXY_METHOD2(bool, AddStream, MediaStreamInterface*,
                 const MediaConstraintsInterface*)
   PROXY_METHOD1(void, RemoveStream, MediaStreamInterface*)
-  PROXY_METHOD1(talk_base::scoped_refptr<DtmfSenderInterface>,
+  PROXY_METHOD1(rtc::scoped_refptr<DtmfSenderInterface>,
                 CreateDtmfSender, AudioTrackInterface*)
   PROXY_METHOD3(bool, GetStats, StatsObserver*,
                 MediaStreamTrackInterface*,
                 StatsOutputLevel)
-  PROXY_METHOD2(talk_base::scoped_refptr<DataChannelInterface>,
+  PROXY_METHOD2(rtc::scoped_refptr<DataChannelInterface>,
                 CreateDataChannel, const std::string&, const DataChannelInit*)
   PROXY_CONSTMETHOD0(const SessionDescriptionInterface*, local_description)
   PROXY_CONSTMETHOD0(const SessionDescriptionInterface*, remote_description)
diff --git a/talk/app/webrtc/portallocatorfactory.cc b/talk/app/webrtc/portallocatorfactory.cc
index 7263c5dc48..9d040f9b63 100644
--- a/talk/app/webrtc/portallocatorfactory.cc
+++ b/talk/app/webrtc/portallocatorfactory.cc
@@ -27,27 +27,27 @@
 
 #include "talk/app/webrtc/portallocatorfactory.h"
 
-#include "talk/base/logging.h"
-#include "talk/base/network.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/network.h"
+#include "webrtc/base/thread.h"
 #include "talk/p2p/base/basicpacketsocketfactory.h"
 #include "talk/p2p/client/basicportallocator.h"
 
 namespace webrtc {
 
-using talk_base::scoped_ptr;
+using rtc::scoped_ptr;
 
-talk_base::scoped_refptr<PortAllocatorFactoryInterface>
+rtc::scoped_refptr<PortAllocatorFactoryInterface>
 PortAllocatorFactory::Create(
-    talk_base::Thread* worker_thread) {
-  talk_base::RefCountedObject<PortAllocatorFactory>* allocator =
-        new talk_base::RefCountedObject<PortAllocatorFactory>(worker_thread);
+    rtc::Thread* worker_thread) {
+  rtc::RefCountedObject<PortAllocatorFactory>* allocator =
+        new rtc::RefCountedObject<PortAllocatorFactory>(worker_thread);
   return allocator;
 }
 
-PortAllocatorFactory::PortAllocatorFactory(talk_base::Thread* worker_thread)
-    : network_manager_(new talk_base::BasicNetworkManager()),
-      socket_factory_(new talk_base::BasicPacketSocketFactory(worker_thread)) {
+PortAllocatorFactory::PortAllocatorFactory(rtc::Thread* worker_thread)
+    : network_manager_(new rtc::BasicNetworkManager()),
+      socket_factory_(new rtc::BasicPacketSocketFactory(worker_thread)) {
 }
 
 PortAllocatorFactory::~PortAllocatorFactory() {}
diff --git a/talk/app/webrtc/portallocatorfactory.h b/talk/app/webrtc/portallocatorfactory.h
index e30024cb0f..c8890ae333 100644
--- a/talk/app/webrtc/portallocatorfactory.h
+++ b/talk/app/webrtc/portallocatorfactory.h
@@ -34,13 +34,13 @@
 #define TALK_APP_WEBRTC_PORTALLOCATORFACTORY_H_
 
 #include "talk/app/webrtc/peerconnectioninterface.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 
 namespace cricket {
 class PortAllocator;
 }
 
-namespace talk_base {
+namespace rtc {
 class BasicNetworkManager;
 class BasicPacketSocketFactory;
 }
@@ -49,20 +49,20 @@ namespace webrtc {
 
 class PortAllocatorFactory : public PortAllocatorFactoryInterface {
  public:
-  static talk_base::scoped_refptr<PortAllocatorFactoryInterface> Create(
-      talk_base::Thread* worker_thread);
+  static rtc::scoped_refptr<PortAllocatorFactoryInterface> Create(
+      rtc::Thread* worker_thread);
 
   virtual cricket::PortAllocator* CreatePortAllocator(
       const std::vector<StunConfiguration>& stun,
       const std::vector<TurnConfiguration>& turn);
 
  protected:
-  explicit PortAllocatorFactory(talk_base::Thread* worker_thread);
+  explicit PortAllocatorFactory(rtc::Thread* worker_thread);
   ~PortAllocatorFactory();
 
  private:
-  talk_base::scoped_ptr<talk_base::BasicNetworkManager> network_manager_;
-  talk_base::scoped_ptr<talk_base::BasicPacketSocketFactory> socket_factory_;
+  rtc::scoped_ptr<rtc::BasicNetworkManager> network_manager_;
+  rtc::scoped_ptr<rtc::BasicPacketSocketFactory> socket_factory_;
 };
 
 }  // namespace webrtc
diff --git a/talk/app/webrtc/proxy.h b/talk/app/webrtc/proxy.h
index 4db4befa65..0c21ef989b 100644
--- a/talk/app/webrtc/proxy.h
+++ b/talk/app/webrtc/proxy.h
@@ -31,7 +31,7 @@
 //
 // Example usage:
 //
-// class TestInterface : public talk_base::RefCountInterface {
+// class TestInterface : public rtc::RefCountInterface {
 //  public:
 //   std::string FooA() = 0;
 //   std::string FooB(bool arg1) const = 0;
@@ -55,7 +55,7 @@
 #ifndef TALK_APP_WEBRTC_PROXY_H_
 #define TALK_APP_WEBRTC_PROXY_H_
 
-#include "talk/base/thread.h"
+#include "webrtc/base/thread.h"
 
 namespace webrtc {
 
@@ -93,19 +93,19 @@ class ReturnType<void> {
 };
 
 template <typename C, typename R>
-class MethodCall0 : public talk_base::Message,
-                    public talk_base::MessageHandler {
+class MethodCall0 : public rtc::Message,
+                    public rtc::MessageHandler {
  public:
   typedef R (C::*Method)();
   MethodCall0(C* c, Method m) : c_(c), m_(m) {}
 
-  R Marshal(talk_base::Thread* t) {
+  R Marshal(rtc::Thread* t) {
     t->Send(this, 0);
     return r_.value();
   }
 
  private:
-  void OnMessage(talk_base::Message*) {  r_.Invoke(c_, m_);}
+  void OnMessage(rtc::Message*) {  r_.Invoke(c_, m_);}
 
   C* c_;
   Method m_;
@@ -113,19 +113,19 @@ class MethodCall0 : public talk_base::Message,
 };
 
 template <typename C, typename R>
-class ConstMethodCall0 : public talk_base::Message,
-                         public talk_base::MessageHandler {
+class ConstMethodCall0 : public rtc::Message,
+                         public rtc::MessageHandler {
  public:
   typedef R (C::*Method)() const;
   ConstMethodCall0(C* c, Method m) : c_(c), m_(m) {}
 
-  R Marshal(talk_base::Thread* t) {
+  R Marshal(rtc::Thread* t) {
     t->Send(this, 0);
     return r_.value();
   }
 
  private:
-  void OnMessage(talk_base::Message*) { r_.Invoke(c_, m_); }
+  void OnMessage(rtc::Message*) { r_.Invoke(c_, m_); }
 
   C* c_;
   Method m_;
@@ -133,19 +133,19 @@ class ConstMethodCall0 : public talk_base::Message,
 };
 
 template <typename C, typename R,  typename T1>
-class MethodCall1 : public talk_base::Message,
-                    public talk_base::MessageHandler {
+class MethodCall1 : public rtc::Message,
+                    public rtc::MessageHandler {
  public:
   typedef R (C::*Method)(T1 a1);
   MethodCall1(C* c, Method m, T1 a1) : c_(c), m_(m), a1_(a1) {}
 
-  R Marshal(talk_base::Thread* t) {
+  R Marshal(rtc::Thread* t) {
     t->Send(this, 0);
     return r_.value();
   }
 
  private:
-  void OnMessage(talk_base::Message*) { r_.Invoke(c_, m_, a1_); }
+  void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_); }
 
   C* c_;
   Method m_;
@@ -154,19 +154,19 @@ class MethodCall1 : public talk_base::Message,
 };
 
 template <typename C, typename R,  typename T1>
-class ConstMethodCall1 : public talk_base::Message,
-                         public talk_base::MessageHandler {
+class ConstMethodCall1 : public rtc::Message,
+                         public rtc::MessageHandler {
  public:
   typedef R (C::*Method)(T1 a1) const;
   ConstMethodCall1(C* c, Method m, T1 a1) : c_(c), m_(m), a1_(a1) {}
 
-  R Marshal(talk_base::Thread* t) {
+  R Marshal(rtc::Thread* t) {
     t->Send(this, 0);
     return r_.value();
   }
 
  private:
-  void OnMessage(talk_base::Message*) { r_.Invoke(c_, m_, a1_); }
+  void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_); }
 
   C* c_;
   Method m_;
@@ -175,19 +175,19 @@ class ConstMethodCall1 : public talk_base::Message,
 };
 
 template <typename C, typename R, typename T1, typename T2>
-class MethodCall2 : public talk_base::Message,
-                    public talk_base::MessageHandler {
+class MethodCall2 : public rtc::Message,
+                    public rtc::MessageHandler {
  public:
   typedef R (C::*Method)(T1 a1, T2 a2);
   MethodCall2(C* c, Method m, T1 a1, T2 a2) : c_(c), m_(m), a1_(a1), a2_(a2) {}
 
-  R Marshal(talk_base::Thread* t) {
+  R Marshal(rtc::Thread* t) {
     t->Send(this, 0);
     return r_.value();
   }
 
  private:
-  void OnMessage(talk_base::Message*) { r_.Invoke(c_, m_, a1_, a2_); }
+  void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_, a2_); }
 
   C* c_;
   Method m_;
@@ -197,20 +197,20 @@ class MethodCall2 : public talk_base::Message,
 };
 
 template <typename C, typename R, typename T1, typename T2, typename T3>
-class MethodCall3 : public talk_base::Message,
-                    public talk_base::MessageHandler {
+class MethodCall3 : public rtc::Message,
+                    public rtc::MessageHandler {
  public:
   typedef R (C::*Method)(T1 a1, T2 a2, T3 a3);
   MethodCall3(C* c, Method m, T1 a1, T2 a2, T3 a3)
       : c_(c), m_(m), a1_(a1), a2_(a2), a3_(a3) {}
 
-  R Marshal(talk_base::Thread* t) {
+  R Marshal(rtc::Thread* t) {
     t->Send(this, 0);
     return r_.value();
   }
 
  private:
-  void OnMessage(talk_base::Message*) { r_.Invoke(c_, m_, a1_, a2_, a3_); }
+  void OnMessage(rtc::Message*) { r_.Invoke(c_, m_, a1_, a2_, a3_); }
 
   C* c_;
   Method m_;
@@ -224,7 +224,7 @@ class MethodCall3 : public talk_base::Message,
   class c##Proxy : public c##Interface {\
    protected:\
     typedef c##Interface C;\
-    c##Proxy(talk_base::Thread* thread, C* c)\
+    c##Proxy(rtc::Thread* thread, C* c)\
       : owner_thread_(thread), \
         c_(c)  {}\
     ~c##Proxy() {\
@@ -232,9 +232,9 @@ class MethodCall3 : public talk_base::Message,
       call.Marshal(owner_thread_);\
     }\
    public:\
-    static talk_base::scoped_refptr<C> Create(talk_base::Thread* thread, \
+    static rtc::scoped_refptr<C> Create(rtc::Thread* thread, \
                                               C* c) {\
-      return new talk_base::RefCountedObject<c##Proxy>(thread, c);\
+      return new rtc::RefCountedObject<c##Proxy>(thread, c);\
     }\
 
 #define PROXY_METHOD0(r, method)\
@@ -278,8 +278,8 @@ class MethodCall3 : public talk_base::Message,
     void Release_s() {\
       c_ = NULL;\
     }\
-    mutable talk_base::Thread* owner_thread_;\
-    talk_base::scoped_refptr<C> c_;\
+    mutable rtc::Thread* owner_thread_;\
+    rtc::scoped_refptr<C> c_;\
   };\
 
 }  // namespace webrtc
diff --git a/talk/app/webrtc/proxy_unittest.cc b/talk/app/webrtc/proxy_unittest.cc
index 71a583c67c..1cab48436c 100644
--- a/talk/app/webrtc/proxy_unittest.cc
+++ b/talk/app/webrtc/proxy_unittest.cc
@@ -29,10 +29,10 @@
 
 #include <string>
 
-#include "talk/base/refcount.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/thread.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/gunit.h"
 #include "testing/base/public/gmock.h"
 
 using ::testing::_;
@@ -44,7 +44,7 @@ using ::testing::Return;
 namespace webrtc {
 
 // Interface used for testing here.
-class FakeInterface : public talk_base::RefCountInterface {
+class FakeInterface : public rtc::RefCountInterface {
  public:
   virtual void VoidMethod0() = 0;
   virtual std::string Method0() = 0;
@@ -70,8 +70,8 @@ END_PROXY()
 // Implementation of the test interface.
 class Fake : public FakeInterface {
  public:
-  static talk_base::scoped_refptr<Fake> Create() {
-    return new talk_base::RefCountedObject<Fake>();
+  static rtc::scoped_refptr<Fake> Create() {
+    return new rtc::RefCountedObject<Fake>();
   }
 
   MOCK_METHOD0(VoidMethod0, void());
@@ -92,21 +92,21 @@ class ProxyTest: public testing::Test {
  public:
   // Checks that the functions is called on the |signaling_thread_|.
   void CheckThread() {
-    EXPECT_EQ(talk_base::Thread::Current(), signaling_thread_.get());
+    EXPECT_EQ(rtc::Thread::Current(), signaling_thread_.get());
   }
 
  protected:
   virtual void SetUp() {
-    signaling_thread_.reset(new talk_base::Thread());
+    signaling_thread_.reset(new rtc::Thread());
     ASSERT_TRUE(signaling_thread_->Start());
     fake_ = Fake::Create();
     fake_proxy_ = FakeProxy::Create(signaling_thread_.get(), fake_.get());
   }
 
  protected:
-  talk_base::scoped_ptr<talk_base::Thread> signaling_thread_;
-  talk_base::scoped_refptr<FakeInterface> fake_proxy_;
-  talk_base::scoped_refptr<Fake> fake_;
+  rtc::scoped_ptr<rtc::Thread> signaling_thread_;
+  rtc::scoped_refptr<FakeInterface> fake_proxy_;
+  rtc::scoped_refptr<Fake> fake_;
 };
 
 TEST_F(ProxyTest, VoidMethod0) {
diff --git a/talk/app/webrtc/remoteaudiosource.cc b/talk/app/webrtc/remoteaudiosource.cc
index 1c275c74c6..955dff0857 100644
--- a/talk/app/webrtc/remoteaudiosource.cc
+++ b/talk/app/webrtc/remoteaudiosource.cc
@@ -30,12 +30,12 @@
 #include <algorithm>
 #include <functional>
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 
 namespace webrtc {
 
-talk_base::scoped_refptr<RemoteAudioSource> RemoteAudioSource::Create() {
-  return new talk_base::RefCountedObject<RemoteAudioSource>();
+rtc::scoped_refptr<RemoteAudioSource> RemoteAudioSource::Create() {
+  return new rtc::RefCountedObject<RemoteAudioSource>();
 }
 
 RemoteAudioSource::RemoteAudioSource() {
diff --git a/talk/app/webrtc/remoteaudiosource.h b/talk/app/webrtc/remoteaudiosource.h
index ed2421449a..e805af6855 100644
--- a/talk/app/webrtc/remoteaudiosource.h
+++ b/talk/app/webrtc/remoteaudiosource.h
@@ -41,7 +41,7 @@ using webrtc::AudioSourceInterface;
 class RemoteAudioSource : public Notifier<AudioSourceInterface> {
  public:
   // Creates an instance of RemoteAudioSource.
-  static talk_base::scoped_refptr<RemoteAudioSource> Create();
+  static rtc::scoped_refptr<RemoteAudioSource> Create();
 
  protected:
   RemoteAudioSource();
diff --git a/talk/app/webrtc/remotevideocapturer.cc b/talk/app/webrtc/remotevideocapturer.cc
index 072c8d81cc..a76a5302d1 100644
--- a/talk/app/webrtc/remotevideocapturer.cc
+++ b/talk/app/webrtc/remotevideocapturer.cc
@@ -27,7 +27,7 @@
 
 #include "talk/app/webrtc/remotevideocapturer.h"
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/media/base/videoframe.h"
 
 namespace webrtc {
diff --git a/talk/app/webrtc/remotevideocapturer_unittest.cc b/talk/app/webrtc/remotevideocapturer_unittest.cc
index 68135507ca..d66ff01b41 100644
--- a/talk/app/webrtc/remotevideocapturer_unittest.cc
+++ b/talk/app/webrtc/remotevideocapturer_unittest.cc
@@ -28,7 +28,7 @@
 #include <string>
 
 #include "talk/app/webrtc/remotevideocapturer.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/webrtc/webrtcvideoframe.h"
 
 using cricket::CaptureState;
diff --git a/talk/app/webrtc/sctputils.cc b/talk/app/webrtc/sctputils.cc
index dcc6ba6eac..988f4680c6 100644
--- a/talk/app/webrtc/sctputils.cc
+++ b/talk/app/webrtc/sctputils.cc
@@ -27,9 +27,9 @@
 
 #include "talk/app/webrtc/sctputils.h"
 
-#include "talk/base/buffer.h"
-#include "talk/base/bytebuffer.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/logging.h"
 
 namespace webrtc {
 
@@ -48,13 +48,13 @@ enum DataChannelOpenMessageChannelType {
   DCOMCT_UNORDERED_PARTIAL_TIME = 0x82,
 };
 
-bool ParseDataChannelOpenMessage(const talk_base::Buffer& payload,
+bool ParseDataChannelOpenMessage(const rtc::Buffer& payload,
                                  std::string* label,
                                  DataChannelInit* config) {
   // Format defined at
   // http://tools.ietf.org/html/draft-jesup-rtcweb-data-protocol-04
 
-  talk_base::ByteBuffer buffer(payload.data(), payload.length());
+  rtc::ByteBuffer buffer(payload.data(), payload.length());
 
   uint8 message_type;
   if (!buffer.ReadUInt8(&message_type)) {
@@ -125,8 +125,8 @@ bool ParseDataChannelOpenMessage(const talk_base::Buffer& payload,
   return true;
 }
 
-bool ParseDataChannelOpenAckMessage(const talk_base::Buffer& payload) {
-  talk_base::ByteBuffer buffer(payload.data(), payload.length());
+bool ParseDataChannelOpenAckMessage(const rtc::Buffer& payload) {
+  rtc::ByteBuffer buffer(payload.data(), payload.length());
 
   uint8 message_type;
   if (!buffer.ReadUInt8(&message_type)) {
@@ -143,7 +143,7 @@ bool ParseDataChannelOpenAckMessage(const talk_base::Buffer& payload) {
 
 bool WriteDataChannelOpenMessage(const std::string& label,
                                  const DataChannelInit& config,
-                                 talk_base::Buffer* payload) {
+                                 rtc::Buffer* payload) {
   // Format defined at
   // http://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-00#section-6.1
   uint8 channel_type = 0;
@@ -171,9 +171,9 @@ bool WriteDataChannelOpenMessage(const std::string& label,
     }
   }
 
-  talk_base::ByteBuffer buffer(
+  rtc::ByteBuffer buffer(
       NULL, 20 + label.length() + config.protocol.length(),
-      talk_base::ByteBuffer::ORDER_NETWORK);
+      rtc::ByteBuffer::ORDER_NETWORK);
   buffer.WriteUInt8(DATA_CHANNEL_OPEN_MESSAGE_TYPE);
   buffer.WriteUInt8(channel_type);
   buffer.WriteUInt16(priority);
@@ -186,8 +186,8 @@ bool WriteDataChannelOpenMessage(const std::string& label,
   return true;
 }
 
-void WriteDataChannelOpenAckMessage(talk_base::Buffer* payload) {
-  talk_base::ByteBuffer buffer(talk_base::ByteBuffer::ORDER_NETWORK);
+void WriteDataChannelOpenAckMessage(rtc::Buffer* payload) {
+  rtc::ByteBuffer buffer(rtc::ByteBuffer::ORDER_NETWORK);
   buffer.WriteUInt8(DATA_CHANNEL_OPEN_ACK_MESSAGE_TYPE);
   payload->SetData(buffer.Data(), buffer.Length());
 }
diff --git a/talk/app/webrtc/sctputils.h b/talk/app/webrtc/sctputils.h
index d0b4e9c36b..ab1818bcf8 100644
--- a/talk/app/webrtc/sctputils.h
+++ b/talk/app/webrtc/sctputils.h
@@ -32,24 +32,24 @@
 
 #include "talk/app/webrtc/datachannelinterface.h"
 
-namespace talk_base {
+namespace rtc {
 class Buffer;
-}  // namespace talk_base
+}  // namespace rtc
 
 namespace webrtc {
 struct DataChannelInit;
 
-bool ParseDataChannelOpenMessage(const talk_base::Buffer& payload,
+bool ParseDataChannelOpenMessage(const rtc::Buffer& payload,
                                  std::string* label,
                                  DataChannelInit* config);
 
-bool ParseDataChannelOpenAckMessage(const talk_base::Buffer& payload);
+bool ParseDataChannelOpenAckMessage(const rtc::Buffer& payload);
 
 bool WriteDataChannelOpenMessage(const std::string& label,
                                  const DataChannelInit& config,
-                                 talk_base::Buffer* payload);
+                                 rtc::Buffer* payload);
 
-void WriteDataChannelOpenAckMessage(talk_base::Buffer* payload);
+void WriteDataChannelOpenAckMessage(rtc::Buffer* payload);
 }  // namespace webrtc
 
 #endif  // TALK_APP_WEBRTC_SCTPUTILS_H_
diff --git a/talk/app/webrtc/sctputils_unittest.cc b/talk/app/webrtc/sctputils_unittest.cc
index 6a139a04c2..ec2c850231 100644
--- a/talk/app/webrtc/sctputils_unittest.cc
+++ b/talk/app/webrtc/sctputils_unittest.cc
@@ -25,13 +25,13 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/gunit.h"
 #include "talk/app/webrtc/sctputils.h"
 
 class SctpUtilsTest : public testing::Test {
  public:
-  void VerifyOpenMessageFormat(const talk_base::Buffer& packet,
+  void VerifyOpenMessageFormat(const rtc::Buffer& packet,
                                const std::string& label,
                                const webrtc::DataChannelInit& config) {
     uint8 message_type;
@@ -41,7 +41,7 @@ class SctpUtilsTest : public testing::Test {
     uint16 label_length;
     uint16 protocol_length;
 
-    talk_base::ByteBuffer buffer(packet.data(), packet.length());
+    rtc::ByteBuffer buffer(packet.data(), packet.length());
     ASSERT_TRUE(buffer.ReadUInt8(&message_type));
     EXPECT_EQ(0x03, message_type);
 
@@ -84,7 +84,7 @@ TEST_F(SctpUtilsTest, WriteParseOpenMessageWithOrderedReliable) {
   std::string label = "abc";
   config.protocol = "y";
 
-  talk_base::Buffer packet;
+  rtc::Buffer packet;
   ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet));
 
   VerifyOpenMessageFormat(packet, label, config);
@@ -108,7 +108,7 @@ TEST_F(SctpUtilsTest, WriteParseOpenMessageWithMaxRetransmitTime) {
   config.maxRetransmitTime = 10;
   config.protocol = "y";
 
-  talk_base::Buffer packet;
+  rtc::Buffer packet;
   ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet));
 
   VerifyOpenMessageFormat(packet, label, config);
@@ -131,7 +131,7 @@ TEST_F(SctpUtilsTest, WriteParseOpenMessageWithMaxRetransmits) {
   config.maxRetransmits = 10;
   config.protocol = "y";
 
-  talk_base::Buffer packet;
+  rtc::Buffer packet;
   ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet));
 
   VerifyOpenMessageFormat(packet, label, config);
@@ -149,11 +149,11 @@ TEST_F(SctpUtilsTest, WriteParseOpenMessageWithMaxRetransmits) {
 }
 
 TEST_F(SctpUtilsTest, WriteParseAckMessage) {
-  talk_base::Buffer packet;
+  rtc::Buffer packet;
   webrtc::WriteDataChannelOpenAckMessage(&packet);
 
   uint8 message_type;
-  talk_base::ByteBuffer buffer(packet.data(), packet.length());
+  rtc::ByteBuffer buffer(packet.data(), packet.length());
   ASSERT_TRUE(buffer.ReadUInt8(&message_type));
   EXPECT_EQ(0x02, message_type);
 
diff --git a/talk/app/webrtc/statscollector.cc b/talk/app/webrtc/statscollector.cc
index 94586fda7c..2b0b36aabc 100644
--- a/talk/app/webrtc/statscollector.cc
+++ b/talk/app/webrtc/statscollector.cc
@@ -30,9 +30,9 @@
 #include <utility>
 #include <vector>
 
-#include "talk/base/base64.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/timing.h"
+#include "webrtc/base/base64.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/timing.h"
 #include "talk/session/media/channel.h"
 
 namespace webrtc {
@@ -199,7 +199,7 @@ void StatsReport::AddValue(StatsReport::StatsValueName name,
 }
 
 void StatsReport::AddValue(StatsReport::StatsValueName name, int64 value) {
-  AddValue(name, talk_base::ToString<int64>(value));
+  AddValue(name, rtc::ToString<int64>(value));
 }
 
 template <typename T>
@@ -208,7 +208,7 @@ void StatsReport::AddValue(StatsReport::StatsValueName name,
   std::ostringstream oss;
   oss << "[";
   for (size_t i = 0; i < value.size(); ++i) {
-    oss << talk_base::ToString<T>(value[i]);
+    oss << rtc::ToString<T>(value[i]);
     if (i != value.size() - 1)
       oss << ", ";
   }
@@ -237,7 +237,7 @@ namespace {
 typedef std::map<std::string, StatsReport> StatsMap;
 
 double GetTimeNow() {
-  return talk_base::Timing::WallTimeNow() * talk_base::kNumMillisecsPerSec;
+  return rtc::Timing::WallTimeNow() * rtc::kNumMillisecsPerSec;
 }
 
 bool GetTransportIdFromProxy(const cricket::ProxyTransportMap& map,
@@ -325,7 +325,7 @@ void ExtractStats(const cricket::VoiceReceiverInfo& info, StatsReport* report) {
   report->AddValue(StatsReport::kStatsValueNameCurrentDelayMs,
                    info.delay_estimate_ms);
   report->AddValue(StatsReport::kStatsValueNameExpandRate,
-                   talk_base::ToString<float>(info.expand_rate));
+                   rtc::ToString<float>(info.expand_rate));
   report->AddValue(StatsReport::kStatsValueNamePacketsReceived,
                    info.packets_rcvd);
   report->AddValue(StatsReport::kStatsValueNamePacketsLost,
@@ -360,7 +360,7 @@ void ExtractStats(const cricket::VoiceSenderInfo& info, StatsReport* report) {
                    info.jitter_ms);
   report->AddValue(StatsReport::kStatsValueNameRtt, info.rtt_ms);
   report->AddValue(StatsReport::kStatsValueNameEchoCancellationQualityMin,
-                   talk_base::ToString<float>(info.aec_quality_min));
+                   rtc::ToString<float>(info.aec_quality_min));
   report->AddValue(StatsReport::kStatsValueNameEchoDelayMedian,
                    info.echo_delay_median_ms);
   report->AddValue(StatsReport::kStatsValueNameEchoDelayStdDev,
@@ -671,7 +671,7 @@ StatsReport* StatsCollector::PrepareLocalReport(
     uint32 ssrc,
     const std::string& transport_id,
     TrackDirection direction) {
-  const std::string ssrc_id = talk_base::ToString<uint32>(ssrc);
+  const std::string ssrc_id = rtc::ToString<uint32>(ssrc);
   StatsMap::iterator it = reports_.find(StatsId(
       StatsReport::kStatsReportTypeSsrc, ssrc_id, direction));
 
@@ -714,7 +714,7 @@ StatsReport* StatsCollector::PrepareRemoteReport(
     uint32 ssrc,
     const std::string& transport_id,
     TrackDirection direction) {
-  const std::string ssrc_id = talk_base::ToString<uint32>(ssrc);
+  const std::string ssrc_id = rtc::ToString<uint32>(ssrc);
   StatsMap::iterator it = reports_.find(StatsId(
       StatsReport::kStatsReportTypeRemoteSsrc, ssrc_id, direction));
 
@@ -751,7 +751,7 @@ StatsReport* StatsCollector::PrepareRemoteReport(
 }
 
 std::string StatsCollector::AddOneCertificateReport(
-    const talk_base::SSLCertificate* cert, const std::string& issuer_id) {
+    const rtc::SSLCertificate* cert, const std::string& issuer_id) {
   // TODO(bemasc): Move this computation to a helper class that caches these
   // values to reduce CPU use in GetStats.  This will require adding a fast
   // SSLCertificate::Equals() method to detect certificate changes.
@@ -760,8 +760,8 @@ std::string StatsCollector::AddOneCertificateReport(
   if (!cert->GetSignatureDigestAlgorithm(&digest_algorithm))
     return std::string();
 
-  talk_base::scoped_ptr<talk_base::SSLFingerprint> ssl_fingerprint(
-      talk_base::SSLFingerprint::Create(digest_algorithm, cert));
+  rtc::scoped_ptr<rtc::SSLFingerprint> ssl_fingerprint(
+      rtc::SSLFingerprint::Create(digest_algorithm, cert));
 
   // SSLFingerprint::Create can fail if the algorithm returned by
   // SSLCertificate::GetSignatureDigestAlgorithm is not supported by the
@@ -772,10 +772,10 @@ std::string StatsCollector::AddOneCertificateReport(
 
   std::string fingerprint = ssl_fingerprint->GetRfc4572Fingerprint();
 
-  talk_base::Buffer der_buffer;
+  rtc::Buffer der_buffer;
   cert->ToDER(&der_buffer);
   std::string der_base64;
-  talk_base::Base64::EncodeFromArray(
+  rtc::Base64::EncodeFromArray(
       der_buffer.data(), der_buffer.length(), &der_base64);
 
   StatsReport report;
@@ -793,7 +793,7 @@ std::string StatsCollector::AddOneCertificateReport(
 }
 
 std::string StatsCollector::AddCertificateReports(
-    const talk_base::SSLCertificate* cert) {
+    const rtc::SSLCertificate* cert) {
   // Produces a chain of StatsReports representing this certificate and the rest
   // of its chain, and adds those reports to |reports_|.  The return value is
   // the id of the leaf report.  The provided cert must be non-null, so at least
@@ -802,14 +802,14 @@ std::string StatsCollector::AddCertificateReports(
   ASSERT(cert != NULL);
 
   std::string issuer_id;
-  talk_base::scoped_ptr<talk_base::SSLCertChain> chain;
+  rtc::scoped_ptr<rtc::SSLCertChain> chain;
   if (cert->GetChain(chain.accept())) {
     // This loop runs in reverse, i.e. from root to leaf, so that each
     // certificate's issuer's report ID is known before the child certificate's
     // report is generated.  The root certificate does not have an issuer ID
     // value.
     for (ptrdiff_t i = chain->GetSize() - 1; i >= 0; --i) {
-      const talk_base::SSLCertificate& cert_i = chain->Get(i);
+      const rtc::SSLCertificate& cert_i = chain->Get(i);
       issuer_id = AddOneCertificateReport(&cert_i, issuer_id);
     }
   }
@@ -849,14 +849,14 @@ void StatsCollector::ExtractSessionInfo() {
 
       cricket::Transport* transport =
           session_->GetTransport(transport_iter->second.content_name);
-      talk_base::scoped_ptr<talk_base::SSLIdentity> identity;
+      rtc::scoped_ptr<rtc::SSLIdentity> identity;
       if (transport && transport->GetIdentity(identity.accept())) {
         local_cert_report_id =
             AddCertificateReports(&(identity->certificate()));
       }
 
       transport = session_->GetTransport(transport_iter->second.content_name);
-      talk_base::scoped_ptr<talk_base::SSLCertificate> cert;
+      rtc::scoped_ptr<rtc::SSLCertificate> cert;
       if (transport && transport->GetRemoteCertificate(cert.accept())) {
         remote_cert_report_id = AddCertificateReports(cert.get());
       }
@@ -1018,7 +1018,7 @@ void StatsCollector::UpdateStatsFromExistingLocalAudioTracks() {
        it != local_audio_tracks_.end(); ++it) {
     AudioTrackInterface* track = it->first;
     uint32 ssrc = it->second;
-    std::string ssrc_id = talk_base::ToString<uint32>(ssrc);
+    std::string ssrc_id = rtc::ToString<uint32>(ssrc);
     StatsReport* report = GetReport(StatsReport::kStatsReportTypeSsrc,
                                     ssrc_id,
                                     kSending);
@@ -1051,10 +1051,10 @@ void StatsCollector::UpdateReportFromAudioTrack(AudioTrackInterface* track,
   int signal_level = 0;
   if (track->GetSignalLevel(&signal_level)) {
     report->ReplaceValue(StatsReport::kStatsValueNameAudioInputLevel,
-                         talk_base::ToString<int>(signal_level));
+                         rtc::ToString<int>(signal_level));
   }
 
-  talk_base::scoped_refptr<AudioProcessorInterface> audio_processor(
+  rtc::scoped_refptr<AudioProcessorInterface> audio_processor(
       track->GetAudioProcessor());
   if (audio_processor.get() == NULL)
     return;
@@ -1064,16 +1064,16 @@ void StatsCollector::UpdateReportFromAudioTrack(AudioTrackInterface* track,
   report->ReplaceValue(StatsReport::kStatsValueNameTypingNoiseState,
                        stats.typing_noise_detected ? "true" : "false");
   report->ReplaceValue(StatsReport::kStatsValueNameEchoReturnLoss,
-                       talk_base::ToString<int>(stats.echo_return_loss));
+                       rtc::ToString<int>(stats.echo_return_loss));
   report->ReplaceValue(
       StatsReport::kStatsValueNameEchoReturnLossEnhancement,
-      talk_base::ToString<int>(stats.echo_return_loss_enhancement));
+      rtc::ToString<int>(stats.echo_return_loss_enhancement));
   report->ReplaceValue(StatsReport::kStatsValueNameEchoDelayMedian,
-                       talk_base::ToString<int>(stats.echo_delay_median_ms));
+                       rtc::ToString<int>(stats.echo_delay_median_ms));
   report->ReplaceValue(StatsReport::kStatsValueNameEchoCancellationQualityMin,
-                       talk_base::ToString<float>(stats.aec_quality_min));
+                       rtc::ToString<float>(stats.aec_quality_min));
   report->ReplaceValue(StatsReport::kStatsValueNameEchoDelayStdDev,
-                       talk_base::ToString<int>(stats.echo_delay_std_ms));
+                       rtc::ToString<int>(stats.echo_delay_std_ms));
 }
 
 bool StatsCollector::GetTrackIdBySsrc(uint32 ssrc, std::string* track_id,
diff --git a/talk/app/webrtc/statscollector.h b/talk/app/webrtc/statscollector.h
index a444da4820..a039813ef3 100644
--- a/talk/app/webrtc/statscollector.h
+++ b/talk/app/webrtc/statscollector.h
@@ -93,11 +93,11 @@ class StatsCollector {
 
   // Helper method for AddCertificateReports.
   std::string AddOneCertificateReport(
-      const talk_base::SSLCertificate* cert, const std::string& issuer_id);
+      const rtc::SSLCertificate* cert, const std::string& issuer_id);
 
   // Adds a report for this certificate and every certificate in its chain, and
   // returns the leaf certificate's report's ID.
-  std::string AddCertificateReports(const talk_base::SSLCertificate* cert);
+  std::string AddCertificateReports(const rtc::SSLCertificate* cert);
 
   void ExtractSessionInfo();
   void ExtractVoiceInfo();
diff --git a/talk/app/webrtc/statscollector_unittest.cc b/talk/app/webrtc/statscollector_unittest.cc
index 72ba111d54..9441e2ddd1 100644
--- a/talk/app/webrtc/statscollector_unittest.cc
+++ b/talk/app/webrtc/statscollector_unittest.cc
@@ -33,9 +33,9 @@
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/mediastreamtrack.h"
 #include "talk/app/webrtc/videotrack.h"
-#include "talk/base/base64.h"
-#include "talk/base/fakesslidentity.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/base64.h"
+#include "webrtc/base/fakesslidentity.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/devices/fakedevicemanager.h"
 #include "talk/p2p/base/fakesession.h"
@@ -75,8 +75,8 @@ const uint32 kSsrcOfTrack = 1234;
 class MockWebRtcSession : public webrtc::WebRtcSession {
  public:
   explicit MockWebRtcSession(cricket::ChannelManager* channel_manager)
-    : WebRtcSession(channel_manager, talk_base::Thread::Current(),
-                    talk_base::Thread::Current(), NULL, NULL) {
+    : WebRtcSession(channel_manager, rtc::Thread::Current(),
+                    rtc::Thread::Current(), NULL, NULL) {
   }
   MOCK_METHOD0(voice_channel, cricket::VoiceChannel*());
   MOCK_METHOD0(video_channel, cricket::VideoChannel*());
@@ -126,7 +126,7 @@ class FakeAudioTrack
  public:
   explicit FakeAudioTrack(const std::string& id)
       : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(id),
-        processor_(new talk_base::RefCountedObject<FakeAudioProcessor>()) {}
+        processor_(new rtc::RefCountedObject<FakeAudioProcessor>()) {}
   std::string kind() const OVERRIDE {
     return "audio";
   }
@@ -139,13 +139,13 @@ class FakeAudioTrack
     *level = 1;
     return true;
   }
-  virtual talk_base::scoped_refptr<webrtc::AudioProcessorInterface>
+  virtual rtc::scoped_refptr<webrtc::AudioProcessorInterface>
       GetAudioProcessor() OVERRIDE {
     return processor_;
   }
 
  private:
-  talk_base::scoped_refptr<FakeAudioProcessor> processor_;
+  rtc::scoped_refptr<FakeAudioProcessor> processor_;
 };
 
 bool GetValue(const StatsReport* report,
@@ -216,8 +216,8 @@ std::string ExtractBweStatsValue(StatsReports reports,
 }
 
 std::string DerToPem(const std::string& der) {
-  return talk_base::SSLIdentity::DerToPem(
-        talk_base::kPemTypeCertificate,
+  return rtc::SSLIdentity::DerToPem(
+        rtc::kPemTypeCertificate,
         reinterpret_cast<const unsigned char*>(der.c_str()),
         der.length());
 }
@@ -241,8 +241,8 @@ void CheckCertChainReports(const StatsReports& reports,
     std::string der_base64;
     EXPECT_TRUE(GetValue(
         report, StatsReport::kStatsValueNameDer, &der_base64));
-    std::string der = talk_base::Base64::Decode(der_base64,
-                                                talk_base::Base64::DO_STRICT);
+    std::string der = rtc::Base64::Decode(der_base64,
+                                                rtc::Base64::DO_STRICT);
     EXPECT_EQ(ders[i], der);
 
     std::string fingerprint_algorithm;
@@ -251,7 +251,7 @@ void CheckCertChainReports(const StatsReports& reports,
         StatsReport::kStatsValueNameFingerprintAlgorithm,
         &fingerprint_algorithm));
     // The digest algorithm for a FakeSSLCertificate is always SHA-1.
-    std::string sha_1_str = talk_base::DIGEST_SHA_1;
+    std::string sha_1_str = rtc::DIGEST_SHA_1;
     EXPECT_EQ(sha_1_str, fingerprint_algorithm);
 
     std::string dummy_fingerprint;  // Value is not checked.
@@ -274,50 +274,50 @@ void VerifyVoiceReceiverInfoReport(
   std::string value_in_report;
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameAudioOutputLevel, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.audio_level), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(info.audio_level), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameBytesReceived, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int64>(info.bytes_rcvd), value_in_report);
+  EXPECT_EQ(rtc::ToString<int64>(info.bytes_rcvd), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameJitterReceived, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.jitter_ms), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(info.jitter_ms), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameJitterBufferMs, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.jitter_buffer_ms), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_ms), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNamePreferredJitterBufferMs,
       &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.jitter_buffer_preferred_ms),
+  EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_preferred_ms),
       value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameCurrentDelayMs, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.delay_estimate_ms), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(info.delay_estimate_ms), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameExpandRate, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<float>(info.expand_rate), value_in_report);
+  EXPECT_EQ(rtc::ToString<float>(info.expand_rate), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNamePacketsReceived, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.packets_rcvd), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(info.packets_rcvd), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameDecodingCTSG, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.decoding_calls_to_silence_generator),
+  EXPECT_EQ(rtc::ToString<int>(info.decoding_calls_to_silence_generator),
       value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameDecodingCTN, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.decoding_calls_to_neteq),
+  EXPECT_EQ(rtc::ToString<int>(info.decoding_calls_to_neteq),
       value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameDecodingNormal, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.decoding_normal), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(info.decoding_normal), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameDecodingPLC, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.decoding_plc), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(info.decoding_plc), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameDecodingCNG, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.decoding_cng), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(info.decoding_cng), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameDecodingPLCCNG, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(info.decoding_plc_cng), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(info.decoding_plc_cng), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameCodecName, &value_in_report));
 }
@@ -331,46 +331,46 @@ void VerifyVoiceSenderInfoReport(const StatsReport* report,
   EXPECT_EQ(sinfo.codec_name, value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameBytesSent, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int64>(sinfo.bytes_sent), value_in_report);
+  EXPECT_EQ(rtc::ToString<int64>(sinfo.bytes_sent), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNamePacketsSent, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.packets_sent), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(sinfo.packets_sent), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNamePacketsLost, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.packets_lost), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(sinfo.packets_lost), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameRtt, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.rtt_ms), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(sinfo.rtt_ms), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameRtt, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.rtt_ms), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(sinfo.rtt_ms), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameJitterReceived, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.jitter_ms), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(sinfo.jitter_ms), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameEchoCancellationQualityMin,
       &value_in_report));
-  EXPECT_EQ(talk_base::ToString<float>(sinfo.aec_quality_min), value_in_report);
+  EXPECT_EQ(rtc::ToString<float>(sinfo.aec_quality_min), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameEchoDelayMedian, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.echo_delay_median_ms),
+  EXPECT_EQ(rtc::ToString<int>(sinfo.echo_delay_median_ms),
             value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameEchoDelayStdDev, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.echo_delay_std_ms),
+  EXPECT_EQ(rtc::ToString<int>(sinfo.echo_delay_std_ms),
             value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameEchoReturnLoss, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.echo_return_loss),
+  EXPECT_EQ(rtc::ToString<int>(sinfo.echo_return_loss),
             value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameEchoReturnLossEnhancement,
       &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.echo_return_loss_enhancement),
+  EXPECT_EQ(rtc::ToString<int>(sinfo.echo_return_loss_enhancement),
             value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameAudioInputLevel, &value_in_report));
-  EXPECT_EQ(talk_base::ToString<int>(sinfo.audio_level), value_in_report);
+  EXPECT_EQ(rtc::ToString<int>(sinfo.audio_level), value_in_report);
   EXPECT_TRUE(GetValue(
       report, StatsReport::kStatsValueNameTypingNoiseState, &value_in_report));
   std::string typing_detected = sinfo.typing_noise_detected ? "true" : "false";
@@ -437,7 +437,7 @@ class StatsCollectorTest : public testing::Test {
       channel_manager_(
           new cricket::ChannelManager(media_engine_,
                                       new cricket::FakeDeviceManager(),
-                                      talk_base::Thread::Current())),
+                                      rtc::Thread::Current())),
       session_(channel_manager_.get()) {
     // By default, we ignore session GetStats calls.
     EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Return(false));
@@ -481,7 +481,7 @@ class StatsCollectorTest : public testing::Test {
     if (stream_ == NULL)
       stream_ = webrtc::MediaStream::Create("streamlabel");
 
-    audio_track_ = new talk_base::RefCountedObject<FakeAudioTrack>(
+    audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(
         kLocalTrackId);
     stream_->AddTrack(audio_track_);
     EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))
@@ -493,7 +493,7 @@ class StatsCollectorTest : public testing::Test {
     if (stream_ == NULL)
       stream_ = webrtc::MediaStream::Create("streamlabel");
 
-    audio_track_ = new talk_base::RefCountedObject<FakeAudioTrack>(
+    audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(
         kRemoteTrackId);
     stream_->AddTrack(audio_track_);
     EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))
@@ -546,7 +546,7 @@ class StatsCollectorTest : public testing::Test {
     EXPECT_EQ(audio_track->id(), track_id);
     std::string ssrc_id = ExtractSsrcStatsValue(
         *reports, StatsReport::kStatsValueNameSsrc);
-    EXPECT_EQ(talk_base::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+    EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
 
     // Verifies the values in the track report.
     if (voice_sender_info) {
@@ -568,16 +568,16 @@ class StatsCollectorTest : public testing::Test {
     EXPECT_EQ(audio_track->id(), track_id);
     ssrc_id = ExtractSsrcStatsValue(track_reports,
                                     StatsReport::kStatsValueNameSsrc);
-    EXPECT_EQ(talk_base::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+    EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
     if (voice_sender_info)
       VerifyVoiceSenderInfoReport(track_report, *voice_sender_info);
     if (voice_receiver_info)
     VerifyVoiceReceiverInfoReport(track_report, *voice_receiver_info);
   }
 
-  void TestCertificateReports(const talk_base::FakeSSLCertificate& local_cert,
+  void TestCertificateReports(const rtc::FakeSSLCertificate& local_cert,
                               const std::vector<std::string>& local_ders,
-                              const talk_base::FakeSSLCertificate& remote_cert,
+                              const rtc::FakeSSLCertificate& remote_cert,
                               const std::vector<std::string>& remote_ders) {
     webrtc::StatsCollector stats(&session_);  // Implementation under test.
     StatsReports reports;  // returned values.
@@ -595,12 +595,12 @@ class StatsCollectorTest : public testing::Test {
         transport_stats;
 
     // Fake certificates to report.
-    talk_base::FakeSSLIdentity local_identity(local_cert);
-    talk_base::scoped_ptr<talk_base::FakeSSLCertificate> remote_cert_copy(
+    rtc::FakeSSLIdentity local_identity(local_cert);
+    rtc::scoped_ptr<rtc::FakeSSLCertificate> remote_cert_copy(
         remote_cert.GetReference());
 
     // Fake transport object.
-    talk_base::scoped_ptr<cricket::FakeTransport> transport(
+    rtc::scoped_ptr<cricket::FakeTransport> transport(
         new cricket::FakeTransport(
             session_.signaling_thread(),
             session_.worker_thread(),
@@ -655,19 +655,19 @@ class StatsCollectorTest : public testing::Test {
   }
 
   cricket::FakeMediaEngine* media_engine_;
-  talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
+  rtc::scoped_ptr<cricket::ChannelManager> channel_manager_;
   MockWebRtcSession session_;
   cricket::SessionStats session_stats_;
-  talk_base::scoped_refptr<webrtc::MediaStream> stream_;
-  talk_base::scoped_refptr<webrtc::VideoTrack> track_;
-  talk_base::scoped_refptr<FakeAudioTrack> audio_track_;
+  rtc::scoped_refptr<webrtc::MediaStream> stream_;
+  rtc::scoped_refptr<webrtc::VideoTrack> track_;
+  rtc::scoped_refptr<FakeAudioTrack> audio_track_;
 };
 
 // This test verifies that 64-bit counters are passed successfully.
 TEST_F(StatsCollectorTest, BytesCounterHandles64Bits) {
   webrtc::StatsCollector stats(&session_);  // Implementation under test.
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
-  cricket::VideoChannel video_channel(talk_base::Thread::Current(),
+  cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, "", false, NULL);
   StatsReports reports;  // returned values.
   cricket::VideoSenderInfo video_sender_info;
@@ -700,7 +700,7 @@ TEST_F(StatsCollectorTest, BytesCounterHandles64Bits) {
 TEST_F(StatsCollectorTest, BandwidthEstimationInfoIsReported) {
   webrtc::StatsCollector stats(&session_);  // Implementation under test.
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
-  cricket::VideoChannel video_channel(talk_base::Thread::Current(),
+  cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, "", false, NULL);
   StatsReports reports;  // returned values.
   cricket::VideoSenderInfo video_sender_info;
@@ -776,7 +776,7 @@ TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
 TEST_F(StatsCollectorTest, TrackObjectExistsWithoutUpdateStats) {
   webrtc::StatsCollector stats(&session_);  // Implementation under test.
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
-  cricket::VideoChannel video_channel(talk_base::Thread::Current(),
+  cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, "", false, NULL);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
@@ -800,7 +800,7 @@ TEST_F(StatsCollectorTest, TrackObjectExistsWithoutUpdateStats) {
 TEST_F(StatsCollectorTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
   webrtc::StatsCollector stats(&session_);  // Implementation under test.
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
-  cricket::VideoChannel video_channel(talk_base::Thread::Current(),
+  cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, "", false, NULL);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
@@ -842,7 +842,7 @@ TEST_F(StatsCollectorTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
 
   std::string ssrc_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameSsrc);
-  EXPECT_EQ(talk_base::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+  EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
 
   std::string track_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameTrackId);
@@ -859,7 +859,7 @@ TEST_F(StatsCollectorTest, TransportObjectLinkedFromSsrcObject) {
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // The content_name known by the video channel.
   const std::string kVcName("vcname");
-  cricket::VideoChannel video_channel(talk_base::Thread::Current(),
+  cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, kVcName, false, NULL);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
@@ -905,7 +905,7 @@ TEST_F(StatsCollectorTest, RemoteSsrcInfoIsAbsent) {
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // The content_name known by the video channel.
   const std::string kVcName("vcname");
-  cricket::VideoChannel video_channel(talk_base::Thread::Current(),
+  cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, kVcName, false, NULL);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
@@ -931,7 +931,7 @@ TEST_F(StatsCollectorTest, RemoteSsrcInfoIsPresent) {
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // The content_name known by the video channel.
   const std::string kVcName("vcname");
-  cricket::VideoChannel video_channel(talk_base::Thread::Current(),
+  cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, kVcName, false, NULL);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
@@ -974,7 +974,7 @@ TEST_F(StatsCollectorTest, RemoteSsrcInfoIsPresent) {
 TEST_F(StatsCollectorTest, ReportsFromRemoteTrack) {
   webrtc::StatsCollector stats(&session_);  // Implementation under test.
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
-  cricket::VideoChannel video_channel(talk_base::Thread::Current(),
+  cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, "", false, NULL);
   AddIncomingVideoTrackStats();
   stats.AddStream(stream_);
@@ -1007,7 +1007,7 @@ TEST_F(StatsCollectorTest, ReportsFromRemoteTrack) {
 
   std::string ssrc_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameSsrc);
-  EXPECT_EQ(talk_base::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+  EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
 
   std::string track_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameTrackId);
@@ -1024,7 +1024,7 @@ TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
   local_ders[2] = "some";
   local_ders[3] = "der";
   local_ders[4] = "values";
-  talk_base::FakeSSLCertificate local_cert(DersToPems(local_ders));
+  rtc::FakeSSLCertificate local_cert(DersToPems(local_ders));
 
   // Build remote certificate chain
   std::vector<std::string> remote_ders(4);
@@ -1032,7 +1032,7 @@ TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
   remote_ders[1] = "non-";
   remote_ders[2] = "intersecting";
   remote_ders[3] = "set";
-  talk_base::FakeSSLCertificate remote_cert(DersToPems(remote_ders));
+  rtc::FakeSSLCertificate remote_cert(DersToPems(remote_ders));
 
   TestCertificateReports(local_cert, local_ders, remote_cert, remote_ders);
 }
@@ -1042,11 +1042,11 @@ TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
 TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) {
   // Build local certificate.
   std::string local_der = "This is the local der.";
-  talk_base::FakeSSLCertificate local_cert(DerToPem(local_der));
+  rtc::FakeSSLCertificate local_cert(DerToPem(local_der));
 
   // Build remote certificate.
   std::string remote_der = "This is somebody else's der.";
-  talk_base::FakeSSLCertificate remote_cert(DerToPem(remote_der));
+  rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
 
   TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
                          remote_cert, std::vector<std::string>(1, remote_der));
@@ -1117,7 +1117,7 @@ TEST_F(StatsCollectorTest, NoCertificates) {
       transport_stats;
 
   // Fake transport object.
-  talk_base::scoped_ptr<cricket::FakeTransport> transport(
+  rtc::scoped_ptr<cricket::FakeTransport> transport(
       new cricket::FakeTransport(
           session_.signaling_thread(),
           session_.worker_thread(),
@@ -1155,11 +1155,11 @@ TEST_F(StatsCollectorTest, NoCertificates) {
 TEST_F(StatsCollectorTest, UnsupportedDigestIgnored) {
   // Build a local certificate.
   std::string local_der = "This is the local der.";
-  talk_base::FakeSSLCertificate local_cert(DerToPem(local_der));
+  rtc::FakeSSLCertificate local_cert(DerToPem(local_der));
 
   // Build a remote certificate with an unsupported digest algorithm.
   std::string remote_der = "This is somebody else's der.";
-  talk_base::FakeSSLCertificate remote_cert(DerToPem(remote_der));
+  rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
   remote_cert.set_digest_algorithm("foobar");
 
   TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
@@ -1171,7 +1171,7 @@ TEST_F(StatsCollectorTest, UnsupportedDigestIgnored) {
 TEST_F(StatsCollectorTest, StatsOutputLevelVerbose) {
   webrtc::StatsCollector stats(&session_);  // Implementation under test.
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
-  cricket::VideoChannel video_channel(talk_base::Thread::Current(),
+  cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, "", false, NULL);
 
   cricket::VideoMediaInfo stats_read;
@@ -1222,7 +1222,7 @@ TEST_F(StatsCollectorTest, GetStatsFromLocalAudioTrack) {
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The content_name known by the voice channel.
   const std::string kVcName("vcname");
-  cricket::VoiceChannel voice_channel(talk_base::Thread::Current(),
+  cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, kVcName, false);
   AddOutgoingAudioTrackStats();
   stats.AddStream(stream_);
@@ -1254,7 +1254,7 @@ TEST_F(StatsCollectorTest, GetStatsFromRemoteStream) {
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The content_name known by the voice channel.
   const std::string kVcName("vcname");
-  cricket::VoiceChannel voice_channel(talk_base::Thread::Current(),
+  cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, kVcName, false);
   AddIncomingAudioTrackStats();
   stats.AddStream(stream_);
@@ -1280,7 +1280,7 @@ TEST_F(StatsCollectorTest, GetStatsAfterRemoveAudioStream) {
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The content_name known by the voice channel.
   const std::string kVcName("vcname");
-  cricket::VoiceChannel voice_channel(talk_base::Thread::Current(),
+  cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, kVcName, false);
   AddOutgoingAudioTrackStats();
   stats.AddStream(stream_);
@@ -1319,7 +1319,7 @@ TEST_F(StatsCollectorTest, GetStatsAfterRemoveAudioStream) {
   EXPECT_EQ(kLocalTrackId, track_id);
   std::string ssrc_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameSsrc);
-  EXPECT_EQ(talk_base::ToString<uint32>(kSsrcOfTrack), ssrc_id);
+  EXPECT_EQ(rtc::ToString<uint32>(kSsrcOfTrack), ssrc_id);
 
   // Verifies the values in the track report, no value will be changed by the
   // AudioTrackInterface::GetSignalValue() and
@@ -1337,7 +1337,7 @@ TEST_F(StatsCollectorTest, LocalAndRemoteTracksWithSameSsrc) {
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The content_name known by the voice channel.
   const std::string kVcName("vcname");
-  cricket::VoiceChannel voice_channel(talk_base::Thread::Current(),
+  cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, kVcName, false);
 
   // Create a local stream with a local audio track and adds it to the stats.
@@ -1346,10 +1346,10 @@ TEST_F(StatsCollectorTest, LocalAndRemoteTracksWithSameSsrc) {
   stats.AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
 
   // Create a remote stream with a remote audio track and adds it to the stats.
-  talk_base::scoped_refptr<webrtc::MediaStream> remote_stream(
+  rtc::scoped_refptr<webrtc::MediaStream> remote_stream(
       webrtc::MediaStream::Create("remotestreamlabel"));
-  talk_base::scoped_refptr<FakeAudioTrack> remote_track(
-      new talk_base::RefCountedObject<FakeAudioTrack>(kRemoteTrackId));
+  rtc::scoped_refptr<FakeAudioTrack> remote_track(
+      new rtc::RefCountedObject<FakeAudioTrack>(kRemoteTrackId));
   EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))
       .WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));
   remote_stream->AddTrack(remote_track);
@@ -1418,7 +1418,7 @@ TEST_F(StatsCollectorTest, TwoLocalTracksWithSameSsrc) {
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The content_name known by the voice channel.
   const std::string kVcName("vcname");
-  cricket::VoiceChannel voice_channel(talk_base::Thread::Current(),
+  cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, &session_, kVcName, false);
 
   // Create a local stream with a local audio track and adds it to the stats.
@@ -1441,8 +1441,8 @@ TEST_F(StatsCollectorTest, TwoLocalTracksWithSameSsrc) {
 
   // Create a new audio track and adds it to the stream and stats.
   static const std::string kNewTrackId = "new_track_id";
-  talk_base::scoped_refptr<FakeAudioTrack> new_audio_track(
-      new talk_base::RefCountedObject<FakeAudioTrack>(kNewTrackId));
+  rtc::scoped_refptr<FakeAudioTrack> new_audio_track(
+      new rtc::RefCountedObject<FakeAudioTrack>(kNewTrackId));
   EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))
       .WillOnce(DoAll(SetArgPointee<1>(kNewTrackId), Return(true)));
   stream_->AddTrack(new_audio_track);
diff --git a/talk/app/webrtc/statstypes.h b/talk/app/webrtc/statstypes.h
index 828b9f5f49..2b1317adfe 100644
--- a/talk/app/webrtc/statstypes.h
+++ b/talk/app/webrtc/statstypes.h
@@ -34,8 +34,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"
 
 namespace webrtc {
 
diff --git a/talk/app/webrtc/streamcollection.h b/talk/app/webrtc/streamcollection.h
index 7796b42660..0db59a3330 100644
--- a/talk/app/webrtc/streamcollection.h
+++ b/talk/app/webrtc/streamcollection.h
@@ -38,16 +38,16 @@ namespace webrtc {
 // Implementation of StreamCollection.
 class StreamCollection : public StreamCollectionInterface {
  public:
-  static talk_base::scoped_refptr<StreamCollection> Create() {
-    talk_base::RefCountedObject<StreamCollection>* implementation =
-         new talk_base::RefCountedObject<StreamCollection>();
+  static rtc::scoped_refptr<StreamCollection> Create() {
+    rtc::RefCountedObject<StreamCollection>* implementation =
+         new rtc::RefCountedObject<StreamCollection>();
     return implementation;
   }
 
-  static talk_base::scoped_refptr<StreamCollection> Create(
+  static rtc::scoped_refptr<StreamCollection> Create(
       StreamCollection* streams) {
-    talk_base::RefCountedObject<StreamCollection>* implementation =
-         new talk_base::RefCountedObject<StreamCollection>(streams);
+    rtc::RefCountedObject<StreamCollection>* implementation =
+         new rtc::RefCountedObject<StreamCollection>(streams);
     return implementation;
   }
 
@@ -115,7 +115,7 @@ class StreamCollection : public StreamCollectionInterface {
   explicit StreamCollection(StreamCollection* original)
       : media_streams_(original->media_streams_) {
   }
-  typedef std::vector<talk_base::scoped_refptr<MediaStreamInterface> >
+  typedef std::vector<rtc::scoped_refptr<MediaStreamInterface> >
       StreamVector;
   StreamVector media_streams_;
 };
diff --git a/talk/app/webrtc/test/fakeaudiocapturemodule.cc b/talk/app/webrtc/test/fakeaudiocapturemodule.cc
index ec155cb9c5..ff45f140a9 100644
--- a/talk/app/webrtc/test/fakeaudiocapturemodule.cc
+++ b/talk/app/webrtc/test/fakeaudiocapturemodule.cc
@@ -27,10 +27,10 @@
 
 #include "talk/app/webrtc/test/fakeaudiocapturemodule.h"
 
-#include "talk/base/common.h"
-#include "talk/base/refcount.h"
-#include "talk/base/thread.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/timeutils.h"
 
 // Audio sample value that is high enough that it doesn't occur naturally when
 // frames are being faked. E.g. NetEq will not generate this large sample value
@@ -58,7 +58,7 @@ enum {
 };
 
 FakeAudioCaptureModule::FakeAudioCaptureModule(
-    talk_base::Thread* process_thread)
+    rtc::Thread* process_thread)
     : last_process_time_ms_(0),
       audio_callback_(NULL),
       recording_(false),
@@ -77,12 +77,12 @@ FakeAudioCaptureModule::~FakeAudioCaptureModule() {
   process_thread_->Send(this, MSG_STOP_PROCESS);
 }
 
-talk_base::scoped_refptr<FakeAudioCaptureModule> FakeAudioCaptureModule::Create(
-    talk_base::Thread* process_thread) {
+rtc::scoped_refptr<FakeAudioCaptureModule> FakeAudioCaptureModule::Create(
+    rtc::Thread* process_thread) {
   if (process_thread == NULL) return NULL;
 
-  talk_base::scoped_refptr<FakeAudioCaptureModule> capture_module(
-      new talk_base::RefCountedObject<FakeAudioCaptureModule>(process_thread));
+  rtc::scoped_refptr<FakeAudioCaptureModule> capture_module(
+      new rtc::RefCountedObject<FakeAudioCaptureModule>(process_thread));
   if (!capture_module->Initialize()) {
     return NULL;
   }
@@ -90,7 +90,7 @@ talk_base::scoped_refptr<FakeAudioCaptureModule> FakeAudioCaptureModule::Create(
 }
 
 int FakeAudioCaptureModule::frames_received() const {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   return frames_received_;
 }
 
@@ -102,7 +102,7 @@ int32_t FakeAudioCaptureModule::Version(char* /*version*/,
 }
 
 int32_t FakeAudioCaptureModule::TimeUntilNextProcess() {
-  const uint32 current_time = talk_base::Time();
+  const uint32 current_time = rtc::Time();
   if (current_time < last_process_time_ms_) {
     // TODO: wraparound could be handled more gracefully.
     return 0;
@@ -115,7 +115,7 @@ int32_t FakeAudioCaptureModule::TimeUntilNextProcess() {
 }
 
 int32_t FakeAudioCaptureModule::Process() {
-  last_process_time_ms_ = talk_base::Time();
+  last_process_time_ms_ = rtc::Time();
   return 0;
 }
 
@@ -144,7 +144,7 @@ int32_t FakeAudioCaptureModule::RegisterEventObserver(
 
 int32_t FakeAudioCaptureModule::RegisterAudioCallback(
     webrtc::AudioTransport* audio_callback) {
-  talk_base::CritScope cs(&crit_callback_);
+  rtc::CritScope cs(&crit_callback_);
   audio_callback_ = audio_callback;
   return 0;
 }
@@ -249,7 +249,7 @@ int32_t FakeAudioCaptureModule::StartPlayout() {
     return -1;
   }
   {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     playing_ = true;
   }
   bool start = true;
@@ -260,7 +260,7 @@ int32_t FakeAudioCaptureModule::StartPlayout() {
 int32_t FakeAudioCaptureModule::StopPlayout() {
   bool start = false;
   {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     playing_ = false;
     start = ShouldStartProcessing();
   }
@@ -269,7 +269,7 @@ int32_t FakeAudioCaptureModule::StopPlayout() {
 }
 
 bool FakeAudioCaptureModule::Playing() const {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   return playing_;
 }
 
@@ -278,7 +278,7 @@ int32_t FakeAudioCaptureModule::StartRecording() {
     return -1;
   }
   {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     recording_ = true;
   }
   bool start = true;
@@ -289,7 +289,7 @@ int32_t FakeAudioCaptureModule::StartRecording() {
 int32_t FakeAudioCaptureModule::StopRecording() {
   bool start = false;
   {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     recording_ = false;
     start = ShouldStartProcessing();
   }
@@ -298,7 +298,7 @@ int32_t FakeAudioCaptureModule::StopRecording() {
 }
 
 bool FakeAudioCaptureModule::Recording() const {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   return recording_;
 }
 
@@ -397,13 +397,13 @@ int32_t FakeAudioCaptureModule::MicrophoneVolumeIsAvailable(
 }
 
 int32_t FakeAudioCaptureModule::SetMicrophoneVolume(uint32_t volume) {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   current_mic_level_ = volume;
   return 0;
 }
 
 int32_t FakeAudioCaptureModule::MicrophoneVolume(uint32_t* volume) const {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   *volume = current_mic_level_;
   return 0;
 }
@@ -617,7 +617,7 @@ int32_t FakeAudioCaptureModule::GetLoudspeakerStatus(bool* /*enabled*/) const {
   return 0;
 }
 
-void FakeAudioCaptureModule::OnMessage(talk_base::Message* msg) {
+void FakeAudioCaptureModule::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_START_PROCESS:
       StartProcessP();
@@ -641,7 +641,7 @@ bool FakeAudioCaptureModule::Initialize() {
   // sent to it. Note that the audio processing pipeline will likely distort the
   // original signal.
   SetSendBuffer(kHighSampleValue);
-  last_process_time_ms_ = talk_base::Time();
+  last_process_time_ms_ = rtc::Time();
   return true;
 }
 
@@ -681,7 +681,7 @@ void FakeAudioCaptureModule::UpdateProcessing(bool start) {
 }
 
 void FakeAudioCaptureModule::StartProcessP() {
-  ASSERT(talk_base::Thread::Current() == process_thread_);
+  ASSERT(rtc::Thread::Current() == process_thread_);
   if (started_) {
     // Already started.
     return;
@@ -690,16 +690,16 @@ void FakeAudioCaptureModule::StartProcessP() {
 }
 
 void FakeAudioCaptureModule::ProcessFrameP() {
-  ASSERT(talk_base::Thread::Current() == process_thread_);
+  ASSERT(rtc::Thread::Current() == process_thread_);
   if (!started_) {
-    next_frame_time_ = talk_base::Time();
+    next_frame_time_ = rtc::Time();
     started_ = true;
   }
 
   bool playing;
   bool recording;
   {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     playing = playing_;
     recording = recording_;
   }
@@ -713,16 +713,16 @@ void FakeAudioCaptureModule::ProcessFrameP() {
   }
 
   next_frame_time_ += kTimePerFrameMs;
-  const uint32 current_time = talk_base::Time();
+  const uint32 current_time = rtc::Time();
   const uint32 wait_time = (next_frame_time_ > current_time) ?
       next_frame_time_ - current_time : 0;
   process_thread_->PostDelayed(wait_time, this, MSG_RUN_PROCESS);
 }
 
 void FakeAudioCaptureModule::ReceiveFrameP() {
-  ASSERT(talk_base::Thread::Current() == process_thread_);
+  ASSERT(rtc::Thread::Current() == process_thread_);
   {
-    talk_base::CritScope cs(&crit_callback_);
+    rtc::CritScope cs(&crit_callback_);
     if (!audio_callback_) {
       return;
     }
@@ -753,14 +753,14 @@ void FakeAudioCaptureModule::ReceiveFrameP() {
   // has been received from the remote side (i.e. faked frames are not being
   // pulled).
   if (CheckRecBuffer(kHighSampleValue)) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     ++frames_received_;
   }
 }
 
 void FakeAudioCaptureModule::SendFrameP() {
-  ASSERT(talk_base::Thread::Current() == process_thread_);
-  talk_base::CritScope cs(&crit_callback_);
+  ASSERT(rtc::Thread::Current() == process_thread_);
+  rtc::CritScope cs(&crit_callback_);
   if (!audio_callback_) {
     return;
   }
@@ -780,7 +780,7 @@ void FakeAudioCaptureModule::SendFrameP() {
 }
 
 void FakeAudioCaptureModule::StopProcessP() {
-  ASSERT(talk_base::Thread::Current() == process_thread_);
+  ASSERT(rtc::Thread::Current() == process_thread_);
   started_ = false;
   process_thread_->Clear(this);
 }
diff --git a/talk/app/webrtc/test/fakeaudiocapturemodule.h b/talk/app/webrtc/test/fakeaudiocapturemodule.h
index 2267902ab3..aec3e5e1c3 100644
--- a/talk/app/webrtc/test/fakeaudiocapturemodule.h
+++ b/talk/app/webrtc/test/fakeaudiocapturemodule.h
@@ -37,22 +37,22 @@
 #ifndef TALK_APP_WEBRTC_TEST_FAKEAUDIOCAPTUREMODULE_H_
 #define TALK_APP_WEBRTC_TEST_FAKEAUDIOCAPTUREMODULE_H_
 
-#include "talk/base/basictypes.h"
-#include "talk/base/criticalsection.h"
-#include "talk/base/messagehandler.h"
-#include "talk/base/scoped_ref_ptr.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 
-namespace talk_base {
+namespace rtc {
 
 class Thread;
 
-}  // namespace talk_base
+}  // namespace rtc
 
 class FakeAudioCaptureModule
     : public webrtc::AudioDeviceModule,
-      public talk_base::MessageHandler {
+      public rtc::MessageHandler {
  public:
   typedef uint16 Sample;
 
@@ -64,8 +64,8 @@ class FakeAudioCaptureModule
   // Creates a FakeAudioCaptureModule or returns NULL on failure.
   // |process_thread| is used to push and pull audio frames to and from the
   // returned instance. Note: ownership of |process_thread| is not handed over.
-  static talk_base::scoped_refptr<FakeAudioCaptureModule> Create(
-      talk_base::Thread* process_thread);
+  static rtc::scoped_refptr<FakeAudioCaptureModule> Create(
+      rtc::Thread* process_thread);
 
   // Returns the number of frames that have been successfully pulled by the
   // instance. Note that correctly detecting success can only be done if the
@@ -201,8 +201,8 @@ class FakeAudioCaptureModule
   virtual int32_t GetLoudspeakerStatus(bool* enabled) const;
   // End of functions inherited from webrtc::AudioDeviceModule.
 
-  // The following function is inherited from talk_base::MessageHandler.
-  virtual void OnMessage(talk_base::Message* msg);
+  // The following function is inherited from rtc::MessageHandler.
+  virtual void OnMessage(rtc::Message* msg);
 
  protected:
   // The constructor is protected because the class needs to be created as a
@@ -210,7 +210,7 @@ class FakeAudioCaptureModule
   // exposed in which case the burden of proper instantiation would be put on
   // the creator of a FakeAudioCaptureModule instance. To create an instance of
   // this class use the Create(..) API.
-  explicit FakeAudioCaptureModule(talk_base::Thread* process_thread);
+  explicit FakeAudioCaptureModule(rtc::Thread* process_thread);
   // The destructor is protected because it is reference counted and should not
   // be deleted directly.
   virtual ~FakeAudioCaptureModule();
@@ -271,7 +271,7 @@ class FakeAudioCaptureModule
   uint32 next_frame_time_;
 
   // User provided thread context.
-  talk_base::Thread* process_thread_;
+  rtc::Thread* process_thread_;
 
   // Buffer for storing samples received from the webrtc::AudioTransport.
   char rec_buffer_[kNumberSamples * kNumberBytesPerSample];
@@ -285,10 +285,10 @@ class FakeAudioCaptureModule
 
   // Protects variables that are accessed from process_thread_ and
   // the main thread.
-  mutable talk_base::CriticalSection crit_;
+  mutable rtc::CriticalSection crit_;
   // Protects |audio_callback_| that is accessed from process_thread_ and
   // the main thread.
-  talk_base::CriticalSection crit_callback_;
+  rtc::CriticalSection crit_callback_;
 };
 
 #endif  // TALK_APP_WEBRTC_TEST_FAKEAUDIOCAPTUREMODULE_H_
diff --git a/talk/app/webrtc/test/fakeaudiocapturemodule_unittest.cc b/talk/app/webrtc/test/fakeaudiocapturemodule_unittest.cc
index bdd70f68fc..9e63c1cf31 100644
--- a/talk/app/webrtc/test/fakeaudiocapturemodule_unittest.cc
+++ b/talk/app/webrtc/test/fakeaudiocapturemodule_unittest.cc
@@ -29,9 +29,9 @@
 
 #include <algorithm>
 
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ref_ptr.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/thread.h"
 
 using std::min;
 
@@ -49,7 +49,7 @@ class FakeAdmTest : public testing::Test,
 
   virtual void SetUp() {
     fake_audio_capture_module_ = FakeAudioCaptureModule::Create(
-        talk_base::Thread::Current());
+        rtc::Thread::Current());
     EXPECT_TRUE(fake_audio_capture_module_.get() != NULL);
   }
 
@@ -109,7 +109,7 @@ class FakeAdmTest : public testing::Test,
   int push_iterations() const { return push_iterations_; }
   int pull_iterations() const { return pull_iterations_; }
 
-  talk_base::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+  rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
 
  private:
   bool RecordedDataReceived() const {
diff --git a/talk/app/webrtc/test/fakeconstraints.h b/talk/app/webrtc/test/fakeconstraints.h
index b23007eafc..f1b7f77b7c 100644
--- a/talk/app/webrtc/test/fakeconstraints.h
+++ b/talk/app/webrtc/test/fakeconstraints.h
@@ -32,7 +32,7 @@
 #include <vector>
 
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/stringencode.h"
 
 namespace webrtc {
 
@@ -51,7 +51,7 @@ class FakeConstraints : public webrtc::MediaConstraintsInterface {
 
   template <class T>
   void AddMandatory(const std::string& key, const T& value) {
-    mandatory_.push_back(Constraint(key, talk_base::ToString<T>(value)));
+    mandatory_.push_back(Constraint(key, rtc::ToString<T>(value)));
   }
 
   template <class T>
@@ -66,12 +66,12 @@ class FakeConstraints : public webrtc::MediaConstraintsInterface {
         }
       }
     }
-    mandatory_.push_back(Constraint(key, talk_base::ToString<T>(value)));
+    mandatory_.push_back(Constraint(key, rtc::ToString<T>(value)));
   }
 
   template <class T>
   void AddOptional(const std::string& key, const T& value) {
-    optional_.push_back(Constraint(key, talk_base::ToString<T>(value)));
+    optional_.push_back(Constraint(key, rtc::ToString<T>(value)));
   }
 
   void SetMandatoryMinAspectRatio(double ratio) {
diff --git a/talk/app/webrtc/test/fakedatachannelprovider.h b/talk/app/webrtc/test/fakedatachannelprovider.h
index 5859cdba24..2e71f9401c 100644
--- a/talk/app/webrtc/test/fakedatachannelprovider.h
+++ b/talk/app/webrtc/test/fakedatachannelprovider.h
@@ -37,7 +37,7 @@ class FakeDataChannelProvider : public webrtc::DataChannelProviderInterface {
   virtual ~FakeDataChannelProvider() {}
 
   virtual bool SendData(const cricket::SendDataParams& params,
-                        const talk_base::Buffer& payload,
+                        const rtc::Buffer& payload,
                         cricket::SendDataResult* result) OVERRIDE {
     ASSERT(ready_to_send_ && transport_available_);
     if (send_blocked_) {
diff --git a/talk/app/webrtc/test/fakedtlsidentityservice.h b/talk/app/webrtc/test/fakedtlsidentityservice.h
index 0c1a2a0c7c..57ffcf6294 100644
--- a/talk/app/webrtc/test/fakedtlsidentityservice.h
+++ b/talk/app/webrtc/test/fakedtlsidentityservice.h
@@ -65,7 +65,7 @@ static const char kCERT_PEM[] =
 using webrtc::DTLSIdentityRequestObserver;
 
 class FakeIdentityService : public webrtc::DTLSIdentityServiceInterface,
-                            public talk_base::MessageHandler {
+                            public rtc::MessageHandler {
  public:
   struct Request {
     Request(const std::string& common_name,
@@ -73,9 +73,9 @@ class FakeIdentityService : public webrtc::DTLSIdentityServiceInterface,
         : common_name(common_name), observer(observer) {}
 
     std::string common_name;
-    talk_base::scoped_refptr<DTLSIdentityRequestObserver> observer;
+    rtc::scoped_refptr<DTLSIdentityRequestObserver> observer;
   };
-  typedef talk_base::TypedMessageData<Request> MessageData;
+  typedef rtc::TypedMessageData<Request> MessageData;
 
   FakeIdentityService() : should_fail_(false) {}
 
@@ -89,9 +89,9 @@ class FakeIdentityService : public webrtc::DTLSIdentityServiceInterface,
                                DTLSIdentityRequestObserver* observer) {
     MessageData* msg = new MessageData(Request(common_name, observer));
     if (should_fail_) {
-      talk_base::Thread::Current()->Post(this, MSG_FAILURE, msg);
+      rtc::Thread::Current()->Post(this, MSG_FAILURE, msg);
     } else {
-      talk_base::Thread::Current()->Post(this, MSG_SUCCESS, msg);
+      rtc::Thread::Current()->Post(this, MSG_SUCCESS, msg);
     }
     return true;
   }
@@ -102,8 +102,8 @@ class FakeIdentityService : public webrtc::DTLSIdentityServiceInterface,
     MSG_FAILURE,
   };
 
-  // talk_base::MessageHandler implementation.
-  void OnMessage(talk_base::Message* msg) {
+  // rtc::MessageHandler implementation.
+  void OnMessage(rtc::Message* msg) {
     FakeIdentityService::MessageData* message_data =
         static_cast<FakeIdentityService::MessageData*>(msg->pdata);
     DTLSIdentityRequestObserver* observer = message_data->data().observer.get();
@@ -125,8 +125,8 @@ class FakeIdentityService : public webrtc::DTLSIdentityServiceInterface,
       const std::string& common_name,
       std::string* der_cert,
       std::string* der_key) {
-    talk_base::SSLIdentity::PemToDer("CERTIFICATE", kCERT_PEM, der_cert);
-    talk_base::SSLIdentity::PemToDer("RSA PRIVATE KEY",
+    rtc::SSLIdentity::PemToDer("CERTIFICATE", kCERT_PEM, der_cert);
+    rtc::SSLIdentity::PemToDer("RSA PRIVATE KEY",
                                      kRSA_PRIVATE_KEY_PEM,
                                      der_key);
   }
diff --git a/talk/app/webrtc/test/fakemediastreamsignaling.h b/talk/app/webrtc/test/fakemediastreamsignaling.h
index c7b30aaa50..bd125490dd 100644
--- a/talk/app/webrtc/test/fakemediastreamsignaling.h
+++ b/talk/app/webrtc/test/fakemediastreamsignaling.h
@@ -45,7 +45,7 @@ class FakeMediaStreamSignaling : public webrtc::MediaStreamSignaling,
                                  public webrtc::MediaStreamSignalingObserver {
  public:
   explicit FakeMediaStreamSignaling(cricket::ChannelManager* channel_manager) :
-    webrtc::MediaStreamSignaling(talk_base::Thread::Current(), this,
+    webrtc::MediaStreamSignaling(rtc::Thread::Current(), this,
                                  channel_manager) {
   }
 
@@ -133,21 +133,21 @@ class FakeMediaStreamSignaling : public webrtc::MediaStreamSignaling,
   }
 
  private:
-  talk_base::scoped_refptr<webrtc::MediaStreamInterface> CreateStream(
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> CreateStream(
       const std::string& stream_label,
       const std::string& audio_track_id,
       const std::string& video_track_id) {
-    talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream(
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
         webrtc::MediaStream::Create(stream_label));
 
     if (!audio_track_id.empty()) {
-      talk_base::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+      rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
           webrtc::AudioTrack::Create(audio_track_id, NULL));
       stream->AddTrack(audio_track);
     }
 
     if (!video_track_id.empty()) {
-      talk_base::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+      rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
           webrtc::VideoTrack::Create(video_track_id, NULL));
       stream->AddTrack(video_track);
     }
diff --git a/talk/app/webrtc/test/fakeperiodicvideocapturer.h b/talk/app/webrtc/test/fakeperiodicvideocapturer.h
index 7f70ae2ed8..35388403b5 100644
--- a/talk/app/webrtc/test/fakeperiodicvideocapturer.h
+++ b/talk/app/webrtc/test/fakeperiodicvideocapturer.h
@@ -31,7 +31,7 @@
 #ifndef TALK_APP_WEBRTC_TEST_FAKEPERIODICVIDEOCAPTURER_H_
 #define TALK_APP_WEBRTC_TEST_FAKEPERIODICVIDEOCAPTURER_H_
 
-#include "talk/base/thread.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/fakevideocapturer.h"
 
 namespace webrtc {
@@ -56,20 +56,20 @@ class FakePeriodicVideoCapturer : public cricket::FakeVideoCapturer {
   virtual cricket::CaptureState Start(const cricket::VideoFormat& format) {
     cricket::CaptureState state = FakeVideoCapturer::Start(format);
     if (state != cricket::CS_FAILED) {
-      talk_base::Thread::Current()->Post(this, MSG_CREATEFRAME);
+      rtc::Thread::Current()->Post(this, MSG_CREATEFRAME);
     }
     return state;
   }
   virtual void Stop() {
-    talk_base::Thread::Current()->Clear(this);
+    rtc::Thread::Current()->Clear(this);
   }
   // Inherited from MesageHandler.
-  virtual void OnMessage(talk_base::Message* msg) {
+  virtual void OnMessage(rtc::Message* msg) {
     if (msg->message_id == MSG_CREATEFRAME) {
       if (IsRunning()) {
         CaptureFrame();
-        talk_base::Thread::Current()->PostDelayed(static_cast<int>(
-            GetCaptureFormat()->interval / talk_base::kNumNanosecsPerMillisec),
+        rtc::Thread::Current()->PostDelayed(static_cast<int>(
+            GetCaptureFormat()->interval / rtc::kNumNanosecsPerMillisec),
             this, MSG_CREATEFRAME);
         }
     } else {
diff --git a/talk/app/webrtc/test/fakevideotrackrenderer.h b/talk/app/webrtc/test/fakevideotrackrenderer.h
index 0030a0c39d..5cb67a379b 100644
--- a/talk/app/webrtc/test/fakevideotrackrenderer.h
+++ b/talk/app/webrtc/test/fakevideotrackrenderer.h
@@ -62,7 +62,7 @@ class FakeVideoTrackRenderer : public VideoRendererInterface {
 
  private:
   cricket::FakeVideoRenderer fake_renderer_;
-  talk_base::scoped_refptr<VideoTrackInterface> video_track_;
+  rtc::scoped_refptr<VideoTrackInterface> video_track_;
 };
 
 }  // namespace webrtc
diff --git a/talk/app/webrtc/test/mockpeerconnectionobservers.h b/talk/app/webrtc/test/mockpeerconnectionobservers.h
index 3ae2162bc7..884c7a801d 100644
--- a/talk/app/webrtc/test/mockpeerconnectionobservers.h
+++ b/talk/app/webrtc/test/mockpeerconnectionobservers.h
@@ -61,7 +61,7 @@ class MockCreateSessionDescriptionObserver
  private:
   bool called_;
   bool result_;
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_;
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_;
 };
 
 class MockSetSessionDescriptionObserver
@@ -109,7 +109,7 @@ class MockDataChannelObserver : public webrtc::DataChannelObserver {
   size_t received_message_count() const { return received_message_count_; }
 
  private:
-  talk_base::scoped_refptr<webrtc::DataChannelInterface> channel_;
+  rtc::scoped_refptr<webrtc::DataChannelInterface> channel_;
   DataChannelInterface::DataState state_;
   std::string last_message_;
   size_t received_message_count_;
@@ -159,7 +159,7 @@ class MockStatsObserver : public webrtc::StatsObserver {
           reports_[i].values.begin();
       for (; it != reports_[i].values.end(); ++it) {
         if (it->name == name) {
-          return talk_base::FromString<int>(it->value);
+          return rtc::FromString<int>(it->value);
         }
       }
     }
diff --git a/talk/app/webrtc/test/peerconnectiontestwrapper.cc b/talk/app/webrtc/test/peerconnectiontestwrapper.cc
index be70969db9..8a4f45cc93 100644
--- a/talk/app/webrtc/test/peerconnectiontestwrapper.cc
+++ b/talk/app/webrtc/test/peerconnectiontestwrapper.cc
@@ -31,7 +31,7 @@
 #include "talk/app/webrtc/test/mockpeerconnectionobservers.h"
 #include "talk/app/webrtc/test/peerconnectiontestwrapper.h"
 #include "talk/app/webrtc/videosourceinterface.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 
 static const char kStreamLabelBase[] = "stream_label";
 static const char kVideoTrackLabelBase[] = "video_track";
@@ -83,7 +83,7 @@ bool PeerConnectionTestWrapper::CreatePc(
   }
 
   peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
-      talk_base::Thread::Current(), talk_base::Thread::Current(),
+      rtc::Thread::Current(), rtc::Thread::Current(),
       fake_audio_capture_module_, NULL, NULL);
   if (!peer_connection_factory_) {
     return false;
@@ -95,7 +95,7 @@ bool PeerConnectionTestWrapper::CreatePc(
   ice_server.uri = "stun:stun.l.google.com:19302";
   ice_servers.push_back(ice_server);
   FakeIdentityService* dtls_service =
-      talk_base::SSLStreamAdapter::HaveDtlsSrtp() ?
+      rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
           new FakeIdentityService() : NULL;
   peer_connection_ = peer_connection_factory_->CreatePeerConnection(
       ice_servers, constraints, allocator_factory_.get(), dtls_service, this);
@@ -103,7 +103,7 @@ bool PeerConnectionTestWrapper::CreatePc(
   return peer_connection_.get() != NULL;
 }
 
-talk_base::scoped_refptr<webrtc::DataChannelInterface>
+rtc::scoped_refptr<webrtc::DataChannelInterface>
 PeerConnectionTestWrapper::CreateDataChannel(
     const std::string& label,
     const webrtc::DataChannelInit& init) {
@@ -136,7 +136,7 @@ void PeerConnectionTestWrapper::OnDataChannel(
 
 void PeerConnectionTestWrapper::OnSuccess(SessionDescriptionInterface* desc) {
   // This callback should take the ownership of |desc|.
-  talk_base::scoped_ptr<SessionDescriptionInterface> owned_desc(desc);
+  rtc::scoped_ptr<SessionDescriptionInterface> owned_desc(desc);
   std::string sdp;
   EXPECT_TRUE(desc->ToString(&sdp));
 
@@ -179,8 +179,8 @@ void PeerConnectionTestWrapper::SetLocalDescription(const std::string& type,
   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
                << ": SetLocalDescription " << type << " " << sdp;
 
-  talk_base::scoped_refptr<MockSetSessionDescriptionObserver>
-      observer(new talk_base::RefCountedObject<
+  rtc::scoped_refptr<MockSetSessionDescriptionObserver>
+      observer(new rtc::RefCountedObject<
                    MockSetSessionDescriptionObserver>());
   peer_connection_->SetLocalDescription(
       observer, webrtc::CreateSessionDescription(type, sdp, NULL));
@@ -191,8 +191,8 @@ void PeerConnectionTestWrapper::SetRemoteDescription(const std::string& type,
   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
                << ": SetRemoteDescription " << type << " " << sdp;
 
-  talk_base::scoped_refptr<MockSetSessionDescriptionObserver>
-      observer(new talk_base::RefCountedObject<
+  rtc::scoped_refptr<MockSetSessionDescriptionObserver>
+      observer(new rtc::RefCountedObject<
                    MockSetSessionDescriptionObserver>());
   peer_connection_->SetRemoteDescription(
       observer, webrtc::CreateSessionDescription(type, sdp, NULL));
@@ -201,7 +201,7 @@ void PeerConnectionTestWrapper::SetRemoteDescription(const std::string& type,
 void PeerConnectionTestWrapper::AddIceCandidate(const std::string& sdp_mid,
                                                 int sdp_mline_index,
                                                 const std::string& candidate) {
-  talk_base::scoped_ptr<webrtc::IceCandidateInterface> owned_candidate(
+  rtc::scoped_ptr<webrtc::IceCandidateInterface> owned_candidate(
       webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, candidate, NULL));
   EXPECT_TRUE(peer_connection_->AddIceCandidate(owned_candidate.get()));
 }
@@ -252,19 +252,19 @@ bool PeerConnectionTestWrapper::CheckForVideo() {
 void PeerConnectionTestWrapper::GetAndAddUserMedia(
     bool audio, const webrtc::FakeConstraints& audio_constraints,
     bool video, const webrtc::FakeConstraints& video_constraints) {
-  talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream =
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
       GetUserMedia(audio, audio_constraints, video, video_constraints);
   EXPECT_TRUE(peer_connection_->AddStream(stream, NULL));
 }
 
-talk_base::scoped_refptr<webrtc::MediaStreamInterface>
+rtc::scoped_refptr<webrtc::MediaStreamInterface>
     PeerConnectionTestWrapper::GetUserMedia(
         bool audio, const webrtc::FakeConstraints& audio_constraints,
         bool video, const webrtc::FakeConstraints& video_constraints) {
   std::string label = kStreamLabelBase +
-      talk_base::ToString<int>(
+      rtc::ToString<int>(
           static_cast<int>(peer_connection_->local_streams()->count()));
-  talk_base::scoped_refptr<webrtc::MediaStreamInterface> stream =
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
       peer_connection_factory_->CreateLocalMediaStream(label);
 
   if (audio) {
@@ -272,9 +272,9 @@ talk_base::scoped_refptr<webrtc::MediaStreamInterface>
     // Disable highpass filter so that we can get all the test audio frames.
     constraints.AddMandatory(
         MediaConstraintsInterface::kHighpassFilter, false);
-    talk_base::scoped_refptr<webrtc::AudioSourceInterface> source =
+    rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
         peer_connection_factory_->CreateAudioSource(&constraints);
-    talk_base::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+    rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase,
                                                    source));
     stream->AddTrack(audio_track);
@@ -285,11 +285,11 @@ talk_base::scoped_refptr<webrtc::MediaStreamInterface>
     FakeConstraints constraints = video_constraints;
     constraints.SetMandatoryMaxFrameRate(10);
 
-    talk_base::scoped_refptr<webrtc::VideoSourceInterface> source =
+    rtc::scoped_refptr<webrtc::VideoSourceInterface> source =
         peer_connection_factory_->CreateVideoSource(
             new webrtc::FakePeriodicVideoCapturer(), &constraints);
     std::string videotrack_label = label + kVideoTrackLabelBase;
-    talk_base::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+    rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
         peer_connection_factory_->CreateVideoTrack(videotrack_label, source));
 
     stream->AddTrack(video_track);
diff --git a/talk/app/webrtc/test/peerconnectiontestwrapper.h b/talk/app/webrtc/test/peerconnectiontestwrapper.h
index 05e9b623c5..f3477cecdc 100644
--- a/talk/app/webrtc/test/peerconnectiontestwrapper.h
+++ b/talk/app/webrtc/test/peerconnectiontestwrapper.h
@@ -32,8 +32,8 @@
 #include "talk/app/webrtc/test/fakeaudiocapturemodule.h"
 #include "talk/app/webrtc/test/fakeconstraints.h"
 #include "talk/app/webrtc/test/fakevideotrackrenderer.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/thread.h"
 
 namespace webrtc {
 class PortAllocatorFactoryInterface;
@@ -52,7 +52,7 @@ class PeerConnectionTestWrapper
 
   bool CreatePc(const webrtc::MediaConstraintsInterface* constraints);
 
-  talk_base::scoped_refptr<webrtc::DataChannelInterface> CreateDataChannel(
+  rtc::scoped_refptr<webrtc::DataChannelInterface> CreateDataChannel(
       const std::string& label,
       const webrtc::DataChannelInit& init);
 
@@ -106,19 +106,19 @@ class PeerConnectionTestWrapper
   bool CheckForConnection();
   bool CheckForAudio();
   bool CheckForVideo();
-  talk_base::scoped_refptr<webrtc::MediaStreamInterface> GetUserMedia(
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> GetUserMedia(
       bool audio, const webrtc::FakeConstraints& audio_constraints,
       bool video, const webrtc::FakeConstraints& video_constraints);
 
   std::string name_;
-  talk_base::Thread audio_thread_;
-  talk_base::scoped_refptr<webrtc::PortAllocatorFactoryInterface>
+  rtc::Thread audio_thread_;
+  rtc::scoped_refptr<webrtc::PortAllocatorFactoryInterface>
       allocator_factory_;
-  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_;
-  talk_base::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
-  talk_base::scoped_ptr<webrtc::FakeVideoTrackRenderer> renderer_;
+  rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
+  rtc::scoped_ptr<webrtc::FakeVideoTrackRenderer> renderer_;
 };
 
 #endif  // TALK_APP_WEBRTC_TEST_PEERCONNECTIONTESTWRAPPER_H_
diff --git a/talk/app/webrtc/videosource.cc b/talk/app/webrtc/videosource.cc
index eb4ab97ea9..8770e6dfc5 100644
--- a/talk/app/webrtc/videosource.cc
+++ b/talk/app/webrtc/videosource.cc
@@ -93,10 +93,10 @@ void SetUpperLimitFromConstraint(
     const MediaConstraintsInterface::Constraint& constraint,
     cricket::VideoFormat* format_upper_limit) {
   if (constraint.key == MediaConstraintsInterface::kMaxWidth) {
-    int value = talk_base::FromString<int>(constraint.value);
+    int value = rtc::FromString<int>(constraint.value);
     SetUpperLimit(value, &(format_upper_limit->width));
   } else if (constraint.key == MediaConstraintsInterface::kMaxHeight) {
-    int value = talk_base::FromString<int>(constraint.value);
+    int value = rtc::FromString<int>(constraint.value);
     SetUpperLimit(value, &(format_upper_limit->height));
   }
 }
@@ -131,22 +131,22 @@ bool NewFormatWithConstraints(
   *format_out = format_in;
 
   if (constraint.key == MediaConstraintsInterface::kMinWidth) {
-    int value = talk_base::FromString<int>(constraint.value);
+    int value = rtc::FromString<int>(constraint.value);
     return (value <= format_in.width);
   } else if (constraint.key == MediaConstraintsInterface::kMaxWidth) {
-    int value = talk_base::FromString<int>(constraint.value);
+    int value = rtc::FromString<int>(constraint.value);
     return (value >= format_in.width);
   } else if (constraint.key == MediaConstraintsInterface::kMinHeight) {
-    int value = talk_base::FromString<int>(constraint.value);
+    int value = rtc::FromString<int>(constraint.value);
     return (value <= format_in.height);
   } else if (constraint.key == MediaConstraintsInterface::kMaxHeight) {
-    int value = talk_base::FromString<int>(constraint.value);
+    int value = rtc::FromString<int>(constraint.value);
     return (value >= format_in.height);
   } else if (constraint.key == MediaConstraintsInterface::kMinFrameRate) {
-    int value = talk_base::FromString<int>(constraint.value);
+    int value = rtc::FromString<int>(constraint.value);
     return (value <= cricket::VideoFormat::IntervalToFps(format_in.interval));
   } else if (constraint.key == MediaConstraintsInterface::kMaxFrameRate) {
-    int value = talk_base::FromString<int>(constraint.value);
+    int value = rtc::FromString<int>(constraint.value);
     if (value == 0) {
       if (mandatory) {
         // TODO(ronghuawu): Convert the constraint value to float when sub-1fps
@@ -163,7 +163,7 @@ bool NewFormatWithConstraints(
       return false;
     }
   } else if (constraint.key == MediaConstraintsInterface::kMinAspectRatio) {
-    double value = talk_base::FromString<double>(constraint.value);
+    double value = rtc::FromString<double>(constraint.value);
     // The aspect ratio in |constraint.value| has been converted to a string and
     // back to a double, so it may have a rounding error.
     // E.g if the value 1/3 is converted to a string, the string will not have
@@ -173,7 +173,7 @@ bool NewFormatWithConstraints(
     double ratio = static_cast<double>(format_in.width) / format_in.height;
     return  (value <= ratio + kRoundingTruncation);
   } else if (constraint.key == MediaConstraintsInterface::kMaxAspectRatio) {
-    double value = talk_base::FromString<double>(constraint.value);
+    double value = rtc::FromString<double>(constraint.value);
     double ratio = static_cast<double>(format_in.width) / format_in.height;
     // Subtract 0.0005 to avoid rounding problems. Same as above.
     const double kRoundingTruncation = 0.0005;
@@ -337,14 +337,14 @@ class FrameInputWrapper : public cricket::VideoRenderer {
 
 namespace webrtc {
 
-talk_base::scoped_refptr<VideoSource> VideoSource::Create(
+rtc::scoped_refptr<VideoSource> VideoSource::Create(
     cricket::ChannelManager* channel_manager,
     cricket::VideoCapturer* capturer,
     const webrtc::MediaConstraintsInterface* constraints) {
   ASSERT(channel_manager != NULL);
   ASSERT(capturer != NULL);
-  talk_base::scoped_refptr<VideoSource> source(
-      new talk_base::RefCountedObject<VideoSource>(channel_manager,
+  rtc::scoped_refptr<VideoSource> source(
+      new rtc::RefCountedObject<VideoSource>(channel_manager,
                                                    capturer));
   source->Initialize(constraints);
   return source;
diff --git a/talk/app/webrtc/videosource.h b/talk/app/webrtc/videosource.h
index f58b479c28..e690a5d737 100644
--- a/talk/app/webrtc/videosource.h
+++ b/talk/app/webrtc/videosource.h
@@ -32,8 +32,8 @@
 #include "talk/app/webrtc/notifier.h"
 #include "talk/app/webrtc/videosourceinterface.h"
 #include "talk/app/webrtc/videotrackrenderers.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videocommon.h"
 
@@ -61,7 +61,7 @@ class VideoSource : public Notifier<VideoSourceInterface>,
   // VideoSource take ownership of |capturer|.
   // |constraints| can be NULL and in that case the camera is opened using a
   // default resolution.
-  static talk_base::scoped_refptr<VideoSource> Create(
+  static rtc::scoped_refptr<VideoSource> Create(
       cricket::ChannelManager* channel_manager,
       cricket::VideoCapturer* capturer,
       const webrtc::MediaConstraintsInterface* constraints);
@@ -90,8 +90,8 @@ class VideoSource : public Notifier<VideoSourceInterface>,
   void SetState(SourceState new_state);
 
   cricket::ChannelManager* channel_manager_;
-  talk_base::scoped_ptr<cricket::VideoCapturer> video_capturer_;
-  talk_base::scoped_ptr<cricket::VideoRenderer> frame_input_;
+  rtc::scoped_ptr<cricket::VideoCapturer> video_capturer_;
+  rtc::scoped_ptr<cricket::VideoRenderer> frame_input_;
 
   cricket::VideoFormat format_;
   cricket::VideoOptions options_;
diff --git a/talk/app/webrtc/videosource_unittest.cc b/talk/app/webrtc/videosource_unittest.cc
index 43811760c4..38b4afa0b4 100644
--- a/talk/app/webrtc/videosource_unittest.cc
+++ b/talk/app/webrtc/videosource_unittest.cc
@@ -31,7 +31,7 @@
 #include "talk/app/webrtc/test/fakeconstraints.h"
 #include "talk/app/webrtc/remotevideocapturer.h"
 #include "talk/app/webrtc/videosource.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakevideorenderer.h"
 #include "talk/media/devices/fakedevicemanager.h"
@@ -121,7 +121,7 @@ class StateObserver : public ObserverInterface {
 
  private:
   MediaSourceInterface::SourceState state_;
-  talk_base::scoped_refptr<VideoSourceInterface> source_;
+  rtc::scoped_refptr<VideoSourceInterface> source_;
 };
 
 class VideoSourceTest : public testing::Test {
@@ -131,7 +131,7 @@ class VideoSourceTest : public testing::Test {
         capturer_(capturer_cleanup_.get()),
         channel_manager_(new cricket::ChannelManager(
           new cricket::FakeMediaEngine(),
-          new cricket::FakeDeviceManager(), talk_base::Thread::Current())) {
+          new cricket::FakeDeviceManager(), rtc::Thread::Current())) {
   }
 
   void SetUp() {
@@ -157,12 +157,12 @@ class VideoSourceTest : public testing::Test {
     source_->AddSink(&renderer_);
   }
 
-  talk_base::scoped_ptr<TestVideoCapturer> capturer_cleanup_;
+  rtc::scoped_ptr<TestVideoCapturer> capturer_cleanup_;
   TestVideoCapturer* capturer_;
   cricket::FakeVideoRenderer renderer_;
-  talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
-  talk_base::scoped_ptr<StateObserver> state_observer_;
-  talk_base::scoped_refptr<VideoSource> source_;
+  rtc::scoped_ptr<cricket::ChannelManager> channel_manager_;
+  rtc::scoped_ptr<StateObserver> state_observer_;
+  rtc::scoped_refptr<VideoSource> source_;
 };
 
 
diff --git a/talk/app/webrtc/videotrack.cc b/talk/app/webrtc/videotrack.cc
index 7ab7815ba2..8c244a64f0 100644
--- a/talk/app/webrtc/videotrack.cc
+++ b/talk/app/webrtc/videotrack.cc
@@ -64,10 +64,10 @@ bool VideoTrack::set_enabled(bool enable) {
   return MediaStreamTrack<VideoTrackInterface>::set_enabled(enable);
 }
 
-talk_base::scoped_refptr<VideoTrack> VideoTrack::Create(
+rtc::scoped_refptr<VideoTrack> VideoTrack::Create(
     const std::string& id, VideoSourceInterface* source) {
-  talk_base::RefCountedObject<VideoTrack>* track =
-      new talk_base::RefCountedObject<VideoTrack>(id, source);
+  rtc::RefCountedObject<VideoTrack>* track =
+      new rtc::RefCountedObject<VideoTrack>(id, source);
   return track;
 }
 
diff --git a/talk/app/webrtc/videotrack.h b/talk/app/webrtc/videotrack.h
index acd1b755c5..40a38f222a 100644
--- a/talk/app/webrtc/videotrack.h
+++ b/talk/app/webrtc/videotrack.h
@@ -33,13 +33,13 @@
 #include "talk/app/webrtc/mediastreamtrack.h"
 #include "talk/app/webrtc/videosourceinterface.h"
 #include "talk/app/webrtc/videotrackrenderers.h"
-#include "talk/base/scoped_ref_ptr.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 
 namespace webrtc {
 
 class VideoTrack : public MediaStreamTrack<VideoTrackInterface> {
  public:
-  static talk_base::scoped_refptr<VideoTrack> Create(
+  static rtc::scoped_refptr<VideoTrack> Create(
       const std::string& label, VideoSourceInterface* source);
 
   virtual void AddRenderer(VideoRendererInterface* renderer);
@@ -56,7 +56,7 @@ class VideoTrack : public MediaStreamTrack<VideoTrackInterface> {
 
  private:
   VideoTrackRenderers renderers_;
-  talk_base::scoped_refptr<VideoSourceInterface> video_source_;
+  rtc::scoped_refptr<VideoSourceInterface> video_source_;
 };
 
 }  // namespace webrtc
diff --git a/talk/app/webrtc/videotrack_unittest.cc b/talk/app/webrtc/videotrack_unittest.cc
index 4a30293c7e..57b883d1a7 100644
--- a/talk/app/webrtc/videotrack_unittest.cc
+++ b/talk/app/webrtc/videotrack_unittest.cc
@@ -31,8 +31,8 @@
 #include "talk/app/webrtc/remotevideocapturer.h"
 #include "talk/app/webrtc/videosource.h"
 #include "talk/app/webrtc/videotrack.h"
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/devices/fakedevicemanager.h"
 #include "talk/media/webrtc/webrtcvideoframe.h"
@@ -48,19 +48,19 @@ using webrtc::VideoTrackInterface;
 TEST(VideoTrack, RenderVideo) {
   static const char kVideoTrackId[] = "track_id";
 
-  talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
+  rtc::scoped_ptr<cricket::ChannelManager> channel_manager_;
   channel_manager_.reset(
     new cricket::ChannelManager(new cricket::FakeMediaEngine(),
                                 new cricket::FakeDeviceManager(),
-                                talk_base::Thread::Current()));
+                                rtc::Thread::Current()));
   ASSERT_TRUE(channel_manager_->Init());
-  talk_base::scoped_refptr<VideoTrackInterface> video_track(
+  rtc::scoped_refptr<VideoTrackInterface> video_track(
       VideoTrack::Create(kVideoTrackId,
                          VideoSource::Create(channel_manager_.get(),
                                              new webrtc::RemoteVideoCapturer(),
                                              NULL)));
   // FakeVideoTrackRenderer register itself to |video_track|
-  talk_base::scoped_ptr<FakeVideoTrackRenderer> renderer_1(
+  rtc::scoped_ptr<FakeVideoTrackRenderer> renderer_1(
       new FakeVideoTrackRenderer(video_track.get()));
 
   cricket::VideoRenderer* render_input = video_track->GetSource()->FrameInput();
@@ -76,7 +76,7 @@ TEST(VideoTrack, RenderVideo) {
   EXPECT_EQ(123, renderer_1->height());
 
   // FakeVideoTrackRenderer register itself to |video_track|
-  talk_base::scoped_ptr<FakeVideoTrackRenderer> renderer_2(
+  rtc::scoped_ptr<FakeVideoTrackRenderer> renderer_2(
       new FakeVideoTrackRenderer(video_track.get()));
 
   render_input->RenderFrame(&frame);
diff --git a/talk/app/webrtc/videotrackrenderers.cc b/talk/app/webrtc/videotrackrenderers.cc
index b0e0c1f547..75ce2be688 100644
--- a/talk/app/webrtc/videotrackrenderers.cc
+++ b/talk/app/webrtc/videotrackrenderers.cc
@@ -38,7 +38,7 @@ VideoTrackRenderers::~VideoTrackRenderers() {
 }
 
 void VideoTrackRenderers::AddRenderer(VideoRendererInterface* renderer) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   std::vector<RenderObserver>::iterator it =  renderers_.begin();
   for (; it != renderers_.end(); ++it) {
     if (it->renderer_ == renderer)
@@ -48,7 +48,7 @@ void VideoTrackRenderers::AddRenderer(VideoRendererInterface* renderer) {
 }
 
 void VideoTrackRenderers::RemoveRenderer(VideoRendererInterface* renderer) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   std::vector<RenderObserver>::iterator it =  renderers_.begin();
   for (; it != renderers_.end(); ++it) {
     if (it->renderer_ == renderer) {
@@ -59,12 +59,12 @@ void VideoTrackRenderers::RemoveRenderer(VideoRendererInterface* renderer) {
 }
 
 void VideoTrackRenderers::SetEnabled(bool enable) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   enabled_ = enable;
 }
 
 bool VideoTrackRenderers::SetSize(int width, int height, int reserved) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   width_ = width;
   height_ = height;
   std::vector<RenderObserver>::iterator it = renderers_.begin();
@@ -76,7 +76,7 @@ bool VideoTrackRenderers::SetSize(int width, int height, int reserved) {
 }
 
 bool VideoTrackRenderers::RenderFrame(const cricket::VideoFrame* frame) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   if (!enabled_) {
     return true;
   }
diff --git a/talk/app/webrtc/videotrackrenderers.h b/talk/app/webrtc/videotrackrenderers.h
index 4bcf6a3a14..a6ba0945b5 100644
--- a/talk/app/webrtc/videotrackrenderers.h
+++ b/talk/app/webrtc/videotrackrenderers.h
@@ -31,7 +31,7 @@
 #include <vector>
 
 #include "talk/app/webrtc/mediastreaminterface.h"
-#include "talk/base/criticalsection.h"
+#include "webrtc/base/criticalsection.h"
 #include "talk/media/base/videorenderer.h"
 
 namespace webrtc {
@@ -69,7 +69,7 @@ class VideoTrackRenderers : public cricket::VideoRenderer {
   bool enabled_;
   std::vector<RenderObserver> renderers_;
 
-  talk_base::CriticalSection critical_section_;  // Protects the above variables
+  rtc::CriticalSection critical_section_;  // Protects the above variables
 };
 
 }  // namespace webrtc
diff --git a/talk/app/webrtc/webrtcsdp.cc b/talk/app/webrtc/webrtcsdp.cc
index 997cead135..4f774a702e 100644
--- a/talk/app/webrtc/webrtcsdp.cc
+++ b/talk/app/webrtc/webrtcsdp.cc
@@ -35,10 +35,10 @@
 
 #include "talk/app/webrtc/jsepicecandidate.h"
 #include "talk/app/webrtc/jsepsessiondescription.h"
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/messagedigest.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/messagedigest.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/cryptoparams.h"
@@ -83,7 +83,7 @@ using cricket::StreamParamsVec;
 using cricket::TransportDescription;
 using cricket::TransportInfo;
 using cricket::VideoContentDescription;
-using talk_base::SocketAddress;
+using rtc::SocketAddress;
 
 typedef std::vector<RtpHeaderExtension> RtpHeaderExtensions;
 
@@ -216,7 +216,7 @@ struct SsrcInfo {
       : msid_identifier(kDefaultMsid),
         // TODO(ronghuawu): What should we do if the appdata doesn't appear?
         // Create random string (which will be used as track label later)?
-        msid_appdata(talk_base::CreateRandomString(8)) {
+        msid_appdata(rtc::CreateRandomString(8)) {
   }
   uint32 ssrc_id;
   std::string cname;
@@ -314,7 +314,7 @@ static bool ParseExtmap(const std::string& line,
                         RtpHeaderExtension* extmap,
                         SdpParseError* error);
 static bool ParseFingerprintAttribute(const std::string& line,
-                                      talk_base::SSLFingerprint** fingerprint,
+                                      rtc::SSLFingerprint** fingerprint,
                                       SdpParseError* error);
 static bool ParseDtlsSetup(const std::string& line,
                            cricket::ConnectionRole* role,
@@ -591,7 +591,7 @@ static bool GetValueFromString(const std::string& line,
                                const std::string& s,
                                T* t,
                                SdpParseError* error) {
-  if (!talk_base::FromString(s, t)) {
+  if (!rtc::FromString(s, t)) {
     std::ostringstream description;
     description << "Invalid value: " << s << ".";
     return ParseFailed(line, description.str(), error);
@@ -719,7 +719,7 @@ static void UpdateMediaDefaultDestination(
   // RFC 4566
   // m=<media> <port> <proto> <fmt> ...
   std::vector<std::string> fields;
-  talk_base::split(mline, kSdpDelimiterSpace, &fields);
+  rtc::split(mline, kSdpDelimiterSpace, &fields);
   if (fields.size() < 3) {
     return;
   }
@@ -973,7 +973,7 @@ bool ParseCandidate(const std::string& message, Candidate* candidate,
   }
 
   std::vector<std::string> fields;
-  talk_base::split(first_line.substr(start_pos),
+  rtc::split(first_line.substr(start_pos),
                    kSdpDelimiterSpace, &fields);
   // RFC 5245
   // a=candidate:<foundation> <component-id> <transport> <priority>
@@ -1085,7 +1085,7 @@ bool ParseIceOptions(const std::string& line,
     return false;
   }
   std::vector<std::string> fields;
-  talk_base::split(ice_options, kSdpDelimiterSpace, &fields);
+  rtc::split(ice_options, kSdpDelimiterSpace, &fields);
   for (size_t i = 0; i < fields.size(); ++i) {
     transport_options->push_back(fields[i]);
   }
@@ -1097,7 +1097,7 @@ bool ParseExtmap(const std::string& line, RtpHeaderExtension* extmap,
   // RFC 5285
   // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
   std::vector<std::string> fields;
-  talk_base::split(line.substr(kLinePrefixLength),
+  rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   const size_t expected_min_fields = 2;
   if (fields.size() < expected_min_fields) {
@@ -1110,7 +1110,7 @@ bool ParseExtmap(const std::string& line, RtpHeaderExtension* extmap,
     return false;
   }
   std::vector<std::string> sub_fields;
-  talk_base::split(value_direction, kSdpDelimiterSlash, &sub_fields);
+  rtc::split(value_direction, kSdpDelimiterSlash, &sub_fields);
   int value = 0;
   if (!GetValueFromString(line, sub_fields[0], &value, error)) {
     return false;
@@ -1163,7 +1163,7 @@ void BuildMediaDescription(const ContentInfo* content_info,
              video_desc->codecs().begin();
          it != video_desc->codecs().end(); ++it) {
       fmt.append(" ");
-      fmt.append(talk_base::ToString<int>(it->id));
+      fmt.append(rtc::ToString<int>(it->id));
     }
   } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     const AudioContentDescription* audio_desc =
@@ -1172,7 +1172,7 @@ void BuildMediaDescription(const ContentInfo* content_info,
              audio_desc->codecs().begin();
          it != audio_desc->codecs().end(); ++it) {
       fmt.append(" ");
-      fmt.append(talk_base::ToString<int>(it->id));
+      fmt.append(rtc::ToString<int>(it->id));
     }
   } else if (media_type == cricket::MEDIA_TYPE_DATA) {
     const DataContentDescription* data_desc =
@@ -1189,13 +1189,13 @@ void BuildMediaDescription(const ContentInfo* content_info,
         }
       }
 
-      fmt.append(talk_base::ToString<int>(sctp_port));
+      fmt.append(rtc::ToString<int>(sctp_port));
     } else {
       for (std::vector<cricket::DataCodec>::const_iterator it =
            data_desc->codecs().begin();
            it != data_desc->codecs().end(); ++it) {
         fmt.append(" ");
-        fmt.append(talk_base::ToString<int>(it->id));
+        fmt.append(rtc::ToString<int>(it->id));
       }
     }
   }
@@ -1213,7 +1213,7 @@ void BuildMediaDescription(const ContentInfo* content_info,
   const std::string port = content_info->rejected ?
       kMediaPortRejected : kDefaultPort;
 
-  talk_base::SSLFingerprint* fp = (transport_info) ?
+  rtc::SSLFingerprint* fp = (transport_info) ?
       transport_info->description.identity_fingerprint.get() : NULL;
 
   // Add the m and c lines.
@@ -1242,7 +1242,7 @@ void BuildMediaDescription(const ContentInfo* content_info,
   // Add the a=rtcp line.
   bool is_rtp =
       media_desc->protocol().empty() ||
-      talk_base::starts_with(media_desc->protocol().data(),
+      rtc::starts_with(media_desc->protocol().data(),
                              cricket::kMediaProtocolRtpPrefix);
   if (is_rtp) {
     std::string rtcp_line = GetRtcpLine(candidates);
@@ -1420,7 +1420,7 @@ void BuildRtpContentAttributes(
       std::vector<uint32>::const_iterator ssrc =
           track->ssrc_groups[i].ssrcs.begin();
       for (; ssrc != track->ssrc_groups[i].ssrcs.end(); ++ssrc) {
-        os << kSdpDelimiterSpace << talk_base::ToString<uint32>(*ssrc);
+        os << kSdpDelimiterSpace << rtc::ToString<uint32>(*ssrc);
       }
       AddLine(os.str(), message);
     }
@@ -1572,7 +1572,7 @@ bool GetParameter(const std::string& name,
   if (found == params.end()) {
     return false;
   }
-  if (!talk_base::FromString(found->second, value)) {
+  if (!rtc::FromString(found->second, value)) {
     return false;
   }
   return true;
@@ -1752,7 +1752,7 @@ bool ParseSessionDescription(const std::string& message, size_t* pos,
                                  std::string(), error);
   }
   std::vector<std::string> fields;
-  talk_base::split(line.substr(kLinePrefixLength),
+  rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   const size_t expected_fields = 6;
   if (fields.size() != expected_fields) {
@@ -1855,7 +1855,7 @@ bool ParseSessionDescription(const std::string& message, size_t* pos,
             "Can't have multiple fingerprint attributes at the same level.",
             error);
       }
-      talk_base::SSLFingerprint* fingerprint = NULL;
+      rtc::SSLFingerprint* fingerprint = NULL;
       if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
         return false;
       }
@@ -1890,7 +1890,7 @@ bool ParseGroupAttribute(const std::string& line,
   // RFC 5888 and draft-holmberg-mmusic-sdp-bundle-negotiation-00
   // a=group:BUNDLE video voice
   std::vector<std::string> fields;
-  talk_base::split(line.substr(kLinePrefixLength),
+  rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   std::string semantics;
   if (!GetValue(fields[0], kAttributeGroup, &semantics, error)) {
@@ -1905,7 +1905,7 @@ bool ParseGroupAttribute(const std::string& line,
 }
 
 static bool ParseFingerprintAttribute(const std::string& line,
-                                      talk_base::SSLFingerprint** fingerprint,
+                                      rtc::SSLFingerprint** fingerprint,
                                       SdpParseError* error) {
   if (!IsLineType(line, kLineTypeAttributes) ||
       !HasAttribute(line, kAttributeFingerprint)) {
@@ -1914,7 +1914,7 @@ static bool ParseFingerprintAttribute(const std::string& line,
   }
 
   std::vector<std::string> fields;
-  talk_base::split(line.substr(kLinePrefixLength),
+  rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   const size_t expected_fields = 2;
   if (fields.size() != expected_fields) {
@@ -1933,7 +1933,7 @@ static bool ParseFingerprintAttribute(const std::string& line,
                  ::tolower);
 
   // The second field is the digest value. De-hexify it.
-  *fingerprint = talk_base::SSLFingerprint::CreateFromRfc4572(
+  *fingerprint = rtc::SSLFingerprint::CreateFromRfc4572(
       algorithm, fields[1]);
   if (!*fingerprint) {
     return ParseFailed(line,
@@ -1950,7 +1950,7 @@ static bool ParseDtlsSetup(const std::string& line,
   // setup-attr           =  "a=setup:" role
   // role                 =  "active" / "passive" / "actpass" / "holdconn"
   std::vector<std::string> fields;
-  talk_base::split(line.substr(kLinePrefixLength), kSdpDelimiterColon, &fields);
+  rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterColon, &fields);
   const size_t expected_fields = 2;
   if (fields.size() != expected_fields) {
     return ParseFailedExpectFieldNum(line, expected_fields, error);
@@ -2095,7 +2095,7 @@ bool ParseMediaDescription(const std::string& message,
     ++mline_index;
 
     std::vector<std::string> fields;
-    talk_base::split(line.substr(kLinePrefixLength),
+    rtc::split(line.substr(kLinePrefixLength),
                      kSdpDelimiterSpace, &fields);
     const size_t expected_min_fields = 4;
     if (fields.size() < expected_min_fields) {
@@ -2139,7 +2139,7 @@ bool ParseMediaDescription(const std::string& message,
                                    session_td.identity_fingerprint.get(),
                                    Candidates());
 
-    talk_base::scoped_ptr<MediaContentDescription> content;
+    rtc::scoped_ptr<MediaContentDescription> content;
     std::string content_name;
     if (HasAttribute(line, kMediaTypeVideo)) {
       content.reset(ParseContentDescription<VideoContentDescription>(
@@ -2423,7 +2423,7 @@ bool ParseContent(const std::string& message,
 
   bool is_rtp =
       protocol.empty() ||
-      talk_base::starts_with(protocol.data(),
+      rtc::starts_with(protocol.data(),
                              cricket::kMediaProtocolRtpPrefix);
 
   // Loop until the next m line
@@ -2493,7 +2493,7 @@ bool ParseContent(const std::string& message,
         return false;
       }
     } else if (HasAttribute(line, kAttributeFingerprint)) {
-      talk_base::SSLFingerprint* fingerprint = NULL;
+      rtc::SSLFingerprint* fingerprint = NULL;
 
       if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
         return false;
@@ -2706,7 +2706,7 @@ bool ParseSsrcAttribute(const std::string& line, SsrcInfoVec* ssrc_infos,
     // draft-alvestrand-mmusic-msid-00
     // "msid:" identifier [ " " appdata ]
     std::vector<std::string> fields;
-    talk_base::split(value, kSdpDelimiterSpace, &fields);
+    rtc::split(value, kSdpDelimiterSpace, &fields);
     if (fields.size() < 1 || fields.size() > 2) {
       return ParseFailed(line,
                          "Expected format \"msid:<identifier>[ <appdata>]\".",
@@ -2735,7 +2735,7 @@ bool ParseSsrcGroupAttribute(const std::string& line,
   // RFC 5576
   // a=ssrc-group:<semantics> <ssrc-id> ...
   std::vector<std::string> fields;
-  talk_base::split(line.substr(kLinePrefixLength),
+  rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   const size_t expected_min_fields = 2;
   if (fields.size() < expected_min_fields) {
@@ -2761,7 +2761,7 @@ bool ParseCryptoAttribute(const std::string& line,
                           MediaContentDescription* media_desc,
                           SdpParseError* error) {
   std::vector<std::string> fields;
-  talk_base::split(line.substr(kLinePrefixLength),
+  rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   // RFC 4568
   // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
@@ -2828,7 +2828,7 @@ bool ParseRtpmapAttribute(const std::string& line,
                           MediaContentDescription* media_desc,
                           SdpParseError* error) {
   std::vector<std::string> fields;
-  talk_base::split(line.substr(kLinePrefixLength),
+  rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   // RFC 4566
   // a=rtpmap:<payload type> <encoding name>/<clock rate>[/<encodingparameters>]
@@ -2857,7 +2857,7 @@ bool ParseRtpmapAttribute(const std::string& line,
   }
   const std::string encoder = fields[1];
   std::vector<std::string> codec_params;
-  talk_base::split(encoder, '/', &codec_params);
+  rtc::split(encoder, '/', &codec_params);
   // <encoding name>/<clock rate>[/<encodingparameters>]
   // 2 mandatory fields
   if (codec_params.size() < 2 || codec_params.size() > 3) {
@@ -2945,7 +2945,7 @@ bool ParseFmtpAttributes(const std::string& line, const MediaType media_type,
     return true;
   }
   std::vector<std::string> fields;
-  talk_base::split(line.substr(kLinePrefixLength),
+  rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
 
   // RFC 5576
@@ -3000,7 +3000,7 @@ bool ParseRtcpFbAttribute(const std::string& line, const MediaType media_type,
     return true;
   }
   std::vector<std::string> rtcp_fb_fields;
-  talk_base::split(line.c_str(), kSdpDelimiterSpace, &rtcp_fb_fields);
+  rtc::split(line.c_str(), kSdpDelimiterSpace, &rtcp_fb_fields);
   if (rtcp_fb_fields.size() < 2) {
     return ParseFailedGetValue(line, kAttributeRtcpFb, error);
   }
diff --git a/talk/app/webrtc/webrtcsdp_unittest.cc b/talk/app/webrtc/webrtcsdp_unittest.cc
index 2d275a1c27..e018034fc8 100644
--- a/talk/app/webrtc/webrtcsdp_unittest.cc
+++ b/talk/app/webrtc/webrtcsdp_unittest.cc
@@ -31,13 +31,13 @@
 
 #include "talk/app/webrtc/jsepsessiondescription.h"
 #include "talk/app/webrtc/webrtcsdp.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/sslfingerprint.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.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/sslfingerprint.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/constants.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/session/media/mediasession.h"
@@ -390,14 +390,14 @@ static void InjectAfter(const std::string& line,
                         const std::string& newlines,
                         std::string* message) {
   const std::string tmp = line + newlines;
-  talk_base::replace_substrs(line.c_str(), line.length(),
+  rtc::replace_substrs(line.c_str(), line.length(),
                              tmp.c_str(), tmp.length(), message);
 }
 
 static void Replace(const std::string& line,
                     const std::string& newlines,
                     std::string* message) {
-  talk_base::replace_substrs(line.c_str(), line.length(),
+  rtc::replace_substrs(line.c_str(), line.length(),
                              newlines.c_str(), newlines.length(), message);
 }
 
@@ -474,7 +474,7 @@ class WebRtcSdpTest : public testing::Test {
     desc_.AddContent(kAudioContentName, NS_JINGLE_RTP, audio_desc_);
 
     // VideoContentDescription
-    talk_base::scoped_ptr<VideoContentDescription> video(
+    rtc::scoped_ptr<VideoContentDescription> video(
         new VideoContentDescription());
     video_desc_ = video.get();
     StreamParams video_stream1;
@@ -526,7 +526,7 @@ class WebRtcSdpTest : public testing::Test {
 
     // v4 host
     int port = 1234;
-    talk_base::SocketAddress address("192.168.1.5", port++);
+    rtc::SocketAddress address("192.168.1.5", port++);
     Candidate candidate1(
         "", ICE_CANDIDATE_COMPONENT_RTP, "udp", address, kCandidatePriority,
         "", "", LOCAL_PORT_TYPE,
@@ -548,7 +548,7 @@ class WebRtcSdpTest : public testing::Test {
         "", kCandidateGeneration, kCandidateFoundation1);
 
     // v6 host
-    talk_base::SocketAddress v6_address("::1", port++);
+    rtc::SocketAddress v6_address("::1", port++);
     cricket::Candidate candidate5(
         "", cricket::ICE_CANDIDATE_COMPONENT_RTP,
         "udp", v6_address, kCandidatePriority,
@@ -575,8 +575,8 @@ class WebRtcSdpTest : public testing::Test {
 
     // stun
     int port_stun = 2345;
-    talk_base::SocketAddress address_stun("74.125.127.126", port_stun++);
-    talk_base::SocketAddress rel_address_stun("192.168.1.5", port_stun++);
+    rtc::SocketAddress address_stun("74.125.127.126", port_stun++);
+    rtc::SocketAddress rel_address_stun("192.168.1.5", port_stun++);
     cricket::Candidate candidate9
         ("", cricket::ICE_CANDIDATE_COMPONENT_RTP,
          "udp", address_stun, kCandidatePriority,
@@ -595,7 +595,7 @@ class WebRtcSdpTest : public testing::Test {
 
     // relay
     int port_relay = 3456;
-    talk_base::SocketAddress address_relay("74.125.224.39", port_relay++);
+    rtc::SocketAddress address_relay("74.125.224.39", port_relay++);
     cricket::Candidate candidate11(
         "", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
         "udp", address_relay, kCandidatePriority,
@@ -865,9 +865,9 @@ class WebRtcSdpTest : public testing::Test {
     const char ice_ufragx[] = "a=xice-ufrag";
     const char ice_pwd[] = "a=ice-pwd";
     const char ice_pwdx[] = "a=xice-pwd";
-    talk_base::replace_substrs(ice_ufrag, strlen(ice_ufrag),
+    rtc::replace_substrs(ice_ufrag, strlen(ice_ufrag),
         ice_ufragx, strlen(ice_ufragx), sdp);
-    talk_base::replace_substrs(ice_pwd, strlen(ice_pwd),
+    rtc::replace_substrs(ice_pwd, strlen(ice_pwd),
         ice_pwdx, strlen(ice_pwdx), sdp);
     return true;
   }
@@ -917,7 +917,7 @@ class WebRtcSdpTest : public testing::Test {
   void AddFingerprint() {
     desc_.RemoveTransportInfoByName(kAudioContentName);
     desc_.RemoveTransportInfoByName(kVideoContentName);
-    talk_base::SSLFingerprint fingerprint(talk_base::DIGEST_SHA_1,
+    rtc::SSLFingerprint fingerprint(rtc::DIGEST_SHA_1,
                                           kIdentityDigest,
                                           sizeof(kIdentityDigest));
     EXPECT_TRUE(desc_.AddTransportInfo(
@@ -1001,7 +1001,7 @@ class WebRtcSdpTest : public testing::Test {
   }
 
   void AddSctpDataChannel() {
-    talk_base::scoped_ptr<DataContentDescription> data(
+    rtc::scoped_ptr<DataContentDescription> data(
         new DataContentDescription());
     data_desc_ = data.get();
     data_desc_->set_protocol(cricket::kMediaProtocolDtlsSctp);
@@ -1018,7 +1018,7 @@ class WebRtcSdpTest : public testing::Test {
   }
 
   void AddRtpDataChannel() {
-    talk_base::scoped_ptr<DataContentDescription> data(
+    rtc::scoped_ptr<DataContentDescription> data(
         new DataContentDescription());
     data_desc_ = data.get();
 
@@ -1119,7 +1119,7 @@ class WebRtcSdpTest : public testing::Test {
       const std::string& name, int expected_value) {
     cricket::CodecParameterMap::const_iterator found = params.find(name);
     ASSERT_TRUE(found != params.end());
-    EXPECT_EQ(found->second, talk_base::ToString<int>(expected_value));
+    EXPECT_EQ(found->second, rtc::ToString<int>(expected_value));
   }
 
   void TestDeserializeCodecParams(const CodecParams& params,
@@ -1287,7 +1287,7 @@ class WebRtcSdpTest : public testing::Test {
   VideoContentDescription* video_desc_;
   DataContentDescription* data_desc_;
   Candidates candidates_;
-  talk_base::scoped_ptr<IceCandidateInterface> jcandidate_;
+  rtc::scoped_ptr<IceCandidateInterface> jcandidate_;
   JsepSessionDescription jdesc_;
 };
 
@@ -1509,10 +1509,10 @@ TEST_F(WebRtcSdpTest, SerializeWithSctpDataChannelAndNewPort) {
 
   char default_portstr[16];
   char new_portstr[16];
-  talk_base::sprintfn(default_portstr, sizeof(default_portstr), "%d",
+  rtc::sprintfn(default_portstr, sizeof(default_portstr), "%d",
                       kDefaultSctpPort);
-  talk_base::sprintfn(new_portstr, sizeof(new_portstr), "%d", kNewPort);
-  talk_base::replace_substrs(default_portstr, strlen(default_portstr),
+  rtc::sprintfn(new_portstr, sizeof(new_portstr), "%d", kNewPort);
+  rtc::replace_substrs(default_portstr, strlen(default_portstr),
                              new_portstr, strlen(new_portstr),
                              &expected_sdp);
 
@@ -1946,9 +1946,9 @@ TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelAndNewPort) {
   const uint16 kUnusualSctpPort = 9556;
   char default_portstr[16];
   char unusual_portstr[16];
-  talk_base::sprintfn(default_portstr, sizeof(default_portstr), "%d",
+  rtc::sprintfn(default_portstr, sizeof(default_portstr), "%d",
                       kDefaultSctpPort);
-  talk_base::sprintfn(unusual_portstr, sizeof(unusual_portstr), "%d",
+  rtc::sprintfn(unusual_portstr, sizeof(unusual_portstr), "%d",
                       kUnusualSctpPort);
 
   // First setup the expected JsepSessionDescription.
@@ -1970,7 +1970,7 @@ TEST_F(WebRtcSdpTest, DeserializeSdpWithSctpDataChannelAndNewPort) {
   // Then get the deserialized JsepSessionDescription.
   std::string sdp_with_data = kSdpString;
   sdp_with_data.append(kSdpSctpDataChannelString);
-  talk_base::replace_substrs(default_portstr, strlen(default_portstr),
+  rtc::replace_substrs(default_portstr, strlen(default_portstr),
                              unusual_portstr, strlen(unusual_portstr),
                              &sdp_with_data);
   JsepSessionDescription jdesc_output(kDummyString);
diff --git a/talk/app/webrtc/webrtcsession.cc b/talk/app/webrtc/webrtcsession.cc
index 6f745fc423..17b05de844 100644
--- a/talk/app/webrtc/webrtcsession.cc
+++ b/talk/app/webrtc/webrtcsession.cc
@@ -38,10 +38,10 @@
 #include "talk/app/webrtc/mediastreamsignaling.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
 #include "talk/app/webrtc/webrtcsessiondescriptionfactory.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/session/media/channel.h"
@@ -381,7 +381,7 @@ static void SetOptionFromOptionalConstraint(
   std::string string_value;
   T value;
   if (constraints->GetOptional().FindFirst(key, &string_value)) {
-    if (talk_base::FromString(string_value, &value)) {
+    if (rtc::FromString(string_value, &value)) {
       option->Set(value);
     }
   }
@@ -447,12 +447,12 @@ class IceRestartAnswerLatch {
 
 WebRtcSession::WebRtcSession(
     cricket::ChannelManager* channel_manager,
-    talk_base::Thread* signaling_thread,
-    talk_base::Thread* worker_thread,
+    rtc::Thread* signaling_thread,
+    rtc::Thread* worker_thread,
     cricket::PortAllocator* port_allocator,
     MediaStreamSignaling* mediastream_signaling)
     : cricket::BaseSession(signaling_thread, worker_thread, port_allocator,
-                           talk_base::ToString(talk_base::CreateRandomId64() &
+                           rtc::ToString(rtc::CreateRandomId64() &
                                                LLONG_MAX),
                            cricket::NS_JINGLE_RTP, false),
       // RFC 3264: The numeric value of the session id and version in the
@@ -673,7 +673,7 @@ cricket::SecurePolicy WebRtcSession::SdesPolicy() const {
   return webrtc_session_desc_factory_->SdesPolicy();
 }
 
-bool WebRtcSession::GetSslRole(talk_base::SSLRole* role) {
+bool WebRtcSession::GetSslRole(rtc::SSLRole* role) {
   if (local_description() == NULL || remote_description() == NULL) {
     LOG(LS_INFO) << "Local and Remote descriptions must be applied to get "
                  << "SSL Role of the session.";
@@ -706,7 +706,7 @@ void WebRtcSession::CreateAnswer(CreateSessionDescriptionObserver* observer,
 bool WebRtcSession::SetLocalDescription(SessionDescriptionInterface* desc,
                                         std::string* err_desc) {
   // Takes the ownership of |desc| regardless of the result.
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_temp(desc);
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_temp(desc);
 
   // Validate SDP.
   if (!ValidateSessionDescription(desc, cricket::CS_LOCAL, err_desc)) {
@@ -751,7 +751,7 @@ bool WebRtcSession::SetLocalDescription(SessionDescriptionInterface* desc,
   // local session description.
   mediastream_signaling_->OnLocalDescriptionChanged(local_desc_.get());
 
-  talk_base::SSLRole role;
+  rtc::SSLRole role;
   if (data_channel_type_ == cricket::DCT_SCTP && GetSslRole(&role)) {
     mediastream_signaling_->OnDtlsRoleReadyForSctp(role);
   }
@@ -764,7 +764,7 @@ bool WebRtcSession::SetLocalDescription(SessionDescriptionInterface* desc,
 bool WebRtcSession::SetRemoteDescription(SessionDescriptionInterface* desc,
                                          std::string* err_desc) {
   // Takes the ownership of |desc| regardless of the result.
-  talk_base::scoped_ptr<SessionDescriptionInterface> desc_temp(desc);
+  rtc::scoped_ptr<SessionDescriptionInterface> desc_temp(desc);
 
   // Validate SDP.
   if (!ValidateSessionDescription(desc, cricket::CS_REMOTE, err_desc)) {
@@ -807,7 +807,7 @@ bool WebRtcSession::SetRemoteDescription(SessionDescriptionInterface* desc,
                                                desc);
   remote_desc_.reset(desc_temp.release());
 
-  talk_base::SSLRole role;
+  rtc::SSLRole role;
   if (data_channel_type_ == cricket::DCT_SCTP && GetSslRole(&role)) {
     mediastream_signaling_->OnDtlsRoleReadyForSctp(role);
   }
@@ -1082,7 +1082,7 @@ sigslot::signal0<>* WebRtcSession::GetOnDestroyedSignal() {
 }
 
 bool WebRtcSession::SendData(const cricket::SendDataParams& params,
-                             const talk_base::Buffer& payload,
+                             const rtc::Buffer& payload,
                              cricket::SendDataResult* result) {
   if (!data_channel_.get()) {
     LOG(LS_ERROR) << "SendData called when data_channel_ is NULL.";
@@ -1137,7 +1137,7 @@ bool WebRtcSession::ReadyToSendData() const {
   return data_channel_.get() && data_channel_->ready_to_send_data();
 }
 
-talk_base::scoped_refptr<DataChannel> WebRtcSession::CreateDataChannel(
+rtc::scoped_refptr<DataChannel> WebRtcSession::CreateDataChannel(
     const std::string& label,
     const InternalDataChannelInit* config) {
   if (state() == STATE_RECEIVEDTERMINATE) {
@@ -1151,7 +1151,7 @@ talk_base::scoped_refptr<DataChannel> WebRtcSession::CreateDataChannel(
       config ? (*config) : InternalDataChannelInit();
   if (data_channel_type_ == cricket::DCT_SCTP) {
     if (new_config.id < 0) {
-      talk_base::SSLRole role;
+      rtc::SSLRole role;
       if (GetSslRole(&role) &&
           !mediastream_signaling_->AllocateSctpSid(role, &new_config.id)) {
         LOG(LS_ERROR) << "No id can be allocated for the SCTP data channel.";
@@ -1164,7 +1164,7 @@ talk_base::scoped_refptr<DataChannel> WebRtcSession::CreateDataChannel(
     }
   }
 
-  talk_base::scoped_refptr<DataChannel> channel(DataChannel::Create(
+  rtc::scoped_refptr<DataChannel> channel(DataChannel::Create(
       this, data_channel_type_, label, new_config));
   if (channel && !mediastream_signaling_->AddDataChannel(channel))
     return NULL;
@@ -1184,7 +1184,7 @@ void WebRtcSession::ResetIceRestartLatch() {
   ice_restart_latch_->Reset();
 }
 
-void WebRtcSession::OnIdentityReady(talk_base::SSLIdentity* identity) {
+void WebRtcSession::OnIdentityReady(rtc::SSLIdentity* identity) {
   SetIdentity(identity);
 }
 
@@ -1551,7 +1551,7 @@ void WebRtcSession::CopySavedCandidates(
 void WebRtcSession::OnDataChannelMessageReceived(
     cricket::DataChannel* channel,
     const cricket::ReceiveDataParams& params,
-    const talk_base::Buffer& payload) {
+    const rtc::Buffer& payload) {
   ASSERT(data_channel_type_ == cricket::DCT_SCTP);
   if (params.type == cricket::DMT_CONTROL &&
       mediastream_signaling_->IsSctpSidAvailable(params.ssrc)) {
diff --git a/talk/app/webrtc/webrtcsession.h b/talk/app/webrtc/webrtcsession.h
index 63e0cc4b99..efab75ca7e 100644
--- a/talk/app/webrtc/webrtcsession.h
+++ b/talk/app/webrtc/webrtcsession.h
@@ -35,8 +35,8 @@
 #include "talk/app/webrtc/mediastreamprovider.h"
 #include "talk/app/webrtc/datachannel.h"
 #include "talk/app/webrtc/statstypes.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/p2p/base/session.h"
 #include "talk/session/media/mediasession.h"
@@ -106,8 +106,8 @@ class WebRtcSession : public cricket::BaseSession,
                       public DataChannelProviderInterface {
  public:
   WebRtcSession(cricket::ChannelManager* channel_manager,
-                talk_base::Thread* signaling_thread,
-                talk_base::Thread* worker_thread,
+                rtc::Thread* signaling_thread,
+                rtc::Thread* worker_thread,
                 cricket::PortAllocator* port_allocator,
                 MediaStreamSignaling* mediastream_signaling);
   virtual ~WebRtcSession();
@@ -138,7 +138,7 @@ class WebRtcSession : public cricket::BaseSession,
   cricket::SecurePolicy SdesPolicy() const;
 
   // Get current ssl role from transport.
-  bool GetSslRole(talk_base::SSLRole* role);
+  bool GetSslRole(rtc::SSLRole* role);
 
   // Generic error message callback from WebRtcSession.
   // TODO - It may be necessary to supply error code as well.
@@ -195,7 +195,7 @@ class WebRtcSession : public cricket::BaseSession,
 
   // Implements DataChannelProviderInterface.
   virtual bool SendData(const cricket::SendDataParams& params,
-                        const talk_base::Buffer& payload,
+                        const rtc::Buffer& payload,
                         cricket::SendDataResult* result) OVERRIDE;
   virtual bool ConnectDataChannel(DataChannel* webrtc_data_channel) OVERRIDE;
   virtual void DisconnectDataChannel(DataChannel* webrtc_data_channel) OVERRIDE;
@@ -204,7 +204,7 @@ class WebRtcSession : public cricket::BaseSession,
   virtual bool ReadyToSendData() const OVERRIDE;
 
   // Implements DataChannelFactory.
-  talk_base::scoped_refptr<DataChannel> CreateDataChannel(
+  rtc::scoped_refptr<DataChannel> CreateDataChannel(
       const std::string& label,
       const InternalDataChannelInit* config) OVERRIDE;
 
@@ -216,7 +216,7 @@ class WebRtcSession : public cricket::BaseSession,
 
   // Called when an SSLIdentity is generated or retrieved by
   // WebRTCSessionDescriptionFactory. Should happen before setLocalDescription.
-  void OnIdentityReady(talk_base::SSLIdentity* identity);
+  void OnIdentityReady(rtc::SSLIdentity* identity);
 
   // For unit test.
   bool waiting_for_identity() const;
@@ -289,7 +289,7 @@ class WebRtcSession : public cricket::BaseSession,
   // messages.
   void OnDataChannelMessageReceived(cricket::DataChannel* channel,
                                     const cricket::ReceiveDataParams& params,
-                                    const talk_base::Buffer& payload);
+                                    const rtc::Buffer& payload);
 
   std::string BadStateErrMsg(State state);
   void SetIceConnectionState(PeerConnectionInterface::IceConnectionState state);
@@ -319,15 +319,15 @@ class WebRtcSession : public cricket::BaseSession,
 
   std::string GetSessionErrorMsg();
 
-  talk_base::scoped_ptr<cricket::VoiceChannel> voice_channel_;
-  talk_base::scoped_ptr<cricket::VideoChannel> video_channel_;
-  talk_base::scoped_ptr<cricket::DataChannel> data_channel_;
+  rtc::scoped_ptr<cricket::VoiceChannel> voice_channel_;
+  rtc::scoped_ptr<cricket::VideoChannel> video_channel_;
+  rtc::scoped_ptr<cricket::DataChannel> data_channel_;
   cricket::ChannelManager* channel_manager_;
   MediaStreamSignaling* mediastream_signaling_;
   IceObserver* ice_observer_;
   PeerConnectionInterface::IceConnectionState ice_connection_state_;
-  talk_base::scoped_ptr<SessionDescriptionInterface> local_desc_;
-  talk_base::scoped_ptr<SessionDescriptionInterface> remote_desc_;
+  rtc::scoped_ptr<SessionDescriptionInterface> local_desc_;
+  rtc::scoped_ptr<SessionDescriptionInterface> remote_desc_;
   // Candidates that arrived before the remote description was set.
   std::vector<IceCandidateInterface*> saved_candidates_;
   // If the remote peer is using a older version of implementation.
@@ -341,9 +341,9 @@ class WebRtcSession : public cricket::BaseSession,
   // 2. If constraint kEnableRtpDataChannels is true, RTP is allowed (DCT_RTP);
   // 3. If both 1&2 are false, data channel is not allowed (DCT_NONE).
   cricket::DataChannelType data_channel_type_;
-  talk_base::scoped_ptr<IceRestartAnswerLatch> ice_restart_latch_;
+  rtc::scoped_ptr<IceRestartAnswerLatch> ice_restart_latch_;
 
-  talk_base::scoped_ptr<WebRtcSessionDescriptionFactory>
+  rtc::scoped_ptr<WebRtcSessionDescriptionFactory>
       webrtc_session_desc_factory_;
 
   sigslot::signal0<> SignalVoiceChannelDestroyed;
diff --git a/talk/app/webrtc/webrtcsession_unittest.cc b/talk/app/webrtc/webrtcsession_unittest.cc
index 460d4a4e23..51f0c038b5 100644
--- a/talk/app/webrtc/webrtcsession_unittest.cc
+++ b/talk/app/webrtc/webrtcsession_unittest.cc
@@ -36,17 +36,17 @@
 #include "talk/app/webrtc/test/fakemediastreamsignaling.h"
 #include "talk/app/webrtc/webrtcsession.h"
 #include "talk/app/webrtc/webrtcsessiondescriptionfactory.h"
-#include "talk/base/fakenetwork.h"
-#include "talk/base/firewallsocketserver.h"
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/network.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/sslstreamadapter.h"
-#include "talk/base/stringutils.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/logging.h"
+#include "webrtc/base/network.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/sslstreamadapter.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/virtualsocketserver.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakevideorenderer.h"
 #include "talk/media/base/mediachannel.h"
@@ -71,9 +71,9 @@ using cricket::FakeVoiceMediaChannel;
 using cricket::NS_GINGLE_P2P;
 using cricket::NS_JINGLE_ICE_UDP;
 using cricket::TransportInfo;
-using talk_base::SocketAddress;
-using talk_base::scoped_ptr;
-using talk_base::Thread;
+using rtc::SocketAddress;
+using rtc::scoped_ptr;
+using rtc::Thread;
 using webrtc::CreateSessionDescription;
 using webrtc::CreateSessionDescriptionObserver;
 using webrtc::CreateSessionDescriptionRequest;
@@ -133,7 +133,7 @@ static void InjectAfter(const std::string& line,
                         const std::string& newlines,
                         std::string* message) {
   const std::string tmp = line + newlines;
-  talk_base::replace_substrs(line.c_str(), line.length(),
+  rtc::replace_substrs(line.c_str(), line.length(),
                              tmp.c_str(), tmp.length(), message);
 }
 
@@ -203,8 +203,8 @@ class MockIceObserver : public webrtc::IceObserver {
 class WebRtcSessionForTest : public webrtc::WebRtcSession {
  public:
   WebRtcSessionForTest(cricket::ChannelManager* cmgr,
-                       talk_base::Thread* signaling_thread,
-                       talk_base::Thread* worker_thread,
+                       rtc::Thread* signaling_thread,
+                       rtc::Thread* worker_thread,
                        cricket::PortAllocator* port_allocator,
                        webrtc::IceObserver* ice_observer,
                        webrtc::MediaStreamSignaling* mediastream_signaling)
@@ -223,7 +223,7 @@ class WebRtcSessionForTest : public webrtc::WebRtcSession {
 };
 
 class WebRtcSessionCreateSDPObserverForTest
-    : public talk_base::RefCountedObject<CreateSessionDescriptionObserver> {
+    : public rtc::RefCountedObject<CreateSessionDescriptionObserver> {
  public:
   enum State {
     kInit,
@@ -253,7 +253,7 @@ class WebRtcSessionCreateSDPObserverForTest
   ~WebRtcSessionCreateSDPObserverForTest() {}
 
  private:
-  talk_base::scoped_ptr<SessionDescriptionInterface> description_;
+  rtc::scoped_ptr<SessionDescriptionInterface> description_;
   State state_;
 };
 
@@ -294,15 +294,15 @@ class WebRtcSessionTest : public testing::Test {
       device_manager_(new cricket::FakeDeviceManager()),
       channel_manager_(new cricket::ChannelManager(
          media_engine_, data_engine_, device_manager_,
-         new cricket::CaptureManager(), talk_base::Thread::Current())),
+         new cricket::CaptureManager(), rtc::Thread::Current())),
       tdesc_factory_(new cricket::TransportDescriptionFactory()),
       desc_factory_(new cricket::MediaSessionDescriptionFactory(
           channel_manager_.get(), tdesc_factory_.get())),
-      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()),
-      stun_socket_addr_(talk_base::SocketAddress(kStunAddrHost,
+      stun_socket_addr_(rtc::SocketAddress(kStunAddrHost,
                                                  cricket::STUN_SERVER_PORT)),
       stun_server_(Thread::Current(), stun_socket_addr_),
       turn_server_(Thread::Current(), kTurnUdpIntAddr, kTurnUdpExtAddr),
@@ -325,11 +325,11 @@ class WebRtcSessionTest : public testing::Test {
   }
 
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   void AddInterface(const SocketAddress& addr) {
@@ -343,8 +343,8 @@ class WebRtcSessionTest : public testing::Test {
   void Init(DTLSIdentityServiceInterface* identity_service) {
     ASSERT_TRUE(session_.get() == NULL);
     session_.reset(new WebRtcSessionForTest(
-        channel_manager_.get(), talk_base::Thread::Current(),
-        talk_base::Thread::Current(), allocator_.get(),
+        channel_manager_.get(), rtc::Thread::Current(),
+        rtc::Thread::Current(), allocator_.get(),
         &observer_,
         &mediastream_signaling_));
 
@@ -387,7 +387,7 @@ class WebRtcSessionTest : public testing::Test {
 
   SessionDescriptionInterface* CreateOffer(
       const webrtc::MediaConstraintsInterface* constraints) {
-    talk_base::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
+    rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
         observer = new WebRtcSessionCreateSDPObserverForTest();
     session_->CreateOffer(observer, constraints);
     EXPECT_TRUE_WAIT(
@@ -398,7 +398,7 @@ class WebRtcSessionTest : public testing::Test {
 
   SessionDescriptionInterface* CreateAnswer(
       const webrtc::MediaConstraintsInterface* constraints) {
-    talk_base::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observer
+    rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observer
         = new WebRtcSessionCreateSDPObserverForTest();
     session_->CreateAnswer(observer, constraints);
     EXPECT_TRUE_WAIT(
@@ -482,8 +482,8 @@ class WebRtcSessionTest : public testing::Test {
   void SetFactoryDtlsSrtp() {
     desc_factory_->set_secure(cricket::SEC_DISABLED);
     std::string identity_name = "WebRTC" +
-        talk_base::ToString(talk_base::CreateRandomId());
-    identity_.reset(talk_base::SSLIdentity::Generate(identity_name));
+        rtc::ToString(rtc::CreateRandomId());
+    identity_.reset(rtc::SSLIdentity::Generate(identity_name));
     tdesc_factory_->set_identity(identity_.get());
     tdesc_factory_->set_secure(cricket::SEC_REQUIRED);
   }
@@ -571,10 +571,10 @@ class WebRtcSessionTest : public testing::Test {
           + "\r\n";
       std::string pwd_line = "a=ice-pwd:" + transport_desc->ice_pwd
           + "\r\n";
-      talk_base::replace_substrs(ufrag_line.c_str(), ufrag_line.length(),
+      rtc::replace_substrs(ufrag_line.c_str(), ufrag_line.length(),
                                  "", 0,
                                  sdp);
-      talk_base::replace_substrs(pwd_line.c_str(), pwd_line.length(),
+      rtc::replace_substrs(pwd_line.c_str(), pwd_line.length(),
                                  "", 0,
                                  sdp);
     }
@@ -600,10 +600,10 @@ class WebRtcSessionTest : public testing::Test {
           + "\r\n";
       std::string mod_ufrag = "a=ice-ufrag:" + modified_ice_ufrag + "\r\n";
       std::string mod_pwd = "a=ice-pwd:" + modified_ice_pwd + "\r\n";
-      talk_base::replace_substrs(ufrag_line.c_str(), ufrag_line.length(),
+      rtc::replace_substrs(ufrag_line.c_str(), ufrag_line.length(),
                                  mod_ufrag.c_str(), mod_ufrag.length(),
                                  sdp);
-      talk_base::replace_substrs(pwd_line.c_str(), pwd_line.length(),
+      rtc::replace_substrs(pwd_line.c_str(), pwd_line.length(),
                                  mod_pwd.c_str(), mod_pwd.length(),
                                  sdp);
     }
@@ -702,7 +702,7 @@ class WebRtcSessionTest : public testing::Test {
     options.has_video = true;
     options.bundle_enabled = true;
 
-    talk_base::scoped_ptr<SessionDescriptionInterface> temp_offer(
+    rtc::scoped_ptr<SessionDescriptionInterface> temp_offer(
         CreateRemoteOffer(options, cricket::SEC_ENABLED));
 
     *nodtls_answer =
@@ -723,7 +723,7 @@ class WebRtcSessionTest : public testing::Test {
         cricket::SecurePolicy secure_policy,
         const std::string& session_version,
         const SessionDescriptionInterface* current_desc) {
-    std::string session_id = talk_base::ToString(talk_base::CreateRandomId64());
+    std::string session_id = rtc::ToString(rtc::CreateRandomId64());
     const cricket::SessionDescription* cricket_desc = NULL;
     if (current_desc) {
       cricket_desc = current_desc->description();
@@ -773,10 +773,10 @@ class WebRtcSessionTest : public testing::Test {
     // SessionDescription from the mutated string.
     const char* default_port_str = "5000";
     char new_port_str[16];
-    talk_base::sprintfn(new_port_str, sizeof(new_port_str), "%d", new_port);
+    rtc::sprintfn(new_port_str, sizeof(new_port_str), "%d", new_port);
     std::string offer_str;
     offer_basis->ToString(&offer_str);
-    talk_base::replace_substrs(default_port_str, strlen(default_port_str),
+    rtc::replace_substrs(default_port_str, strlen(default_port_str),
                                new_port_str, strlen(new_port_str),
                                &offer_str);
     JsepSessionDescription* offer = new JsepSessionDescription(
@@ -800,7 +800,7 @@ class WebRtcSessionTest : public testing::Test {
       cricket::SecurePolicy policy) {
     desc_factory_->set_secure(policy);
     const std::string session_id =
-        talk_base::ToString(talk_base::CreateRandomId64());
+        rtc::ToString(rtc::CreateRandomId64());
     JsepSessionDescription* answer(
         new JsepSessionDescription(JsepSessionDescription::kAnswer));
     if (!answer->Initialize(desc_factory_->CreateAnswer(offer->description(),
@@ -830,7 +830,7 @@ class WebRtcSessionTest : public testing::Test {
   }
 
   void TestSessionCandidatesWithBundleRtcpMux(bool bundle, bool rtcp_mux) {
-    AddInterface(talk_base::SocketAddress(kClientAddrHost1, kClientAddrPort));
+    AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
     Init(NULL);
     mediastream_signaling_.SendAudioVideoStream1();
     FakeConstraints constraints;
@@ -840,7 +840,7 @@ class WebRtcSessionTest : public testing::Test {
     // and answer.
     SetLocalDescriptionWithoutError(offer);
 
-    talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+    rtc::scoped_ptr<SessionDescriptionInterface> answer(
         CreateRemoteAnswer(session_->local_description()));
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
@@ -853,7 +853,7 @@ class WebRtcSessionTest : public testing::Test {
       // Disable rtcp-mux from the answer
       const std::string kRtcpMux = "a=rtcp-mux";
       const std::string kXRtcpMux = "a=xrtcp-mux";
-      talk_base::replace_substrs(kRtcpMux.c_str(), kRtcpMux.length(),
+      rtc::replace_substrs(kRtcpMux.c_str(), kRtcpMux.length(),
                                  kXRtcpMux.c_str(), kXRtcpMux.length(),
                                  &sdp);
     }
@@ -902,7 +902,7 @@ class WebRtcSessionTest : public testing::Test {
   //     -> Failed.
   // The Gathering state should go: New -> Gathering -> Completed.
   void TestLoopbackCall() {
-    AddInterface(talk_base::SocketAddress(kClientAddrHost1, kClientAddrPort));
+    AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
     Init(NULL);
     mediastream_signaling_.SendAudioVideoStream1();
     SessionDescriptionInterface* offer = CreateOffer(NULL);
@@ -939,9 +939,9 @@ class WebRtcSessionTest : public testing::Test {
     // Adding firewall rule to block ping requests, which should cause
     // transport channel failure.
     fss_->AddRule(false,
-                  talk_base::FP_ANY,
-                  talk_base::FD_ANY,
-                  talk_base::SocketAddress(kClientAddrHost1, kClientAddrPort));
+                  rtc::FP_ANY,
+                  rtc::FD_ANY,
+                  rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionDisconnected,
                    observer_.ice_connection_state_,
                    kIceCandidatesTimeout);
@@ -960,9 +960,9 @@ class WebRtcSessionTest : public testing::Test {
     // wait for the Port to timeout.
     int port_timeout = 30000;
     fss_->AddRule(false,
-                  talk_base::FP_ANY,
-                  talk_base::FD_ANY,
-                  talk_base::SocketAddress(kClientAddrHost1, kClientAddrPort));
+                  rtc::FP_ANY,
+                  rtc::FD_ANY,
+                  rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionFailed,
                    observer_.ice_connection_state_,
                    kIceCandidatesTimeout + port_timeout);
@@ -1022,7 +1022,7 @@ class WebRtcSessionTest : public testing::Test {
     }
 
     const int kNumber = 3;
-    talk_base::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
+    rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
         observers[kNumber];
     for (int i = 0; i < kNumber; ++i) {
       observers[i] = new WebRtcSessionCreateSDPObserverForTest();
@@ -1050,23 +1050,23 @@ class WebRtcSessionTest : public testing::Test {
   cricket::FakeMediaEngine* media_engine_;
   cricket::FakeDataEngine* data_engine_;
   cricket::FakeDeviceManager* device_manager_;
-  talk_base::scoped_ptr<cricket::ChannelManager> channel_manager_;
-  talk_base::scoped_ptr<cricket::TransportDescriptionFactory> tdesc_factory_;
-  talk_base::scoped_ptr<talk_base::SSLIdentity> identity_;
-  talk_base::scoped_ptr<cricket::MediaSessionDescriptionFactory> desc_factory_;
-  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::SocketAddress stun_socket_addr_;
+  rtc::scoped_ptr<cricket::ChannelManager> channel_manager_;
+  rtc::scoped_ptr<cricket::TransportDescriptionFactory> tdesc_factory_;
+  rtc::scoped_ptr<rtc::SSLIdentity> identity_;
+  rtc::scoped_ptr<cricket::MediaSessionDescriptionFactory> desc_factory_;
+  rtc::scoped_ptr<rtc::PhysicalSocketServer> pss_;
+  rtc::scoped_ptr<rtc::VirtualSocketServer> vss_;
+  rtc::scoped_ptr<rtc::FirewallSocketServer> fss_;
+  rtc::SocketServerScope ss_scope_;
+  rtc::SocketAddress stun_socket_addr_;
   cricket::TestStunServer stun_server_;
   cricket::TestTurnServer turn_server_;
-  talk_base::FakeNetworkManager network_manager_;
-  talk_base::scoped_ptr<cricket::BasicPortAllocator> allocator_;
+  rtc::FakeNetworkManager network_manager_;
+  rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
   PeerConnectionFactoryInterface::Options options_;
-  talk_base::scoped_ptr<FakeConstraints> constraints_;
+  rtc::scoped_ptr<FakeConstraints> constraints_;
   FakeMediaStreamSignaling mediastream_signaling_;
-  talk_base::scoped_ptr<WebRtcSessionForTest> session_;
+  rtc::scoped_ptr<WebRtcSessionForTest> session_;
   MockIceObserver observer_;
   cricket::FakeVideoMediaChannel* video_channel_;
   cricket::FakeVoiceMediaChannel* voice_channel_;
@@ -1100,8 +1100,8 @@ TEST_F(WebRtcSessionTest, TestSessionCandidatesWithBundleRtcpMux) {
 }
 
 TEST_F(WebRtcSessionTest, TestMultihomeCandidates) {
-  AddInterface(talk_base::SocketAddress(kClientAddrHost1, kClientAddrPort));
-  AddInterface(talk_base::SocketAddress(kClientAddrHost2, kClientAddrPort));
+  AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
+  AddInterface(rtc::SocketAddress(kClientAddrHost2, kClientAddrPort));
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
   InitiateCall();
@@ -1111,12 +1111,12 @@ TEST_F(WebRtcSessionTest, TestMultihomeCandidates) {
 }
 
 TEST_F(WebRtcSessionTest, TestStunError) {
-  AddInterface(talk_base::SocketAddress(kClientAddrHost1, kClientAddrPort));
-  AddInterface(talk_base::SocketAddress(kClientAddrHost2, kClientAddrPort));
+  AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
+  AddInterface(rtc::SocketAddress(kClientAddrHost2, kClientAddrPort));
   fss_->AddRule(false,
-                talk_base::FP_UDP,
-                talk_base::FD_ANY,
-                talk_base::SocketAddress(kClientAddrHost1, kClientAddrPort));
+                rtc::FP_UDP,
+                rtc::FD_ANY,
+                rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
   InitiateCall();
@@ -1171,8 +1171,8 @@ TEST_F(WebRtcSessionTest, TestCreateSdesOfferReceiveSdesAnswer) {
   // Verify the session id is the same and the session version is
   // increased.
   EXPECT_EQ(session_id_orig, offer->session_id());
-  EXPECT_LT(talk_base::FromString<uint64>(session_version_orig),
-            talk_base::FromString<uint64>(offer->session_version()));
+  EXPECT_LT(rtc::FromString<uint64>(session_version_orig),
+            rtc::FromString<uint64>(offer->session_version()));
 
   SetLocalDescriptionWithoutError(offer);
 
@@ -1232,8 +1232,8 @@ TEST_F(WebRtcSessionTest, TestReceiveSdesOfferCreateSdesAnswer) {
   // Verify the session id is the same and the session version is
   // increased.
   EXPECT_EQ(session_id_orig, answer->session_id());
-  EXPECT_LT(talk_base::FromString<uint64>(session_version_orig),
-            talk_base::FromString<uint64>(answer->session_version()));
+  EXPECT_LT(rtc::FromString<uint64>(session_version_orig),
+            rtc::FromString<uint64>(answer->session_version()));
   SetLocalDescriptionWithoutError(answer);
 
   ASSERT_EQ(2u, video_channel_->recv_streams().size());
@@ -1339,7 +1339,7 @@ TEST_F(WebRtcSessionTest, TestSetRemoteNonSdesAnswerWhenSdesOn) {
 // Test that we accept an offer with a DTLS fingerprint when DTLS is on
 // and that we return an answer with a DTLS fingerprint.
 TEST_F(WebRtcSessionTest, TestReceiveDtlsOfferCreateDtlsAnswer) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   mediastream_signaling_.SendAudioVideoStream1();
   InitWithDtls();
   SetFactoryDtlsSrtp();
@@ -1368,7 +1368,7 @@ TEST_F(WebRtcSessionTest, TestReceiveDtlsOfferCreateDtlsAnswer) {
 // Test that we set a local offer with a DTLS fingerprint when DTLS is on
 // and then we accept a remote answer with a DTLS fingerprint successfully.
 TEST_F(WebRtcSessionTest, TestCreateDtlsOfferReceiveDtlsAnswer) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   mediastream_signaling_.SendAudioVideoStream1();
   InitWithDtls();
   SetFactoryDtlsSrtp();
@@ -1398,7 +1398,7 @@ TEST_F(WebRtcSessionTest, TestCreateDtlsOfferReceiveDtlsAnswer) {
 // Test that if we support DTLS and the other side didn't offer a fingerprint,
 // we will fail to set the remote description.
 TEST_F(WebRtcSessionTest, TestReceiveNonDtlsOfferWhenDtlsOn) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls();
   cricket::MediaSessionOptions options;
   options.has_video = true;
@@ -1422,7 +1422,7 @@ TEST_F(WebRtcSessionTest, TestReceiveNonDtlsOfferWhenDtlsOn) {
 // Test that we return a failure when applying a local answer that doesn't have
 // a DTLS fingerprint when DTLS is required.
 TEST_F(WebRtcSessionTest, TestSetLocalNonDtlsAnswerWhenDtlsOn) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls();
   SessionDescriptionInterface* offer = NULL;
   SessionDescriptionInterface* answer = NULL;
@@ -1438,7 +1438,7 @@ TEST_F(WebRtcSessionTest, TestSetLocalNonDtlsAnswerWhenDtlsOn) {
 // Test that we return a failure when applying a remote answer that doesn't have
 // a DTLS fingerprint when DTLS is required.
 TEST_F(WebRtcSessionTest, TestSetRemoteNonDtlsAnswerWhenDtlsOn) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls();
   SessionDescriptionInterface* offer = CreateOffer(NULL);
   cricket::MediaSessionOptions options;
@@ -1606,7 +1606,7 @@ TEST_F(WebRtcSessionTest, TestSetRemotePrAnswer) {
 TEST_F(WebRtcSessionTest, TestSetLocalAnswerWithoutOffer) {
   Init(NULL);
   mediastream_signaling_.SendNothing();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(NULL));
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(offer.get());
@@ -1617,7 +1617,7 @@ TEST_F(WebRtcSessionTest, TestSetLocalAnswerWithoutOffer) {
 TEST_F(WebRtcSessionTest, TestSetRemoteAnswerWithoutOffer) {
   Init(NULL);
   mediastream_signaling_.SendNothing();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
         CreateOffer(NULL));
   SessionDescriptionInterface* answer =
       CreateRemoteAnswer(offer.get());
@@ -1727,7 +1727,7 @@ TEST_F(WebRtcSessionTest, TestRemoteCandidatesAddedToSessionDescription) {
 // Test that local candidates are added to the local session description and
 // that they are retained if the local session description is changed.
 TEST_F(WebRtcSessionTest, TestLocalCandidatesAddedToSessionDescription) {
-  AddInterface(talk_base::SocketAddress(kClientAddrHost1, kClientAddrPort));
+  AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
   CreateAndSetRemoteOfferAndLocalAnswer();
@@ -1791,7 +1791,7 @@ TEST_F(WebRtcSessionTest, TestSetRemoteSessionDescriptionWithCandidates) {
 // Test that offers and answers contains ice candidates when Ice candidates have
 // been gathered.
 TEST_F(WebRtcSessionTest, TestSetLocalAndRemoteDescriptionWithCandidates) {
-  AddInterface(talk_base::SocketAddress(kClientAddrHost1, kClientAddrPort));
+  AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
   // Ice is started but candidates are not provided until SetLocalDescription
@@ -1805,7 +1805,7 @@ TEST_F(WebRtcSessionTest, TestSetLocalAndRemoteDescriptionWithCandidates) {
   EXPECT_TRUE_WAIT(0u < observer_.mline_1_candidates_.size(),
                    kIceCandidatesTimeout);
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> local_offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> local_offer(
       CreateOffer(NULL));
   ASSERT_TRUE(local_offer->candidates(kMediaContentIndex0) != NULL);
   EXPECT_LT(0u, local_offer->candidates(kMediaContentIndex0)->count());
@@ -1827,7 +1827,7 @@ TEST_F(WebRtcSessionTest, TestSetLocalAndRemoteDescriptionWithCandidates) {
 TEST_F(WebRtcSessionTest, TestChannelCreationsWithContentNames) {
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(NULL));
 
   // CreateOffer creates session description with the content names "audio" and
@@ -1842,12 +1842,12 @@ TEST_F(WebRtcSessionTest, TestChannelCreationsWithContentNames) {
   const std::string kVideoMidReplaceStr = "a=mid:video_content_name";
 
   // Replacing |audio| with |audio_content_name|.
-  talk_base::replace_substrs(kAudioMid.c_str(), kAudioMid.length(),
+  rtc::replace_substrs(kAudioMid.c_str(), kAudioMid.length(),
                              kAudioMidReplaceStr.c_str(),
                              kAudioMidReplaceStr.length(),
                              &sdp);
   // Replacing |video| with |video_content_name|.
-  talk_base::replace_substrs(kVideoMid.c_str(), kVideoMid.length(),
+  rtc::replace_substrs(kVideoMid.c_str(), kVideoMid.length(),
                              kVideoMidReplaceStr.c_str(),
                              kVideoMidReplaceStr.length(),
                              &sdp);
@@ -1871,7 +1871,7 @@ TEST_F(WebRtcSessionTest, TestChannelCreationsWithContentNames) {
 // the send streams when no constraints have been set.
 TEST_F(WebRtcSessionTest, CreateOfferWithoutConstraintsOrStreams) {
   Init(NULL);
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(NULL));
   ASSERT_TRUE(offer != NULL);
   const cricket::ContentInfo* content =
@@ -1887,7 +1887,7 @@ TEST_F(WebRtcSessionTest, CreateOfferWithoutConstraints) {
   Init(NULL);
   // Test Audio only offer.
   mediastream_signaling_.UseOptionsAudioOnly();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
         CreateOffer(NULL));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
@@ -1912,7 +1912,7 @@ TEST_F(WebRtcSessionTest, CreateOfferWithConstraintsWithoutStreams) {
   constraints_no_receive.SetMandatoryReceiveAudio(false);
   constraints_no_receive.SetMandatoryReceiveVideo(false);
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(&constraints_no_receive));
   ASSERT_TRUE(offer != NULL);
   const cricket::ContentInfo* content =
@@ -1928,7 +1928,7 @@ TEST_F(WebRtcSessionTest, CreateAudioOnlyOfferWithConstraints) {
   Init(NULL);
   webrtc::FakeConstraints constraints_audio_only;
   constraints_audio_only.SetMandatoryReceiveAudio(true);
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
         CreateOffer(&constraints_audio_only));
 
   const cricket::ContentInfo* content =
@@ -1946,7 +1946,7 @@ TEST_F(WebRtcSessionTest, CreateOfferWithConstraints) {
   webrtc::FakeConstraints constraints_audio_video;
   constraints_audio_video.SetMandatoryReceiveAudio(true);
   constraints_audio_video.SetMandatoryReceiveVideo(true);
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(&constraints_audio_video));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
@@ -1975,9 +1975,9 @@ TEST_F(WebRtcSessionTest, CreateAnswerWithoutAnOffer) {
 TEST_F(WebRtcSessionTest, CreateAnswerWithoutConstraintsOrStreams) {
   Init(NULL);
   // Create a remote offer with audio and video content.
-  talk_base::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
+  rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(NULL));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
@@ -1997,13 +1997,13 @@ TEST_F(WebRtcSessionTest, CreateAudioAnswerWithoutConstraintsOrStreams) {
   cricket::MediaSessionOptions options;
   options.has_audio = true;
   options.has_video = false;
-  talk_base::scoped_ptr<JsepSessionDescription> offer(
+  rtc::scoped_ptr<JsepSessionDescription> offer(
       CreateRemoteOffer(options));
   ASSERT_TRUE(cricket::GetFirstVideoContent(offer->description()) == NULL);
   ASSERT_TRUE(cricket::GetFirstAudioContent(offer->description()) != NULL);
 
   SetRemoteDescriptionWithoutError(offer.release());
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(NULL));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
@@ -2018,11 +2018,11 @@ TEST_F(WebRtcSessionTest, CreateAudioAnswerWithoutConstraintsOrStreams) {
 TEST_F(WebRtcSessionTest, CreateAnswerWithoutConstraints) {
   Init(NULL);
   // Create a remote offer with audio and video content.
-  talk_base::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
+  rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
   // Test with a stream with tracks.
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(NULL));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
@@ -2039,14 +2039,14 @@ TEST_F(WebRtcSessionTest, CreateAnswerWithoutConstraints) {
 TEST_F(WebRtcSessionTest, CreateAnswerWithConstraintsWithoutStreams) {
   Init(NULL);
   // Create a remote offer with audio and video content.
-  talk_base::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
+  rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
   webrtc::FakeConstraints constraints_no_receive;
   constraints_no_receive.SetMandatoryReceiveAudio(false);
   constraints_no_receive.SetMandatoryReceiveVideo(false);
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(&constraints_no_receive));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
@@ -2063,7 +2063,7 @@ TEST_F(WebRtcSessionTest, CreateAnswerWithConstraintsWithoutStreams) {
 TEST_F(WebRtcSessionTest, CreateAnswerWithConstraints) {
   Init(NULL);
   // Create a remote offer with audio and video content.
-  talk_base::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
+  rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
   webrtc::FakeConstraints constraints_no_receive;
@@ -2072,7 +2072,7 @@ TEST_F(WebRtcSessionTest, CreateAnswerWithConstraints) {
 
   // Test with a stream with tracks.
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(&constraints_no_receive));
 
   // TODO(perkj): Should the direction be set to SEND_ONLY?
@@ -2092,7 +2092,7 @@ TEST_F(WebRtcSessionTest, CreateOfferWithoutCNCodecs) {
   Init(NULL);
   webrtc::FakeConstraints constraints;
   constraints.SetOptionalVAD(false);
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(&constraints));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(offer->description());
@@ -2104,12 +2104,12 @@ TEST_F(WebRtcSessionTest, CreateAnswerWithoutCNCodecs) {
   AddCNCodecs();
   Init(NULL);
   // Create a remote offer with audio and video content.
-  talk_base::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
+  rtc::scoped_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
   SetRemoteDescriptionWithoutError(offer.release());
 
   webrtc::FakeConstraints constraints;
   constraints.SetOptionalVAD(false);
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(&constraints));
   const cricket::ContentInfo* content =
       cricket::GetFirstAudioContent(answer->description());
@@ -2265,7 +2265,7 @@ TEST_F(WebRtcSessionTest, VerifyAnswerFromCryptoOffer) {
 TEST_F(WebRtcSessionTest, TestSetLocalDescriptionWithoutIce) {
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
   std::string sdp;
   RemoveIceUfragPwdLines(offer.get(), &sdp);
   SessionDescriptionInterface* modified_offer =
@@ -2277,7 +2277,7 @@ TEST_F(WebRtcSessionTest, TestSetLocalDescriptionWithoutIce) {
 // no a=ice-ufrag and a=ice-pwd lines are present in the SDP.
 TEST_F(WebRtcSessionTest, TestSetRemoteDescriptionWithoutIce) {
   Init(NULL);
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(CreateRemoteOffer());
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateRemoteOffer());
   std::string sdp;
   RemoveIceUfragPwdLines(offer.get(), &sdp);
   SessionDescriptionInterface* modified_offer =
@@ -2291,7 +2291,7 @@ TEST_F(WebRtcSessionTest, TestSetLocalDescriptionInvalidIceCredentials) {
   Init(NULL);
   tdesc_factory_->set_protocol(cricket::ICEPROTO_RFC5245);
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
   std::string sdp;
   // Modifying ice ufrag and pwd in local offer with strings smaller than the
   // recommended values of 4 and 22 bytes respectively.
@@ -2315,7 +2315,7 @@ TEST_F(WebRtcSessionTest, TestSetLocalDescriptionInvalidIceCredentials) {
 TEST_F(WebRtcSessionTest, TestSetRemoteDescriptionInvalidIceCredentials) {
   Init(NULL);
   tdesc_factory_->set_protocol(cricket::ICEPROTO_RFC5245);
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(CreateRemoteOffer());
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateRemoteOffer());
   std::string sdp;
   // Modifying ice ufrag and pwd in remote offer with strings smaller than the
   // recommended values of 4 and 22 bytes respectively.
@@ -2340,7 +2340,7 @@ TEST_F(WebRtcSessionTest, VerifyBundleFlagInPA) {
   Init(NULL);
   EXPECT_TRUE((cricket::PORTALLOCATOR_ENABLE_BUNDLE &
       allocator_->flags()) == cricket::PORTALLOCATOR_ENABLE_BUNDLE);
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(NULL));
   cricket::SessionDescription* offer_copy =
       offer->description()->Copy();
@@ -2363,7 +2363,7 @@ TEST_F(WebRtcSessionTest, TestDisabledBundleInAnswer) {
   SessionDescriptionInterface* offer = CreateOffer(&constraints);
   SetLocalDescriptionWithoutError(offer);
   mediastream_signaling_.SendAudioVideoStream2();
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateRemoteAnswer(session_->local_description()));
   cricket::SessionDescription* answer_copy = answer->description()->Copy();
   answer_copy->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
@@ -2404,7 +2404,7 @@ TEST_F(WebRtcSessionTest, TestDisabledRtcpMuxWithBundleEnabled) {
   // Disable rtcp-mux
   const std::string rtcp_mux = "rtcp-mux";
   const std::string xrtcp_mux = "xrtcp-mux";
-  talk_base::replace_substrs(rtcp_mux.c_str(), rtcp_mux.length(),
+  rtc::replace_substrs(rtcp_mux.c_str(), rtcp_mux.length(),
                              xrtcp_mux.c_str(), xrtcp_mux.length(),
                              &offer_str);
   JsepSessionDescription *local_offer =
@@ -2431,7 +2431,7 @@ TEST_F(WebRtcSessionTest, SetAudioPlayout) {
   EXPECT_TRUE(channel->GetOutputScaling(receive_ssrc, &left_vol, &right_vol));
   EXPECT_EQ(1, left_vol);
   EXPECT_EQ(1, right_vol);
-  talk_base::scoped_ptr<FakeAudioRenderer> renderer(new FakeAudioRenderer());
+  rtc::scoped_ptr<FakeAudioRenderer> renderer(new FakeAudioRenderer());
   session_->SetAudioPlayout(receive_ssrc, false, renderer.get());
   EXPECT_TRUE(channel->GetOutputScaling(receive_ssrc, &left_vol, &right_vol));
   EXPECT_EQ(0, left_vol);
@@ -2457,7 +2457,7 @@ TEST_F(WebRtcSessionTest, SetAudioSend) {
   cricket::AudioOptions options;
   options.echo_cancellation.Set(true);
 
-  talk_base::scoped_ptr<FakeAudioRenderer> renderer(new FakeAudioRenderer());
+  rtc::scoped_ptr<FakeAudioRenderer> renderer(new FakeAudioRenderer());
   session_->SetAudioSend(send_ssrc, false, options, renderer.get());
   EXPECT_TRUE(channel->IsStreamMuted(send_ssrc));
   EXPECT_FALSE(channel->options().echo_cancellation.IsSet());
@@ -2483,7 +2483,7 @@ TEST_F(WebRtcSessionTest, AudioRendererForLocalStream) {
   ASSERT_EQ(1u, channel->send_streams().size());
   uint32 send_ssrc  = channel->send_streams()[0].first_ssrc();
 
-  talk_base::scoped_ptr<FakeAudioRenderer> renderer(new FakeAudioRenderer());
+  rtc::scoped_ptr<FakeAudioRenderer> renderer(new FakeAudioRenderer());
   cricket::AudioOptions options;
   session_->SetAudioSend(send_ssrc, true, options, renderer.get());
   EXPECT_TRUE(renderer->sink() != NULL);
@@ -2595,7 +2595,7 @@ TEST_F(WebRtcSessionTest, TestInitiatorGIceInAnswer) {
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer(NULL);
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateRemoteAnswer(offer));
   SetLocalDescriptionWithoutError(offer);
   std::string sdp;
@@ -2632,7 +2632,7 @@ TEST_F(WebRtcSessionTest, TestReceiverGIceInOffer) {
   mediastream_signaling_.SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer(NULL);
   SetRemoteDescriptionWithoutError(offer);
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(NULL));
   std::string sdp;
   EXPECT_TRUE(answer->ToString(&sdp));
@@ -2665,14 +2665,14 @@ TEST_F(WebRtcSessionTest, TestReceiverIceInOffer) {
 TEST_F(WebRtcSessionTest, TestIceOfferGIceOnlyAnswer) {
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(NULL));
   std::string offer_str;
   offer->ToString(&offer_str);
   // Disable google-ice
   const std::string gice_option = "google-ice";
   const std::string xgoogle_xice = "xgoogle-xice";
-  talk_base::replace_substrs(gice_option.c_str(), gice_option.length(),
+  rtc::replace_substrs(gice_option.c_str(), gice_option.length(),
                              xgoogle_xice.c_str(), xgoogle_xice.length(),
                              &offer_str);
   JsepSessionDescription *ice_only_offer =
@@ -2699,7 +2699,7 @@ TEST_F(WebRtcSessionTest, TestIncorrectMLinesInRemoteAnswer) {
   mediastream_signaling_.SendAudioVideoStream1();
   SessionDescriptionInterface* offer = CreateOffer(NULL);
   SetLocalDescriptionWithoutError(offer);
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateRemoteAnswer(session_->local_description()));
 
   cricket::SessionDescription* answer_copy = answer->description()->Copy();
@@ -2717,7 +2717,7 @@ TEST_F(WebRtcSessionTest, TestIncorrectMLinesInRemoteAnswer) {
   EXPECT_TRUE(answer->ToString(&sdp));
   const std::string kAudioMid = "a=mid:audio";
   const std::string kAudioMidReplaceStr = "a=mid:audio_content_name";
-  talk_base::replace_substrs(kAudioMid.c_str(), kAudioMid.length(),
+  rtc::replace_substrs(kAudioMid.c_str(), kAudioMid.length(),
                              kAudioMidReplaceStr.c_str(),
                              kAudioMidReplaceStr.length(),
                              &sdp);
@@ -2729,7 +2729,7 @@ TEST_F(WebRtcSessionTest, TestIncorrectMLinesInRemoteAnswer) {
   EXPECT_TRUE(answer->ToString(&sdp));
   const std::string kAudioMline = "m=audio";
   const std::string kAudioMlineReplaceStr = "m=video";
-  talk_base::replace_substrs(kAudioMline.c_str(), kAudioMline.length(),
+  rtc::replace_substrs(kAudioMline.c_str(), kAudioMline.length(),
                              kAudioMlineReplaceStr.c_str(),
                              kAudioMlineReplaceStr.length(),
                              &sdp);
@@ -2782,7 +2782,7 @@ TEST_F(WebRtcSessionTest, TestIceStartAfterSetLocalDescriptionOnly) {
   ASSERT_TRUE(session_->GetTransportProxy("video") != NULL);
 
   // Pump for 1 second and verify that no candidates are generated.
-  talk_base::Thread::Current()->ProcessMessages(1000);
+  rtc::Thread::Current()->ProcessMessages(1000);
   EXPECT_TRUE(observer_.mline_0_candidates_.empty());
   EXPECT_TRUE(observer_.mline_1_candidates_.empty());
 
@@ -2798,7 +2798,7 @@ TEST_F(WebRtcSessionTest, TestIceStartAfterSetLocalDescriptionOnly) {
 TEST_F(WebRtcSessionTest, TestCryptoAfterSetLocalDescription) {
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(NULL));
 
   // Making sure SetLocalDescription correctly sets crypto value in
@@ -2818,7 +2818,7 @@ TEST_F(WebRtcSessionTest, TestCryptoAfterSetLocalDescriptionWithDisabled) {
   options_.disable_encryption = true;
   Init(NULL);
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(
       CreateOffer(NULL));
 
   // Making sure SetLocalDescription correctly sets crypto value in
@@ -2840,22 +2840,22 @@ TEST_F(WebRtcSessionTest, TestCreateAnswerWithNewUfragAndPassword) {
   cricket::MediaSessionOptions options;
   options.has_audio = true;
   options.has_video = true;
-  talk_base::scoped_ptr<JsepSessionDescription> offer(
+  rtc::scoped_ptr<JsepSessionDescription> offer(
       CreateRemoteOffer(options));
   SetRemoteDescriptionWithoutError(offer.release());
 
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(NULL));
   SetLocalDescriptionWithoutError(answer.release());
 
   // Receive an offer with new ufrag and password.
   options.transport_options.ice_restart = true;
-  talk_base::scoped_ptr<JsepSessionDescription> updated_offer1(
+  rtc::scoped_ptr<JsepSessionDescription> updated_offer1(
       CreateRemoteOffer(options, session_->remote_description()));
   SetRemoteDescriptionWithoutError(updated_offer1.release());
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> updated_answer1(
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer1(
       CreateAnswer(NULL));
 
   CompareIceUfragAndPassword(updated_answer1->description(),
@@ -2872,22 +2872,22 @@ TEST_F(WebRtcSessionTest, TestCreateAnswerWithOldUfragAndPassword) {
   cricket::MediaSessionOptions options;
   options.has_audio = true;
   options.has_video = true;
-  talk_base::scoped_ptr<JsepSessionDescription> offer(
+  rtc::scoped_ptr<JsepSessionDescription> offer(
       CreateRemoteOffer(options));
   SetRemoteDescriptionWithoutError(offer.release());
 
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(
       CreateAnswer(NULL));
   SetLocalDescriptionWithoutError(answer.release());
 
   // Receive an offer without changed ufrag or password.
   options.transport_options.ice_restart = false;
-  talk_base::scoped_ptr<JsepSessionDescription> updated_offer2(
+  rtc::scoped_ptr<JsepSessionDescription> updated_offer2(
       CreateRemoteOffer(options, session_->remote_description()));
   SetRemoteDescriptionWithoutError(updated_offer2.release());
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> updated_answer2(
+  rtc::scoped_ptr<SessionDescriptionInterface> updated_answer2(
       CreateAnswer(NULL));
 
   CompareIceUfragAndPassword(updated_answer2->description(),
@@ -2967,7 +2967,7 @@ TEST_F(WebRtcSessionTest, TestRtpDataChannel) {
 }
 
 TEST_F(WebRtcSessionTest, TestRtpDataChannelConstraintTakesPrecedence) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   constraints_.reset(new FakeConstraints());
   constraints_->AddOptional(
@@ -2981,17 +2981,17 @@ TEST_F(WebRtcSessionTest, TestRtpDataChannelConstraintTakesPrecedence) {
 }
 
 TEST_F(WebRtcSessionTest, TestCreateOfferWithSctpEnabledWithoutStreams) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   InitWithDtls();
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
   EXPECT_TRUE(offer->description()->GetContentByName("data") == NULL);
   EXPECT_TRUE(offer->description()->GetTransportInfoByName("data") == NULL);
 }
 
 TEST_F(WebRtcSessionTest, TestCreateAnswerWithSctpInOfferAndNoStreams) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   SetFactoryDtlsSrtp();
   InitWithDtls();
 
@@ -3003,7 +3003,7 @@ TEST_F(WebRtcSessionTest, TestCreateAnswerWithSctpInOfferAndNoStreams) {
   SetRemoteDescriptionWithoutError(offer);
 
   // Verifies the answer contains SCTP.
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(NULL));
   EXPECT_TRUE(answer != NULL);
   EXPECT_TRUE(answer->description()->GetContentByName("data") != NULL);
   EXPECT_TRUE(answer->description()->GetTransportInfoByName("data") != NULL);
@@ -3020,7 +3020,7 @@ TEST_F(WebRtcSessionTest, TestSctpDataChannelWithoutDtls) {
 }
 
 TEST_F(WebRtcSessionTest, TestSctpDataChannelWithDtls) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   InitWithDtls();
 
@@ -3029,7 +3029,7 @@ TEST_F(WebRtcSessionTest, TestSctpDataChannelWithDtls) {
 }
 
 TEST_F(WebRtcSessionTest, TestDisableSctpDataChannels) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   options_.disable_sctp_data_channels = true;
   InitWithDtls();
 
@@ -3038,7 +3038,7 @@ TEST_F(WebRtcSessionTest, TestDisableSctpDataChannels) {
 }
 
 TEST_F(WebRtcSessionTest, TestSctpDataChannelSendPortParsing) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   const int new_send_port = 9998;
   const int new_recv_port = 7775;
 
@@ -3068,7 +3068,7 @@ TEST_F(WebRtcSessionTest, TestSctpDataChannelSendPortParsing) {
   webrtc::InternalDataChannelInit dci;
   dci.reliable = true;
   EXPECT_EQ(cricket::DCT_SCTP, data_engine_->last_channel_type());
-  talk_base::scoped_refptr<webrtc::DataChannel> dc =
+  rtc::scoped_refptr<webrtc::DataChannel> dc =
       session_->CreateDataChannel("datachannel", &dci);
 
   cricket::FakeDataMediaChannel* ch = data_engine_->GetChannel(0);
@@ -3094,12 +3094,12 @@ TEST_F(WebRtcSessionTest, TestSctpDataChannelSendPortParsing) {
 // Verifies that CreateOffer succeeds when CreateOffer is called before async
 // identity generation is finished.
 TEST_F(WebRtcSessionTest, TestCreateOfferBeforeIdentityRequestReturnSuccess) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls();
 
   EXPECT_TRUE(session_->waiting_for_identity());
   mediastream_signaling_.SendAudioVideoStream1();
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
   EXPECT_TRUE(offer != NULL);
   VerifyNoCryptoParams(offer->description(), true);
   VerifyFingerprintStatus(offer->description(), true);
@@ -3108,7 +3108,7 @@ TEST_F(WebRtcSessionTest, TestCreateOfferBeforeIdentityRequestReturnSuccess) {
 // Verifies that CreateAnswer succeeds when CreateOffer is called before async
 // identity generation is finished.
 TEST_F(WebRtcSessionTest, TestCreateAnswerBeforeIdentityRequestReturnSuccess) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls();
   SetFactoryDtlsSrtp();
 
@@ -3119,7 +3119,7 @@ TEST_F(WebRtcSessionTest, TestCreateAnswerBeforeIdentityRequestReturnSuccess) {
   ASSERT_TRUE(offer.get() != NULL);
   SetRemoteDescriptionWithoutError(offer.release());
 
-  talk_base::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> answer(CreateAnswer(NULL));
   EXPECT_TRUE(answer != NULL);
   VerifyNoCryptoParams(answer->description(), true);
   VerifyFingerprintStatus(answer->description(), true);
@@ -3128,22 +3128,22 @@ TEST_F(WebRtcSessionTest, TestCreateAnswerBeforeIdentityRequestReturnSuccess) {
 // Verifies that CreateOffer succeeds when CreateOffer is called after async
 // identity generation is finished.
 TEST_F(WebRtcSessionTest, TestCreateOfferAfterIdentityRequestReturnSuccess) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls();
 
   EXPECT_TRUE_WAIT(!session_->waiting_for_identity(), 1000);
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
   EXPECT_TRUE(offer != NULL);
 }
 
 // Verifies that CreateOffer fails when CreateOffer is called after async
 // identity generation fails.
 TEST_F(WebRtcSessionTest, TestCreateOfferAfterIdentityRequestReturnFailure) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls(true);
 
   EXPECT_TRUE_WAIT(!session_->waiting_for_identity(), 1000);
-  talk_base::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
+  rtc::scoped_ptr<SessionDescriptionInterface> offer(CreateOffer(NULL));
   EXPECT_TRUE(offer == NULL);
 }
 
@@ -3151,7 +3151,7 @@ TEST_F(WebRtcSessionTest, TestCreateOfferAfterIdentityRequestReturnFailure) {
 // before async identity generation is finished.
 TEST_F(WebRtcSessionTest,
        TestMultipleCreateOfferBeforeIdentityRequestReturnSuccess) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   VerifyMultipleAsyncCreateDescription(
       true, CreateSessionDescriptionRequest::kOffer);
 }
@@ -3160,7 +3160,7 @@ TEST_F(WebRtcSessionTest,
 // before async identity generation fails.
 TEST_F(WebRtcSessionTest,
        TestMultipleCreateOfferBeforeIdentityRequestReturnFailure) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   VerifyMultipleAsyncCreateDescription(
       false, CreateSessionDescriptionRequest::kOffer);
 }
@@ -3169,7 +3169,7 @@ TEST_F(WebRtcSessionTest,
 // before async identity generation is finished.
 TEST_F(WebRtcSessionTest,
        TestMultipleCreateAnswerBeforeIdentityRequestReturnSuccess) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   VerifyMultipleAsyncCreateDescription(
       true, CreateSessionDescriptionRequest::kAnswer);
 }
@@ -3178,7 +3178,7 @@ TEST_F(WebRtcSessionTest,
 // before async identity generation fails.
 TEST_F(WebRtcSessionTest,
        TestMultipleCreateAnswerBeforeIdentityRequestReturnFailure) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   VerifyMultipleAsyncCreateDescription(
       false, CreateSessionDescriptionRequest::kAnswer);
 }
@@ -3198,8 +3198,8 @@ TEST_F(WebRtcSessionTest, TestSetRemoteOfferFailIfDtlsDisabledAndNoCrypto) {
   ASSERT_TRUE(audio != NULL);
   ASSERT_TRUE(audio->description.identity_fingerprint.get() == NULL);
   audio->description.identity_fingerprint.reset(
-      talk_base::SSLFingerprint::CreateFromRfc4572(
-          talk_base::DIGEST_SHA_256, kFakeDtlsFingerprint));
+      rtc::SSLFingerprint::CreateFromRfc4572(
+          rtc::DIGEST_SHA_256, kFakeDtlsFingerprint));
   SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto,
                                        offer);
 }
@@ -3253,7 +3253,7 @@ TEST_F(WebRtcSessionTest, TestSuspendBelowMinBitrateConstraint) {
 // Tests that we can renegotiate new media content with ICE candidates in the
 // new remote SDP.
 TEST_F(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesInSdp) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls();
   SetFactoryDtlsSrtp();
 
@@ -3269,7 +3269,7 @@ TEST_F(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesInSdp) {
   offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
 
   cricket::Candidate candidate1;
-  candidate1.set_address(talk_base::SocketAddress("1.1.1.1", 5000));
+  candidate1.set_address(rtc::SocketAddress("1.1.1.1", 5000));
   candidate1.set_component(1);
   JsepIceCandidate ice_candidate(kMediaContentName1, kMediaContentIndex1,
                                  candidate1);
@@ -3283,7 +3283,7 @@ TEST_F(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesInSdp) {
 // Tests that we can renegotiate new media content with ICE candidates separated
 // from the remote SDP.
 TEST_F(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesSeparated) {
-  MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp);
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   InitWithDtls();
   SetFactoryDtlsSrtp();
 
@@ -3300,7 +3300,7 @@ TEST_F(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesSeparated) {
   SetRemoteDescriptionWithoutError(offer);
 
   cricket::Candidate candidate1;
-  candidate1.set_address(talk_base::SocketAddress("1.1.1.1", 5000));
+  candidate1.set_address(rtc::SocketAddress("1.1.1.1", 5000));
   candidate1.set_component(1);
   JsepIceCandidate ice_candidate(kMediaContentName1, kMediaContentIndex1,
                                  candidate1);
diff --git a/talk/app/webrtc/webrtcsessiondescriptionfactory.cc b/talk/app/webrtc/webrtcsessiondescriptionfactory.cc
index 25d8fc9316..3dce0d3899 100644
--- a/talk/app/webrtc/webrtcsessiondescriptionfactory.cc
+++ b/talk/app/webrtc/webrtcsessiondescriptionfactory.cc
@@ -72,15 +72,15 @@ enum {
   MSG_GENERATE_IDENTITY,
 };
 
-struct CreateSessionDescriptionMsg : public talk_base::MessageData {
+struct CreateSessionDescriptionMsg : public rtc::MessageData {
   explicit CreateSessionDescriptionMsg(
       webrtc::CreateSessionDescriptionObserver* observer)
       : observer(observer) {
   }
 
-  talk_base::scoped_refptr<webrtc::CreateSessionDescriptionObserver> observer;
+  rtc::scoped_refptr<webrtc::CreateSessionDescriptionObserver> observer;
   std::string error;
-  talk_base::scoped_ptr<webrtc::SessionDescriptionInterface> description;
+  rtc::scoped_ptr<webrtc::SessionDescriptionInterface> description;
 };
 }  // namespace
 
@@ -104,7 +104,7 @@ void WebRtcSessionDescriptionFactory::CopyCandidatesFromSessionDescription(
 }
 
 WebRtcSessionDescriptionFactory::WebRtcSessionDescriptionFactory(
-    talk_base::Thread* signaling_thread,
+    rtc::Thread* signaling_thread,
     cricket::ChannelManager* channel_manager,
     MediaStreamSignaling* mediastream_signaling,
     DTLSIdentityServiceInterface* dtls_identity_service,
@@ -136,7 +136,7 @@ WebRtcSessionDescriptionFactory::WebRtcSessionDescriptionFactory(
 
   if (identity_service_.get()) {
     identity_request_observer_ =
-      new talk_base::RefCountedObject<WebRtcIdentityRequestObserver>();
+      new rtc::RefCountedObject<WebRtcIdentityRequestObserver>();
 
     identity_request_observer_->SignalRequestFailed.connect(
         this, &WebRtcSessionDescriptionFactory::OnIdentityRequestFailed);
@@ -270,7 +270,7 @@ cricket::SecurePolicy WebRtcSessionDescriptionFactory::SdesPolicy() const {
   return session_desc_factory_.secure();
 }
 
-void WebRtcSessionDescriptionFactory::OnMessage(talk_base::Message* msg) {
+void WebRtcSessionDescriptionFactory::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_CREATE_SESSIONDESCRIPTION_SUCCESS: {
       CreateSessionDescriptionMsg* param =
@@ -288,7 +288,7 @@ void WebRtcSessionDescriptionFactory::OnMessage(talk_base::Message* msg) {
     }
     case MSG_GENERATE_IDENTITY: {
       LOG(LS_INFO) << "Generating identity.";
-      SetIdentity(talk_base::SSLIdentity::Generate(kWebRTCIdentityName));
+      SetIdentity(rtc::SSLIdentity::Generate(kWebRTCIdentityName));
       break;
     }
     default:
@@ -316,7 +316,7 @@ void WebRtcSessionDescriptionFactory::InternalCreateOffer(
   JsepSessionDescription* offer(new JsepSessionDescription(
       JsepSessionDescription::kOffer));
   if (!offer->Initialize(desc, session_id_,
-                         talk_base::ToString(session_version_++))) {
+                         rtc::ToString(session_version_++))) {
     delete offer;
     PostCreateSessionDescriptionFailed(request.observer,
                                        "Failed to initialize the offer.");
@@ -339,10 +339,10 @@ void WebRtcSessionDescriptionFactory::InternalCreateAnswer(
   request.options.transport_options.ice_restart = session_->IceRestartPending();
   // We should pass current ssl role to the transport description factory, if
   // there is already an existing ongoing session.
-  talk_base::SSLRole ssl_role;
+  rtc::SSLRole ssl_role;
   if (session_->GetSslRole(&ssl_role)) {
     request.options.transport_options.prefer_passive_role =
-        (talk_base::SSL_SERVER == ssl_role);
+        (rtc::SSL_SERVER == ssl_role);
   }
 
   cricket::SessionDescription* desc(session_desc_factory_.CreateAnswer(
@@ -360,7 +360,7 @@ void WebRtcSessionDescriptionFactory::InternalCreateAnswer(
   JsepSessionDescription* answer(new JsepSessionDescription(
       JsepSessionDescription::kAnswer));
   if (!answer->Initialize(desc, session_id_,
-                          talk_base::ToString(session_version_++))) {
+                          rtc::ToString(session_version_++))) {
     delete answer;
     PostCreateSessionDescriptionFailed(request.observer,
                                        "Failed to initialize the answer.");
@@ -416,22 +416,22 @@ void WebRtcSessionDescriptionFactory::OnIdentityReady(
   ASSERT(signaling_thread_->IsCurrent());
   LOG(LS_VERBOSE) << "Identity is successfully generated.";
 
-  std::string pem_cert = talk_base::SSLIdentity::DerToPem(
-      talk_base::kPemTypeCertificate,
+  std::string pem_cert = rtc::SSLIdentity::DerToPem(
+      rtc::kPemTypeCertificate,
       reinterpret_cast<const unsigned char*>(der_cert.data()),
       der_cert.length());
-  std::string pem_key = talk_base::SSLIdentity::DerToPem(
-      talk_base::kPemTypeRsaPrivateKey,
+  std::string pem_key = rtc::SSLIdentity::DerToPem(
+      rtc::kPemTypeRsaPrivateKey,
       reinterpret_cast<const unsigned char*>(der_private_key.data()),
       der_private_key.length());
 
-  talk_base::SSLIdentity* identity =
-      talk_base::SSLIdentity::FromPEMStrings(pem_key, pem_cert);
+  rtc::SSLIdentity* identity =
+      rtc::SSLIdentity::FromPEMStrings(pem_key, pem_cert);
   SetIdentity(identity);
 }
 
 void WebRtcSessionDescriptionFactory::SetIdentity(
-    talk_base::SSLIdentity* identity) {
+    rtc::SSLIdentity* identity) {
   identity_request_state_ = IDENTITY_SUCCEEDED;
   SignalIdentityReady(identity);
 
diff --git a/talk/app/webrtc/webrtcsessiondescriptionfactory.h b/talk/app/webrtc/webrtcsessiondescriptionfactory.h
index cad0c65da1..b09cfcdc0a 100644
--- a/talk/app/webrtc/webrtcsessiondescriptionfactory.h
+++ b/talk/app/webrtc/webrtcsessiondescriptionfactory.h
@@ -29,7 +29,7 @@
 #define TALK_APP_WEBRTC_WEBRTCSESSIONDESCRIPTIONFACTORY_H_
 
 #include "talk/app/webrtc/peerconnectioninterface.h"
-#include "talk/base/messagehandler.h"
+#include "webrtc/base/messagehandler.h"
 #include "talk/p2p/base/transportdescriptionfactory.h"
 #include "talk/session/media/mediasession.h"
 
@@ -77,7 +77,7 @@ struct CreateSessionDescriptionRequest {
         options(options) {}
 
   Type type;
-  talk_base::scoped_refptr<CreateSessionDescriptionObserver> observer;
+  rtc::scoped_refptr<CreateSessionDescriptionObserver> observer;
   cricket::MediaSessionOptions options;
 };
 
@@ -86,11 +86,11 @@ struct CreateSessionDescriptionRequest {
 // It queues the create offer/answer request until the DTLS identity
 // request has completed, i.e. when OnIdentityRequestFailed or OnIdentityReady
 // is called.
-class WebRtcSessionDescriptionFactory : public talk_base::MessageHandler,
+class WebRtcSessionDescriptionFactory : public rtc::MessageHandler,
                                         public sigslot::has_slots<>  {
  public:
   WebRtcSessionDescriptionFactory(
-      talk_base::Thread* signaling_thread,
+      rtc::Thread* signaling_thread,
       cricket::ChannelManager* channel_manager,
       MediaStreamSignaling* mediastream_signaling,
       DTLSIdentityServiceInterface* dtls_identity_service,
@@ -115,7 +115,7 @@ class WebRtcSessionDescriptionFactory : public talk_base::MessageHandler,
   void SetSdesPolicy(cricket::SecurePolicy secure_policy);
   cricket::SecurePolicy SdesPolicy() const;
 
-  sigslot::signal1<talk_base::SSLIdentity*> SignalIdentityReady;
+  sigslot::signal1<rtc::SSLIdentity*> SignalIdentityReady;
 
   // For testing.
   bool waiting_for_identity() const {
@@ -131,7 +131,7 @@ class WebRtcSessionDescriptionFactory : public talk_base::MessageHandler,
   };
 
   // MessageHandler implementation.
-  virtual void OnMessage(talk_base::Message* msg);
+  virtual void OnMessage(rtc::Message* msg);
 
   void InternalCreateOffer(CreateSessionDescriptionRequest request);
   void InternalCreateAnswer(CreateSessionDescriptionRequest request);
@@ -145,17 +145,17 @@ class WebRtcSessionDescriptionFactory : public talk_base::MessageHandler,
   void OnIdentityRequestFailed(int error);
   void OnIdentityReady(const std::string& der_cert,
                        const std::string& der_private_key);
-  void SetIdentity(talk_base::SSLIdentity* identity);
+  void SetIdentity(rtc::SSLIdentity* identity);
 
   std::queue<CreateSessionDescriptionRequest>
       create_session_description_requests_;
-  talk_base::Thread* signaling_thread_;
+  rtc::Thread* signaling_thread_;
   MediaStreamSignaling* mediastream_signaling_;
   cricket::TransportDescriptionFactory transport_desc_factory_;
   cricket::MediaSessionDescriptionFactory session_desc_factory_;
   uint64 session_version_;
-  talk_base::scoped_ptr<DTLSIdentityServiceInterface> identity_service_;
-  talk_base::scoped_refptr<WebRtcIdentityRequestObserver>
+  rtc::scoped_ptr<DTLSIdentityServiceInterface> identity_service_;
+  rtc::scoped_refptr<WebRtcIdentityRequestObserver>
       identity_request_observer_;
   WebRtcSession* session_;
   std::string session_id_;
diff --git a/talk/build/common.gypi b/talk/build/common.gypi
index 24a975818a..8647b42d6c 100644
--- a/talk/build/common.gypi
+++ b/talk/build/common.gypi
@@ -84,6 +84,7 @@
       ['OS=="linux"', {
         'defines': [
           'LINUX',
+          'WEBRTC_LINUX',
         ],
         'conditions': [
           ['clang==1', {
@@ -102,11 +103,19 @@
       ['OS=="mac"', {
         'defines': [
           'OSX',
+          'WEBRTC_MAC',
+        ],
+      }],
+      ['OS=="win"', {
+        'defines': [
+          'WEBRTC_WIN',
         ],
       }],
       ['OS=="ios"', {
         'defines': [
           'IOS',
+          'WEBRTC_MAC',
+          'WEBRTC_IOS',
         ],
       }],
       ['OS=="ios" or (OS=="mac" and target_arch!="ia32")', {
@@ -128,6 +137,7 @@
         'defines': [
           'HASH_NAMESPACE=__gnu_cxx',
           'POSIX',
+          'WEBRTC_POSIX',
           'DISABLE_DYNAMIC_CAST',
           # The POSIX standard says we have to define this.
           '_REENTRANT',
diff --git a/talk/examples/call/call_main.cc b/talk/examples/call/call_main.cc
index 33d5385719..b6168b35b1 100644
--- a/talk/examples/call/call_main.cc
+++ b/talk/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/talk/examples/call/call_unittest.cc b/talk/examples/call/call_unittest.cc
index d95f1dd967..524726d6aa 100644
--- a/talk/examples/call/call_unittest.cc
+++ b/talk/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/talk/examples/call/callclient.cc b/talk/examples/call/callclient.cc
index c691db37ad..7d1cd80628 100644
--- a/talk/examples/call/callclient.cc
+++ b/talk/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/talk/examples/call/callclient.h b/talk/examples/call/callclient.h
index 39a5b11fe9..f25b9f5436 100644
--- a/talk/examples/call/callclient.h
+++ b/talk/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/talk/examples/call/callclient_unittest.cc b/talk/examples/call/callclient_unittest.cc
index b0e9d89774..6268917047 100644
--- a/talk/examples/call/callclient_unittest.cc
+++ b/talk/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/talk/examples/call/console.cc b/talk/examples/call/console.cc
index 647601e817..e3ed4f83e3 100644
--- a/talk/examples/call/console.cc
+++ b/talk/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/talk/examples/call/console.h b/talk/examples/call/console.h
index f0f36e3467..00b35a0909 100644
--- a/talk/examples/call/console.h
+++ b/talk/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/talk/examples/call/mediaenginefactory.cc b/talk/examples/call/mediaenginefactory.cc
index 983345d2f6..472a8807f5 100644
--- a/talk/examples/call/mediaenginefactory.cc
+++ b/talk/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/talk/examples/call/mucinviterecvtask.h b/talk/examples/call/mucinviterecvtask.h
index 24f05e0e4b..4ec06d00fe 100644
--- a/talk/examples/call/mucinviterecvtask.h
+++ b/talk/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/talk/examples/call/presencepushtask.cc b/talk/examples/call/presencepushtask.cc
index af02b1f3e9..31ccc32b59 100644
--- a/talk/examples/call/presencepushtask.cc
+++ b/talk/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/talk/examples/call/presencepushtask.h b/talk/examples/call/presencepushtask.h
index 9cd1b42984..5a080d32ff 100644
--- a/talk/examples/call/presencepushtask.h
+++ b/talk/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/talk/examples/login/login_main.cc b/talk/examples/login/login_main.cc
index 5c5d1d7838..55243aab41 100644
--- a/talk/examples/login/login_main.cc
+++ b/talk/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/talk/examples/peerconnection/client/conductor.cc b/talk/examples/peerconnection/client/conductor.cc
index bbab3d06e3..64026c58d5 100644
--- a/talk/examples/peerconnection/client/conductor.cc
+++ b/talk/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/talk/examples/peerconnection/client/conductor.h b/talk/examples/peerconnection/client/conductor.h
index f9fb3937e6..93b077912e 100644
--- a/talk/examples/peerconnection/client/conductor.h
+++ b/talk/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/talk/examples/peerconnection/client/defaults.cc b/talk/examples/peerconnection/client/defaults.cc
index 40f3dd171a..15252c6554 100644
--- a/talk/examples/peerconnection/client/defaults.cc
+++ b/talk/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/talk/examples/peerconnection/client/defaults.h b/talk/examples/peerconnection/client/defaults.h
index f646149c89..5834f349c7 100644
--- a/talk/examples/peerconnection/client/defaults.h
+++ b/talk/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/talk/examples/peerconnection/client/flagdefs.h b/talk/examples/peerconnection/client/flagdefs.h
index c135bbbc3f..3d3edca742 100644
--- a/talk/examples/peerconnection/client/flagdefs.h
+++ b/talk/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/talk/examples/peerconnection/client/linux/main.cc b/talk/examples/peerconnection/client/linux/main.cc
index 4ef81cdac7..67fd33d89d 100644
--- a/talk/examples/peerconnection/client/linux/main.cc
+++ b/talk/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/talk/examples/peerconnection/client/linux/main_wnd.cc b/talk/examples/peerconnection/client/linux/main_wnd.cc
index 0a2e1f699c..55f3649f04 100644
--- a/talk/examples/peerconnection/client/linux/main_wnd.cc
+++ b/talk/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/talk/examples/peerconnection/client/linux/main_wnd.h b/talk/examples/peerconnection/client/linux/main_wnd.h
index 5a44640e1f..6e45333a76 100644
--- a/talk/examples/peerconnection/client/linux/main_wnd.h
+++ b/talk/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/talk/examples/peerconnection/client/main.cc b/talk/examples/peerconnection/client/main.cc
index 765dfaaa8e..34fadfa61b 100644
--- a/talk/examples/peerconnection/client/main.cc
+++ b/talk/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/talk/examples/peerconnection/client/main_wnd.cc b/talk/examples/peerconnection/client/main_wnd.cc
index cef1da7061..2296c426e2 100644
--- a/talk/examples/peerconnection/client/main_wnd.cc
+++ b/talk/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/talk/examples/peerconnection/client/main_wnd.h b/talk/examples/peerconnection/client/main_wnd.h
index 77da9f69a2..e87153a3b8 100644
--- a/talk/examples/peerconnection/client/main_wnd.h
+++ b/talk/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/talk/examples/peerconnection/client/peer_connection_client.cc b/talk/examples/peerconnection/client/peer_connection_client.cc
index 9cdaedcbf0..e5bef05a41 100644
--- a/talk/examples/peerconnection/client/peer_connection_client.cc
+++ b/talk/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/talk/examples/peerconnection/client/peer_connection_client.h b/talk/examples/peerconnection/client/peer_connection_client.h
index 43fee3456d..3187895c45 100644
--- a/talk/examples/peerconnection/client/peer_connection_client.h
+++ b/talk/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/talk/examples/peerconnection/server/main.cc b/talk/examples/peerconnection/server/main.cc
index 40ede93faf..9be3bbe843 100644
--- a/talk/examples/peerconnection/server/main.cc
+++ b/talk/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/talk/examples/relayserver/relayserver_main.cc b/talk/examples/relayserver/relayserver_main.cc
index 11e8a5bf16..d9dde6631f 100644
--- a/talk/examples/relayserver/relayserver_main.cc
+++ b/talk/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/talk/examples/stunserver/stunserver_main.cc b/talk/examples/stunserver/stunserver_main.cc
index 446794486e..3ac2ea691f 100644
--- a/talk/examples/stunserver/stunserver_main.cc
+++ b/talk/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/talk/examples/turnserver/turnserver_main.cc b/talk/examples/turnserver/turnserver_main.cc
index d40fede032..a32f42c370 100644
--- a/talk/examples/turnserver/turnserver_main.cc
+++ b/talk/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;
 
diff --git a/talk/libjingle.gyp b/talk/libjingle.gyp
index 091cf4dff7..41221cd54e 100755
--- a/talk/libjingle.gyp
+++ b/talk/libjingle.gyp
@@ -303,6 +303,7 @@
       'dependencies': [
         '<(DEPTH)/third_party/expat/expat.gyp:expat',
         '<(DEPTH)/third_party/jsoncpp/jsoncpp.gyp:jsoncpp',
+        '<(webrtc_root)/base/base.gyp:webrtc_base',
       ],
       'export_dependent_settings': [
         '<(DEPTH)/third_party/expat/expat.gyp:expat',
diff --git a/talk/libjingle_tests.gyp b/talk/libjingle_tests.gyp
index cbff0b5e7b..9a00fed708 100755
--- a/talk/libjingle_tests.gyp
+++ b/talk/libjingle_tests.gyp
@@ -28,59 +28,26 @@
 {
   'includes': ['build/common.gypi'],
   'targets': [
-    {
-      # TODO(ronghuawu): Use gtest.gyp from chromium.
-      'target_name': 'gunit',
-      'type': 'static_library',
-      'sources': [
-        '<(DEPTH)/testing/gtest/src/gtest-all.cc',
-      ],
-      'include_dirs': [
-        '<(DEPTH)/testing/gtest/include',
-        '<(DEPTH)/testing/gtest',
-      ],
-      'defines': ['_VARIADIC_MAX=10'],
-      'direct_dependent_settings': {
-        'defines': [
-          '_VARIADIC_MAX=10',
-        ],
-        'include_dirs': [
-          '<(DEPTH)/testing/gtest/include',
-        ],
-      },
-      'conditions': [
-        ['OS=="android"', {
-          'include_dirs': [
-            '<(android_ndk_include)',
-          ]
-        }],
-      ],
-    },  # target gunit
     {
       'target_name': 'libjingle_unittest_main',
       'type': 'static_library',
       'dependencies': [
         '<(DEPTH)/third_party/libyuv/libyuv.gyp:libyuv',
-        'gunit',
+        '<(webrtc_root)/base/base_tests.gyp:webrtc_base_tests_utils',
         '<@(libjingle_tests_additional_deps)',
       ],
       'direct_dependent_settings': {
         'include_dirs': [
           '<(DEPTH)/third_party/libyuv/include',
+          '<(DEPTH)/testing/gtest/include',
+          '<(DEPTH)/testing/gtest',
         ],
       },
+      'include_dirs': [
+         '<(DEPTH)/testing/gtest/include',
+         '<(DEPTH)/testing/gtest',
+       ],
       'sources': [
-        'base/unittest_main.cc',
-        # Also use this as a convenient dumping ground for misc files that are
-        # included by multiple targets below.
-        'base/fakecpumonitor.h',
-        'base/fakenetwork.h',
-        'base/fakesslidentity.h',
-        'base/faketaskrunner.h',
-        'base/gunit.h',
-        'base/testbase64.h',
-        'base/testechoserver.h',
-        'base/win32toolhelp.h',
         'media/base/fakecapturemanager.h',
         'media/base/fakemediaengine.h',
         'media/base/fakemediaprocessor.h',
@@ -107,73 +74,12 @@
       'type': 'executable',
       'includes': [ 'build/ios_tests.gypi', ],
       'dependencies': [
-        'gunit',
+        '<(webrtc_root)/base/base.gyp:webrtc_base',
+        '<(webrtc_root)/base/base_tests.gyp:webrtc_base_tests_utils',
         'libjingle.gyp:libjingle',
         'libjingle_unittest_main',
       ],
       'sources': [
-        'base/asynchttprequest_unittest.cc',
-        'base/atomicops_unittest.cc',
-        'base/autodetectproxy_unittest.cc',
-        'base/bandwidthsmoother_unittest.cc',
-        'base/base64_unittest.cc',
-        'base/basictypes_unittest.cc',
-        'base/bind_unittest.cc',
-        'base/buffer_unittest.cc',
-        'base/bytebuffer_unittest.cc',
-        'base/byteorder_unittest.cc',
-        'base/callback_unittest.cc',
-        'base/cpumonitor_unittest.cc',
-        'base/crc32_unittest.cc',
-        'base/criticalsection_unittest.cc',
-        'base/event_unittest.cc',
-        'base/filelock_unittest.cc',
-        'base/fileutils_unittest.cc',
-        'base/helpers_unittest.cc',
-        'base/httpbase_unittest.cc',
-        'base/httpcommon_unittest.cc',
-        'base/httpserver_unittest.cc',
-        'base/ipaddress_unittest.cc',
-        'base/logging_unittest.cc',
-        'base/md5digest_unittest.cc',
-        'base/messagedigest_unittest.cc',
-        'base/messagequeue_unittest.cc',
-        'base/multipart_unittest.cc',
-        'base/nat_unittest.cc',
-        'base/network_unittest.cc',
-        'base/nullsocketserver_unittest.cc',
-        'base/optionsfile_unittest.cc',
-        'base/pathutils_unittest.cc',
-        'base/physicalsocketserver_unittest.cc',
-        'base/profiler_unittest.cc',
-        'base/proxy_unittest.cc',
-        'base/proxydetect_unittest.cc',
-        'base/ratelimiter_unittest.cc',
-        'base/ratetracker_unittest.cc',
-        'base/referencecountedsingletonfactory_unittest.cc',
-        'base/rollingaccumulator_unittest.cc',
-        'base/scopedptrcollection_unittest.cc',
-        'base/sha1digest_unittest.cc',
-        'base/sharedexclusivelock_unittest.cc',
-        'base/signalthread_unittest.cc',
-        'base/sigslot_unittest.cc',
-        'base/socket_unittest.cc',
-        'base/socket_unittest.h',
-        'base/socketaddress_unittest.cc',
-        'base/stream_unittest.cc',
-        'base/stringencode_unittest.cc',
-        'base/stringutils_unittest.cc',
-        # TODO(ronghuawu): Reenable this test.
-        # 'base/systeminfo_unittest.cc',
-        'base/task_unittest.cc',
-        'base/testclient_unittest.cc',
-        'base/thread_unittest.cc',
-        'base/timeutils_unittest.cc',
-        'base/urlencode_unittest.cc',
-        'base/versionparsing_unittest.cc',
-        'base/virtualsocket_unittest.cc',
-        # TODO(ronghuawu): Reenable this test.
-        # 'base/windowpicker_unittest.cc',
         'xmllite/qname_unittest.cc',
         'xmllite/xmlbuilder_unittest.cc',
         'xmllite/xmlelement_unittest.cc',
@@ -196,54 +102,12 @@
         'xmpp/xmpplogintask_unittest.cc',
         'xmpp/xmppstanzaparser_unittest.cc',
       ],  # sources
-      'conditions': [
-        ['OS=="linux"', {
-          'sources': [
-            'base/latebindingsymboltable_unittest.cc',
-            # TODO(ronghuawu): Reenable this test.
-            # 'base/linux_unittest.cc',
-            'base/linuxfdwalk_unittest.cc',
-          ],
-        }],
-        ['OS=="win"', {
-          'sources': [
-            'base/win32_unittest.cc',
-            'base/win32regkey_unittest.cc',
-            'base/win32socketserver_unittest.cc',
-            'base/win32toolhelp_unittest.cc',
-            'base/win32window_unittest.cc',
-            'base/win32windowpicker_unittest.cc',
-            'base/winfirewall_unittest.cc',
-          ],
-          'sources!': [
-            # TODO(ronghuawu): Fix TestUdpReadyToSendIPv6 on windows bot
-            # then reenable these tests.
-            'base/physicalsocketserver_unittest.cc',
-            'base/socket_unittest.cc',
-            'base/win32socketserver_unittest.cc',
-            'base/win32windowpicker_unittest.cc',
-          ],
-        }],
-        ['OS=="mac"', {
-          'sources': [
-            'base/macsocketserver_unittest.cc',
-            'base/macutils_unittest.cc',
-            'base/macwindowpicker_unittest.cc',
-          ],
-        }],
-        ['os_posix==1', {
-          'sources': [
-            'base/sslidentity_unittest.cc',
-            'base/sslstreamadapter_unittest.cc',
-          ],
-        }],
-      ],  # conditions
     },  # target libjingle_unittest
     {
       'target_name': 'libjingle_sound_unittest',
       'type': 'executable',
       'dependencies': [
-        'gunit',
+        '<(webrtc_root)/base/base_tests.gyp:webrtc_base_tests_utils',
         'libjingle.gyp:libjingle_sound',
         'libjingle_unittest_main',
       ],
@@ -255,7 +119,7 @@
       'target_name': 'libjingle_media_unittest',
       'type': 'executable',
       'dependencies': [
-        'gunit',
+        '<(webrtc_root)/base/base_tests.gyp:webrtc_base_tests_utils',
         'libjingle.gyp:libjingle_media',
         'libjingle_unittest_main',
       ],
@@ -329,7 +193,7 @@
       'type': 'executable',
       'dependencies': [
         '<(DEPTH)/third_party/libsrtp/libsrtp.gyp:libsrtp',
-        'gunit',
+        '<(webrtc_root)/base/base_tests.gyp:webrtc_base_tests_utils',
         'libjingle.gyp:libjingle',
         'libjingle.gyp:libjingle_p2p',
         'libjingle_unittest_main',
@@ -388,7 +252,7 @@
       'type': 'executable',
       'dependencies': [
         '<(DEPTH)/testing/gmock.gyp:gmock',
-        'gunit',
+        '<(webrtc_root)/base/base_tests.gyp:webrtc_base_tests_utils',
         'libjingle.gyp:libjingle',
         'libjingle.gyp:libjingle_p2p',
         'libjingle.gyp:libjingle_peerconnection',
@@ -521,7 +385,7 @@
           'type': 'executable',
           'includes': [ 'build/ios_tests.gypi', ],
           'dependencies': [
-            'gunit',
+            '<(webrtc_root)/base/base_tests.gyp:webrtc_base_tests_utils',
             'libjingle.gyp:libjingle_peerconnection_objc',
           ],
           'sources': [
diff --git a/talk/media/base/capturemanager.cc b/talk/media/base/capturemanager.cc
index 85bfa54b8a..e6fb9f0b17 100644
--- a/talk/media/base/capturemanager.cc
+++ b/talk/media/base/capturemanager.cc
@@ -29,7 +29,7 @@
 
 #include <algorithm>
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videoprocessor.h"
 #include "talk/media/base/videorenderer.h"
@@ -64,7 +64,7 @@ class VideoCapturerState {
 
   explicit VideoCapturerState(CaptureRenderAdapter* adapter);
 
-  talk_base::scoped_ptr<CaptureRenderAdapter> adapter_;
+  rtc::scoped_ptr<CaptureRenderAdapter> adapter_;
 
   int start_count_;
   CaptureFormats capture_formats_;
diff --git a/talk/media/base/capturemanager.h b/talk/media/base/capturemanager.h
index 5226e7b470..211516d93a 100644
--- a/talk/media/base/capturemanager.h
+++ b/talk/media/base/capturemanager.h
@@ -46,7 +46,7 @@
 #include <map>
 #include <vector>
 
-#include "talk/base/sigslotrepeater.h"
+#include "webrtc/base/sigslotrepeater.h"
 #include "talk/media/base/capturerenderadapter.h"
 #include "talk/media/base/videocommon.h"
 
diff --git a/talk/media/base/capturemanager_unittest.cc b/talk/media/base/capturemanager_unittest.cc
index 8025e56ce2..cff9caecde 100644
--- a/talk/media/base/capturemanager_unittest.cc
+++ b/talk/media/base/capturemanager_unittest.cc
@@ -27,8 +27,8 @@
 
 #include "talk/media/base/capturemanager.h"
 
-#include "talk/base/gunit.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/media/base/fakemediaprocessor.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/base/fakevideorenderer.h"
diff --git a/talk/media/base/capturerenderadapter.cc b/talk/media/base/capturerenderadapter.cc
index a281e66a33..010cc061b1 100644
--- a/talk/media/base/capturerenderadapter.cc
+++ b/talk/media/base/capturerenderadapter.cc
@@ -27,7 +27,7 @@
 
 #include "talk/media/base/capturerenderadapter.h"
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videoprocessor.h"
 #include "talk/media/base/videorenderer.h"
@@ -66,7 +66,7 @@ bool CaptureRenderAdapter::AddRenderer(VideoRenderer* video_renderer) {
   if (!video_renderer) {
     return false;
   }
-  talk_base::CritScope cs(&capture_crit_);
+  rtc::CritScope cs(&capture_crit_);
   if (IsRendererRegistered(*video_renderer)) {
     return false;
   }
@@ -78,7 +78,7 @@ bool CaptureRenderAdapter::RemoveRenderer(VideoRenderer* video_renderer) {
   if (!video_renderer) {
     return false;
   }
-  talk_base::CritScope cs(&capture_crit_);
+  rtc::CritScope cs(&capture_crit_);
   for (VideoRenderers::iterator iter = video_renderers_.begin();
        iter != video_renderers_.end(); ++iter) {
     if (video_renderer == iter->renderer) {
@@ -97,7 +97,7 @@ void CaptureRenderAdapter::Init() {
 
 void CaptureRenderAdapter::OnVideoFrame(VideoCapturer* capturer,
                                         const VideoFrame* video_frame) {
-  talk_base::CritScope cs(&capture_crit_);
+  rtc::CritScope cs(&capture_crit_);
   if (video_renderers_.empty()) {
     return;
   }
diff --git a/talk/media/base/capturerenderadapter.h b/talk/media/base/capturerenderadapter.h
index 1df9131d65..73260a55fd 100644
--- a/talk/media/base/capturerenderadapter.h
+++ b/talk/media/base/capturerenderadapter.h
@@ -36,8 +36,8 @@
 
 #include <vector>
 
-#include "talk/base/criticalsection.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/media/base/videocapturer.h"
 
 namespace cricket {
@@ -83,7 +83,7 @@ class CaptureRenderAdapter : public sigslot::has_slots<> {
   VideoRenderers video_renderers_;
   VideoCapturer* video_capturer_;
   // Critical section synchronizing the capture thread.
-  mutable talk_base::CriticalSection capture_crit_;
+  mutable rtc::CriticalSection capture_crit_;
 };
 
 }  // namespace cricket
diff --git a/talk/media/base/codec.cc b/talk/media/base/codec.cc
index c6f0ea5839..e4ab540a24 100644
--- a/talk/media/base/codec.cc
+++ b/talk/media/base/codec.cc
@@ -30,10 +30,10 @@
 #include <algorithm>
 #include <sstream>
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
 
 namespace cricket {
 
@@ -108,7 +108,7 @@ bool Codec::GetParam(const std::string& name, int* out) const {
   CodecParameterMap::const_iterator iter = params.find(name);
   if (iter == params.end())
     return false;
-  return talk_base::FromString(iter->second, out);
+  return rtc::FromString(iter->second, out);
 }
 
 void Codec::SetParam(const std::string& name, const std::string& value) {
@@ -116,7 +116,7 @@ void Codec::SetParam(const std::string& name, const std::string& value) {
 }
 
 void Codec::SetParam(const std::string& name, int value)  {
-  params[name] = talk_base::ToString(value);
+  params[name] = rtc::ToString(value);
 }
 
 bool Codec::RemoveParam(const std::string& name) {
diff --git a/talk/media/base/codec_unittest.cc b/talk/media/base/codec_unittest.cc
index ea7a131122..8ead5ee643 100644
--- a/talk/media/base/codec_unittest.cc
+++ b/talk/media/base/codec_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/codec.h"
 
 using cricket::AudioCodec;
diff --git a/talk/media/base/cpuid.h b/talk/media/base/cpuid.h
index 3b2aa76c8c..310b221626 100644
--- a/talk/media/base/cpuid.h
+++ b/talk/media/base/cpuid.h
@@ -28,7 +28,7 @@
 #ifndef TALK_MEDIA_BASE_CPUID_H_
 #define TALK_MEDIA_BASE_CPUID_H_
 
-#include "talk/base/basictypes.h"  // For DISALLOW_IMPLICIT_CONSTRUCTORS
+#include "webrtc/base/basictypes.h"  // For DISALLOW_IMPLICIT_CONSTRUCTORS
 
 namespace cricket {
 
diff --git a/talk/media/base/cpuid_unittest.cc b/talk/media/base/cpuid_unittest.cc
index e8fcc2cdeb..f03b77f041 100644
--- a/talk/media/base/cpuid_unittest.cc
+++ b/talk/media/base/cpuid_unittest.cc
@@ -29,9 +29,9 @@
 
 #include <iostream>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/gunit.h"
-#include "talk/base/systeminfo.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/systeminfo.h"
 
 TEST(CpuInfoTest, CpuId) {
   LOG(LS_INFO) << "ARM: "
diff --git a/talk/media/base/fakemediaengine.h b/talk/media/base/fakemediaengine.h
index 27fbeb094e..6fc6a348fc 100644
--- a/talk/media/base/fakemediaengine.h
+++ b/talk/media/base/fakemediaengine.h
@@ -34,8 +34,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/buffer.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/audiorenderer.h"
 #include "talk/media/base/mediaengine.h"
 #include "talk/media/base/rtputils.h"
@@ -73,11 +73,11 @@ template <class Base> class RtpHelper : public Base {
     if (!sending_) {
       return false;
     }
-    talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+    rtc::Buffer packet(data, len, kMaxRtpPacketLen);
     return Base::SendPacket(&packet);
   }
   bool SendRtcp(const void* data, int len) {
-    talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+    rtc::Buffer packet(data, len, kMaxRtpPacketLen);
     return Base::SendRtcp(&packet);
   }
 
@@ -191,12 +191,12 @@ template <class Base> class RtpHelper : public Base {
     return true;
   }
   void set_playout(bool playout) { playout_ = playout; }
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time) {
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time) {
     rtp_packets_.push_back(std::string(packet->data(), packet->length()));
   }
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time) {
     rtcp_packets_.push_back(std::string(packet->data(), packet->length()));
   }
   virtual void OnReadyToSend(bool ready) {
@@ -690,7 +690,7 @@ class FakeDataMediaChannel : public RtpHelper<DataMediaChannel> {
   }
 
   virtual bool SendData(const SendDataParams& params,
-                        const talk_base::Buffer& payload,
+                        const rtc::Buffer& payload,
                         SendDataResult* result) {
     if (send_blocked_) {
       *result = SDR_BLOCK;
@@ -724,7 +724,7 @@ class FakeBaseEngine {
       : loglevel_(-1),
         options_changed_(false),
         fail_create_channel_(false) {}
-  bool Init(talk_base::Thread* worker_thread) { return true; }
+  bool Init(rtc::Thread* worker_thread) { return true; }
   void Terminate() {}
 
   void SetLogging(int level, const char* filter) {
@@ -824,7 +824,7 @@ class FakeVoiceEngine : public FakeBaseEngine {
 
   bool SetLocalMonitor(bool enable) { return true; }
 
-  bool StartAecDump(talk_base::PlatformFile file) { return false; }
+  bool StartAecDump(rtc::PlatformFile file) { return false; }
 
   bool RegisterProcessor(uint32 ssrc, VoiceProcessor* voice_processor,
                          MediaProcessorDirection direction) {
diff --git a/talk/media/base/fakenetworkinterface.h b/talk/media/base/fakenetworkinterface.h
index eb0175b7f8..e4878e7d64 100644
--- a/talk/media/base/fakenetworkinterface.h
+++ b/talk/media/base/fakenetworkinterface.h
@@ -31,13 +31,13 @@
 #include <vector>
 #include <map>
 
-#include "talk/base/buffer.h"
-#include "talk/base/byteorder.h"
-#include "talk/base/criticalsection.h"
-#include "talk/base/dscp.h"
-#include "talk/base/messagehandler.h"
-#include "talk/base/messagequeue.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/dscp.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/rtputils.h"
 
@@ -45,15 +45,15 @@ namespace cricket {
 
 // Fake NetworkInterface that sends/receives RTP/RTCP packets.
 class FakeNetworkInterface : public MediaChannel::NetworkInterface,
-                             public talk_base::MessageHandler {
+                             public rtc::MessageHandler {
  public:
   FakeNetworkInterface()
-      : thread_(talk_base::Thread::Current()),
+      : thread_(rtc::Thread::Current()),
         dest_(NULL),
         conf_(false),
         sendbuf_size_(-1),
         recvbuf_size_(-1),
-        dscp_(talk_base::DSCP_NO_CHANGE) {
+        dscp_(rtc::DSCP_NO_CHANGE) {
   }
 
   void SetDestination(MediaChannel* dest) { dest_ = dest; }
@@ -62,13 +62,13 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
   // the transport will send multiple copies of the packet with the specified
   // SSRCs. This allows us to simulate receiving media from multiple sources.
   void SetConferenceMode(bool conf, const std::vector<uint32>& ssrcs) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     conf_ = conf;
     conf_sent_ssrcs_ = ssrcs;
   }
 
   int NumRtpBytes() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     int bytes = 0;
     for (size_t i = 0; i < rtp_packets_.size(); ++i) {
       bytes += static_cast<int>(rtp_packets_[i].length());
@@ -77,50 +77,50 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
   }
 
   int NumRtpBytes(uint32 ssrc) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     int bytes = 0;
     GetNumRtpBytesAndPackets(ssrc, &bytes, NULL);
     return bytes;
   }
 
   int NumRtpPackets() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return static_cast<int>(rtp_packets_.size());
   }
 
   int NumRtpPackets(uint32 ssrc) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     int packets = 0;
     GetNumRtpBytesAndPackets(ssrc, NULL, &packets);
     return packets;
   }
 
   int NumSentSsrcs() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return static_cast<int>(sent_ssrcs_.size());
   }
 
   // Note: callers are responsible for deleting the returned buffer.
-  const talk_base::Buffer* GetRtpPacket(int index) {
-    talk_base::CritScope cs(&crit_);
+  const rtc::Buffer* GetRtpPacket(int index) {
+    rtc::CritScope cs(&crit_);
     if (index >= NumRtpPackets()) {
       return NULL;
     }
-    return new talk_base::Buffer(rtp_packets_[index]);
+    return new rtc::Buffer(rtp_packets_[index]);
   }
 
   int NumRtcpPackets() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return static_cast<int>(rtcp_packets_.size());
   }
 
   // Note: callers are responsible for deleting the returned buffer.
-  const talk_base::Buffer* GetRtcpPacket(int index) {
-    talk_base::CritScope cs(&crit_);
+  const rtc::Buffer* GetRtcpPacket(int index) {
+    rtc::CritScope cs(&crit_);
     if (index >= NumRtcpPackets()) {
       return NULL;
     }
-    return new talk_base::Buffer(rtcp_packets_[index]);
+    return new rtc::Buffer(rtcp_packets_[index]);
   }
 
   // Indicate that |n|'th packet for |ssrc| should be dropped.
@@ -130,12 +130,12 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
 
   int sendbuf_size() const { return sendbuf_size_; }
   int recvbuf_size() const { return recvbuf_size_; }
-  talk_base::DiffServCodePoint dscp() const { return dscp_; }
+  rtc::DiffServCodePoint dscp() const { return dscp_; }
 
  protected:
-  virtual bool SendPacket(talk_base::Buffer* packet,
-                          talk_base::DiffServCodePoint dscp) {
-    talk_base::CritScope cs(&crit_);
+  virtual bool SendPacket(rtc::Buffer* packet,
+                          rtc::DiffServCodePoint dscp) {
+    rtc::CritScope cs(&crit_);
 
     uint32 cur_ssrc = 0;
     if (!GetRtpSsrc(packet->data(), packet->length(), &cur_ssrc)) {
@@ -154,7 +154,7 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
 
     rtp_packets_.push_back(*packet);
     if (conf_) {
-      talk_base::Buffer buffer_copy(*packet);
+      rtc::Buffer buffer_copy(*packet);
       for (size_t i = 0; i < conf_sent_ssrcs_.size(); ++i) {
         if (!SetRtpSsrc(buffer_copy.data(), buffer_copy.length(),
                         conf_sent_ssrcs_[i])) {
@@ -168,9 +168,9 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
     return true;
   }
 
-  virtual bool SendRtcp(talk_base::Buffer* packet,
-                        talk_base::DiffServCodePoint dscp) {
-    talk_base::CritScope cs(&crit_);
+  virtual bool SendRtcp(rtc::Buffer* packet,
+                        rtc::DiffServCodePoint dscp) {
+    rtc::CritScope cs(&crit_);
     rtcp_packets_.push_back(*packet);
     if (!conf_) {
       // don't worry about RTCP in conf mode for now
@@ -179,33 +179,33 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
     return true;
   }
 
-  virtual int SetOption(SocketType type, talk_base::Socket::Option opt,
+  virtual int SetOption(SocketType type, rtc::Socket::Option opt,
                         int option) {
-    if (opt == talk_base::Socket::OPT_SNDBUF) {
+    if (opt == rtc::Socket::OPT_SNDBUF) {
       sendbuf_size_ = option;
-    } else if (opt == talk_base::Socket::OPT_RCVBUF) {
+    } else if (opt == rtc::Socket::OPT_RCVBUF) {
       recvbuf_size_ = option;
-    } else if (opt == talk_base::Socket::OPT_DSCP) {
-      dscp_ = static_cast<talk_base::DiffServCodePoint>(option);
+    } else if (opt == rtc::Socket::OPT_DSCP) {
+      dscp_ = static_cast<rtc::DiffServCodePoint>(option);
     }
     return 0;
   }
 
-  void PostMessage(int id, const talk_base::Buffer& packet) {
-    thread_->Post(this, id, talk_base::WrapMessageData(packet));
+  void PostMessage(int id, const rtc::Buffer& packet) {
+    thread_->Post(this, id, rtc::WrapMessageData(packet));
   }
 
-  virtual void OnMessage(talk_base::Message* msg) {
-    talk_base::TypedMessageData<talk_base::Buffer>* msg_data =
-        static_cast<talk_base::TypedMessageData<talk_base::Buffer>*>(
+  virtual void OnMessage(rtc::Message* msg) {
+    rtc::TypedMessageData<rtc::Buffer>* msg_data =
+        static_cast<rtc::TypedMessageData<rtc::Buffer>*>(
             msg->pdata);
     if (dest_) {
       if (msg->message_id == ST_RTP) {
         dest_->OnPacketReceived(&msg_data->data(),
-                                talk_base::CreatePacketTime(0));
+                                rtc::CreatePacketTime(0));
       } else {
         dest_->OnRtcpReceived(&msg_data->data(),
-                              talk_base::CreatePacketTime(0));
+                              rtc::CreatePacketTime(0));
       }
     }
     delete msg_data;
@@ -236,7 +236,7 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
     }
   }
 
-  talk_base::Thread* thread_;
+  rtc::Thread* thread_;
   MediaChannel* dest_;
   bool conf_;
   // The ssrcs used in sending out packets in conference mode.
@@ -246,12 +246,12 @@ class FakeNetworkInterface : public MediaChannel::NetworkInterface,
   std::map<uint32, uint32> sent_ssrcs_;
   // Map to track packet-number that needs to be dropped per ssrc.
   std::map<uint32, std::set<uint32> > drop_map_;
-  talk_base::CriticalSection crit_;
-  std::vector<talk_base::Buffer> rtp_packets_;
-  std::vector<talk_base::Buffer> rtcp_packets_;
+  rtc::CriticalSection crit_;
+  std::vector<rtc::Buffer> rtp_packets_;
+  std::vector<rtc::Buffer> rtcp_packets_;
   int sendbuf_size_;
   int recvbuf_size_;
-  talk_base::DiffServCodePoint dscp_;
+  rtc::DiffServCodePoint dscp_;
 };
 
 }  // namespace cricket
diff --git a/talk/media/base/fakevideocapturer.h b/talk/media/base/fakevideocapturer.h
index 8dc69c3454..089151fc29 100644
--- a/talk/media/base/fakevideocapturer.h
+++ b/talk/media/base/fakevideocapturer.h
@@ -32,7 +32,7 @@
 
 #include <vector>
 
-#include "talk/base/timeutils.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videocommon.h"
 #include "talk/media/base/videoframe.h"
@@ -44,8 +44,8 @@ class FakeVideoCapturer : public cricket::VideoCapturer {
  public:
   FakeVideoCapturer()
       : running_(false),
-        initial_unix_timestamp_(time(NULL) * talk_base::kNumNanosecsPerSec),
-        next_timestamp_(talk_base::kNumNanosecsPerMillisec),
+        initial_unix_timestamp_(time(NULL) * rtc::kNumNanosecsPerSec),
+        next_timestamp_(rtc::kNumNanosecsPerMillisec),
         is_screencast_(false) {
     // Default supported formats. Use ResetSupportedFormats to over write.
     std::vector<cricket::VideoFormat> formats;
@@ -101,7 +101,7 @@ class FakeVideoCapturer : public cricket::VideoCapturer {
     frame.time_stamp = initial_unix_timestamp_ + next_timestamp_;
     next_timestamp_ += 33333333;  // 30 fps
 
-    talk_base::scoped_ptr<char[]> data(new char[size]);
+    rtc::scoped_ptr<char[]> data(new char[size]);
     frame.data = data.get();
     // Copy something non-zero into the buffer so Validate wont complain that
     // the frame is all duplicate.
diff --git a/talk/media/base/fakevideorenderer.h b/talk/media/base/fakevideorenderer.h
index cab77dda72..f32fad553b 100644
--- a/talk/media/base/fakevideorenderer.h
+++ b/talk/media/base/fakevideorenderer.h
@@ -28,8 +28,8 @@
 #ifndef TALK_MEDIA_BASE_FAKEVIDEORENDERER_H_
 #define TALK_MEDIA_BASE_FAKEVIDEORENDERER_H_
 
-#include "talk/base/logging.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/media/base/videoframe.h"
 #include "talk/media/base/videorenderer.h"
 
@@ -48,7 +48,7 @@ class FakeVideoRenderer : public VideoRenderer {
   }
 
   virtual bool SetSize(int width, int height, int reserved) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     width_ = width;
     height_ = height;
     ++num_set_sizes_;
@@ -57,7 +57,7 @@ class FakeVideoRenderer : public VideoRenderer {
   }
 
   virtual bool RenderFrame(const VideoFrame* frame) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     // TODO(zhurunz) Check with VP8 team to see if we can remove this
     // tolerance on Y values.
     black_frame_ = CheckFrameColorYuv(6, 48, 128, 128, 128, 128, frame);
@@ -82,23 +82,23 @@ class FakeVideoRenderer : public VideoRenderer {
 
   int errors() const { return errors_; }
   int width() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return width_;
   }
   int height() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return height_;
   }
   int num_set_sizes() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return num_set_sizes_;
   }
   int num_rendered_frames() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return num_rendered_frames_;
   }
   bool black_frame() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return black_frame_;
   }
 
@@ -160,7 +160,7 @@ class FakeVideoRenderer : public VideoRenderer {
   int num_set_sizes_;
   int num_rendered_frames_;
   bool black_frame_;
-  mutable talk_base::CriticalSection crit_;
+  mutable rtc::CriticalSection crit_;
 };
 
 }  // namespace cricket
diff --git a/talk/media/base/filemediaengine.cc b/talk/media/base/filemediaengine.cc
index e8c356e4fb..08cea239a4 100644
--- a/talk/media/base/filemediaengine.cc
+++ b/talk/media/base/filemediaengine.cc
@@ -27,11 +27,11 @@
 
 #include <limits.h>
 
-#include "talk/base/buffer.h"
-#include "talk/base/event.h"
-#include "talk/base/logging.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/event.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/stream.h"
 #include "talk/media/base/rtpdump.h"
 #include "talk/media/base/rtputils.h"
 #include "talk/media/base/streamparams.h"
@@ -59,14 +59,14 @@ int FileMediaEngine::GetCapabilities() {
 }
 
 VoiceMediaChannel* FileMediaEngine::CreateChannel() {
-  talk_base::FileStream* input_file_stream = NULL;
-  talk_base::FileStream* output_file_stream = NULL;
+  rtc::FileStream* input_file_stream = NULL;
+  rtc::FileStream* output_file_stream = NULL;
 
   if (voice_input_filename_.empty() && voice_output_filename_.empty())
     return NULL;
   if (!voice_input_filename_.empty()) {
-    input_file_stream = talk_base::Filesystem::OpenFile(
-        talk_base::Pathname(voice_input_filename_), "rb");
+    input_file_stream = rtc::Filesystem::OpenFile(
+        rtc::Pathname(voice_input_filename_), "rb");
     if (!input_file_stream) {
       LOG(LS_ERROR) << "Not able to open the input audio stream file.";
       return NULL;
@@ -74,8 +74,8 @@ VoiceMediaChannel* FileMediaEngine::CreateChannel() {
   }
 
   if (!voice_output_filename_.empty()) {
-    output_file_stream = talk_base::Filesystem::OpenFile(
-        talk_base::Pathname(voice_output_filename_), "wb");
+    output_file_stream = rtc::Filesystem::OpenFile(
+        rtc::Pathname(voice_output_filename_), "wb");
     if (!output_file_stream) {
       delete input_file_stream;
       LOG(LS_ERROR) << "Not able to open the output audio stream file.";
@@ -89,15 +89,15 @@ VoiceMediaChannel* FileMediaEngine::CreateChannel() {
 
 VideoMediaChannel* FileMediaEngine::CreateVideoChannel(
     VoiceMediaChannel* voice_ch) {
-  talk_base::FileStream* input_file_stream = NULL;
-  talk_base::FileStream* output_file_stream = NULL;
+  rtc::FileStream* input_file_stream = NULL;
+  rtc::FileStream* output_file_stream = NULL;
 
   if (video_input_filename_.empty() && video_output_filename_.empty())
       return NULL;
 
   if (!video_input_filename_.empty()) {
-    input_file_stream = talk_base::Filesystem::OpenFile(
-        talk_base::Pathname(video_input_filename_), "rb");
+    input_file_stream = rtc::Filesystem::OpenFile(
+        rtc::Pathname(video_input_filename_), "rb");
     if (!input_file_stream) {
       LOG(LS_ERROR) << "Not able to open the input video stream file.";
       return NULL;
@@ -105,8 +105,8 @@ VideoMediaChannel* FileMediaEngine::CreateVideoChannel(
   }
 
   if (!video_output_filename_.empty()) {
-    output_file_stream = talk_base::Filesystem::OpenFile(
-        talk_base::Pathname(video_output_filename_), "wb");
+    output_file_stream = rtc::Filesystem::OpenFile(
+        rtc::Pathname(video_output_filename_), "wb");
     if (!output_file_stream) {
       delete input_file_stream;
       LOG(LS_ERROR) << "Not able to open the output video stream file.";
@@ -121,21 +121,21 @@ VideoMediaChannel* FileMediaEngine::CreateVideoChannel(
 ///////////////////////////////////////////////////////////////////////////
 // Definition of RtpSenderReceiver.
 ///////////////////////////////////////////////////////////////////////////
-class RtpSenderReceiver : public talk_base::MessageHandler {
+class RtpSenderReceiver : public rtc::MessageHandler {
  public:
   RtpSenderReceiver(MediaChannel* channel,
-                    talk_base::StreamInterface* input_file_stream,
-                    talk_base::StreamInterface* output_file_stream,
-                    talk_base::Thread* sender_thread);
+                    rtc::StreamInterface* input_file_stream,
+                    rtc::StreamInterface* output_file_stream,
+                    rtc::Thread* sender_thread);
   virtual ~RtpSenderReceiver();
 
   // Called by media channel. Context: media channel thread.
   bool SetSend(bool send);
   void SetSendSsrc(uint32 ssrc);
-  void OnPacketReceived(talk_base::Buffer* packet);
+  void OnPacketReceived(rtc::Buffer* packet);
 
   // Override virtual method of parent MessageHandler. Context: Worker Thread.
-  virtual void OnMessage(talk_base::Message* pmsg);
+  virtual void OnMessage(rtc::Message* pmsg);
 
  private:
   // Read the next RTP dump packet, whose RTP SSRC is the same as first_ssrc_.
@@ -147,11 +147,11 @@ class RtpSenderReceiver : public talk_base::MessageHandler {
   bool SendRtpPacket(const void* data, size_t len);
 
   MediaChannel* media_channel_;
-  talk_base::scoped_ptr<talk_base::StreamInterface> input_stream_;
-  talk_base::scoped_ptr<talk_base::StreamInterface> output_stream_;
-  talk_base::scoped_ptr<RtpDumpLoopReader> rtp_dump_reader_;
-  talk_base::scoped_ptr<RtpDumpWriter> rtp_dump_writer_;
-  talk_base::Thread* sender_thread_;
+  rtc::scoped_ptr<rtc::StreamInterface> input_stream_;
+  rtc::scoped_ptr<rtc::StreamInterface> output_stream_;
+  rtc::scoped_ptr<RtpDumpLoopReader> rtp_dump_reader_;
+  rtc::scoped_ptr<RtpDumpWriter> rtp_dump_writer_;
+  rtc::Thread* sender_thread_;
   bool own_sender_thread_;
   // RTP dump packet read from the input stream.
   RtpDumpPacket rtp_dump_packet_;
@@ -168,16 +168,16 @@ class RtpSenderReceiver : public talk_base::MessageHandler {
 ///////////////////////////////////////////////////////////////////////////
 RtpSenderReceiver::RtpSenderReceiver(
     MediaChannel* channel,
-    talk_base::StreamInterface* input_file_stream,
-    talk_base::StreamInterface* output_file_stream,
-    talk_base::Thread* sender_thread)
+    rtc::StreamInterface* input_file_stream,
+    rtc::StreamInterface* output_file_stream,
+    rtc::Thread* sender_thread)
     : media_channel_(channel),
       input_stream_(input_file_stream),
       output_stream_(output_file_stream),
       sending_(false),
       first_packet_(true) {
   if (sender_thread == NULL) {
-    sender_thread_ = new talk_base::Thread();
+    sender_thread_ = new rtc::Thread();
     own_sender_thread_ = true;
   } else {
     sender_thread_ = sender_thread;
@@ -211,7 +211,7 @@ bool RtpSenderReceiver::SetSend(bool send) {
   sending_ = send;
   if (!was_sending && sending_) {
     sender_thread_->PostDelayed(0, this);  // Wake up the send thread.
-    start_send_time_ = talk_base::Time();
+    start_send_time_ = rtc::Time();
   }
   return true;
 }
@@ -222,13 +222,13 @@ void RtpSenderReceiver::SetSendSsrc(uint32 ssrc) {
   }
 }
 
-void RtpSenderReceiver::OnPacketReceived(talk_base::Buffer* packet) {
+void RtpSenderReceiver::OnPacketReceived(rtc::Buffer* packet) {
   if (rtp_dump_writer_) {
     rtp_dump_writer_->WriteRtpPacket(packet->data(), packet->length());
   }
 }
 
-void RtpSenderReceiver::OnMessage(talk_base::Message* pmsg) {
+void RtpSenderReceiver::OnMessage(rtc::Message* pmsg) {
   if (!sending_) {
     // If the sender thread is not sending, ignore this message. The thread goes
     // to sleep until SetSend(true) wakes it up.
@@ -240,9 +240,9 @@ void RtpSenderReceiver::OnMessage(talk_base::Message* pmsg) {
   }
 
   if (ReadNextPacket(&rtp_dump_packet_)) {
-    int wait = talk_base::TimeUntil(
+    int wait = rtc::TimeUntil(
         start_send_time_ + rtp_dump_packet_.elapsed_time);
-    wait = talk_base::_max(0, wait);
+    wait = rtc::_max(0, wait);
     sender_thread_->PostDelayed(wait, this);
   } else {
     sender_thread_->Quit();
@@ -250,7 +250,7 @@ void RtpSenderReceiver::OnMessage(talk_base::Message* pmsg) {
 }
 
 bool RtpSenderReceiver::ReadNextPacket(RtpDumpPacket* packet) {
-  while (talk_base::SR_SUCCESS == rtp_dump_reader_->ReadPacket(packet)) {
+  while (rtc::SR_SUCCESS == rtp_dump_reader_->ReadPacket(packet)) {
     uint32 ssrc;
     if (!packet->GetRtpSsrc(&ssrc)) {
       return false;
@@ -270,7 +270,7 @@ bool RtpSenderReceiver::SendRtpPacket(const void* data, size_t len) {
   if (!media_channel_)
     return false;
 
-  talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+  rtc::Buffer packet(data, len, kMaxRtpPacketLen);
   return media_channel_->SendPacket(&packet);
 }
 
@@ -278,9 +278,9 @@ bool RtpSenderReceiver::SendRtpPacket(const void* data, size_t len) {
 // Implementation of FileVoiceChannel.
 ///////////////////////////////////////////////////////////////////////////
 FileVoiceChannel::FileVoiceChannel(
-    talk_base::StreamInterface* input_file_stream,
-    talk_base::StreamInterface* output_file_stream,
-    talk_base::Thread* rtp_sender_thread)
+    rtc::StreamInterface* input_file_stream,
+    rtc::StreamInterface* output_file_stream,
+    rtc::Thread* rtp_sender_thread)
     : send_ssrc_(0),
       rtp_sender_receiver_(new RtpSenderReceiver(this, input_file_stream,
                                                  output_file_stream,
@@ -316,7 +316,7 @@ bool FileVoiceChannel::RemoveSendStream(uint32 ssrc) {
 }
 
 void FileVoiceChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   rtp_sender_receiver_->OnPacketReceived(packet);
 }
 
@@ -324,9 +324,9 @@ void FileVoiceChannel::OnPacketReceived(
 // Implementation of FileVideoChannel.
 ///////////////////////////////////////////////////////////////////////////
 FileVideoChannel::FileVideoChannel(
-    talk_base::StreamInterface* input_file_stream,
-    talk_base::StreamInterface* output_file_stream,
-    talk_base::Thread* rtp_sender_thread)
+    rtc::StreamInterface* input_file_stream,
+    rtc::StreamInterface* output_file_stream,
+    rtc::Thread* rtp_sender_thread)
     : send_ssrc_(0),
       rtp_sender_receiver_(new RtpSenderReceiver(this, input_file_stream,
                                                  output_file_stream,
@@ -362,7 +362,7 @@ bool FileVideoChannel::RemoveSendStream(uint32 ssrc) {
 }
 
 void FileVideoChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   rtp_sender_receiver_->OnPacketReceived(packet);
 }
 
diff --git a/talk/media/base/filemediaengine.h b/talk/media/base/filemediaengine.h
index 6656cdfa18..47802ca883 100644
--- a/talk/media/base/filemediaengine.h
+++ b/talk/media/base/filemediaengine.h
@@ -29,13 +29,13 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stream.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/mediaengine.h"
 
-namespace talk_base {
+namespace rtc {
 class StreamInterface;
 }
 
@@ -78,7 +78,7 @@ class FileMediaEngine : public MediaEngineInterface {
   }
 
   // Implement pure virtual methods of MediaEngine.
-  virtual bool Init(talk_base::Thread* worker_thread) {
+  virtual bool Init(rtc::Thread* worker_thread) {
     return true;
   }
   virtual void Terminate() {}
@@ -133,7 +133,7 @@ class FileMediaEngine : public MediaEngineInterface {
   virtual bool FindVideoCodec(const VideoCodec& codec) { return true; }
   virtual void SetVoiceLogging(int min_sev, const char* filter) {}
   virtual void SetVideoLogging(int min_sev, const char* filter) {}
-  virtual bool StartAecDump(talk_base::PlatformFile) { return false; }
+  virtual bool StartAecDump(rtc::PlatformFile) { return false; }
 
   virtual bool RegisterVideoProcessor(VideoProcessor* processor) {
     return true;
@@ -160,7 +160,7 @@ class FileMediaEngine : public MediaEngineInterface {
     return signal_state_change_;
   }
 
-  void set_rtp_sender_thread(talk_base::Thread* thread) {
+  void set_rtp_sender_thread(rtc::Thread* thread) {
     rtp_sender_thread_ = thread;
   }
 
@@ -175,7 +175,7 @@ class FileMediaEngine : public MediaEngineInterface {
   std::vector<RtpHeaderExtension> video_rtp_header_extensions_;
   sigslot::repeater2<VideoCapturer*, CaptureState>
      signal_state_change_;
-  talk_base::Thread* rtp_sender_thread_;
+  rtc::Thread* rtp_sender_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(FileMediaEngine);
 };
@@ -184,9 +184,9 @@ class RtpSenderReceiver;  // Forward declaration. Defined in the .cc file.
 
 class FileVoiceChannel : public VoiceMediaChannel {
  public:
-  FileVoiceChannel(talk_base::StreamInterface* input_file_stream,
-      talk_base::StreamInterface* output_file_stream,
-      talk_base::Thread* rtp_sender_thread);
+  FileVoiceChannel(rtc::StreamInterface* input_file_stream,
+      rtc::StreamInterface* output_file_stream,
+      rtc::Thread* rtp_sender_thread);
   virtual ~FileVoiceChannel();
 
   // Implement pure virtual methods of VoiceMediaChannel.
@@ -233,10 +233,10 @@ class FileVoiceChannel : public VoiceMediaChannel {
   virtual bool GetStats(VoiceMediaInfo* info) { return true; }
 
   // Implement pure virtual methods of MediaChannel.
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {}
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time);
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time) {}
   virtual void OnReadyToSend(bool ready) {}
   virtual bool AddSendStream(const StreamParams& sp);
   virtual bool RemoveSendStream(uint32 ssrc);
@@ -256,7 +256,7 @@ class FileVoiceChannel : public VoiceMediaChannel {
 
  private:
   uint32 send_ssrc_;
-  talk_base::scoped_ptr<RtpSenderReceiver> rtp_sender_receiver_;
+  rtc::scoped_ptr<RtpSenderReceiver> rtp_sender_receiver_;
   AudioOptions options_;
 
   DISALLOW_COPY_AND_ASSIGN(FileVoiceChannel);
@@ -264,9 +264,9 @@ class FileVoiceChannel : public VoiceMediaChannel {
 
 class FileVideoChannel : public VideoMediaChannel {
  public:
-  FileVideoChannel(talk_base::StreamInterface* input_file_stream,
-      talk_base::StreamInterface* output_file_stream,
-      talk_base::Thread* rtp_sender_thread);
+  FileVideoChannel(rtc::StreamInterface* input_file_stream,
+      rtc::StreamInterface* output_file_stream,
+      rtc::Thread* rtp_sender_thread);
   virtual ~FileVideoChannel();
 
   // Implement pure virtual methods of VideoMediaChannel.
@@ -304,10 +304,10 @@ class FileVideoChannel : public VideoMediaChannel {
   virtual bool RequestIntraFrame() { return false; }
 
   // Implement pure virtual methods of MediaChannel.
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {}
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time);
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time) {}
   virtual void OnReadyToSend(bool ready) {}
   virtual bool AddSendStream(const StreamParams& sp);
   virtual bool RemoveSendStream(uint32 ssrc);
@@ -328,7 +328,7 @@ class FileVideoChannel : public VideoMediaChannel {
 
  private:
   uint32 send_ssrc_;
-  talk_base::scoped_ptr<RtpSenderReceiver> rtp_sender_receiver_;
+  rtc::scoped_ptr<RtpSenderReceiver> rtp_sender_receiver_;
   VideoOptions options_;
 
   DISALLOW_COPY_AND_ASSIGN(FileVideoChannel);
diff --git a/talk/media/base/filemediaengine_unittest.cc b/talk/media/base/filemediaengine_unittest.cc
index b1b021d090..00be12877e 100644
--- a/talk/media/base/filemediaengine_unittest.cc
+++ b/talk/media/base/filemediaengine_unittest.cc
@@ -27,11 +27,11 @@
 
 #include <set>
 
-#include "talk/base/buffer.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/stream.h"
 #include "talk/media/base/filemediaengine.h"
 #include "talk/media/base/rtpdump.h"
 #include "talk/media/base/streamparams.h"
@@ -49,7 +49,7 @@ static const std::string kFakeFileName = "foobar";
 //////////////////////////////////////////////////////////////////////////////
 class FileNetworkInterface : public MediaChannel::NetworkInterface {
  public:
-  FileNetworkInterface(talk_base::StreamInterface* output, MediaChannel* ch)
+  FileNetworkInterface(rtc::StreamInterface* output, MediaChannel* ch)
       : media_channel_(ch),
         num_sent_packets_(0) {
     if (output) {
@@ -58,15 +58,15 @@ class FileNetworkInterface : public MediaChannel::NetworkInterface {
   }
 
   // Implement pure virtual methods of NetworkInterface.
-  virtual bool SendPacket(talk_base::Buffer* packet,
-                          talk_base::DiffServCodePoint dscp) {
+  virtual bool SendPacket(rtc::Buffer* packet,
+                          rtc::DiffServCodePoint dscp) {
     if (!packet) return false;
 
     if (media_channel_) {
-      media_channel_->OnPacketReceived(packet, talk_base::PacketTime());
+      media_channel_->OnPacketReceived(packet, rtc::PacketTime());
     }
     if (dump_writer_.get() &&
-        talk_base::SR_SUCCESS != dump_writer_->WriteRtpPacket(
+        rtc::SR_SUCCESS != dump_writer_->WriteRtpPacket(
             packet->data(), packet->length())) {
       return false;
     }
@@ -75,19 +75,19 @@ class FileNetworkInterface : public MediaChannel::NetworkInterface {
     return true;
   }
 
-  virtual bool SendRtcp(talk_base::Buffer* packet,
-                        talk_base::DiffServCodePoint dscp) { return false; }
+  virtual bool SendRtcp(rtc::Buffer* packet,
+                        rtc::DiffServCodePoint dscp) { return false; }
   virtual int SetOption(MediaChannel::NetworkInterface::SocketType type,
-      talk_base::Socket::Option opt, int option) {
+      rtc::Socket::Option opt, int option) {
     return 0;
   }
-  virtual void SetDefaultDSCPCode(talk_base::DiffServCodePoint dscp) {}
+  virtual void SetDefaultDSCPCode(rtc::DiffServCodePoint dscp) {}
 
   size_t num_sent_packets() const { return num_sent_packets_; }
 
  private:
   MediaChannel* media_channel_;
-  talk_base::scoped_ptr<RtpDumpWriter> dump_writer_;
+  rtc::scoped_ptr<RtpDumpWriter> dump_writer_;
   size_t num_sent_packets_;
 
   DISALLOW_COPY_AND_ASSIGN(FileNetworkInterface);
@@ -136,7 +136,7 @@ class FileMediaEngineTest : public testing::Test {
     engine_->set_voice_output_filename(voice_out);
     engine_->set_video_input_filename(video_in);
     engine_->set_video_output_filename(video_out);
-    engine_->set_rtp_sender_thread(talk_base::Thread::Current());
+    engine_->set_rtp_sender_thread(rtc::Thread::Current());
 
     voice_channel_.reset(engine_->CreateChannel());
     video_channel_.reset(engine_->CreateVideoChannel(NULL));
@@ -145,12 +145,12 @@ class FileMediaEngineTest : public testing::Test {
   }
 
   bool GetTempFilename(std::string* filename) {
-    talk_base::Pathname temp_path;
-    if (!talk_base::Filesystem::GetTemporaryFolder(temp_path, true, NULL)) {
+    rtc::Pathname temp_path;
+    if (!rtc::Filesystem::GetTemporaryFolder(temp_path, true, NULL)) {
       return false;
     }
     temp_path.SetPathname(
-        talk_base::Filesystem::TempFilename(temp_path, "fme-test-"));
+        rtc::Filesystem::TempFilename(temp_path, "fme-test-"));
 
     if (filename) {
       *filename = temp_path.pathname();
@@ -159,8 +159,8 @@ class FileMediaEngineTest : public testing::Test {
   }
 
   bool WriteTestPacketsToFile(const std::string& filename, size_t ssrc_count) {
-    talk_base::scoped_ptr<talk_base::StreamInterface> stream(
-        talk_base::Filesystem::OpenFile(talk_base::Pathname(filename), "wb"));
+    rtc::scoped_ptr<rtc::StreamInterface> stream(
+        rtc::Filesystem::OpenFile(rtc::Pathname(filename), "wb"));
     bool ret = (NULL != stream.get());
     RtpDumpWriter writer(stream.get());
 
@@ -174,19 +174,19 @@ class FileMediaEngineTest : public testing::Test {
   }
 
   void DeleteTempFile(std::string filename) {
-    talk_base::Pathname pathname(filename);
-    if (talk_base::Filesystem::IsFile(talk_base::Pathname(pathname))) {
-      talk_base::Filesystem::DeleteFile(pathname);
+    rtc::Pathname pathname(filename);
+    if (rtc::Filesystem::IsFile(rtc::Pathname(pathname))) {
+      rtc::Filesystem::DeleteFile(pathname);
     }
   }
 
-  bool GetSsrcAndPacketCounts(talk_base::StreamInterface* stream,
+  bool GetSsrcAndPacketCounts(rtc::StreamInterface* stream,
                               size_t* ssrc_count, size_t* packet_count) {
-    talk_base::scoped_ptr<RtpDumpReader> reader(new RtpDumpReader(stream));
+    rtc::scoped_ptr<RtpDumpReader> reader(new RtpDumpReader(stream));
     size_t count = 0;
     RtpDumpPacket packet;
     std::set<uint32> ssrcs;
-    while (talk_base::SR_SUCCESS == reader->ReadPacket(&packet)) {
+    while (rtc::SR_SUCCESS == reader->ReadPacket(&packet)) {
       count++;
       uint32 ssrc;
       if (!packet.GetRtpSsrc(&ssrc)) {
@@ -209,14 +209,14 @@ class FileMediaEngineTest : public testing::Test {
   std::string voice_output_filename_;
   std::string video_input_filename_;
   std::string video_output_filename_;
-  talk_base::scoped_ptr<FileMediaEngine> engine_;
-  talk_base::scoped_ptr<VoiceMediaChannel> voice_channel_;
-  talk_base::scoped_ptr<VideoMediaChannel> video_channel_;
+  rtc::scoped_ptr<FileMediaEngine> engine_;
+  rtc::scoped_ptr<VoiceMediaChannel> voice_channel_;
+  rtc::scoped_ptr<VideoMediaChannel> video_channel_;
 };
 
 TEST_F(FileMediaEngineTest, TestDefaultImplementation) {
   EXPECT_TRUE(CreateEngineAndChannels("", "", "", "", 1));
-  EXPECT_TRUE(engine_->Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_->Init(rtc::Thread::Current()));
   EXPECT_EQ(0, engine_->GetCapabilities());
   EXPECT_TRUE(NULL == voice_channel_.get());
   EXPECT_TRUE(NULL == video_channel_.get());
@@ -313,12 +313,12 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSetSend) {
   EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_,
                                       voice_output_filename_, "", "", 1));
   EXPECT_TRUE(NULL != voice_channel_.get());
-  talk_base::MemoryStream net_dump;
+  rtc::MemoryStream net_dump;
   FileNetworkInterface net_interface(&net_dump, voice_channel_.get());
   voice_channel_->SetInterface(&net_interface);
 
   // The channel is not sending yet.
-  talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+  rtc::Thread::Current()->ProcessMessages(kWaitTimeMs);
   EXPECT_EQ(0U, net_interface.num_sent_packets());
 
   // The channel starts sending.
@@ -328,9 +328,9 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSetSend) {
   // The channel stops sending.
   voice_channel_->SetSend(SEND_NOTHING);
   // Wait until packets are all delivered.
-  talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+  rtc::Thread::Current()->ProcessMessages(kWaitTimeMs);
   size_t old_number = net_interface.num_sent_packets();
-  talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+  rtc::Thread::Current()->ProcessMessages(kWaitTimeMs);
   EXPECT_EQ(old_number, net_interface.num_sent_packets());
 
   // The channel starts sending again.
@@ -342,7 +342,7 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSetSend) {
   // fault. We hence stop sending and wait until all packets are delivered
   // before we exit this function.
   voice_channel_->SetSend(SEND_NOTHING);
-  talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+  rtc::Thread::Current()->ProcessMessages(kWaitTimeMs);
 }
 
 // Test the sender thread of the channel. The sender sends RTP packets
@@ -351,7 +351,7 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThread) {
   EXPECT_TRUE(CreateEngineAndChannels(voice_input_filename_,
                                       voice_output_filename_, "", "", 1));
   EXPECT_TRUE(NULL != voice_channel_.get());
-  talk_base::MemoryStream net_dump;
+  rtc::MemoryStream net_dump;
   FileNetworkInterface net_interface(&net_dump, voice_channel_.get());
   voice_channel_->SetInterface(&net_interface);
 
@@ -363,7 +363,7 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThread) {
       kWaitTimeout);
   voice_channel_->SetSend(SEND_NOTHING);
   // Wait until packets are all delivered.
-  talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+  rtc::Thread::Current()->ProcessMessages(kWaitTimeMs);
   EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
       2 * RtpTestUtility::GetTestPacketCount(), &net_dump,
       RtpTestUtility::kDefaultSsrc));
@@ -372,9 +372,9 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThread) {
   // via OnPacketReceived, which in turn writes the packets into voice_output_.
   // We next verify the packets in voice_output_.
   voice_channel_.reset();  // Force to close the files.
-  talk_base::scoped_ptr<talk_base::StreamInterface> voice_output_;
-  voice_output_.reset(talk_base::Filesystem::OpenFile(
-      talk_base::Pathname(voice_output_filename_), "rb"));
+  rtc::scoped_ptr<rtc::StreamInterface> voice_output_;
+  voice_output_.reset(rtc::Filesystem::OpenFile(
+      rtc::Pathname(voice_output_filename_), "rb"));
   EXPECT_TRUE(voice_output_.get() != NULL);
   EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
       2 * RtpTestUtility::GetTestPacketCount(), voice_output_.get(),
@@ -389,7 +389,7 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSendSsrc) {
   const uint32 send_ssrc = RtpTestUtility::kDefaultSsrc + 1;
   voice_channel_->AddSendStream(StreamParams::CreateLegacy(send_ssrc));
 
-  talk_base::MemoryStream net_dump;
+  rtc::MemoryStream net_dump;
   FileNetworkInterface net_interface(&net_dump, voice_channel_.get());
   voice_channel_->SetInterface(&net_interface);
 
@@ -401,7 +401,7 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSendSsrc) {
       kWaitTimeout);
   voice_channel_->SetSend(SEND_NOTHING);
   // Wait until packets are all delivered.
-  talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+  rtc::Thread::Current()->ProcessMessages(kWaitTimeMs);
   EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
       2 * RtpTestUtility::GetTestPacketCount(), &net_dump, send_ssrc));
 
@@ -409,9 +409,9 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSendSsrc) {
   // via OnPacketReceived, which in turn writes the packets into voice_output_.
   // We next verify the packets in voice_output_.
   voice_channel_.reset();  // Force to close the files.
-  talk_base::scoped_ptr<talk_base::StreamInterface> voice_output_;
-  voice_output_.reset(talk_base::Filesystem::OpenFile(
-      talk_base::Pathname(voice_output_filename_), "rb"));
+  rtc::scoped_ptr<rtc::StreamInterface> voice_output_;
+  voice_output_.reset(rtc::Filesystem::OpenFile(
+      rtc::Pathname(voice_output_filename_), "rb"));
   EXPECT_TRUE(voice_output_.get() != NULL);
   EXPECT_TRUE(RtpTestUtility::VerifyTestPacketsFromStream(
       2 * RtpTestUtility::GetTestPacketCount(), voice_output_.get(),
@@ -425,9 +425,9 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThreadTwoSsrcs) {
   // Verify that voice_input_filename_ contains 2 *
   // RtpTestUtility::GetTestPacketCount() packets
   // with different SSRCs.
-  talk_base::scoped_ptr<talk_base::StreamInterface> input_stream(
-      talk_base::Filesystem::OpenFile(
-          talk_base::Pathname(voice_input_filename_), "rb"));
+  rtc::scoped_ptr<rtc::StreamInterface> input_stream(
+      rtc::Filesystem::OpenFile(
+          rtc::Pathname(voice_input_filename_), "rb"));
   ASSERT_TRUE(NULL != input_stream.get());
   size_t ssrc_count;
   size_t packet_count;
@@ -441,7 +441,7 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThreadTwoSsrcs) {
   // these packets have the same SSRCs (that is, the packets with different
   // SSRCs are skipped by the filemediaengine).
   EXPECT_TRUE(NULL != voice_channel_.get());
-  talk_base::MemoryStream net_dump;
+  rtc::MemoryStream net_dump;
   FileNetworkInterface net_interface(&net_dump, voice_channel_.get());
   voice_channel_->SetInterface(&net_interface);
   voice_channel_->SetSend(SEND_MICROPHONE);
@@ -451,7 +451,7 @@ TEST_F(FileMediaEngineTest, TestVoiceChannelSenderThreadTwoSsrcs) {
       kWaitTimeout);
   voice_channel_->SetSend(SEND_NOTHING);
   // Wait until packets are all delivered.
-  talk_base::Thread::Current()->ProcessMessages(kWaitTimeMs);
+  rtc::Thread::Current()->ProcessMessages(kWaitTimeMs);
   net_dump.Rewind();
   EXPECT_TRUE(GetSsrcAndPacketCounts(&net_dump, &ssrc_count, &packet_count));
   EXPECT_EQ(1U, ssrc_count);
diff --git a/talk/media/base/hybriddataengine.h b/talk/media/base/hybriddataengine.h
index bece492aa7..1d5b8b835d 100644
--- a/talk/media/base/hybriddataengine.h
+++ b/talk/media/base/hybriddataengine.h
@@ -31,7 +31,7 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/mediaengine.h"
@@ -66,8 +66,8 @@ class HybridDataEngine : public DataEngineInterface {
   virtual const std::vector<DataCodec>& data_codecs() { return codecs_; }
 
  private:
-  talk_base::scoped_ptr<DataEngineInterface> first_;
-  talk_base::scoped_ptr<DataEngineInterface> second_;
+  rtc::scoped_ptr<DataEngineInterface> first_;
+  rtc::scoped_ptr<DataEngineInterface> second_;
   std::vector<DataCodec> codecs_;
 };
 
diff --git a/talk/media/base/hybridvideoengine.cc b/talk/media/base/hybridvideoengine.cc
index 8e992f0abf..289c4fe944 100644
--- a/talk/media/base/hybridvideoengine.cc
+++ b/talk/media/base/hybridvideoengine.cc
@@ -27,7 +27,7 @@
 
 #include "talk/media/base/hybridvideoengine.h"
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 
 namespace cricket {
 
@@ -281,7 +281,7 @@ bool HybridVideoMediaChannel::GetStats(
 }
 
 void HybridVideoMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   // Eat packets until we have an active channel;
   if (active_channel_) {
     active_channel_->OnPacketReceived(packet, packet_time);
@@ -291,7 +291,7 @@ void HybridVideoMediaChannel::OnPacketReceived(
 }
 
 void HybridVideoMediaChannel::OnRtcpReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   // Eat packets until we have an active channel;
   if (active_channel_) {
     active_channel_->OnRtcpReceived(packet, packet_time);
diff --git a/talk/media/base/hybridvideoengine.h b/talk/media/base/hybridvideoengine.h
index 8cfb884f12..4d819c7ca5 100644
--- a/talk/media/base/hybridvideoengine.h
+++ b/talk/media/base/hybridvideoengine.h
@@ -31,8 +31,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/logging.h"
-#include "talk/base/sigslotrepeater.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/sigslotrepeater.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/videocapturer.h"
@@ -88,10 +88,10 @@ class HybridVideoMediaChannel : public VideoMediaChannel {
 
   virtual bool GetStats(const StatsOptions& options, VideoMediaInfo* info);
 
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time);
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time);
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time);
   virtual void OnReadyToSend(bool ready);
 
   virtual void UpdateAspectRatio(int ratio_w, int ratio_h);
@@ -110,8 +110,8 @@ class HybridVideoMediaChannel : public VideoMediaChannel {
   void OnMediaError(uint32 ssrc, Error error);
 
   HybridVideoEngineInterface* engine_;
-  talk_base::scoped_ptr<VideoMediaChannel> channel1_;
-  talk_base::scoped_ptr<VideoMediaChannel> channel2_;
+  rtc::scoped_ptr<VideoMediaChannel> channel1_;
+  rtc::scoped_ptr<VideoMediaChannel> channel2_;
   VideoMediaChannel* active_channel_;
   bool sending_;
 };
@@ -149,7 +149,7 @@ class HybridVideoEngine : public HybridVideoEngineInterface {
     SignalCaptureStateChange.repeat(video2_.SignalCaptureStateChange);
   }
 
-  bool Init(talk_base::Thread* worker_thread) {
+  bool Init(rtc::Thread* worker_thread) {
     if (!video1_.Init(worker_thread)) {
       LOG(LS_ERROR) << "Failed to init VideoEngine1";
       return false;
@@ -170,13 +170,13 @@ class HybridVideoEngine : public HybridVideoEngineInterface {
     return (video1_.GetCapabilities() | video2_.GetCapabilities());
   }
   HybridVideoMediaChannel* CreateChannel(VoiceMediaChannel* channel) {
-    talk_base::scoped_ptr<VideoMediaChannel> channel1(
+    rtc::scoped_ptr<VideoMediaChannel> channel1(
         video1_.CreateChannel(channel));
     if (!channel1) {
       LOG(LS_ERROR) << "Failed to create VideoMediaChannel1";
       return NULL;
     }
-    talk_base::scoped_ptr<VideoMediaChannel> channel2(
+    rtc::scoped_ptr<VideoMediaChannel> channel2(
         video2_.CreateChannel(channel));
     if (!channel2) {
       LOG(LS_ERROR) << "Failed to create VideoMediaChannel2";
diff --git a/talk/media/base/hybridvideoengine_unittest.cc b/talk/media/base/hybridvideoengine_unittest.cc
index aa9d4ac207..df7e1fa10c 100644
--- a/talk/media/base/hybridvideoengine_unittest.cc
+++ b/talk/media/base/hybridvideoengine_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakenetworkinterface.h"
 #include "talk/media/base/fakevideocapturer.h"
@@ -116,7 +116,7 @@ class HybridVideoEngineTest : public testing::Test {
     engine_.Terminate();
   }
   bool SetupEngine() {
-    bool result = engine_.Init(talk_base::Thread::Current());
+    bool result = engine_.Init(rtc::Thread::Current());
     if (result) {
       channel_.reset(engine_.CreateChannel(NULL));
       result = (channel_.get() != NULL);
@@ -134,12 +134,12 @@ class HybridVideoEngineTest : public testing::Test {
         channel_->SetRender(true);
   }
   void DeliverPacket(const void* data, int len) {
-    talk_base::Buffer packet(data, len);
-    channel_->OnPacketReceived(&packet, talk_base::CreatePacketTime(0));
+    rtc::Buffer packet(data, len);
+    channel_->OnPacketReceived(&packet, rtc::CreatePacketTime(0));
   }
   void DeliverRtcp(const void* data, int len) {
-    talk_base::Buffer packet(data, len);
-    channel_->OnRtcpReceived(&packet, talk_base::CreatePacketTime(0));
+    rtc::Buffer packet(data, len);
+    channel_->OnRtcpReceived(&packet, rtc::CreatePacketTime(0));
   }
 
  protected:
@@ -166,14 +166,14 @@ class HybridVideoEngineTest : public testing::Test {
     EXPECT_EQ(max_bitrate, sub_channel->max_bps());
   }
   HybridVideoEngineForTest engine_;
-  talk_base::scoped_ptr<cricket::HybridVideoMediaChannel> channel_;
-  talk_base::scoped_ptr<cricket::FakeNetworkInterface> transport_;
+  rtc::scoped_ptr<cricket::HybridVideoMediaChannel> channel_;
+  rtc::scoped_ptr<cricket::FakeNetworkInterface> transport_;
   cricket::FakeVideoMediaChannel* sub_channel1_;
   cricket::FakeVideoMediaChannel* sub_channel2_;
 };
 
 TEST_F(HybridVideoEngineTest, StartupShutdown) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   engine_.Terminate();
 }
 
diff --git a/talk/media/base/mediachannel.h b/talk/media/base/mediachannel.h
index ab5bdb4d7c..c45ae2972f 100644
--- a/talk/media/base/mediachannel.h
+++ b/talk/media/base/mediachannel.h
@@ -31,20 +31,20 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/buffer.h"
-#include "talk/base/dscp.h"
-#include "talk/base/logging.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/socket.h"
-#include "talk/base/window.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/dscp.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/socket.h"
+#include "webrtc/base/window.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/streamparams.h"
 // TODO(juberti): re-evaluate this include
 #include "talk/session/media/audiomonitor.h"
 
-namespace talk_base {
+namespace rtc {
 class Buffer;
 class RateLimiter;
 class Timing;
@@ -104,7 +104,7 @@ class Settable {
   }
 
   std::string ToString() const {
-    return set_ ? talk_base::ToString(val_) : "";
+    return set_ ? rtc::ToString(val_) : "";
   }
 
   bool operator==(const Settable<T>& o) const {
@@ -560,12 +560,12 @@ class MediaChannel : public sigslot::has_slots<> {
    public:
     enum SocketType { ST_RTP, ST_RTCP };
     virtual bool SendPacket(
-        talk_base::Buffer* packet,
-        talk_base::DiffServCodePoint dscp = talk_base::DSCP_NO_CHANGE) = 0;
+        rtc::Buffer* packet,
+        rtc::DiffServCodePoint dscp = rtc::DSCP_NO_CHANGE) = 0;
     virtual bool SendRtcp(
-        talk_base::Buffer* packet,
-        talk_base::DiffServCodePoint dscp = talk_base::DSCP_NO_CHANGE) = 0;
-    virtual int SetOption(SocketType type, talk_base::Socket::Option opt,
+        rtc::Buffer* packet,
+        rtc::DiffServCodePoint dscp = rtc::DSCP_NO_CHANGE) = 0;
+    virtual int SetOption(SocketType type, rtc::Socket::Option opt,
                           int option) = 0;
     virtual ~NetworkInterface() {}
   };
@@ -575,16 +575,16 @@ class MediaChannel : public sigslot::has_slots<> {
 
   // Sets the abstract interface class for sending RTP/RTCP data.
   virtual void SetInterface(NetworkInterface *iface) {
-    talk_base::CritScope cs(&network_interface_crit_);
+    rtc::CritScope cs(&network_interface_crit_);
     network_interface_ = iface;
   }
 
   // Called when a RTP packet is received.
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time) = 0;
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time) = 0;
   // Called when a RTCP packet is received.
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) = 0;
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time) = 0;
   // Called when the socket's ability to send has changed.
   virtual void OnReadyToSend(bool ready) = 0;
   // Creates a new outgoing media stream with SSRCs and CNAME as described
@@ -620,18 +620,18 @@ class MediaChannel : public sigslot::has_slots<> {
   virtual bool SetMaxSendBandwidth(int bps) = 0;
 
   // Base method to send packet using NetworkInterface.
-  bool SendPacket(talk_base::Buffer* packet) {
+  bool SendPacket(rtc::Buffer* packet) {
     return DoSendPacket(packet, false);
   }
 
-  bool SendRtcp(talk_base::Buffer* packet) {
+  bool SendRtcp(rtc::Buffer* packet) {
     return DoSendPacket(packet, true);
   }
 
   int SetOption(NetworkInterface::SocketType type,
-                talk_base::Socket::Option opt,
+                rtc::Socket::Option opt,
                 int option) {
-    talk_base::CritScope cs(&network_interface_crit_);
+    rtc::CritScope cs(&network_interface_crit_);
     if (!network_interface_)
       return -1;
 
@@ -640,22 +640,22 @@ class MediaChannel : public sigslot::has_slots<> {
 
  protected:
   // This method sets DSCP |value| on both RTP and RTCP channels.
-  int SetDscp(talk_base::DiffServCodePoint value) {
+  int SetDscp(rtc::DiffServCodePoint value) {
     int ret;
     ret = SetOption(NetworkInterface::ST_RTP,
-                    talk_base::Socket::OPT_DSCP,
+                    rtc::Socket::OPT_DSCP,
                     value);
     if (ret == 0) {
       ret = SetOption(NetworkInterface::ST_RTCP,
-                      talk_base::Socket::OPT_DSCP,
+                      rtc::Socket::OPT_DSCP,
                       value);
     }
     return ret;
   }
 
  private:
-  bool DoSendPacket(talk_base::Buffer* packet, bool rtcp) {
-    talk_base::CritScope cs(&network_interface_crit_);
+  bool DoSendPacket(rtc::Buffer* packet, bool rtcp) {
+    rtc::CritScope cs(&network_interface_crit_);
     if (!network_interface_)
       return false;
 
@@ -666,7 +666,7 @@ class MediaChannel : public sigslot::has_slots<> {
   // |network_interface_| can be accessed from the worker_thread and
   // from any MediaEngine threads. This critical section is to protect accessing
   // of network_interface_ object.
-  talk_base::CriticalSection network_interface_crit_;
+  rtc::CriticalSection network_interface_crit_;
   NetworkInterface* network_interface_;
 };
 
@@ -1288,7 +1288,7 @@ class DataMediaChannel : public MediaChannel {
 
   virtual bool SendData(
       const SendDataParams& params,
-      const talk_base::Buffer& payload,
+      const rtc::Buffer& payload,
       SendDataResult* result = NULL) = 0;
   // Signals when data is received (params, data, len)
   sigslot::signal3<const ReceiveDataParams&,
diff --git a/talk/media/base/mediacommon.h b/talk/media/base/mediacommon.h
index e0d7ecaa70..6eb545773d 100644
--- a/talk/media/base/mediacommon.h
+++ b/talk/media/base/mediacommon.h
@@ -28,7 +28,7 @@
 #ifndef TALK_MEDIA_BASE_MEDIACOMMON_H_
 #define TALK_MEDIA_BASE_MEDIACOMMON_H_
 
-#include "talk/base/stringencode.h"
+#include "webrtc/base/stringencode.h"
 
 namespace cricket {
 
diff --git a/talk/media/base/mediaengine.h b/talk/media/base/mediaengine.h
index 326b722bd0..23804307c6 100644
--- a/talk/media/base/mediaengine.h
+++ b/talk/media/base/mediaengine.h
@@ -37,8 +37,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/fileutils.h"
-#include "talk/base/sigslotrepeater.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/sigslotrepeater.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/mediacommon.h"
@@ -69,7 +69,7 @@ class MediaEngineInterface {
 
   // Initialization
   // Starts the engine.
-  virtual bool Init(talk_base::Thread* worker_thread) = 0;
+  virtual bool Init(rtc::Thread* worker_thread) = 0;
   // Shuts down the engine.
   virtual void Terminate() = 0;
   // Returns what the engine is capable of, as a set of Capabilities, above.
@@ -138,7 +138,7 @@ class MediaEngineInterface {
   virtual void SetVideoLogging(int min_sev, const char* filter) = 0;
 
   // Starts AEC dump using existing file.
-  virtual bool StartAecDump(talk_base::PlatformFile file) = 0;
+  virtual bool StartAecDump(rtc::PlatformFile file) = 0;
 
   // Voice processors for effects.
   virtual bool RegisterVoiceProcessor(uint32 ssrc,
@@ -180,7 +180,7 @@ class CompositeMediaEngine : public MediaEngineInterface {
  public:
   CompositeMediaEngine() {}
   virtual ~CompositeMediaEngine() {}
-  virtual bool Init(talk_base::Thread* worker_thread) {
+  virtual bool Init(rtc::Thread* worker_thread) {
     if (!voice_.Init(worker_thread))
       return false;
     if (!video_.Init(worker_thread)) {
@@ -269,7 +269,7 @@ class CompositeMediaEngine : public MediaEngineInterface {
     video_.SetLogging(min_sev, filter);
   }
 
-  virtual bool StartAecDump(talk_base::PlatformFile file) {
+  virtual bool StartAecDump(rtc::PlatformFile file) {
     return voice_.StartAecDump(file);
   }
 
@@ -301,7 +301,7 @@ class CompositeMediaEngine : public MediaEngineInterface {
 // a video engine is desired.
 class NullVoiceEngine {
  public:
-  bool Init(talk_base::Thread* worker_thread) { return true; }
+  bool Init(rtc::Thread* worker_thread) { return true; }
   void Terminate() {}
   int GetCapabilities() { return 0; }
   // If you need this to return an actual channel, use FakeMediaEngine instead.
@@ -329,7 +329,7 @@ class NullVoiceEngine {
     return rtp_header_extensions_;
   }
   void SetLogging(int min_sev, const char* filter) {}
-  bool StartAecDump(talk_base::PlatformFile file) { return false; }
+  bool StartAecDump(rtc::PlatformFile file) { return false; }
   bool RegisterProcessor(uint32 ssrc,
                          VoiceProcessor* voice_processor,
                          MediaProcessorDirection direction) { return true; }
@@ -346,7 +346,7 @@ class NullVoiceEngine {
 // a voice engine is desired.
 class NullVideoEngine {
  public:
-  bool Init(talk_base::Thread* worker_thread) { return true; }
+  bool Init(rtc::Thread* worker_thread) { return true; }
   void Terminate() {}
   int GetCapabilities() { return 0; }
   // If you need this to return an actual channel, use FakeMediaEngine instead.
diff --git a/talk/media/base/mutedvideocapturer.cc b/talk/media/base/mutedvideocapturer.cc
index 0c74b9fd91..6ff60a061b 100644
--- a/talk/media/base/mutedvideocapturer.cc
+++ b/talk/media/base/mutedvideocapturer.cc
@@ -25,8 +25,8 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/mutedvideocapturer.h"
 #include "talk/media/base/videoframe.h"
 
@@ -39,7 +39,7 @@ namespace cricket {
 
 const char MutedVideoCapturer::kCapturerId[] = "muted_camera";
 
-class MutedFramesGenerator : public talk_base::MessageHandler {
+class MutedFramesGenerator : public rtc::MessageHandler {
  public:
   explicit MutedFramesGenerator(const VideoFormat& format);
   virtual ~MutedFramesGenerator();
@@ -49,11 +49,11 @@ class MutedFramesGenerator : public talk_base::MessageHandler {
   sigslot::signal1<VideoFrame*> SignalFrame;
 
  protected:
-  virtual void OnMessage(talk_base::Message* message);
+  virtual void OnMessage(rtc::Message* message);
 
  private:
-  talk_base::Thread capture_thread_;
-  talk_base::scoped_ptr<VideoFrame> muted_frame_;
+  rtc::Thread capture_thread_;
+  rtc::scoped_ptr<VideoFrame> muted_frame_;
   const VideoFormat format_;
   const int interval_;
   uint32 create_time_;
@@ -62,15 +62,15 @@ class MutedFramesGenerator : public talk_base::MessageHandler {
 MutedFramesGenerator::MutedFramesGenerator(const VideoFormat& format)
     : format_(format),
       interval_(static_cast<int>(format.interval /
-                                 talk_base::kNumNanosecsPerMillisec)),
-      create_time_(talk_base::Time()) {
+                                 rtc::kNumNanosecsPerMillisec)),
+      create_time_(rtc::Time()) {
   capture_thread_.Start();
   capture_thread_.PostDelayed(interval_, this);
 }
 
 MutedFramesGenerator::~MutedFramesGenerator() { capture_thread_.Clear(this); }
 
-void MutedFramesGenerator::OnMessage(talk_base::Message* message) {
+void MutedFramesGenerator::OnMessage(rtc::Message* message) {
   // Queue a new frame as soon as possible to minimize drift.
   capture_thread_.PostDelayed(interval_, this);
   if (!muted_frame_) {
@@ -83,7 +83,7 @@ void MutedFramesGenerator::OnMessage(talk_base::Message* message) {
     return;
 #endif
   }
-  uint32 current_timestamp = talk_base::Time();
+  uint32 current_timestamp = rtc::Time();
   // Delta between create time and current time will be correct even if there is
   // a wraparound since they are unsigned integers.
   uint32 elapsed_time = current_timestamp - create_time_;
diff --git a/talk/media/base/mutedvideocapturer.h b/talk/media/base/mutedvideocapturer.h
index fb249a94a9..11512bcb6c 100644
--- a/talk/media/base/mutedvideocapturer.h
+++ b/talk/media/base/mutedvideocapturer.h
@@ -28,7 +28,7 @@
 #ifndef TALK_MEDIA_BASE_MUTEDVIDEOCAPTURER_H_
 #define TALK_MEDIA_BASE_MUTEDVIDEOCAPTURER_H_
 
-#include "talk/base/thread.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/videocapturer.h"
 
 namespace cricket {
@@ -52,7 +52,7 @@ class MutedVideoCapturer : public VideoCapturer {
  protected:
   void OnMutedFrame(VideoFrame* muted_frame);
 
-  talk_base::scoped_ptr<MutedFramesGenerator> frame_generator_;
+  rtc::scoped_ptr<MutedFramesGenerator> frame_generator_;
 };
 
 }  // namespace cricket
diff --git a/talk/media/base/mutedvideocapturer_unittest.cc b/talk/media/base/mutedvideocapturer_unittest.cc
index dfb56dfef6..739874fd9e 100644
--- a/talk/media/base/mutedvideocapturer_unittest.cc
+++ b/talk/media/base/mutedvideocapturer_unittest.cc
@@ -27,7 +27,7 @@
 
 #include "talk/media/base/mutedvideocapturer.h"
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/videoframe.h"
 
 class MutedVideoCapturerTest : public sigslot::has_slots<>,
diff --git a/talk/media/base/rtpdataengine.cc b/talk/media/base/rtpdataengine.cc
index 3d0efc43b0..4505911268 100644
--- a/talk/media/base/rtpdataengine.cc
+++ b/talk/media/base/rtpdataengine.cc
@@ -27,11 +27,11 @@
 
 #include "talk/media/base/rtpdataengine.h"
 
-#include "talk/base/buffer.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/ratelimiter.h"
-#include "talk/base/timing.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/ratelimiter.h"
+#include "webrtc/base/timing.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/rtputils.h"
@@ -55,7 +55,7 @@ RtpDataEngine::RtpDataEngine() {
   data_codecs_.push_back(
       DataCodec(kGoogleRtpDataCodecId,
                 kGoogleRtpDataCodecName, 0));
-  SetTiming(new talk_base::Timing());
+  SetTiming(new rtc::Timing());
 }
 
 DataMediaChannel* RtpDataEngine::CreateChannel(
@@ -92,7 +92,7 @@ bool FindCodecByName(const std::vector<DataCodec>& codecs,
   return false;
 }
 
-RtpDataMediaChannel::RtpDataMediaChannel(talk_base::Timing* timing) {
+RtpDataMediaChannel::RtpDataMediaChannel(rtc::Timing* timing) {
   Construct(timing);
 }
 
@@ -100,11 +100,11 @@ RtpDataMediaChannel::RtpDataMediaChannel() {
   Construct(NULL);
 }
 
-void RtpDataMediaChannel::Construct(talk_base::Timing* timing) {
+void RtpDataMediaChannel::Construct(rtc::Timing* timing) {
   sending_ = false;
   receiving_ = false;
   timing_ = timing;
-  send_limiter_.reset(new talk_base::RateLimiter(kDataMaxBandwidth / 8, 1.0));
+  send_limiter_.reset(new rtc::RateLimiter(kDataMaxBandwidth / 8, 1.0));
 }
 
 
@@ -187,7 +187,7 @@ bool RtpDataMediaChannel::AddSendStream(const StreamParams& stream) {
   // And we should probably allow more than one per stream.
   rtp_clock_by_send_ssrc_[stream.first_ssrc()] = new RtpClock(
       kDataCodecClockrate,
-      talk_base::CreateRandomNonZeroId(), talk_base::CreateRandomNonZeroId());
+      rtc::CreateRandomNonZeroId(), rtc::CreateRandomNonZeroId());
 
   LOG(LS_INFO) << "Added data send stream '" << stream.id
                << "' with ssrc=" << stream.first_ssrc();
@@ -231,7 +231,7 @@ bool RtpDataMediaChannel::RemoveRecvStream(uint32 ssrc) {
 }
 
 void RtpDataMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   RtpHeader header;
   if (!GetRtpHeader(packet->data(), packet->length(), &header)) {
     // Don't want to log for every corrupt packet.
@@ -294,14 +294,14 @@ bool RtpDataMediaChannel::SetMaxSendBandwidth(int bps) {
   if (bps <= 0) {
     bps = kDataMaxBandwidth;
   }
-  send_limiter_.reset(new talk_base::RateLimiter(bps / 8, 1.0));
+  send_limiter_.reset(new rtc::RateLimiter(bps / 8, 1.0));
   LOG(LS_INFO) << "RtpDataMediaChannel::SetSendBandwidth to " << bps << "bps.";
   return true;
 }
 
 bool RtpDataMediaChannel::SendData(
     const SendDataParams& params,
-    const talk_base::Buffer& payload,
+    const rtc::Buffer& payload,
     SendDataResult* result) {
   if (result) {
     // If we return true, we'll set this to SDR_SUCCESS.
@@ -353,7 +353,7 @@ bool RtpDataMediaChannel::SendData(
   rtp_clock_by_send_ssrc_[header.ssrc]->Tick(
       now, &header.seq_num, &header.timestamp);
 
-  talk_base::Buffer packet;
+  rtc::Buffer packet;
   packet.SetCapacity(packet_len);
   packet.SetLength(kMinRtpPacketLen);
   if (!SetRtpHeader(packet.data(), packet.length(), header)) {
diff --git a/talk/media/base/rtpdataengine.h b/talk/media/base/rtpdataengine.h
index d5abeef68a..6dc578806d 100644
--- a/talk/media/base/rtpdataengine.h
+++ b/talk/media/base/rtpdataengine.h
@@ -31,7 +31,7 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/timing.h"
+#include "webrtc/base/timing.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/mediaengine.h"
@@ -51,13 +51,13 @@ class RtpDataEngine : public DataEngineInterface {
   }
 
   // Mostly for testing with a fake clock.  Ownership is passed in.
-  void SetTiming(talk_base::Timing* timing) {
+  void SetTiming(rtc::Timing* timing) {
     timing_.reset(timing);
   }
 
  private:
   std::vector<DataCodec> data_codecs_;
-  talk_base::scoped_ptr<talk_base::Timing> timing_;
+  rtc::scoped_ptr<rtc::Timing> timing_;
 };
 
 // Keep track of sequence number and timestamp of an RTP stream.  The
@@ -86,13 +86,13 @@ class RtpClock {
 class RtpDataMediaChannel : public DataMediaChannel {
  public:
   // Timing* Used for the RtpClock
-  explicit RtpDataMediaChannel(talk_base::Timing* timing);
+  explicit RtpDataMediaChannel(rtc::Timing* timing);
   // Sets Timing == NULL, so you'll need to call set_timer() before
   // using it.  This is needed by FakeMediaEngine.
   RtpDataMediaChannel();
   virtual ~RtpDataMediaChannel();
 
-  void set_timing(talk_base::Timing* timing) {
+  void set_timing(rtc::Timing* timing) {
     timing_ = timing;
   }
 
@@ -116,28 +116,28 @@ class RtpDataMediaChannel : public DataMediaChannel {
     receiving_ = receive;
     return true;
   }
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {}
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time);
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time) {}
   virtual void OnReadyToSend(bool ready) {}
   virtual bool SendData(
     const SendDataParams& params,
-    const talk_base::Buffer& payload,
+    const rtc::Buffer& payload,
     SendDataResult* result);
 
  private:
-  void Construct(talk_base::Timing* timing);
+  void Construct(rtc::Timing* timing);
 
   bool sending_;
   bool receiving_;
-  talk_base::Timing* timing_;
+  rtc::Timing* timing_;
   std::vector<DataCodec> send_codecs_;
   std::vector<DataCodec> recv_codecs_;
   std::vector<StreamParams> send_streams_;
   std::vector<StreamParams> recv_streams_;
   std::map<uint32, RtpClock*> rtp_clock_by_send_ssrc_;
-  talk_base::scoped_ptr<talk_base::RateLimiter> send_limiter_;
+  rtc::scoped_ptr<rtc::RateLimiter> send_limiter_;
 };
 
 }  // namespace cricket
diff --git a/talk/media/base/rtpdataengine_unittest.cc b/talk/media/base/rtpdataengine_unittest.cc
index 640c18dbfc..034df54285 100644
--- a/talk/media/base/rtpdataengine_unittest.cc
+++ b/talk/media/base/rtpdataengine_unittest.cc
@@ -27,18 +27,18 @@
 
 #include <string>
 
-#include "talk/base/buffer.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/timing.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/timing.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/fakenetworkinterface.h"
 #include "talk/media/base/rtpdataengine.h"
 #include "talk/media/base/rtputils.h"
 
-class FakeTiming : public talk_base::Timing {
+class FakeTiming : public rtc::Timing {
  public:
   FakeTiming() : now_(0.0) {}
 
@@ -84,11 +84,11 @@ class FakeDataReceiver : public sigslot::has_slots<> {
 class RtpDataMediaChannelTest : public testing::Test {
  protected:
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   virtual void SetUp() {
@@ -149,7 +149,7 @@ class RtpDataMediaChannelTest : public testing::Test {
 
   std::string GetSentData(int index) {
     // Assume RTP header of length 12
-    talk_base::scoped_ptr<const talk_base::Buffer> packet(
+    rtc::scoped_ptr<const rtc::Buffer> packet(
         iface_->GetRtpPacket(index));
     if (packet->length() > 12) {
       return std::string(packet->data() + 12, packet->length() - 12);
@@ -159,7 +159,7 @@ class RtpDataMediaChannelTest : public testing::Test {
   }
 
   cricket::RtpHeader GetSentDataHeader(int index) {
-    talk_base::scoped_ptr<const talk_base::Buffer> packet(
+    rtc::scoped_ptr<const rtc::Buffer> packet(
         iface_->GetRtpPacket(index));
     cricket::RtpHeader header;
     GetRtpHeader(packet->data(), packet->length(), &header);
@@ -167,15 +167,15 @@ class RtpDataMediaChannelTest : public testing::Test {
   }
 
  private:
-  talk_base::scoped_ptr<cricket::RtpDataEngine> dme_;
+  rtc::scoped_ptr<cricket::RtpDataEngine> dme_;
   // Timing passed into dme_.  Owned by dme_;
   FakeTiming* timing_;
-  talk_base::scoped_ptr<cricket::FakeNetworkInterface> iface_;
-  talk_base::scoped_ptr<FakeDataReceiver> receiver_;
+  rtc::scoped_ptr<cricket::FakeNetworkInterface> iface_;
+  rtc::scoped_ptr<FakeDataReceiver> receiver_;
 };
 
 TEST_F(RtpDataMediaChannelTest, SetUnknownCodecs) {
-  talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::DataCodec known_codec;
   known_codec.id = 103;
@@ -203,7 +203,7 @@ TEST_F(RtpDataMediaChannelTest, SetUnknownCodecs) {
 }
 
 TEST_F(RtpDataMediaChannelTest, AddRemoveSendStream) {
-  talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::StreamParams stream1;
   stream1.add_ssrc(41);
@@ -218,7 +218,7 @@ TEST_F(RtpDataMediaChannelTest, AddRemoveSendStream) {
 }
 
 TEST_F(RtpDataMediaChannelTest, AddRemoveRecvStream) {
-  talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::StreamParams stream1;
   stream1.add_ssrc(41);
@@ -233,12 +233,12 @@ TEST_F(RtpDataMediaChannelTest, AddRemoveRecvStream) {
 }
 
 TEST_F(RtpDataMediaChannelTest, SendData) {
-  talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   cricket::SendDataParams params;
   params.ssrc = 42;
   unsigned char data[] = "food";
-  talk_base::Buffer payload(data, 4);
+  rtc::Buffer payload(data, 4);
   unsigned char padded_data[] = {
     0x00, 0x00, 0x00, 0x00,
     'f', 'o', 'o', 'd',
@@ -275,7 +275,7 @@ TEST_F(RtpDataMediaChannelTest, SendData) {
   // Length too large;
   std::string x10000(10000, 'x');
   EXPECT_FALSE(dmc->SendData(
-      params, talk_base::Buffer(x10000.data(), x10000.length()), &result));
+      params, rtc::Buffer(x10000.data(), x10000.length()), &result));
   EXPECT_EQ(cricket::SDR_ERROR, result);
   EXPECT_FALSE(HasSentData(0));
 
@@ -311,12 +311,12 @@ TEST_F(RtpDataMediaChannelTest, SendData) {
 TEST_F(RtpDataMediaChannelTest, SendDataMultipleClocks) {
   // Timings owned by RtpDataEngines.
   FakeTiming* timing1 = new FakeTiming();
-  talk_base::scoped_ptr<cricket::RtpDataEngine> dme1(CreateEngine(timing1));
-  talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc1(
+  rtc::scoped_ptr<cricket::RtpDataEngine> dme1(CreateEngine(timing1));
+  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc1(
       CreateChannel(dme1.get()));
   FakeTiming* timing2 = new FakeTiming();
-  talk_base::scoped_ptr<cricket::RtpDataEngine> dme2(CreateEngine(timing2));
-  talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc2(
+  rtc::scoped_ptr<cricket::RtpDataEngine> dme2(CreateEngine(timing2));
+  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc2(
       CreateChannel(dme2.get()));
 
   ASSERT_TRUE(dmc1->SetSend(true));
@@ -343,7 +343,7 @@ TEST_F(RtpDataMediaChannelTest, SendDataMultipleClocks) {
   params2.ssrc = 42;
 
   unsigned char data[] = "foo";
-  talk_base::Buffer payload(data, 3);
+  rtc::Buffer payload(data, 3);
   cricket::SendDataResult result;
 
   EXPECT_TRUE(dmc1->SendData(params1, payload, &result));
@@ -372,7 +372,7 @@ TEST_F(RtpDataMediaChannelTest, SendDataMultipleClocks) {
 }
 
 TEST_F(RtpDataMediaChannelTest, SendDataRate) {
-  talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   ASSERT_TRUE(dmc->SetSend(true));
 
@@ -390,7 +390,7 @@ TEST_F(RtpDataMediaChannelTest, SendDataRate) {
   cricket::SendDataParams params;
   params.ssrc = 42;
   unsigned char data[] = "food";
-  talk_base::Buffer payload(data, 4);
+  rtc::Buffer payload(data, 4);
   cricket::SendDataResult result;
 
   // With rtp overhead of 32 bytes, each one of our packets is 36
@@ -427,18 +427,18 @@ TEST_F(RtpDataMediaChannelTest, ReceiveData) {
     0x00, 0x00, 0x00, 0x00,
     'a', 'b', 'c', 'd', 'e'
   };
-  talk_base::Buffer packet(data, sizeof(data));
+  rtc::Buffer packet(data, sizeof(data));
 
-  talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // SetReceived not called.
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 
   dmc->SetReceive(true);
 
   // Unknown payload id
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 
   cricket::DataCodec codec;
@@ -449,7 +449,7 @@ TEST_F(RtpDataMediaChannelTest, ReceiveData) {
   ASSERT_TRUE(dmc->SetRecvCodecs(codecs));
 
   // Unknown stream
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 
   cricket::StreamParams stream;
@@ -457,7 +457,7 @@ TEST_F(RtpDataMediaChannelTest, ReceiveData) {
   ASSERT_TRUE(dmc->AddRecvStream(stream));
 
   // Finally works!
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_TRUE(HasReceivedData());
   EXPECT_EQ("abcde", GetReceivedData());
   EXPECT_EQ(5U, GetReceivedDataLen());
@@ -467,11 +467,11 @@ TEST_F(RtpDataMediaChannelTest, InvalidRtpPackets) {
   unsigned char data[] = {
     0x80, 0x65, 0x00, 0x02
   };
-  talk_base::Buffer packet(data, sizeof(data));
+  rtc::Buffer packet(data, sizeof(data));
 
-  talk_base::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
+  rtc::scoped_ptr<cricket::RtpDataMediaChannel> dmc(CreateChannel());
 
   // Too short
-  dmc->OnPacketReceived(&packet, talk_base::PacketTime());
+  dmc->OnPacketReceived(&packet, rtc::PacketTime());
   EXPECT_FALSE(HasReceivedData());
 }
diff --git a/talk/media/base/rtpdump.cc b/talk/media/base/rtpdump.cc
index 10c835c8c3..0b09b2a13f 100644
--- a/talk/media/base/rtpdump.cc
+++ b/talk/media/base/rtpdump.cc
@@ -31,9 +31,9 @@
 
 #include <string>
 
-#include "talk/base/byteorder.h"
-#include "talk/base/logging.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/media/base/rtputils.h"
 
 namespace {
@@ -53,7 +53,7 @@ RtpDumpFileHeader::RtpDumpFileHeader(uint32 start_ms, uint32 s, uint16 p)
       padding(0) {
 }
 
-void RtpDumpFileHeader::WriteToByteBuffer(talk_base::ByteBuffer* buf) {
+void RtpDumpFileHeader::WriteToByteBuffer(rtc::ByteBuffer* buf) {
   buf->WriteUInt32(start_sec);
   buf->WriteUInt32(start_usec);
   buf->WriteUInt32(source);
@@ -111,14 +111,14 @@ void RtpDumpReader::SetSsrc(uint32 ssrc) {
   ssrc_override_ = ssrc;
 }
 
-talk_base::StreamResult RtpDumpReader::ReadPacket(RtpDumpPacket* packet) {
-  if (!packet) return talk_base::SR_ERROR;
+rtc::StreamResult RtpDumpReader::ReadPacket(RtpDumpPacket* packet) {
+  if (!packet) return rtc::SR_ERROR;
 
-  talk_base::StreamResult res = talk_base::SR_SUCCESS;
+  rtc::StreamResult res = rtc::SR_SUCCESS;
   // Read the file header if it has not been read yet.
   if (!file_header_read_) {
     res = ReadFileHeader();
-    if (res != talk_base::SR_SUCCESS) {
+    if (res != rtc::SR_SUCCESS) {
       return res;
     }
     file_header_read_ = true;
@@ -127,10 +127,10 @@ talk_base::StreamResult RtpDumpReader::ReadPacket(RtpDumpPacket* packet) {
   // Read the RTP dump packet header.
   char header[RtpDumpPacket::kHeaderLength];
   res = stream_->ReadAll(header, sizeof(header), NULL, NULL);
-  if (res != talk_base::SR_SUCCESS) {
+  if (res != rtc::SR_SUCCESS) {
     return res;
   }
-  talk_base::ByteBuffer buf(header, sizeof(header));
+  rtc::ByteBuffer buf(header, sizeof(header));
   uint16 dump_packet_len;
   uint16 data_len;
   // Read the full length of the rtpdump packet, including the rtpdump header.
@@ -150,31 +150,31 @@ talk_base::StreamResult RtpDumpReader::ReadPacket(RtpDumpPacket* packet) {
 
   // If the packet is RTP and we have specified a ssrc, replace the RTP ssrc
   // with the specified ssrc.
-  if (res == talk_base::SR_SUCCESS &&
+  if (res == rtc::SR_SUCCESS &&
       packet->IsValidRtpPacket() &&
       ssrc_override_ != 0) {
-    talk_base::SetBE32(&packet->data[kRtpSsrcOffset], ssrc_override_);
+    rtc::SetBE32(&packet->data[kRtpSsrcOffset], ssrc_override_);
   }
 
   return res;
 }
 
-talk_base::StreamResult RtpDumpReader::ReadFileHeader() {
+rtc::StreamResult RtpDumpReader::ReadFileHeader() {
   // Read the first line.
   std::string first_line;
-  talk_base::StreamResult res = stream_->ReadLine(&first_line);
-  if (res != talk_base::SR_SUCCESS) {
+  rtc::StreamResult res = stream_->ReadLine(&first_line);
+  if (res != rtc::SR_SUCCESS) {
     return res;
   }
   if (!CheckFirstLine(first_line)) {
-    return talk_base::SR_ERROR;
+    return rtc::SR_ERROR;
   }
 
   // Read the 16 byte file header.
   char header[RtpDumpFileHeader::kHeaderLength];
   res = stream_->ReadAll(header, sizeof(header), NULL, NULL);
-  if (res == talk_base::SR_SUCCESS) {
-    talk_base::ByteBuffer buf(header, sizeof(header));
+  if (res == rtc::SR_SUCCESS) {
+    rtc::ByteBuffer buf(header, sizeof(header));
     uint32 start_sec;
     uint32 start_usec;
     buf.ReadUInt32(&start_sec);
@@ -204,7 +204,7 @@ bool RtpDumpReader::CheckFirstLine(const std::string& first_line) {
 ///////////////////////////////////////////////////////////////////////////
 // Implementation of RtpDumpLoopReader.
 ///////////////////////////////////////////////////////////////////////////
-RtpDumpLoopReader::RtpDumpLoopReader(talk_base::StreamInterface* stream)
+RtpDumpLoopReader::RtpDumpLoopReader(rtc::StreamInterface* stream)
     : RtpDumpReader(stream),
       loop_count_(0),
       elapsed_time_increases_(0),
@@ -220,16 +220,16 @@ RtpDumpLoopReader::RtpDumpLoopReader(talk_base::StreamInterface* stream)
       prev_rtp_timestamp_(0) {
 }
 
-talk_base::StreamResult RtpDumpLoopReader::ReadPacket(RtpDumpPacket* packet) {
-  if (!packet) return talk_base::SR_ERROR;
+rtc::StreamResult RtpDumpLoopReader::ReadPacket(RtpDumpPacket* packet) {
+  if (!packet) return rtc::SR_ERROR;
 
-  talk_base::StreamResult res = RtpDumpReader::ReadPacket(packet);
-  if (talk_base::SR_SUCCESS == res) {
+  rtc::StreamResult res = RtpDumpReader::ReadPacket(packet);
+  if (rtc::SR_SUCCESS == res) {
     if (0 == loop_count_) {
       // During the first loop, we update the statistics of the input stream.
       UpdateStreamStatistics(*packet);
     }
-  } else if (talk_base::SR_EOS == res) {
+  } else if (rtc::SR_EOS == res) {
     if (0 == loop_count_) {
       // At the end of the first loop, calculate elapsed_time_increases_,
       // rtp_seq_num_increase_, and rtp_timestamp_increase_, which will be
@@ -244,7 +244,7 @@ talk_base::StreamResult RtpDumpLoopReader::ReadPacket(RtpDumpPacket* packet) {
     }
   }
 
-  if (talk_base::SR_SUCCESS == res && loop_count_ > 0) {
+  if (rtc::SR_SUCCESS == res && loop_count_ > 0) {
     // During the second and later loops, we update the elapsed time of the dump
     // packet. If the dumped packet is a RTP packet, we also update its RTP
     // sequence number and timestamp.
@@ -307,7 +307,7 @@ void RtpDumpLoopReader::UpdateDumpPacket(RtpDumpPacket* packet) {
     sequence += loop_count_ * rtp_seq_num_increase_;
     timestamp += loop_count_ * rtp_timestamp_increase_;
     // Write the updated sequence number and timestamp back to the RTP packet.
-    talk_base::ByteBuffer buffer;
+    rtc::ByteBuffer buffer;
     buffer.WriteUInt16(sequence);
     buffer.WriteUInt32(timestamp);
     memcpy(&packet->data[2], buffer.Data(), buffer.Length());
@@ -318,11 +318,11 @@ void RtpDumpLoopReader::UpdateDumpPacket(RtpDumpPacket* packet) {
 // Implementation of RtpDumpWriter.
 ///////////////////////////////////////////////////////////////////////////
 
-RtpDumpWriter::RtpDumpWriter(talk_base::StreamInterface* stream)
+RtpDumpWriter::RtpDumpWriter(rtc::StreamInterface* stream)
     : stream_(stream),
       packet_filter_(PF_ALL),
       file_header_written_(false),
-      start_time_ms_(talk_base::Time()),
+      start_time_ms_(rtc::Time()),
       warn_slow_writes_delay_(kWarnSlowWritesDelayMs) {
 }
 
@@ -332,32 +332,32 @@ void RtpDumpWriter::set_packet_filter(int filter) {
 }
 
 uint32 RtpDumpWriter::GetElapsedTime() const {
-  return talk_base::TimeSince(start_time_ms_);
+  return rtc::TimeSince(start_time_ms_);
 }
 
-talk_base::StreamResult RtpDumpWriter::WriteFileHeader() {
-  talk_base::StreamResult res = WriteToStream(
+rtc::StreamResult RtpDumpWriter::WriteFileHeader() {
+  rtc::StreamResult res = WriteToStream(
       RtpDumpFileHeader::kFirstLine,
       strlen(RtpDumpFileHeader::kFirstLine));
-  if (res != talk_base::SR_SUCCESS) {
+  if (res != rtc::SR_SUCCESS) {
     return res;
   }
 
-  talk_base::ByteBuffer buf;
-  RtpDumpFileHeader file_header(talk_base::Time(), 0, 0);
+  rtc::ByteBuffer buf;
+  RtpDumpFileHeader file_header(rtc::Time(), 0, 0);
   file_header.WriteToByteBuffer(&buf);
   return WriteToStream(buf.Data(), buf.Length());
 }
 
-talk_base::StreamResult RtpDumpWriter::WritePacket(
+rtc::StreamResult RtpDumpWriter::WritePacket(
     const void* data, size_t data_len, uint32 elapsed, bool rtcp) {
-  if (!stream_ || !data || 0 == data_len) return talk_base::SR_ERROR;
+  if (!stream_ || !data || 0 == data_len) return rtc::SR_ERROR;
 
-  talk_base::StreamResult res = talk_base::SR_SUCCESS;
+  rtc::StreamResult res = rtc::SR_SUCCESS;
   // Write the file header if it has not been written yet.
   if (!file_header_written_) {
     res = WriteFileHeader();
-    if (res != talk_base::SR_SUCCESS) {
+    if (res != rtc::SR_SUCCESS) {
       return res;
     }
     file_header_written_ = true;
@@ -366,17 +366,17 @@ talk_base::StreamResult RtpDumpWriter::WritePacket(
   // Figure out what to write.
   size_t write_len = FilterPacket(data, data_len, rtcp);
   if (write_len == 0) {
-    return talk_base::SR_SUCCESS;
+    return rtc::SR_SUCCESS;
   }
 
   // Write the dump packet header.
-  talk_base::ByteBuffer buf;
+  rtc::ByteBuffer buf;
   buf.WriteUInt16(static_cast<uint16>(
                       RtpDumpPacket::kHeaderLength + write_len));
   buf.WriteUInt16(static_cast<uint16>(rtcp ? 0 : data_len));
   buf.WriteUInt32(elapsed);
   res = WriteToStream(buf.Data(), buf.Length());
-  if (res != talk_base::SR_SUCCESS) {
+  if (res != rtc::SR_SUCCESS) {
     return res;
   }
 
@@ -408,12 +408,12 @@ size_t RtpDumpWriter::FilterPacket(const void* data, size_t data_len,
   return filtered_len;
 }
 
-talk_base::StreamResult RtpDumpWriter::WriteToStream(
+rtc::StreamResult RtpDumpWriter::WriteToStream(
     const void* data, size_t data_len) {
-  uint32 before = talk_base::Time();
-  talk_base::StreamResult result =
+  uint32 before = rtc::Time();
+  rtc::StreamResult result =
       stream_->WriteAll(data, data_len, NULL, NULL);
-  uint32 delay = talk_base::TimeSince(before);
+  uint32 delay = rtc::TimeSince(before);
   if (delay >= warn_slow_writes_delay_) {
     LOG(LS_WARNING) << "Slow RtpDump: took " << delay << "ms to write "
                     << data_len << " bytes.";
diff --git a/talk/media/base/rtpdump.h b/talk/media/base/rtpdump.h
index ceacab2cda..33c31c9837 100644
--- a/talk/media/base/rtpdump.h
+++ b/talk/media/base/rtpdump.h
@@ -33,9 +33,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/bytebuffer.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/stream.h"
 
 namespace cricket {
 
@@ -57,7 +57,7 @@ enum RtpDumpPacketFilter {
 
 struct RtpDumpFileHeader {
   RtpDumpFileHeader(uint32 start_ms, uint32 s, uint16 p);
-  void WriteToByteBuffer(talk_base::ByteBuffer* buf);
+  void WriteToByteBuffer(rtc::ByteBuffer* buf);
 
   static const char kFirstLine[];
   static const size_t kHeaderLength = 16;
@@ -104,7 +104,7 @@ struct RtpDumpPacket {
 
 class RtpDumpReader {
  public:
-  explicit RtpDumpReader(talk_base::StreamInterface* stream)
+  explicit RtpDumpReader(rtc::StreamInterface* stream)
       : stream_(stream),
         file_header_read_(false),
         first_line_and_file_header_len_(0),
@@ -115,10 +115,10 @@ class RtpDumpReader {
 
   // Use the specified ssrc, rather than the ssrc from dump, for RTP packets.
   void SetSsrc(uint32 ssrc);
-  virtual talk_base::StreamResult ReadPacket(RtpDumpPacket* packet);
+  virtual rtc::StreamResult ReadPacket(RtpDumpPacket* packet);
 
  protected:
-  talk_base::StreamResult ReadFileHeader();
+  rtc::StreamResult ReadFileHeader();
   bool RewindToFirstDumpPacket() {
     return stream_->SetPosition(first_line_and_file_header_len_);
   }
@@ -127,7 +127,7 @@ class RtpDumpReader {
   // Check if its matches "#!rtpplay1.0 address/port\n".
   bool CheckFirstLine(const std::string& first_line);
 
-  talk_base::StreamInterface* stream_;
+  rtc::StreamInterface* stream_;
   bool file_header_read_;
   size_t first_line_and_file_header_len_;
   uint32 start_time_ms_;
@@ -143,8 +143,8 @@ class RtpDumpReader {
 // RTP packets and RTCP packets.
 class RtpDumpLoopReader : public RtpDumpReader {
  public:
-  explicit RtpDumpLoopReader(talk_base::StreamInterface* stream);
-  virtual talk_base::StreamResult ReadPacket(RtpDumpPacket* packet);
+  explicit RtpDumpLoopReader(rtc::StreamInterface* stream);
+  virtual rtc::StreamResult ReadPacket(RtpDumpPacket* packet);
 
  private:
   // During the first loop, update the statistics, including packet count, frame
@@ -186,19 +186,19 @@ class RtpDumpLoopReader : public RtpDumpReader {
 
 class RtpDumpWriter {
  public:
-  explicit RtpDumpWriter(talk_base::StreamInterface* stream);
+  explicit RtpDumpWriter(rtc::StreamInterface* stream);
 
   // Filter to control what packets we actually record.
   void set_packet_filter(int filter);
   // Write a RTP or RTCP packet. The parameters data points to the packet and
   // data_len is its length.
-  talk_base::StreamResult WriteRtpPacket(const void* data, size_t data_len) {
+  rtc::StreamResult WriteRtpPacket(const void* data, size_t data_len) {
     return WritePacket(data, data_len, GetElapsedTime(), false);
   }
-  talk_base::StreamResult WriteRtcpPacket(const void* data, size_t data_len) {
+  rtc::StreamResult WriteRtcpPacket(const void* data, size_t data_len) {
     return WritePacket(data, data_len, GetElapsedTime(), true);
   }
-  talk_base::StreamResult WritePacket(const RtpDumpPacket& packet) {
+  rtc::StreamResult WritePacket(const RtpDumpPacket& packet) {
     return WritePacket(&packet.data[0], packet.data.size(), packet.elapsed_time,
                        packet.is_rtcp());
   }
@@ -211,15 +211,15 @@ class RtpDumpWriter {
   }
 
  protected:
-  talk_base::StreamResult WriteFileHeader();
+  rtc::StreamResult WriteFileHeader();
 
  private:
-  talk_base::StreamResult WritePacket(const void* data, size_t data_len,
+  rtc::StreamResult WritePacket(const void* data, size_t data_len,
                                       uint32 elapsed, bool rtcp);
   size_t FilterPacket(const void* data, size_t data_len, bool rtcp);
-  talk_base::StreamResult WriteToStream(const void* data, size_t data_len);
+  rtc::StreamResult WriteToStream(const void* data, size_t data_len);
 
-  talk_base::StreamInterface* stream_;
+  rtc::StreamInterface* stream_;
   int packet_filter_;
   bool file_header_written_;
   uint32 start_time_ms_;  // Time when the record starts.
diff --git a/talk/media/base/rtpdump_unittest.cc b/talk/media/base/rtpdump_unittest.cc
index c327189534..4e32f0abb8 100644
--- a/talk/media/base/rtpdump_unittest.cc
+++ b/talk/media/base/rtpdump_unittest.cc
@@ -27,9 +27,9 @@
 
 #include <string>
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/gunit.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/rtpdump.h"
 #include "talk/media/base/rtputils.h"
 #include "talk/media/base/testutils.h"
@@ -40,7 +40,7 @@ static const uint32 kTestSsrc = 1;
 
 // Test that we read the correct header fields from the RTP/RTCP packet.
 TEST(RtpDumpTest, ReadRtpDumpPacket) {
-  talk_base::ByteBuffer rtp_buf;
+  rtc::ByteBuffer rtp_buf;
   RtpTestUtility::kTestRawRtpPackets[0].WriteToByteBuffer(kTestSsrc, &rtp_buf);
   RtpDumpPacket rtp_packet(rtp_buf.Data(), rtp_buf.Length(), 0, false);
 
@@ -61,7 +61,7 @@ TEST(RtpDumpTest, ReadRtpDumpPacket) {
   EXPECT_EQ(kTestSsrc, ssrc);
   EXPECT_FALSE(rtp_packet.GetRtcpType(&type));
 
-  talk_base::ByteBuffer rtcp_buf;
+  rtc::ByteBuffer rtcp_buf;
   RtpTestUtility::kTestRawRtcpPackets[0].WriteToByteBuffer(&rtcp_buf);
   RtpDumpPacket rtcp_packet(rtcp_buf.Data(), rtcp_buf.Length(), 0, true);
 
@@ -75,48 +75,48 @@ TEST(RtpDumpTest, ReadRtpDumpPacket) {
 // Test that we read only the RTP dump file.
 TEST(RtpDumpTest, ReadRtpDumpFile) {
   RtpDumpPacket packet;
-  talk_base::MemoryStream stream;
+  rtc::MemoryStream stream;
   RtpDumpWriter writer(&stream);
-  talk_base::scoped_ptr<RtpDumpReader> reader;
+  rtc::scoped_ptr<RtpDumpReader> reader;
 
   // Write a RTP packet to the stream, which is a valid RTP dump. Next, we will
   // change the first line to make the RTP dump valid or invalid.
   ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, false, kTestSsrc, &writer));
   stream.Rewind();
   reader.reset(new RtpDumpReader(&stream));
-  EXPECT_EQ(talk_base::SR_SUCCESS, reader->ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, reader->ReadPacket(&packet));
 
   // The first line is correct.
   stream.Rewind();
   const char new_line[] = "#!rtpplay1.0 1.1.1.1/1\n";
-  EXPECT_EQ(talk_base::SR_SUCCESS,
+  EXPECT_EQ(rtc::SR_SUCCESS,
             stream.WriteAll(new_line, strlen(new_line), NULL, NULL));
   stream.Rewind();
   reader.reset(new RtpDumpReader(&stream));
-  EXPECT_EQ(talk_base::SR_SUCCESS, reader->ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, reader->ReadPacket(&packet));
 
   // The first line is not correct: not started with #!rtpplay1.0.
   stream.Rewind();
   const char new_line2[] = "#!rtpplaz1.0 0.0.0.0/0\n";
-  EXPECT_EQ(talk_base::SR_SUCCESS,
+  EXPECT_EQ(rtc::SR_SUCCESS,
             stream.WriteAll(new_line2, strlen(new_line2), NULL, NULL));
   stream.Rewind();
   reader.reset(new RtpDumpReader(&stream));
-  EXPECT_EQ(talk_base::SR_ERROR, reader->ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_ERROR, reader->ReadPacket(&packet));
 
   // The first line is not correct: no port.
   stream.Rewind();
   const char new_line3[] = "#!rtpplay1.0 0.0.0.0//\n";
-  EXPECT_EQ(talk_base::SR_SUCCESS,
+  EXPECT_EQ(rtc::SR_SUCCESS,
             stream.WriteAll(new_line3, strlen(new_line3), NULL, NULL));
   stream.Rewind();
   reader.reset(new RtpDumpReader(&stream));
-  EXPECT_EQ(talk_base::SR_ERROR, reader->ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_ERROR, reader->ReadPacket(&packet));
 }
 
 // Test that we read the same RTP packets that rtp dump writes.
 TEST(RtpDumpTest, WriteReadSameRtp) {
-  talk_base::MemoryStream stream;
+  rtc::MemoryStream stream;
   RtpDumpWriter writer(&stream);
   ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
       RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
@@ -127,13 +127,13 @@ TEST(RtpDumpTest, WriteReadSameRtp) {
   RtpDumpPacket packet;
   RtpDumpReader reader(&stream);
   for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
     uint32 ssrc;
     EXPECT_TRUE(GetRtpSsrc(&packet.data[0], packet.data.size(), &ssrc));
     EXPECT_EQ(kTestSsrc, ssrc);
   }
   // No more packets to read.
-  EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
 
   // Rewind the stream and read again with a specified ssrc.
   stream.Rewind();
@@ -141,7 +141,7 @@ TEST(RtpDumpTest, WriteReadSameRtp) {
   const uint32 send_ssrc = kTestSsrc + 1;
   reader_w_ssrc.SetSsrc(send_ssrc);
   for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(talk_base::SR_SUCCESS, reader_w_ssrc.ReadPacket(&packet));
+    EXPECT_EQ(rtc::SR_SUCCESS, reader_w_ssrc.ReadPacket(&packet));
     EXPECT_FALSE(packet.is_rtcp());
     EXPECT_EQ(packet.original_data_len, packet.data.size());
     uint32 ssrc;
@@ -149,12 +149,12 @@ TEST(RtpDumpTest, WriteReadSameRtp) {
     EXPECT_EQ(send_ssrc, ssrc);
   }
   // No more packets to read.
-  EXPECT_EQ(talk_base::SR_EOS, reader_w_ssrc.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, reader_w_ssrc.ReadPacket(&packet));
 }
 
 // Test that we read the same RTCP packets that rtp dump writes.
 TEST(RtpDumpTest, WriteReadSameRtcp) {
-  talk_base::MemoryStream stream;
+  rtc::MemoryStream stream;
   RtpDumpWriter writer(&stream);
   ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
       RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
@@ -166,17 +166,17 @@ TEST(RtpDumpTest, WriteReadSameRtcp) {
   RtpDumpReader reader(&stream);
   reader.SetSsrc(kTestSsrc + 1);  // Does not affect RTCP packet.
   for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
     EXPECT_TRUE(packet.is_rtcp());
     EXPECT_EQ(0U, packet.original_data_len);
   }
   // No more packets to read.
-  EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
 }
 
 // Test dumping only RTP packet headers.
 TEST(RtpDumpTest, WriteReadRtpHeadersOnly) {
-  talk_base::MemoryStream stream;
+  rtc::MemoryStream stream;
   RtpDumpWriter writer(&stream);
   writer.set_packet_filter(PF_RTPHEADER);
 
@@ -192,7 +192,7 @@ TEST(RtpDumpTest, WriteReadRtpHeadersOnly) {
   RtpDumpPacket packet;
   RtpDumpReader reader(&stream);
   for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
     EXPECT_FALSE(packet.is_rtcp());
     size_t len = 0;
     packet.GetRtpHeaderLen(&len);
@@ -200,12 +200,12 @@ TEST(RtpDumpTest, WriteReadRtpHeadersOnly) {
     EXPECT_GT(packet.original_data_len, packet.data.size());
   }
   // No more packets to read.
-  EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
 }
 
 // Test dumping only RTCP packets.
 TEST(RtpDumpTest, WriteReadRtcpOnly) {
-  talk_base::MemoryStream stream;
+  rtc::MemoryStream stream;
   RtpDumpWriter writer(&stream);
   writer.set_packet_filter(PF_RTCPPACKET);
 
@@ -220,18 +220,18 @@ TEST(RtpDumpTest, WriteReadRtcpOnly) {
   RtpDumpPacket packet;
   RtpDumpReader reader(&stream);
   for (size_t i = 0; i < RtpTestUtility::GetTestPacketCount(); ++i) {
-    EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
     EXPECT_TRUE(packet.is_rtcp());
     EXPECT_EQ(0U, packet.original_data_len);
   }
   // No more packets to read.
-  EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
 }
 
 // Test that RtpDumpLoopReader reads RTP packets continously and the elapsed
 // time, the sequence number, and timestamp are maintained properly.
 TEST(RtpDumpTest, LoopReadRtp) {
-  talk_base::MemoryStream stream;
+  rtc::MemoryStream stream;
   RtpDumpWriter writer(&stream);
   ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
       RtpTestUtility::GetTestPacketCount(), false, kTestSsrc, &writer));
@@ -242,7 +242,7 @@ TEST(RtpDumpTest, LoopReadRtp) {
 // Test that RtpDumpLoopReader reads RTCP packets continously and the elapsed
 // time is maintained properly.
 TEST(RtpDumpTest, LoopReadRtcp) {
-  talk_base::MemoryStream stream;
+  rtc::MemoryStream stream;
   RtpDumpWriter writer(&stream);
   ASSERT_TRUE(RtpTestUtility::WriteTestPackets(
       RtpTestUtility::GetTestPacketCount(), true, kTestSsrc, &writer));
@@ -253,7 +253,7 @@ TEST(RtpDumpTest, LoopReadRtcp) {
 // Test that RtpDumpLoopReader reads continously from stream with a single RTP
 // packets.
 TEST(RtpDumpTest, LoopReadSingleRtp) {
-  talk_base::MemoryStream stream;
+  rtc::MemoryStream stream;
   RtpDumpWriter writer(&stream);
   ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, false, kTestSsrc, &writer));
 
@@ -261,21 +261,21 @@ TEST(RtpDumpTest, LoopReadSingleRtp) {
   RtpDumpPacket packet;
   stream.Rewind();
   RtpDumpReader reader(&stream);
-  EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
-  EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
 
   // The loop reader reads three packets from the input stream.
   stream.Rewind();
   RtpDumpLoopReader loop_reader(&stream);
-  EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-  EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-  EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
 }
 
 // Test that RtpDumpLoopReader reads continously from stream with a single RTCP
 // packets.
 TEST(RtpDumpTest, LoopReadSingleRtcp) {
-  talk_base::MemoryStream stream;
+  rtc::MemoryStream stream;
   RtpDumpWriter writer(&stream);
   ASSERT_TRUE(RtpTestUtility::WriteTestPackets(1, true, kTestSsrc, &writer));
 
@@ -283,15 +283,15 @@ TEST(RtpDumpTest, LoopReadSingleRtcp) {
   RtpDumpPacket packet;
   stream.Rewind();
   RtpDumpReader reader(&stream);
-  EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
-  EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
 
   // The loop reader reads three packets from the input stream.
   stream.Rewind();
   RtpDumpLoopReader loop_reader(&stream);
-  EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-  EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
-  EXPECT_EQ(talk_base::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, loop_reader.ReadPacket(&packet));
 }
 
 }  // namespace cricket
diff --git a/talk/media/base/rtputils.cc b/talk/media/base/rtputils.cc
index 221d94927b..8c359836e1 100644
--- a/talk/media/base/rtputils.cc
+++ b/talk/media/base/rtputils.cc
@@ -50,7 +50,7 @@ bool GetUint16(const void* data, size_t offset, int* value) {
     return false;
   }
   *value = static_cast<int>(
-      talk_base::GetBE16(static_cast<const uint8*>(data) + offset));
+      rtc::GetBE16(static_cast<const uint8*>(data) + offset));
   return true;
 }
 
@@ -58,7 +58,7 @@ bool GetUint32(const void* data, size_t offset, uint32* value) {
   if (!data || !value) {
     return false;
   }
-  *value = talk_base::GetBE32(static_cast<const uint8*>(data) + offset);
+  *value = rtc::GetBE32(static_cast<const uint8*>(data) + offset);
   return true;
 }
 
@@ -66,7 +66,7 @@ bool SetUint8(void* data, size_t offset, int value) {
   if (!data) {
     return false;
   }
-  talk_base::Set8(data, offset, value);
+  rtc::Set8(data, offset, value);
   return true;
 }
 
@@ -74,7 +74,7 @@ bool SetUint16(void* data, size_t offset, int value) {
   if (!data) {
     return false;
   }
-  talk_base::SetBE16(static_cast<uint8*>(data) + offset, value);
+  rtc::SetBE16(static_cast<uint8*>(data) + offset, value);
   return true;
 }
 
@@ -82,7 +82,7 @@ bool SetUint32(void* data, size_t offset, uint32 value) {
   if (!data) {
     return false;
   }
-  talk_base::SetBE32(static_cast<uint8*>(data) + offset, value);
+  rtc::SetBE32(static_cast<uint8*>(data) + offset, value);
   return true;
 }
 
@@ -134,7 +134,7 @@ bool GetRtpHeaderLen(const void* data, size_t len, size_t* value) {
   // If there's an extension, read and add in the extension size.
   if (header[0] & 0x10) {
     if (len < header_size + sizeof(uint32)) return false;
-    header_size += ((talk_base::GetBE16(header + header_size + 2) + 1) *
+    header_size += ((rtc::GetBE16(header + header_size + 2) + 1) *
                     sizeof(uint32));
     if (len < header_size) return false;
   }
@@ -176,7 +176,7 @@ bool GetRtcpSsrc(const void* data, size_t len, uint32* value) {
   if (!GetRtcpType(data, len, &pl_type)) return false;
   // SDES packet parsing is not supported.
   if (pl_type == kRtcpTypeSDES) return false;
-  *value = talk_base::GetBE32(static_cast<const uint8*>(data) + 4);
+  *value = rtc::GetBE32(static_cast<const uint8*>(data) + 4);
   return true;
 }
 
diff --git a/talk/media/base/rtputils.h b/talk/media/base/rtputils.h
index f653e42300..ca69ace3e2 100644
--- a/talk/media/base/rtputils.h
+++ b/talk/media/base/rtputils.h
@@ -28,7 +28,7 @@
 #ifndef TALK_MEDIA_BASE_RTPUTILS_H_
 #define TALK_MEDIA_BASE_RTPUTILS_H_
 
-#include "talk/base/byteorder.h"
+#include "webrtc/base/byteorder.h"
 
 namespace cricket {
 
diff --git a/talk/media/base/rtputils_unittest.cc b/talk/media/base/rtputils_unittest.cc
index d3ea5217b0..b06f78b281 100644
--- a/talk/media/base/rtputils_unittest.cc
+++ b/talk/media/base/rtputils_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/fakertp.h"
 #include "talk/media/base/rtputils.h"
 
diff --git a/talk/media/base/screencastid.h b/talk/media/base/screencastid.h
index d1f84f3354..b70c1727b2 100644
--- a/talk/media/base/screencastid.h
+++ b/talk/media/base/screencastid.h
@@ -9,8 +9,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/window.h"
-#include "talk/base/windowpicker.h"
+#include "webrtc/base/window.h"
+#include "webrtc/base/windowpicker.h"
 
 namespace cricket {
 
@@ -24,16 +24,16 @@ class ScreencastId {
 
   // Default constructor indicates invalid ScreencastId.
   ScreencastId() : type_(INVALID) {}
-  explicit ScreencastId(const talk_base::WindowId& id)
+  explicit ScreencastId(const rtc::WindowId& id)
       : type_(WINDOW), window_(id) {
   }
-  explicit ScreencastId(const talk_base::DesktopId& id)
+  explicit ScreencastId(const rtc::DesktopId& id)
       : type_(DESKTOP), desktop_(id) {
   }
 
   Type type() const { return type_; }
-  const talk_base::WindowId& window() const { return window_; }
-  const talk_base::DesktopId& desktop() const { return desktop_; }
+  const rtc::WindowId& window() const { return window_; }
+  const rtc::DesktopId& desktop() const { return desktop_; }
 
   // Title is an optional parameter.
   const std::string& title() const { return title_; }
@@ -78,8 +78,8 @@ class ScreencastId {
 
  private:
   Type type_;
-  talk_base::WindowId window_;
-  talk_base::DesktopId desktop_;
+  rtc::WindowId window_;
+  rtc::DesktopId desktop_;
   std::string title_;  // Optional.
 };
 
diff --git a/talk/media/base/streamparams.h b/talk/media/base/streamparams.h
index 8be61b5b37..43b599620a 100644
--- a/talk/media/base/streamparams.h
+++ b/talk/media/base/streamparams.h
@@ -48,7 +48,7 @@
 #include <set>
 #include <vector>
 
-#include "talk/base/basictypes.h"
+#include "webrtc/base/basictypes.h"
 
 namespace cricket {
 
diff --git a/talk/media/base/streamparams_unittest.cc b/talk/media/base/streamparams_unittest.cc
index 0fd6771901..8d51d7d90a 100644
--- a/talk/media/base/streamparams_unittest.cc
+++ b/talk/media/base/streamparams_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/streamparams.h"
 #include "talk/media/base/testutils.h"
 
diff --git a/talk/media/base/testutils.cc b/talk/media/base/testutils.cc
index 7320613841..c06e9e17f7 100644
--- a/talk/media/base/testutils.cc
+++ b/talk/media/base/testutils.cc
@@ -29,13 +29,13 @@
 
 #include <math.h>
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/fileutils.h"
-#include "talk/base/gunit.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/stream.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/testutils.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/testutils.h"
 #include "talk/media/base/rtpdump.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videoframe.h"
@@ -46,7 +46,7 @@ namespace cricket {
 // Implementation of RawRtpPacket
 /////////////////////////////////////////////////////////////////////////
 void RawRtpPacket::WriteToByteBuffer(
-    uint32 in_ssrc, talk_base::ByteBuffer *buf) const {
+    uint32 in_ssrc, rtc::ByteBuffer *buf) const {
   if (!buf) return;
 
   buf->WriteUInt8(ver_to_cc);
@@ -57,7 +57,7 @@ void RawRtpPacket::WriteToByteBuffer(
   buf->WriteBytes(payload, sizeof(payload));
 }
 
-bool RawRtpPacket::ReadFromByteBuffer(talk_base::ByteBuffer* buf) {
+bool RawRtpPacket::ReadFromByteBuffer(rtc::ByteBuffer* buf) {
   if (!buf) return false;
 
   bool ret = true;
@@ -83,7 +83,7 @@ bool RawRtpPacket::SameExceptSeqNumTimestampSsrc(
 /////////////////////////////////////////////////////////////////////////
 // Implementation of RawRtcpPacket
 /////////////////////////////////////////////////////////////////////////
-void RawRtcpPacket::WriteToByteBuffer(talk_base::ByteBuffer *buf) const {
+void RawRtcpPacket::WriteToByteBuffer(rtc::ByteBuffer *buf) const {
   if (!buf) return;
 
   buf->WriteUInt8(ver_to_count);
@@ -92,7 +92,7 @@ void RawRtcpPacket::WriteToByteBuffer(talk_base::ByteBuffer *buf) const {
   buf->WriteBytes(payload, sizeof(payload));
 }
 
-bool RawRtcpPacket::ReadFromByteBuffer(talk_base::ByteBuffer* buf) {
+bool RawRtcpPacket::ReadFromByteBuffer(rtc::ByteBuffer* buf) {
   if (!buf) return false;
 
   bool ret = true;
@@ -128,7 +128,7 @@ const RawRtcpPacket RtpTestUtility::kTestRawRtcpPackets[] = {
 };
 
 size_t RtpTestUtility::GetTestPacketCount() {
-  return talk_base::_min(
+  return rtc::_min(
       ARRAY_SIZE(kTestRawRtpPackets),
       ARRAY_SIZE(kTestRawRtcpPackets));
 }
@@ -140,7 +140,7 @@ bool RtpTestUtility::WriteTestPackets(
   bool result = true;
   uint32 elapsed_time_ms = 0;
   for (size_t i = 0; i < count && result; ++i) {
-    talk_base::ByteBuffer buf;
+    rtc::ByteBuffer buf;
     if (rtcp) {
       kTestRawRtcpPackets[i].WriteToByteBuffer(&buf);
     } else {
@@ -149,13 +149,13 @@ bool RtpTestUtility::WriteTestPackets(
 
     RtpDumpPacket dump_packet(buf.Data(), buf.Length(), elapsed_time_ms, rtcp);
     elapsed_time_ms += kElapsedTimeInterval;
-    result &= (talk_base::SR_SUCCESS == writer->WritePacket(dump_packet));
+    result &= (rtc::SR_SUCCESS == writer->WritePacket(dump_packet));
   }
   return result;
 }
 
 bool RtpTestUtility::VerifyTestPacketsFromStream(
-    size_t count, talk_base::StreamInterface* stream, uint32 ssrc) {
+    size_t count, rtc::StreamInterface* stream, uint32 ssrc) {
   if (!stream) return false;
 
   uint32 prev_elapsed_time = 0;
@@ -168,13 +168,13 @@ bool RtpTestUtility::VerifyTestPacketsFromStream(
     size_t index = i % GetTestPacketCount();
 
     RtpDumpPacket packet;
-    result &= (talk_base::SR_SUCCESS == reader.ReadPacket(&packet));
+    result &= (rtc::SR_SUCCESS == reader.ReadPacket(&packet));
     // Check the elapsed time of the dump packet.
     result &= (packet.elapsed_time >= prev_elapsed_time);
     prev_elapsed_time = packet.elapsed_time;
 
     // Check the RTP or RTCP packet.
-    talk_base::ByteBuffer buf(reinterpret_cast<const char*>(&packet.data[0]),
+    rtc::ByteBuffer buf(reinterpret_cast<const char*>(&packet.data[0]),
                               packet.data.size());
     if (packet.is_rtcp()) {
       // RTCP packet.
@@ -204,7 +204,7 @@ bool RtpTestUtility::VerifyPacket(const RtpDumpPacket* dump,
                                   bool header_only) {
   if (!dump || !raw) return false;
 
-  talk_base::ByteBuffer buf;
+  rtc::ByteBuffer buf;
   raw->WriteToByteBuffer(RtpTestUtility::kDefaultSsrc, &buf);
 
   if (header_only) {
@@ -255,7 +255,7 @@ void VideoCapturerListener::OnFrameCaptured(VideoCapturer* capturer,
 // Returns the absolute path to a file in the testdata/ directory.
 std::string GetTestFilePath(const std::string& filename) {
   // Locate test data directory.
-  talk_base::Pathname path = testing::GetTalkDirectory();
+  rtc::Pathname path = testing::GetTalkDirectory();
   EXPECT_FALSE(path.empty());  // must be run from inside "talk"
   path.AppendFolder("media");
   path.AppendFolder("testdata");
@@ -269,25 +269,25 @@ bool LoadPlanarYuvTestImage(const std::string& prefix,
   std::stringstream ss;
   ss << prefix << "." << width << "x" << height << "_P420.yuv";
 
-  talk_base::scoped_ptr<talk_base::FileStream> stream(
-      talk_base::Filesystem::OpenFile(talk_base::Pathname(
+  rtc::scoped_ptr<rtc::FileStream> stream(
+      rtc::Filesystem::OpenFile(rtc::Pathname(
           GetTestFilePath(ss.str())), "rb"));
   if (!stream) {
     return false;
   }
 
-  talk_base::StreamResult res =
+  rtc::StreamResult res =
       stream->ReadAll(out, I420_SIZE(width, height), NULL, NULL);
-  return (res == talk_base::SR_SUCCESS);
+  return (res == rtc::SR_SUCCESS);
 }
 
 // Dumps the YUV image out to a file, for visual inspection.
 // PYUV tool can be used to view dump files.
 void DumpPlanarYuvTestImage(const std::string& prefix, const uint8* img,
                             int w, int h) {
-  talk_base::FileStream fs;
+  rtc::FileStream fs;
   char filename[256];
-  talk_base::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv",
+  rtc::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv",
                       prefix.c_str(), w, h);
   fs.Open(filename, "wb", NULL);
   fs.Write(img, I420_SIZE(w, h), NULL, NULL);
@@ -297,9 +297,9 @@ void DumpPlanarYuvTestImage(const std::string& prefix, const uint8* img,
 // ffplay tool can be used to view dump files.
 void DumpPlanarArgbTestImage(const std::string& prefix, const uint8* img,
                              int w, int h) {
-  talk_base::FileStream fs;
+  rtc::FileStream fs;
   char filename[256];
-  talk_base::sprintfn(filename, sizeof(filename), "%s.%dx%d_ARGB.raw",
+  rtc::sprintfn(filename, sizeof(filename), "%s.%dx%d_ARGB.raw",
                       prefix.c_str(), w, h);
   fs.Open(filename, "wb", NULL);
   fs.Write(img, ARGB_SIZE(w, h), NULL, NULL);
diff --git a/talk/media/base/testutils.h b/talk/media/base/testutils.h
index dd13d5a0e5..2d5f75fe2b 100644
--- a/talk/media/base/testutils.h
+++ b/talk/media/base/testutils.h
@@ -34,14 +34,14 @@
 #if !defined(DISABLE_YUV)
 #include "libyuv/compare.h"
 #endif
-#include "talk/base/basictypes.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/window.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/window.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videocommon.h"
 
-namespace talk_base {
+namespace rtc {
 class ByteBuffer;
 class StreamInterface;
 }
@@ -63,8 +63,8 @@ class RtpDumpWriter;
 class VideoFrame;
 
 struct RawRtpPacket {
-  void WriteToByteBuffer(uint32 in_ssrc, talk_base::ByteBuffer* buf) const;
-  bool ReadFromByteBuffer(talk_base::ByteBuffer* buf);
+  void WriteToByteBuffer(uint32 in_ssrc, rtc::ByteBuffer* buf) const;
+  bool ReadFromByteBuffer(rtc::ByteBuffer* buf);
   // Check if this packet is the same as the specified packet except the
   // sequence number and timestamp, which should be the same as the specified
   // parameters.
@@ -81,8 +81,8 @@ struct RawRtpPacket {
 };
 
 struct RawRtcpPacket {
-  void WriteToByteBuffer(talk_base::ByteBuffer* buf) const;
-  bool ReadFromByteBuffer(talk_base::ByteBuffer* buf);
+  void WriteToByteBuffer(rtc::ByteBuffer* buf) const;
+  bool ReadFromByteBuffer(rtc::ByteBuffer* buf);
   bool EqualsTo(const RawRtcpPacket& packet) const;
 
   uint8 ver_to_count;
@@ -107,7 +107,7 @@ class RtpTestUtility {
   // payload. If the stream is a RTCP stream, verify the RTCP header and
   // payload.
   static bool VerifyTestPacketsFromStream(
-      size_t count, talk_base::StreamInterface* stream, uint32 ssrc);
+      size_t count, rtc::StreamInterface* stream, uint32 ssrc);
 
   // Verify the dump packet is the same as the raw RTP packet.
   static bool VerifyPacket(const RtpDumpPacket* dump,
@@ -153,16 +153,16 @@ class VideoCapturerListener : public sigslot::has_slots<> {
 
 class ScreencastEventCatcher : public sigslot::has_slots<> {
  public:
-  ScreencastEventCatcher() : ssrc_(0), ev_(talk_base::WE_RESIZE) { }
+  ScreencastEventCatcher() : ssrc_(0), ev_(rtc::WE_RESIZE) { }
   uint32 ssrc() const { return ssrc_; }
-  talk_base::WindowEvent event() const { return ev_; }
-  void OnEvent(uint32 ssrc, talk_base::WindowEvent ev) {
+  rtc::WindowEvent event() const { return ev_; }
+  void OnEvent(uint32 ssrc, rtc::WindowEvent ev) {
     ssrc_ = ssrc;
     ev_ = ev;
   }
  private:
   uint32 ssrc_;
-  talk_base::WindowEvent ev_;
+  rtc::WindowEvent ev_;
 };
 
 class VideoMediaErrorCatcher : public sigslot::has_slots<> {
diff --git a/talk/media/base/videoadapter.cc b/talk/media/base/videoadapter.cc
index 76ec52775c..4b550d2050 100644
--- a/talk/media/base/videoadapter.cc
+++ b/talk/media/base/videoadapter.cc
@@ -27,8 +27,8 @@
 
 #include <limits.h>  // For INT_MAX
 
-#include "talk/base/logging.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/videocommon.h"
 #include "talk/media/base/videoframe.h"
@@ -178,10 +178,10 @@ VideoAdapter::~VideoAdapter() {
 }
 
 void VideoAdapter::SetInputFormat(const VideoFormat& format) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   int64 old_input_interval = input_format_.interval;
   input_format_ = format;
-  output_format_.interval = talk_base::_max(
+  output_format_.interval = rtc::_max(
       output_format_.interval, input_format_.interval);
   if (old_input_interval != input_format_.interval) {
     LOG(LS_INFO) << "VAdapt input interval changed from "
@@ -219,11 +219,11 @@ void CoordinatedVideoAdapter::set_cpu_smoothing(bool enable) {
 }
 
 void VideoAdapter::SetOutputFormat(const VideoFormat& format) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   int64 old_output_interval = output_format_.interval;
   output_format_ = format;
   output_num_pixels_ = output_format_.width * output_format_.height;
-  output_format_.interval = talk_base::_max(
+  output_format_.interval = rtc::_max(
       output_format_.interval, input_format_.interval);
   if (old_output_interval != output_format_.interval) {
     LOG(LS_INFO) << "VAdapt output interval changed from "
@@ -232,7 +232,7 @@ void VideoAdapter::SetOutputFormat(const VideoFormat& format) {
 }
 
 const VideoFormat& VideoAdapter::input_format() {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   return input_format_;
 }
 
@@ -241,12 +241,12 @@ bool VideoAdapter::drops_all_frames() const {
 }
 
 const VideoFormat& VideoAdapter::output_format() {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   return output_format_;
 }
 
 void VideoAdapter::SetBlackOutput(bool black) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   black_output_ = black;
 }
 
@@ -263,7 +263,7 @@ int VideoAdapter::GetOutputNumPixels() const {
 // not resolution.
 bool VideoAdapter::AdaptFrame(VideoFrame* in_frame,
                               VideoFrame** out_frame) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   if (!in_frame || !out_frame) {
     return false;
   }
@@ -489,7 +489,7 @@ CoordinatedVideoAdapter::AdaptRequest CoordinatedVideoAdapter::FindCpuRequest(
 
 // A remote view request for a new resolution.
 void CoordinatedVideoAdapter::OnOutputFormatRequest(const VideoFormat& format) {
-  talk_base::CritScope cs(&request_critical_section_);
+  rtc::CritScope cs(&request_critical_section_);
   if (!view_adaptation_) {
     return;
   }
@@ -553,7 +553,7 @@ void CoordinatedVideoAdapter::set_process_threshold(float process_threshold) {
 // A Bandwidth GD request for new resolution
 void CoordinatedVideoAdapter::OnEncoderResolutionRequest(
     int width, int height, AdaptRequest request) {
-  talk_base::CritScope cs(&request_critical_section_);
+  rtc::CritScope cs(&request_critical_section_);
   if (!gd_adaptation_) {
     return;
   }
@@ -589,7 +589,7 @@ void CoordinatedVideoAdapter::OnEncoderResolutionRequest(
 
 // A Bandwidth GD request for new resolution
 void CoordinatedVideoAdapter::OnCpuResolutionRequest(AdaptRequest request) {
-  talk_base::CritScope cs(&request_critical_section_);
+  rtc::CritScope cs(&request_critical_section_);
   if (!cpu_adaptation_) {
     return;
   }
@@ -644,7 +644,7 @@ void CoordinatedVideoAdapter::OnCpuResolutionRequest(AdaptRequest request) {
 // TODO(fbarchard): Move outside adapter.
 void CoordinatedVideoAdapter::OnCpuLoadUpdated(
     int current_cpus, int max_cpus, float process_load, float system_load) {
-  talk_base::CritScope cs(&request_critical_section_);
+  rtc::CritScope cs(&request_critical_section_);
   if (!cpu_adaptation_) {
     return;
   }
diff --git a/talk/media/base/videoadapter.h b/talk/media/base/videoadapter.h
index 8881837906..50b4a13a71 100644
--- a/talk/media/base/videoadapter.h
+++ b/talk/media/base/videoadapter.h
@@ -26,10 +26,10 @@
 #ifndef TALK_MEDIA_BASE_VIDEOADAPTER_H_  // NOLINT
 #define TALK_MEDIA_BASE_VIDEOADAPTER_H_
 
-#include "talk/base/common.h"  // For ASSERT
-#include "talk/base/criticalsection.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/common.h"  // For ASSERT
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/media/base/videocommon.h"
 
 namespace cricket {
@@ -99,9 +99,9 @@ class VideoAdapter {
   bool black_output_;  // Flag to tell if we need to black output_frame_.
   bool is_black_;  // Flag to tell if output_frame_ is currently black.
   int64 interval_next_frame_;
-  talk_base::scoped_ptr<VideoFrame> output_frame_;
+  rtc::scoped_ptr<VideoFrame> output_frame_;
   // The critical section to protect the above variables.
-  talk_base::CriticalSection critical_section_;
+  rtc::CriticalSection critical_section_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoAdapter);
 };
@@ -206,7 +206,7 @@ class CoordinatedVideoAdapter
   int cpu_desired_num_pixels_;
   CoordinatedVideoAdapter::AdaptReason adapt_reason_;
   // The critical section to protect handling requests.
-  talk_base::CriticalSection request_critical_section_;
+  rtc::CriticalSection request_critical_section_;
 
   // The weighted average of cpu load over time. It's always updated (if cpu
   // adaptation is on), but only used if cpu_smoothing_ is set.
diff --git a/talk/media/base/videocapturer.cc b/talk/media/base/videocapturer.cc
index 59860a40ce..139fd09a5e 100644
--- a/talk/media/base/videocapturer.cc
+++ b/talk/media/base/videocapturer.cc
@@ -32,9 +32,9 @@
 #if !defined(DISABLE_YUV)
 #include "libyuv/scale_argb.h"
 #endif
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/systeminfo.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/systeminfo.h"
 #include "talk/media/base/videoprocessor.h"
 
 #if defined(HAVE_WEBRTC_VIDEO)
@@ -63,7 +63,7 @@ static const int64 kMaxDistance = ~(static_cast<int64>(1) << 63);
 static const int kYU12Penalty = 16;  // Needs to be higher than MJPG index.
 #endif
 static const int kDefaultScreencastFps = 5;
-typedef talk_base::TypedMessageData<CaptureState> StateChangeParams;
+typedef rtc::TypedMessageData<CaptureState> StateChangeParams;
 
 // Limit stats data collections to ~20 seconds of 30fps data before dropping
 // old data in case stats aren't reset for long periods of time.
@@ -99,14 +99,14 @@ bool CapturedFrame::GetDataSize(uint32* size) const {
 // Implementation of class VideoCapturer
 /////////////////////////////////////////////////////////////////////
 VideoCapturer::VideoCapturer()
-    : thread_(talk_base::Thread::Current()),
+    : thread_(rtc::Thread::Current()),
       adapt_frame_drops_data_(kMaxAccumulatorSize),
       effect_frame_drops_data_(kMaxAccumulatorSize),
       frame_time_data_(kMaxAccumulatorSize) {
   Construct();
 }
 
-VideoCapturer::VideoCapturer(talk_base::Thread* thread)
+VideoCapturer::VideoCapturer(rtc::Thread* thread)
     : thread_(thread),
       adapt_frame_drops_data_(kMaxAccumulatorSize),
       effect_frame_drops_data_(kMaxAccumulatorSize),
@@ -176,7 +176,7 @@ bool VideoCapturer::Pause(bool pause) {
       return false;
     }
     LOG(LS_INFO) << "Pausing a camera.";
-    talk_base::scoped_ptr<VideoFormat> capture_format_when_paused(
+    rtc::scoped_ptr<VideoFormat> capture_format_when_paused(
         capture_format_ ? new VideoFormat(*capture_format_) : NULL);
     Stop();
     SetCaptureState(CS_PAUSED);
@@ -284,14 +284,14 @@ bool VideoCapturer::GetBestCaptureFormat(const VideoFormat& format,
 }
 
 void VideoCapturer::AddVideoProcessor(VideoProcessor* video_processor) {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   ASSERT(std::find(video_processors_.begin(), video_processors_.end(),
                    video_processor) == video_processors_.end());
   video_processors_.push_back(video_processor);
 }
 
 bool VideoCapturer::RemoveVideoProcessor(VideoProcessor* video_processor) {
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   VideoProcessors::iterator found = std::find(
       video_processors_.begin(), video_processors_.end(), video_processor);
   if (found == video_processors_.end()) {
@@ -328,7 +328,7 @@ void VideoCapturer::GetStats(VariableInfo<int>* adapt_drops_stats,
                              VariableInfo<int>* effect_drops_stats,
                              VariableInfo<double>* frame_time_stats,
                              VideoFormat* last_captured_frame_format) {
-  talk_base::CritScope cs(&frame_stats_crit_);
+  rtc::CritScope cs(&frame_stats_crit_);
   GetVariableSnapshot(adapt_frame_drops_data_, adapt_drops_stats);
   GetVariableSnapshot(effect_frame_drops_data_, effect_drops_stats);
   GetVariableSnapshot(frame_time_data_, frame_time_stats);
@@ -407,7 +407,7 @@ void VideoCapturer::OnFrameCaptured(VideoCapturer*,
   // TODO(fbarchard): Avoid scale and convert if muted.
   // Temporary buffer is scoped here so it will persist until i420_frame.Init()
   // makes a copy of the frame, converting to I420.
-  talk_base::scoped_ptr<uint8[]> temp_buffer;
+  rtc::scoped_ptr<uint8[]> temp_buffer;
   // YUY2 can be scaled vertically using an ARGB scaler.  Aspect ratio is only
   // a problem on OSX.  OSX always converts webcams to YUY2 or UYVY.
   bool can_scale =
@@ -547,10 +547,10 @@ void VideoCapturer::SetCaptureState(CaptureState state) {
   thread_->Post(this, MSG_STATE_CHANGE, state_params);
 }
 
-void VideoCapturer::OnMessage(talk_base::Message* message) {
+void VideoCapturer::OnMessage(rtc::Message* message) {
   switch (message->message_id) {
     case MSG_STATE_CHANGE: {
-      talk_base::scoped_ptr<StateChangeParams> p(
+      rtc::scoped_ptr<StateChangeParams> p(
           static_cast<StateChangeParams*>(message->pdata));
       SignalStateChange(this, p->data());
       break;
@@ -667,7 +667,7 @@ int64 VideoCapturer::GetFormatDistance(const VideoFormat& desired,
 
 bool VideoCapturer::ApplyProcessors(VideoFrame* video_frame) {
   bool drop_frame = false;
-  talk_base::CritScope cs(&crit_);
+  rtc::CritScope cs(&crit_);
   for (VideoProcessors::iterator iter = video_processors_.begin();
        iter != video_processors_.end(); ++iter) {
     (*iter)->OnFrame(kDummyVideoSsrc, video_frame, &drop_frame);
@@ -710,7 +710,7 @@ bool VideoCapturer::ShouldFilterFormat(const VideoFormat& format) const {
 
 void VideoCapturer::UpdateStats(const CapturedFrame* captured_frame) {
   // Update stats protected from fetches from different thread.
-  talk_base::CritScope cs(&frame_stats_crit_);
+  rtc::CritScope cs(&frame_stats_crit_);
 
   last_captured_frame_format_.width = captured_frame->width;
   last_captured_frame_format_.height = captured_frame->height;
@@ -731,7 +731,7 @@ void VideoCapturer::UpdateStats(const CapturedFrame* captured_frame) {
 
 template<class T>
 void VideoCapturer::GetVariableSnapshot(
-    const talk_base::RollingAccumulator<T>& data,
+    const rtc::RollingAccumulator<T>& data,
     VariableInfo<T>* stats) {
   stats->max_val = data.ComputeMax();
   stats->mean = data.ComputeMean();
diff --git a/talk/media/base/videocapturer.h b/talk/media/base/videocapturer.h
index 6b1c46ddd3..d4192be586 100644
--- a/talk/media/base/videocapturer.h
+++ b/talk/media/base/videocapturer.h
@@ -31,14 +31,14 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/criticalsection.h"
-#include "talk/base/messagehandler.h"
-#include "talk/base/rollingaccumulator.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/thread.h"
-#include "talk/base/timing.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/rollingaccumulator.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/timing.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/videoadapter.h"
 #include "talk/media/base/videocommon.h"
@@ -125,14 +125,14 @@ struct CapturedFrame {
 //
 class VideoCapturer
     : public sigslot::has_slots<>,
-      public talk_base::MessageHandler {
+      public rtc::MessageHandler {
  public:
   typedef std::vector<VideoProcessor*> VideoProcessors;
 
   // All signals are marshalled to |thread| or the creating thread if
   // none is provided.
   VideoCapturer();
-  explicit VideoCapturer(talk_base::Thread* thread);
+  explicit VideoCapturer(rtc::Thread* thread);
   virtual ~VideoCapturer() {}
 
   // Gets the id of the underlying device, which is available after the capturer
@@ -273,7 +273,7 @@ class VideoCapturer
   // resolution of 2048 x 1280.
   int screencast_max_pixels() const { return screencast_max_pixels_; }
   void set_screencast_max_pixels(int p) {
-    screencast_max_pixels_ = talk_base::_max(0, p);
+    screencast_max_pixels_ = rtc::_max(0, p);
   }
 
   // If true, run video adaptation. By default, video adaptation is enabled
@@ -304,7 +304,7 @@ class VideoCapturer
   void SetCaptureState(CaptureState state);
 
   // Marshals SignalStateChange onto thread_.
-  void OnMessage(talk_base::Message* message);
+  void OnMessage(rtc::Message* message);
 
   // subclasses override this virtual method to provide a vector of fourccs, in
   // order of preference, that are expected by the media engine.
@@ -355,15 +355,15 @@ class VideoCapturer
   // RollingAccumulator into stats.
   template<class T>
   static void GetVariableSnapshot(
-      const talk_base::RollingAccumulator<T>& data,
+      const rtc::RollingAccumulator<T>& data,
       VariableInfo<T>* stats);
 
-  talk_base::Thread* thread_;
+  rtc::Thread* thread_;
   std::string id_;
   CaptureState capture_state_;
-  talk_base::scoped_ptr<VideoFormat> capture_format_;
+  rtc::scoped_ptr<VideoFormat> capture_format_;
   std::vector<VideoFormat> supported_formats_;
-  talk_base::scoped_ptr<VideoFormat> max_format_;
+  rtc::scoped_ptr<VideoFormat> max_format_;
   std::vector<VideoFormat> filtered_supported_formats_;
 
   int ratio_w_;  // View resolution. e.g. 1280 x 720.
@@ -379,19 +379,19 @@ class VideoCapturer
   bool enable_video_adapter_;
   CoordinatedVideoAdapter video_adapter_;
 
-  talk_base::Timing frame_length_time_reporter_;
-  talk_base::CriticalSection frame_stats_crit_;
+  rtc::Timing frame_length_time_reporter_;
+  rtc::CriticalSection frame_stats_crit_;
 
   int adapt_frame_drops_;
-  talk_base::RollingAccumulator<int> adapt_frame_drops_data_;
+  rtc::RollingAccumulator<int> adapt_frame_drops_data_;
   int effect_frame_drops_;
-  talk_base::RollingAccumulator<int> effect_frame_drops_data_;
+  rtc::RollingAccumulator<int> effect_frame_drops_data_;
   double previous_frame_time_;
-  talk_base::RollingAccumulator<double> frame_time_data_;
+  rtc::RollingAccumulator<double> frame_time_data_;
   // The captured frame format before potential adapation.
   VideoFormat last_captured_frame_format_;
 
-  talk_base::CriticalSection crit_;
+  rtc::CriticalSection crit_;
   VideoProcessors video_processors_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCapturer);
diff --git a/talk/media/base/videocapturer_unittest.cc b/talk/media/base/videocapturer_unittest.cc
index 9f025e37bb..b70280f1c8 100644
--- a/talk/media/base/videocapturer_unittest.cc
+++ b/talk/media/base/videocapturer_unittest.cc
@@ -3,9 +3,9 @@
 #include <stdio.h>
 #include <vector>
 
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/fakemediaprocessor.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/base/fakevideorenderer.h"
@@ -113,7 +113,7 @@ TEST_F(VideoCapturerTest, CaptureState) {
   EXPECT_EQ_WAIT(cricket::CS_STOPPED, capture_state(), kMsCallbackWait);
   EXPECT_EQ(2, num_state_changes());
   capturer_.Stop();
-  talk_base::Thread::Current()->ProcessMessages(100);
+  rtc::Thread::Current()->ProcessMessages(100);
   EXPECT_EQ(2, num_state_changes());
 }
 
@@ -135,7 +135,7 @@ TEST_F(VideoCapturerTest, TestRestart) {
   EXPECT_TRUE(capturer_.IsRunning());
   EXPECT_GE(1, num_state_changes());
   capturer_.Stop();
-  talk_base::Thread::Current()->ProcessMessages(100);
+  rtc::Thread::Current()->ProcessMessages(100);
   EXPECT_FALSE(capturer_.IsRunning());
 }
 
diff --git a/talk/media/base/videocommon.cc b/talk/media/base/videocommon.cc
index 12d0ee7101..7c35d2ad1c 100644
--- a/talk/media/base/videocommon.cc
+++ b/talk/media/base/videocommon.cc
@@ -29,7 +29,7 @@
 #include <math.h>
 #include <sstream>
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 
 namespace cricket {
 
diff --git a/talk/media/base/videocommon.h b/talk/media/base/videocommon.h
index c83a3d8d13..a175c131af 100644
--- a/talk/media/base/videocommon.h
+++ b/talk/media/base/videocommon.h
@@ -30,8 +30,8 @@
 
 #include <string>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/timeutils.h"
 
 namespace cricket {
 
@@ -44,8 +44,8 @@ const uint32 kDummyVideoSsrc = 0xFFFFFFFF;
 
 // Minimum interval is 10k fps.
 #define FPS_TO_INTERVAL(fps) \
-    (fps ? talk_base::kNumNanosecsPerSec / fps : \
-    talk_base::kNumNanosecsPerSec / 10000)
+    (fps ? rtc::kNumNanosecsPerSec / fps : \
+    rtc::kNumNanosecsPerSec / 10000)
 
 //////////////////////////////////////////////////////////////////////////////
 // Definition of FourCC codes
@@ -186,7 +186,7 @@ struct VideoFormatPod {
 
 struct VideoFormat : VideoFormatPod {
   static const int64 kMinimumInterval =
-      talk_base::kNumNanosecsPerSec / 10000;  // 10k fps.
+      rtc::kNumNanosecsPerSec / 10000;  // 10k fps.
 
   VideoFormat() {
     Construct(0, 0, 0, 0);
@@ -208,21 +208,21 @@ struct VideoFormat : VideoFormatPod {
   }
 
   static int64 FpsToInterval(int fps) {
-    return fps ? talk_base::kNumNanosecsPerSec / fps : kMinimumInterval;
+    return fps ? rtc::kNumNanosecsPerSec / fps : kMinimumInterval;
   }
 
   static int IntervalToFps(int64 interval) {
     if (!interval) {
       return 0;
     }
-    return static_cast<int>(talk_base::kNumNanosecsPerSec / interval);
+    return static_cast<int>(rtc::kNumNanosecsPerSec / interval);
   }
 
   static float IntervalToFpsFloat(int64 interval) {
     if (!interval) {
       return 0.f;
     }
-    return static_cast<float>(talk_base::kNumNanosecsPerSec) /
+    return static_cast<float>(rtc::kNumNanosecsPerSec) /
         static_cast<float>(interval);
   }
 
diff --git a/talk/media/base/videocommon_unittest.cc b/talk/media/base/videocommon_unittest.cc
index 90bcd0aece..a30a2c9527 100644
--- a/talk/media/base/videocommon_unittest.cc
+++ b/talk/media/base/videocommon_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/videocommon.h"
 
 namespace cricket {
@@ -55,8 +55,8 @@ TEST(VideoCommonTest, TestCanonicalFourCC) {
 // Test conversion between interval and fps
 TEST(VideoCommonTest, TestVideoFormatFps) {
   EXPECT_EQ(VideoFormat::kMinimumInterval, VideoFormat::FpsToInterval(0));
-  EXPECT_EQ(talk_base::kNumNanosecsPerSec / 20, VideoFormat::FpsToInterval(20));
-  EXPECT_EQ(20, VideoFormat::IntervalToFps(talk_base::kNumNanosecsPerSec / 20));
+  EXPECT_EQ(rtc::kNumNanosecsPerSec / 20, VideoFormat::FpsToInterval(20));
+  EXPECT_EQ(20, VideoFormat::IntervalToFps(rtc::kNumNanosecsPerSec / 20));
   EXPECT_EQ(0, VideoFormat::IntervalToFps(0));
 }
 
diff --git a/talk/media/base/videoengine_unittest.h b/talk/media/base/videoengine_unittest.h
index a84236b63d..25811ba07d 100644
--- a/talk/media/base/videoengine_unittest.h
+++ b/talk/media/base/videoengine_unittest.h
@@ -29,9 +29,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/gunit.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/media/base/fakenetworkinterface.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/base/fakevideorenderer.h"
@@ -87,7 +87,7 @@ inline std::ostream& operator<<(std::ostream& s, const cricket::VideoCodec& c) {
 inline int TimeBetweenSend(const cricket::VideoCodec& codec) {
   return static_cast<int>(
       cricket::VideoFormat::FpsToInterval(codec.framerate) /
-      talk_base::kNumNanosecsPerMillisec);
+      rtc::kNumNanosecsPerMillisec);
 }
 
 // Fake video engine that makes it possible to test enabling and disabling
@@ -134,7 +134,7 @@ class VideoEngineOverride : public T {
   }
 #define TEST_POST_VIDEOENGINE_INIT(TestClass, func) \
   TEST_F(TestClass, func##PostInit) { \
-    EXPECT_TRUE(engine_.Init(talk_base::Thread::Current())); \
+    EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); \
     func##Body(); \
     engine_.Terminate(); \
   }
@@ -144,7 +144,7 @@ class VideoEngineTest : public testing::Test {
  protected:
   // Tests starting and stopping the engine, and creating a channel.
   void StartupShutdown() {
-    EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+    EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
     cricket::VideoMediaChannel* channel = engine_.CreateChannel(NULL);
     EXPECT_TRUE(channel != NULL);
     delete channel;
@@ -159,7 +159,7 @@ class VideoEngineTest : public testing::Test {
     EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
 
     // Engine should start even with COM already inited.
-    EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+    EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
     engine_.Terminate();
     // Refcount after terminate should be 1; this tests if it is nonzero.
     EXPECT_EQ(S_FALSE, CoInitializeEx(NULL, COINIT_MULTITHREADED));
@@ -479,7 +479,7 @@ class VideoEngineTest : public testing::Test {
   }
 
   VideoEngineOverride<E> engine_;
-  talk_base::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_;
+  rtc::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_;
 };
 
 template<class E, class C>
@@ -494,7 +494,7 @@ class VideoMediaChannelTest : public testing::Test,
 
   virtual void SetUp() {
     cricket::Device device("test", "device");
-    EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+    EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
     channel_.reset(engine_.CreateChannel(NULL));
     EXPECT_TRUE(channel_.get() != NULL);
     ConnectVideoChannelError();
@@ -595,7 +595,7 @@ class VideoMediaChannelTest : public testing::Test,
     do {
       packets = NumRtpPackets();
       // 100 ms should be long enough.
-      talk_base::Thread::Current()->ProcessMessages(100);
+      rtc::Thread::Current()->ProcessMessages(100);
     } while (NumRtpPackets() > packets);
     return NumRtpPackets();
   }
@@ -607,7 +607,7 @@ class VideoMediaChannelTest : public testing::Test,
         video_capturer_->CaptureFrame();
   }
   bool WaitAndSendFrame(int wait_ms) {
-    bool ret = talk_base::Thread::Current()->ProcessMessages(wait_ms);
+    bool ret = rtc::Thread::Current()->ProcessMessages(wait_ms);
     ret &= SendFrame();
     return ret;
   }
@@ -647,24 +647,24 @@ class VideoMediaChannelTest : public testing::Test,
   int NumSentSsrcs() {
     return network_interface_.NumSentSsrcs();
   }
-  const talk_base::Buffer* GetRtpPacket(int index) {
+  const rtc::Buffer* GetRtpPacket(int index) {
     return network_interface_.GetRtpPacket(index);
   }
   int NumRtcpPackets() {
     return network_interface_.NumRtcpPackets();
   }
-  const talk_base::Buffer* GetRtcpPacket(int index) {
+  const rtc::Buffer* GetRtcpPacket(int index) {
     return network_interface_.GetRtcpPacket(index);
   }
-  static int GetPayloadType(const talk_base::Buffer* p) {
+  static int GetPayloadType(const rtc::Buffer* p) {
     int pt = -1;
     ParseRtpPacket(p, NULL, &pt, NULL, NULL, NULL, NULL);
     return pt;
   }
-  static bool ParseRtpPacket(const talk_base::Buffer* p, bool* x, int* pt,
+  static bool ParseRtpPacket(const rtc::Buffer* p, bool* x, int* pt,
                              int* seqnum, uint32* tstamp, uint32* ssrc,
                              std::string* payload) {
-    talk_base::ByteBuffer buf(p->data(), p->length());
+    rtc::ByteBuffer buf(p->data(), p->length());
     uint8 u08 = 0;
     uint16 u16 = 0;
     uint32 u32 = 0;
@@ -723,8 +723,8 @@ class VideoMediaChannelTest : public testing::Test,
   bool CountRtcpFir(int start_index, int stop_index, int* fir_count) {
     int count = 0;
     for (int i = start_index; i < stop_index; ++i) {
-      talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtcpPacket(i));
-      talk_base::ByteBuffer buf(p->data(), p->length());
+      rtc::scoped_ptr<const rtc::Buffer> p(GetRtcpPacket(i));
+      rtc::ByteBuffer buf(p->data(), p->length());
       size_t total_len = 0;
       // The packet may be a compound RTCP packet.
       while (total_len < p->length()) {
@@ -791,7 +791,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
-    talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
+    rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
   }
   // Tests that we can send and receive frames.
@@ -803,7 +803,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
-    talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
+    rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
   }
   // Tests that we only get a VideoRenderer::SetSize() callback when needed.
@@ -818,7 +818,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
     EXPECT_TRUE(WaitAndSendFrame(30));
     EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout);
-    talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
+    rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
     EXPECT_EQ(1, renderer_.num_set_sizes());
 
@@ -853,7 +853,7 @@ class VideoMediaChannelTest : public testing::Test,
       // Therefore insert frames (and call GetStats each sec) for a few seconds
       // before testing stats.
     }
-    talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
+    rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
   }
 
@@ -966,7 +966,7 @@ class VideoMediaChannelTest : public testing::Test,
 
     // Add an additional capturer, and hook up a renderer to receive it.
     cricket::FakeVideoRenderer renderer1;
-    talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer(
+    rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer(
       new cricket::FakeVideoCapturer);
     capturer->SetScreencast(true);
     const int kTestWidth = 160;
@@ -1018,7 +1018,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
     uint32 ssrc = 0;
-    talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
+    rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(kSsrc, ssrc);
     EXPECT_EQ(NumRtpPackets(), NumRtpPackets(ssrc));
@@ -1040,7 +1040,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(WaitAndSendFrame(0));
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
     uint32 ssrc = 0;
-    talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
+    rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(999u, ssrc);
     EXPECT_EQ(NumRtpPackets(), NumRtpPackets(ssrc));
@@ -1056,14 +1056,14 @@ class VideoMediaChannelTest : public testing::Test,
         0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     };
 
-    talk_base::Buffer packet1(data1, sizeof(data1));
-    talk_base::SetBE32(packet1.data() + 8, kSsrc);
+    rtc::Buffer packet1(data1, sizeof(data1));
+    rtc::SetBE32(packet1.data() + 8, kSsrc);
     channel_->SetRenderer(kDefaultReceiveSsrc, NULL);
     EXPECT_TRUE(SetDefaultCodec());
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
-    channel_->OnPacketReceived(&packet1, talk_base::PacketTime());
+    channel_->OnPacketReceived(&packet1, rtc::PacketTime());
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
@@ -1091,7 +1091,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_GE(2, NumRtpPackets());
     uint32 ssrc = 0;
     size_t last_packet = NumRtpPackets() - 1;
-    talk_base::scoped_ptr<const talk_base::Buffer>
+    rtc::scoped_ptr<const rtc::Buffer>
         p(GetRtpPacket(static_cast<int>(last_packet)));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(kSsrc, ssrc);
@@ -1293,7 +1293,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer2, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
 
-    talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
+    rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(DefaultCodec().id, GetPayloadType(p.get()));
     EXPECT_EQ(DefaultCodec().width, renderer1.width());
     EXPECT_EQ(DefaultCodec().height, renderer1.height());
@@ -1316,7 +1316,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
-    talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer(
+    rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer(
         new cricket::FakeVideoCapturer);
     capturer->SetScreencast(true);
     cricket::VideoFormat format(480, 360,
@@ -1332,7 +1332,7 @@ class VideoMediaChannelTest : public testing::Test,
     int captured_frames = 1;
     for (int iterations = 0; iterations < 2; ++iterations) {
       EXPECT_TRUE(channel_->SetCapturer(kSsrc, capturer.get()));
-      talk_base::Thread::Current()->ProcessMessages(time_between_send);
+      rtc::Thread::Current()->ProcessMessages(time_between_send);
       EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
                                                cricket::FOURCC_I420));
       ++captured_frames;
@@ -1385,7 +1385,7 @@ class VideoMediaChannelTest : public testing::Test,
     // No capturer was added, so this RemoveCapturer should
     // fail.
     EXPECT_FALSE(channel_->SetCapturer(kSsrc, NULL));
-    talk_base::Thread::Current()->ProcessMessages(300);
+    rtc::Thread::Current()->ProcessMessages(300);
     // Verify no more frames were sent.
     EXPECT_EQ(2, renderer_.num_rendered_frames());
   }
@@ -1410,7 +1410,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(1)));
-    talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer1(
+    rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer1(
         new cricket::FakeVideoCapturer);
     capturer1->SetScreencast(true);
     EXPECT_EQ(cricket::CS_RUNNING, capturer1->Start(capture_format));
@@ -1422,7 +1422,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(2)));
-    talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer2(
+    rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer2(
         new cricket::FakeVideoCapturer);
     capturer2->SetScreencast(true);
     EXPECT_EQ(cricket::CS_RUNNING, capturer2->Start(capture_format));
@@ -1480,7 +1480,7 @@ class VideoMediaChannelTest : public testing::Test,
 
     // Registering an external capturer is currently the same as screen casting
     // (update the test when this changes).
-    talk_base::scoped_ptr<cricket::FakeVideoCapturer> capturer(
+    rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer(
         new cricket::FakeVideoCapturer);
     capturer->SetScreencast(true);
     const std::vector<cricket::VideoFormat>* formats =
@@ -1490,7 +1490,7 @@ class VideoMediaChannelTest : public testing::Test,
     // Capture frame to not get same frame timestamps as previous capturer.
     capturer->CaptureFrame();
     EXPECT_TRUE(channel_->SetCapturer(kSsrc, capturer.get()));
-    EXPECT_TRUE(talk_base::Thread::Current()->ProcessMessages(30));
+    EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
     EXPECT_TRUE(capturer->CaptureCustomFrame(kWidth, kHeight,
                                              cricket::FOURCC_ARGB));
     EXPECT_GT_FRAME_ON_RENDERER_WAIT(
@@ -1539,7 +1539,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE(SendFrame());
-    talk_base::Thread::Current()->ProcessMessages(500);
+    rtc::Thread::Current()->ProcessMessages(500);
     EXPECT_EQ(0, renderer_.num_rendered_frames());
   }
   // Tests that we can reduce the frame rate on demand properly.
@@ -1556,7 +1556,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(WaitAndSendFrame(30));  // Should be rendered.
     frame_count += 2;
     EXPECT_FRAME_WAIT(frame_count, codec.width, codec.height, kTimeout);
-    talk_base::scoped_ptr<const talk_base::Buffer> p(GetRtpPacket(0));
+    rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
 
     // The channel requires 15 fps.
@@ -1618,7 +1618,7 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE(SendFrame());
-    talk_base::Thread::Current()->ProcessMessages(500);
+    rtc::Thread::Current()->ProcessMessages(500);
     EXPECT_EQ(frame_count, renderer_.num_rendered_frames());
   }
   // Test that setting send stream format to 0x0 resolution will result in
@@ -1643,8 +1643,8 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(channel_->SetSendStreamFormat(kSsrc, format));
     // This frame should not be received.
     EXPECT_TRUE(WaitAndSendFrame(
-        static_cast<int>(interval/talk_base::kNumNanosecsPerMillisec)));
-    talk_base::Thread::Current()->ProcessMessages(500);
+        static_cast<int>(interval/rtc::kNumNanosecsPerMillisec)));
+    rtc::Thread::Current()->ProcessMessages(500);
     EXPECT_EQ(1, renderer_.num_rendered_frames());
   }
 
@@ -1673,7 +1673,7 @@ class VideoMediaChannelTest : public testing::Test,
 
     // Unmute the channel and expect non-black output frame.
     EXPECT_TRUE(channel_->MuteStream(kSsrc, false));
-    EXPECT_TRUE(talk_base::Thread::Current()->ProcessMessages(30));
+    EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
     EXPECT_TRUE(video_capturer.CaptureFrame());
     ++frame_count;
     EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
@@ -1681,14 +1681,14 @@ class VideoMediaChannelTest : public testing::Test,
 
     // Test that we can also Mute using the correct send stream SSRC.
     EXPECT_TRUE(channel_->MuteStream(kSsrc, true));
-    EXPECT_TRUE(talk_base::Thread::Current()->ProcessMessages(30));
+    EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
     EXPECT_TRUE(video_capturer.CaptureFrame());
     ++frame_count;
     EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
     EXPECT_TRUE(renderer_.black_frame());
 
     EXPECT_TRUE(channel_->MuteStream(kSsrc, false));
-    EXPECT_TRUE(talk_base::Thread::Current()->ProcessMessages(30));
+    EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
     EXPECT_TRUE(video_capturer.CaptureFrame());
     ++frame_count;
     EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
@@ -1782,7 +1782,7 @@ class VideoMediaChannelTest : public testing::Test,
     // instead of packets.
     EXPECT_EQ(0, renderer2_.num_rendered_frames());
     // Give a chance for the decoder to process before adding the receiver.
-    talk_base::Thread::Current()->ProcessMessages(100);
+    rtc::Thread::Current()->ProcessMessages(100);
     // Test sending and receiving on second stream.
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc + 2)));
@@ -1808,11 +1808,11 @@ class VideoMediaChannelTest : public testing::Test,
     EXPECT_TRUE(channel_->SetRender(true));
     Send(codec);
     EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout);
-    talk_base::Thread::Current()->ProcessMessages(100);
+    rtc::Thread::Current()->ProcessMessages(100);
     EXPECT_EQ_WAIT(1, renderer_.num_rendered_frames(), kTimeout);
     EXPECT_EQ_WAIT(0, renderer2_.num_rendered_frames(), kTimeout);
     // Give a chance for the decoder to process before adding the receiver.
-    talk_base::Thread::Current()->ProcessMessages(10);
+    rtc::Thread::Current()->ProcessMessages(10);
     // Test sending and receiving on second stream.
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc + 2)));
@@ -1843,7 +1843,7 @@ class VideoMediaChannelTest : public testing::Test,
     // is no registered recv channel for the ssrc.
     EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= 1, kTimeout);
     // Give a chance for the decoder to process before adding the receiver.
-    talk_base::Thread::Current()->ProcessMessages(100);
+    rtc::Thread::Current()->ProcessMessages(100);
     // Test sending and receiving on second stream.
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc + 2)));
@@ -1876,16 +1876,16 @@ class VideoMediaChannelTest : public testing::Test,
     // instead of packets.
     EXPECT_EQ(0, renderer2_.num_rendered_frames());
     // Give a chance for the decoder to process before adding the receiver.
-    talk_base::Thread::Current()->ProcessMessages(100);
+    rtc::Thread::Current()->ProcessMessages(100);
     // Ensure that we can remove the unsignalled recv stream that was created
     // when the first video packet with unsignalled recv ssrc is received.
     EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc + 2));
   }
 
   VideoEngineOverride<E> engine_;
-  talk_base::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_;
-  talk_base::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_2_;
-  talk_base::scoped_ptr<C> channel_;
+  rtc::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_;
+  rtc::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_2_;
+  rtc::scoped_ptr<C> channel_;
   cricket::FakeNetworkInterface network_interface_;
   cricket::FakeVideoRenderer renderer_;
   cricket::VideoMediaChannel::Error media_error_;
diff --git a/talk/media/base/videoframe.cc b/talk/media/base/videoframe.cc
index cf5f852fc9..d84169324f 100644
--- a/talk/media/base/videoframe.cc
+++ b/talk/media/base/videoframe.cc
@@ -35,7 +35,7 @@
 #include "libyuv/scale.h"
 #endif
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/media/base/videocommon.h"
 
 namespace cricket {
@@ -43,9 +43,9 @@ namespace cricket {
 // Round to 2 pixels because Chroma channels are half size.
 #define ROUNDTO2(v) (v & ~1)
 
-talk_base::StreamResult VideoFrame::Write(talk_base::StreamInterface* stream,
+rtc::StreamResult VideoFrame::Write(rtc::StreamInterface* stream,
                                           int* error) {
-  talk_base::StreamResult result = talk_base::SR_SUCCESS;
+  rtc::StreamResult result = rtc::SR_SUCCESS;
   const uint8* src_y = GetYPlane();
   const uint8* src_u = GetUPlane();
   const uint8* src_v = GetVPlane();
@@ -62,21 +62,21 @@ talk_base::StreamResult VideoFrame::Write(talk_base::StreamInterface* stream,
   // Write Y.
   for (size_t row = 0; row < height; ++row) {
     result = stream->Write(src_y + row * y_pitch, width, NULL, error);
-    if (result != talk_base::SR_SUCCESS) {
+    if (result != rtc::SR_SUCCESS) {
       return result;
     }
   }
   // Write U.
   for (size_t row = 0; row < half_height; ++row) {
     result = stream->Write(src_u + row * u_pitch, half_width, NULL, error);
-    if (result != talk_base::SR_SUCCESS) {
+    if (result != rtc::SR_SUCCESS) {
       return result;
     }
   }
   // Write V.
   for (size_t row = 0; row < half_height; ++row) {
     result = stream->Write(src_v + row * v_pitch, half_width, NULL, error);
-    if (result != talk_base::SR_SUCCESS) {
+    if (result != rtc::SR_SUCCESS) {
       return result;
     }
   }
diff --git a/talk/media/base/videoframe.h b/talk/media/base/videoframe.h
index fe5ff01ef8..d94e47081c 100644
--- a/talk/media/base/videoframe.h
+++ b/talk/media/base/videoframe.h
@@ -28,8 +28,8 @@
 #ifndef TALK_MEDIA_BASE_VIDEOFRAME_H_
 #define TALK_MEDIA_BASE_VIDEOFRAME_H_
 
-#include "talk/base/basictypes.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/stream.h"
 
 namespace cricket {
 
@@ -126,10 +126,10 @@ class VideoFrame {
   virtual void CopyToFrame(VideoFrame* target) const;
 
   // Writes the frame into the given stream and returns the StreamResult.
-  // See talk/base/stream.h for a description of StreamResult and error.
+  // See webrtc/base/stream.h for a description of StreamResult and error.
   // Error may be NULL. If a non-success value is returned from
   // StreamInterface::Write(), we immediately return with that value.
-  virtual talk_base::StreamResult Write(talk_base::StreamInterface *stream,
+  virtual rtc::StreamResult Write(rtc::StreamInterface *stream,
                                         int *error);
 
   // Converts the I420 data to RGB of a certain type such as ARGB and ABGR.
diff --git a/talk/media/base/videoframe_unittest.h b/talk/media/base/videoframe_unittest.h
index d7be7e3887..120f0e279e 100644
--- a/talk/media/base/videoframe_unittest.h
+++ b/talk/media/base/videoframe_unittest.h
@@ -35,10 +35,10 @@
 #include "libyuv/format_conversion.h"
 #include "libyuv/planar_functions.h"
 #include "libyuv/rotate.h"
-#include "talk/base/gunit.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/stream.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/testutils.h"
 #include "talk/media/base/videocommon.h"
 #include "talk/media/base/videoframe.h"
@@ -89,16 +89,16 @@ class VideoFrameTest : public testing::Test {
   bool LoadFrame(const std::string& filename, uint32 format,
                  int32 width, int32 height, int dw, int dh, int rotation,
                  T* frame) {
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(LoadSample(filename));
+    rtc::scoped_ptr<rtc::MemoryStream> ms(LoadSample(filename));
     return LoadFrame(ms.get(), format, width, height, dw, dh, rotation, frame);
   }
   // Load a video frame from a memory stream.
-  bool LoadFrame(talk_base::MemoryStream* ms, uint32 format,
+  bool LoadFrame(rtc::MemoryStream* ms, uint32 format,
                  int32 width, int32 height, T* frame) {
     return LoadFrame(ms, format, width, height,
                      width, abs(height), 0, frame);
   }
-  bool LoadFrame(talk_base::MemoryStream* ms, uint32 format,
+  bool LoadFrame(rtc::MemoryStream* ms, uint32 format,
                  int32 width, int32 height, int dw, int dh, int rotation,
                  T* frame) {
     if (!ms) {
@@ -130,19 +130,19 @@ class VideoFrameTest : public testing::Test {
     return ret;
   }
 
-  talk_base::MemoryStream* LoadSample(const std::string& filename) {
-    talk_base::Pathname path(cricket::GetTestFilePath(filename));
-    talk_base::scoped_ptr<talk_base::FileStream> fs(
-        talk_base::Filesystem::OpenFile(path, "rb"));
+  rtc::MemoryStream* LoadSample(const std::string& filename) {
+    rtc::Pathname path(cricket::GetTestFilePath(filename));
+    rtc::scoped_ptr<rtc::FileStream> fs(
+        rtc::Filesystem::OpenFile(path, "rb"));
     if (!fs.get()) {
       return NULL;
     }
 
     char buf[4096];
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
-        new talk_base::MemoryStream());
-    talk_base::StreamResult res = Flow(fs.get(), buf, sizeof(buf), ms.get());
-    if (res != talk_base::SR_SUCCESS) {
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
+        new rtc::MemoryStream());
+    rtc::StreamResult res = Flow(fs.get(), buf, sizeof(buf), ms.get());
+    if (res != rtc::SR_SUCCESS) {
       return NULL;
     }
 
@@ -153,24 +153,24 @@ class VideoFrameTest : public testing::Test {
   bool DumpFrame(const std::string& prefix,
                  const cricket::VideoFrame& frame) {
     char filename[256];
-    talk_base::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv",
+    rtc::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv",
                         prefix.c_str(), frame.GetWidth(), frame.GetHeight());
     size_t out_size = cricket::VideoFrame::SizeOf(frame.GetWidth(),
                                                   frame.GetHeight());
-    talk_base::scoped_ptr<uint8[]> out(new uint8[out_size]);
+    rtc::scoped_ptr<uint8[]> out(new uint8[out_size]);
     frame.CopyToBuffer(out.get(), out_size);
     return DumpSample(filename, out.get(), out_size);
   }
 
   bool DumpSample(const std::string& filename, const void* buffer, int size) {
-    talk_base::Pathname path(filename);
-    talk_base::scoped_ptr<talk_base::FileStream> fs(
-        talk_base::Filesystem::OpenFile(path, "wb"));
+    rtc::Pathname path(filename);
+    rtc::scoped_ptr<rtc::FileStream> fs(
+        rtc::Filesystem::OpenFile(path, "wb"));
     if (!fs.get()) {
       return false;
     }
 
-    return (fs->Write(buffer, size, NULL, NULL) == talk_base::SR_SUCCESS);
+    return (fs->Write(buffer, size, NULL, NULL) == rtc::SR_SUCCESS);
   }
 
   // Create a test image in the desired color space.
@@ -179,15 +179,15 @@ class VideoFrameTest : public testing::Test {
   // The pattern is { { green, orange }, { blue, purple } }
   // There is also a gradient within each square to ensure that the luma
   // values are handled properly.
-  talk_base::MemoryStream* CreateYuv422Sample(uint32 fourcc,
+  rtc::MemoryStream* CreateYuv422Sample(uint32 fourcc,
                                               uint32 width, uint32 height) {
     int y1_pos, y2_pos, u_pos, v_pos;
     if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) {
       return NULL;
     }
 
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
-        new talk_base::MemoryStream);
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
+        new rtc::MemoryStream);
     int awidth = (width + 1) & ~1;
     int size = awidth * 2 * height;
     if (!ms->ReserveSize(size)) {
@@ -207,10 +207,10 @@ class VideoFrameTest : public testing::Test {
   }
 
   // Create a test image for YUV 420 formats with 12 bits per pixel.
-  talk_base::MemoryStream* CreateYuvSample(uint32 width, uint32 height,
+  rtc::MemoryStream* CreateYuvSample(uint32 width, uint32 height,
                                            uint32 bpp) {
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
-        new talk_base::MemoryStream);
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
+        new rtc::MemoryStream);
     if (!ms->ReserveSize(width * height * bpp / 8)) {
       return NULL;
     }
@@ -222,15 +222,15 @@ class VideoFrameTest : public testing::Test {
     return ms.release();
   }
 
-  talk_base::MemoryStream* CreateRgbSample(uint32 fourcc,
+  rtc::MemoryStream* CreateRgbSample(uint32 fourcc,
                                            uint32 width, uint32 height) {
     int r_pos, g_pos, b_pos, bytes;
     if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
       return NULL;
     }
 
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
-        new talk_base::MemoryStream);
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
+        new rtc::MemoryStream);
     if (!ms->ReserveSize(width * height * bytes)) {
       return NULL;
     }
@@ -249,7 +249,7 @@ class VideoFrameTest : public testing::Test {
 
   // Simple conversion routines to verify the optimized VideoFrame routines.
   // Converts from the specified colorspace to I420.
-  bool ConvertYuv422(const talk_base::MemoryStream* ms,
+  bool ConvertYuv422(const rtc::MemoryStream* ms,
                      uint32 fourcc, uint32 width, uint32 height,
                      T* frame) {
     int y1_pos, y2_pos, u_pos, v_pos;
@@ -287,7 +287,7 @@ class VideoFrameTest : public testing::Test {
 
   // Convert RGB to 420.
   // A negative height inverts the image.
-  bool ConvertRgb(const talk_base::MemoryStream* ms,
+  bool ConvertRgb(const rtc::MemoryStream* ms,
                   uint32 fourcc, int32 width, int32 height,
                   T* frame) {
     int r_pos, g_pos, b_pos, bytes;
@@ -482,7 +482,7 @@ class VideoFrameTest : public testing::Test {
   void ConstructI420() {
     T frame;
     EXPECT_TRUE(IsNull(frame));
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420,
                           kWidth, kHeight, &frame));
@@ -497,7 +497,7 @@ class VideoFrameTest : public testing::Test {
   // Test constructing an image from a YV12 buffer.
   void ConstructYV12() {
     T frame;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YV12,
                           kWidth, kHeight, &frame));
@@ -514,7 +514,7 @@ class VideoFrameTest : public testing::Test {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
-    talk_base::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment]);
+    rtc::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment]);
     uint8* y = ALIGNP(buf.get(), kAlignment);
     uint8* u = y + kWidth * kHeight;
     uint8* v = u + (kWidth / 2) * kHeight;
@@ -535,7 +535,7 @@ class VideoFrameTest : public testing::Test {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
-    talk_base::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment]);
+    rtc::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment]);
     uint8* yuy2 = ALIGNP(buf.get(), kAlignment);
     EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(),
                                     frame1.GetUPlane(), frame1.GetUPitch(),
@@ -552,7 +552,7 @@ class VideoFrameTest : public testing::Test {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
-    talk_base::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment + 1]);
+    rtc::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment + 1]);
     uint8* yuy2 = ALIGNP(buf.get(), kAlignment) + 1;
     EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(),
                                     frame1.GetUPlane(), frame1.GetUPitch(),
@@ -568,7 +568,7 @@ class VideoFrameTest : public testing::Test {
   // Normal is 1280x720.  Wide is 12800x72
   void ConstructYuy2Wide() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth * 10, kHeight / 10));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2,
@@ -582,7 +582,7 @@ class VideoFrameTest : public testing::Test {
   // Test constructing an image from a UYVY buffer.
   void ConstructUyvy() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_UYVY, kWidth, kHeight,
@@ -596,7 +596,7 @@ class VideoFrameTest : public testing::Test {
   // We are merely verifying that the code succeeds and is free of crashes.
   void ConstructM420() {
     T frame;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_M420,
@@ -605,7 +605,7 @@ class VideoFrameTest : public testing::Test {
 
   void ConstructQ420() {
     T frame;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_Q420,
@@ -614,7 +614,7 @@ class VideoFrameTest : public testing::Test {
 
   void ConstructNV21() {
     T frame;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_NV21,
@@ -623,7 +623,7 @@ class VideoFrameTest : public testing::Test {
 
   void ConstructNV12() {
     T frame;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_NV12,
@@ -634,7 +634,7 @@ class VideoFrameTest : public testing::Test {
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void ConstructABGR() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ABGR, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ABGR, kWidth, kHeight,
@@ -648,7 +648,7 @@ class VideoFrameTest : public testing::Test {
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void ConstructARGB() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight,
@@ -662,7 +662,7 @@ class VideoFrameTest : public testing::Test {
   // Normal is 1280x720.  Wide is 12800x72
   void ConstructARGBWide() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth * 10, kHeight / 10));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB,
@@ -676,7 +676,7 @@ class VideoFrameTest : public testing::Test {
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void ConstructBGRA() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_BGRA, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_BGRA, kWidth, kHeight,
@@ -690,7 +690,7 @@ class VideoFrameTest : public testing::Test {
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void Construct24BG() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_24BG, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_24BG, kWidth, kHeight,
@@ -704,7 +704,7 @@ class VideoFrameTest : public testing::Test {
   // Due to rounding, some pixels may differ slightly from the VideoFrame impl.
   void ConstructRaw() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_RAW, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_RAW, kWidth, kHeight,
@@ -718,7 +718,7 @@ class VideoFrameTest : public testing::Test {
   void ConstructRGB565() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    talk_base::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
+    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
     uint8 *out = ALIGNP(outbuf.get(), kAlignment);
     T frame;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
@@ -734,7 +734,7 @@ class VideoFrameTest : public testing::Test {
   void ConstructARGB1555() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    talk_base::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
+    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
     uint8 *out = ALIGNP(outbuf.get(), kAlignment);
     T frame;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
@@ -750,7 +750,7 @@ class VideoFrameTest : public testing::Test {
   void ConstructARGB4444() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    talk_base::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
+    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
     uint8 *out = ALIGNP(outbuf.get(), kAlignment);
     T frame;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
@@ -769,11 +769,11 @@ class VideoFrameTest : public testing::Test {
   #define TEST_BYR(NAME, BAYER)                                                \
   void NAME() {                                                                \
     size_t bayer_size = kWidth * kHeight;                                      \
-    talk_base::scoped_ptr<uint8[]> bayerbuf(new uint8[                         \
+    rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[                         \
         bayer_size + kAlignment]);                                             \
     uint8 *bayer = ALIGNP(bayerbuf.get(), kAlignment);                         \
     T frame1, frame2;                                                          \
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(                         \
+    rtc::scoped_ptr<rtc::MemoryStream> ms(                         \
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));               \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8 *>(ms->GetBuffer()),     \
@@ -798,7 +798,7 @@ class VideoFrameTest : public testing::Test {
 #define TEST_MIRROR(FOURCC, BPP)                                               \
 void Construct##FOURCC##Mirror() {                                             \
     T frame1, frame2, frame3;                                                  \
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(                         \
+    rtc::scoped_ptr<rtc::MemoryStream> ms(                         \
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC,                  \
@@ -831,7 +831,7 @@ void Construct##FOURCC##Mirror() {                                             \
 #define TEST_ROTATE(FOURCC, BPP, ROTATE)                                       \
 void Construct##FOURCC##Rotate##ROTATE() {                                     \
     T frame1, frame2, frame3;                                                  \
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(                         \
+    rtc::scoped_ptr<rtc::MemoryStream> ms(                         \
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC,                  \
@@ -887,7 +887,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from a UYVY buffer rotated 90 degrees.
   void ConstructUyvyRotate90() {
     T frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY,
@@ -898,7 +898,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from a UYVY buffer rotated 180 degrees.
   void ConstructUyvyRotate180() {
     T frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY,
@@ -909,7 +909,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from a UYVY buffer rotated 270 degrees.
   void ConstructUyvyRotate270() {
     T frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY,
@@ -920,7 +920,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from a YUY2 buffer rotated 90 degrees.
   void ConstructYuy2Rotate90() {
     T frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2,
@@ -931,7 +931,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from a YUY2 buffer rotated 180 degrees.
   void ConstructYuy2Rotate180() {
     T frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2,
@@ -942,7 +942,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from a YUY2 buffer rotated 270 degrees.
   void ConstructYuy2Rotate270() {
     T frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2,
@@ -994,7 +994,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
     }
     // Convert back to ARGB.
     size_t out_size = 4;
-    talk_base::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
+    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
     uint8 *out = ALIGNP(outbuf.get(), kAlignment);
 
     EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB,
@@ -1031,7 +1031,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
     }
     // Convert back to ARGB
     size_t out_size = 10 * 4;
-    talk_base::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
+    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]);
     uint8 *out = ALIGNP(outbuf.get(), kAlignment);
 
     EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB,
@@ -1055,7 +1055,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from a YUY2 buffer with horizontal cropping.
   void ConstructYuy2CropHorizontal() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight,
@@ -1068,7 +1068,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from an ARGB buffer with horizontal cropping.
   void ConstructARGBCropHorizontal() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight,
@@ -1153,7 +1153,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   void ValidateFrame(const char* name, uint32 fourcc, int data_adjust,
                      int size_adjust, bool expected_result) {
     T frame;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(LoadSample(name));
+    rtc::scoped_ptr<rtc::MemoryStream> ms(LoadSample(name));
     ASSERT_TRUE(ms.get() != NULL);
     const uint8* sample = reinterpret_cast<const uint8*>(ms.get()->GetBuffer());
     size_t sample_size;
@@ -1163,7 +1163,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
 
     // Allocate a buffer with end page aligned.
     const int kPadToHeapSized = 16 * 1024 * 1024;
-    talk_base::scoped_ptr<uint8[]> page_buffer(
+    rtc::scoped_ptr<uint8[]> page_buffer(
         new uint8[((data_size + kPadToHeapSized + 4095) & ~4095)]);
     uint8* data_ptr = page_buffer.get();
     if (!data_ptr) {
@@ -1172,7 +1172,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
       return;
     }
     data_ptr += kPadToHeapSized + (-(static_cast<int>(data_size)) & 4095);
-    memcpy(data_ptr, sample, talk_base::_min(data_size, sample_size));
+    memcpy(data_ptr, sample, rtc::_min(data_size, sample_size));
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_EQ(expected_result, frame.Validate(fourcc, kWidth, kHeight,
                                                 data_ptr,
@@ -1269,7 +1269,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from a YUY2 buffer (and synonymous formats).
   void ConstructYuy2Aliases() {
     T frame1, frame2, frame3, frame4;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight,
@@ -1288,7 +1288,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Test constructing an image from a UYVY buffer (and synonymous formats).
   void ConstructUyvyAliases() {
     T frame1, frame2, frame3, frame4;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight));
     ASSERT_TRUE(ms.get() != NULL);
     EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_UYVY, kWidth, kHeight,
@@ -1343,7 +1343,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
     T frame1, frame2;
     for (int height = kMinHeightAll; height <= kMaxHeightAll; ++height) {
       for (int width = kMinWidthAll; width <= kMaxWidthAll; ++width) {
-        talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+        rtc::scoped_ptr<rtc::MemoryStream> ms(
             CreateYuv422Sample(cricket::FOURCC_YUY2, width, height));
         ASSERT_TRUE(ms.get() != NULL);
         EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, width, height,
@@ -1361,7 +1361,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
     T frame1, frame2;
     for (int height = kMinHeightAll; height <= kMaxHeightAll; ++height) {
       for (int width = kMinWidthAll; width <= kMaxWidthAll; ++width) {
-        talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+        rtc::scoped_ptr<rtc::MemoryStream> ms(
             CreateRgbSample(cricket::FOURCC_ARGB, width, height));
         ASSERT_TRUE(ms.get() != NULL);
         EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, width, height,
@@ -1376,7 +1376,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
     const int kOddHeight = 260;
     for (int j = 0; j < 2; ++j) {
       for (int i = 0; i < 2; ++i) {
-        talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+        rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateRgbSample(cricket::FOURCC_ARGB, kOddWidth + i, kOddHeight + j));
         ASSERT_TRUE(ms.get() != NULL);
         EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB,
@@ -1392,7 +1392,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   // Tests re-initing an existing image.
   void Reset() {
     T frame1, frame2;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
     ASSERT_TRUE(ms.get() != NULL);
     size_t data_size;
@@ -1429,7 +1429,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
 
     int astride = kWidth * bpp + rowpad;
     size_t out_size = astride * kHeight;
-    talk_base::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment + 1]);
+    rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment + 1]);
     memset(outbuf.get(), 0, out_size + kAlignment + 1);
     uint8 *outtop = ALIGNP(outbuf.get(), kAlignment);
     uint8 *out = outtop;
@@ -1843,7 +1843,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   void ConvertToI422Buffer() {
     T frame1, frame2;
     size_t out_size = kWidth * kHeight * 2;
-    talk_base::scoped_ptr<uint8[]> buf(new uint8[out_size + kAlignment]);
+    rtc::scoped_ptr<uint8[]> buf(new uint8[out_size + kAlignment]);
     uint8* y = ALIGNP(buf.get(), kAlignment);
     uint8* u = y + kWidth * kHeight;
     uint8* v = u + (kWidth / 2) * kHeight;
@@ -1867,11 +1867,11 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   #define TEST_TOBYR(NAME, BAYER)                                              \
   void NAME() {                                                                \
     size_t bayer_size = kWidth * kHeight;                                      \
-    talk_base::scoped_ptr<uint8[]> bayerbuf(new uint8[                         \
+    rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[                         \
         bayer_size + kAlignment]);                                             \
     uint8 *bayer = ALIGNP(bayerbuf.get(), kAlignment);                         \
     T frame;                                                                   \
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(                         \
+    rtc::scoped_ptr<rtc::MemoryStream> ms(                         \
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));               \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     for (int i = 0; i < repeat_; ++i) {                                        \
@@ -1880,7 +1880,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
                                  bayer, kWidth,                                \
                                  kWidth, kHeight);                             \
     }                                                                          \
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms2(                        \
+    rtc::scoped_ptr<rtc::MemoryStream> ms2(                        \
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));               \
     size_t data_size;                                                          \
     bool ret = ms2->GetSize(&data_size);                                       \
@@ -1896,11 +1896,11 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   }                                                                            \
   void NAME##Unaligned() {                                                     \
     size_t bayer_size = kWidth * kHeight;                                      \
-    talk_base::scoped_ptr<uint8[]> bayerbuf(new uint8[                         \
+    rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[                         \
         bayer_size + 1 + kAlignment]);                                         \
     uint8 *bayer = ALIGNP(bayerbuf.get(), kAlignment) + 1;                     \
     T frame;                                                                   \
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(                         \
+    rtc::scoped_ptr<rtc::MemoryStream> ms(                         \
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));               \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     for (int i = 0; i < repeat_; ++i) {                                        \
@@ -1909,7 +1909,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
                                  bayer, kWidth,                                \
                                  kWidth, kHeight);                             \
     }                                                                          \
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms2(                        \
+    rtc::scoped_ptr<rtc::MemoryStream> ms2(                        \
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));               \
     size_t data_size;                                                          \
     bool ret = ms2->GetSize(&data_size);                                       \
@@ -1933,14 +1933,14 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   #define TEST_BYRTORGB(NAME, BAYER)                                           \
   void NAME() {                                                                \
     size_t bayer_size = kWidth * kHeight;                                      \
-    talk_base::scoped_ptr<uint8[]> bayerbuf(new uint8[                         \
+    rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[                         \
         bayer_size + kAlignment]);                                             \
     uint8 *bayer1 = ALIGNP(bayerbuf.get(), kAlignment);                        \
     for (int i = 0; i < kWidth * kHeight; ++i) {                               \
       bayer1[i] = static_cast<uint8>(i * 33u + 183u);                          \
     }                                                                          \
     T frame;                                                                   \
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(                         \
+    rtc::scoped_ptr<rtc::MemoryStream> ms(                         \
         CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight));               \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     for (int i = 0; i < repeat_; ++i) {                                        \
@@ -1949,7 +1949,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
                              kWidth * 4,                                       \
                              kWidth, kHeight);                                 \
     }                                                                          \
-    talk_base::scoped_ptr<uint8[]> bayer2buf(new uint8[                        \
+    rtc::scoped_ptr<uint8[]> bayer2buf(new uint8[                        \
         bayer_size + kAlignment]);                                             \
     uint8 *bayer2 = ALIGNP(bayer2buf.get(), kAlignment);                       \
     libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8*>(ms->GetBuffer()),      \
@@ -1973,8 +1973,8 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   ///////////////////
 
   void Copy() {
-    talk_base::scoped_ptr<T> source(new T);
-    talk_base::scoped_ptr<cricket::VideoFrame> target;
+    rtc::scoped_ptr<T> source(new T);
+    rtc::scoped_ptr<cricket::VideoFrame> target;
     ASSERT_TRUE(LoadFrameNoRepeat(source.get()));
     target.reset(source->Copy());
     EXPECT_TRUE(IsEqual(*source, *target, 0));
@@ -1983,8 +1983,8 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   }
 
   void CopyIsRef() {
-    talk_base::scoped_ptr<T> source(new T);
-    talk_base::scoped_ptr<cricket::VideoFrame> target;
+    rtc::scoped_ptr<T> source(new T);
+    rtc::scoped_ptr<cricket::VideoFrame> target;
     ASSERT_TRUE(LoadFrameNoRepeat(source.get()));
     target.reset(source->Copy());
     EXPECT_TRUE(IsEqual(*source, *target, 0));
@@ -1994,8 +1994,8 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
   }
 
   void MakeExclusive() {
-    talk_base::scoped_ptr<T> source(new T);
-    talk_base::scoped_ptr<cricket::VideoFrame> target;
+    rtc::scoped_ptr<T> source(new T);
+    rtc::scoped_ptr<cricket::VideoFrame> target;
     ASSERT_TRUE(LoadFrameNoRepeat(source.get()));
     target.reset(source->Copy());
     EXPECT_TRUE(target->MakeExclusive());
@@ -2007,13 +2007,13 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
 
   void CopyToBuffer() {
     T frame;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
     ASSERT_TRUE(ms.get() != NULL);
     ASSERT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420, kWidth, kHeight,
                           &frame));
     size_t out_size = kWidth * kHeight * 3 / 2;
-    talk_base::scoped_ptr<uint8[]> out(new uint8[out_size]);
+    rtc::scoped_ptr<uint8[]> out(new uint8[out_size]);
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size));
     }
@@ -2022,7 +2022,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
 
   void CopyToFrame() {
     T source;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
     ASSERT_TRUE(ms.get() != NULL);
     ASSERT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420, kWidth, kHeight,
@@ -2041,10 +2041,10 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
 
   void Write() {
     T frame;
-    talk_base::scoped_ptr<talk_base::MemoryStream> ms(
+    rtc::scoped_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
     ASSERT_TRUE(ms.get() != NULL);
-    talk_base::MemoryStream ms2;
+    rtc::MemoryStream ms2;
     size_t size;
     ASSERT_TRUE(ms->GetSize(&size));
     ASSERT_TRUE(ms2.ReserveSize(size));
@@ -2053,7 +2053,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
     for (int i = 0; i < repeat_; ++i) {
       ms2.SetPosition(0u);  // Useful when repeat_ > 1.
       int error;
-      EXPECT_EQ(talk_base::SR_SUCCESS, frame.Write(&ms2, &error));
+      EXPECT_EQ(rtc::SR_SUCCESS, frame.Write(&ms2, &error));
     }
     size_t out_size = cricket::VideoFrame::SizeOf(kWidth, kHeight);
     EXPECT_EQ(0, memcmp(ms2.GetBuffer(), ms->GetBuffer(), out_size));
@@ -2061,7 +2061,7 @@ void Construct##FOURCC##Rotate##ROTATE() {                                     \
 
   void CopyToBuffer1Pixel() {
     size_t out_size = 3;
-    talk_base::scoped_ptr<uint8[]> out(new uint8[out_size + 1]);
+    rtc::scoped_ptr<uint8[]> out(new uint8[out_size + 1]);
     memset(out.get(), 0xfb, out_size + 1);  // Fill buffer
     uint8 pixel[3] = { 1, 2, 3 };
     T frame;
diff --git a/talk/media/base/videoprocessor.h b/talk/media/base/videoprocessor.h
index 412d9892a8..78a3bf8633 100755
--- a/talk/media/base/videoprocessor.h
+++ b/talk/media/base/videoprocessor.h
@@ -28,7 +28,7 @@
 #ifndef TALK_MEDIA_BASE_VIDEOPROCESSOR_H_
 #define TALK_MEDIA_BASE_VIDEOPROCESSOR_H_
 
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/media/base/videoframe.h"
 
 namespace cricket {
diff --git a/talk/media/base/videorenderer.h b/talk/media/base/videorenderer.h
index ccbe978ca6..73b0eab267 100644
--- a/talk/media/base/videorenderer.h
+++ b/talk/media/base/videorenderer.h
@@ -32,7 +32,7 @@
 #include <string>
 #endif  // _DEBUG
 
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 
 namespace cricket {
 
diff --git a/talk/media/base/voiceprocessor.h b/talk/media/base/voiceprocessor.h
index 576bdca663..90dfc2724f 100755
--- a/talk/media/base/voiceprocessor.h
+++ b/talk/media/base/voiceprocessor.h
@@ -28,8 +28,8 @@
 #ifndef TALK_MEDIA_BASE_VOICEPROCESSOR_H_
 #define TALK_MEDIA_BASE_VOICEPROCESSOR_H_
 
-#include "talk/base/basictypes.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/media/base/audioframe.h"
 
 namespace cricket {
diff --git a/talk/media/base/yuvframegenerator.cc b/talk/media/base/yuvframegenerator.cc
index 57b5314361..bffa71508e 100644
--- a/talk/media/base/yuvframegenerator.cc
+++ b/talk/media/base/yuvframegenerator.cc
@@ -3,8 +3,8 @@
 #include <string.h>
 #include <sstream>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/common.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/common.h"
 
 namespace cricket {
 
diff --git a/talk/media/base/yuvframegenerator.h b/talk/media/base/yuvframegenerator.h
index 4adf971f64..104fb542e7 100644
--- a/talk/media/base/yuvframegenerator.h
+++ b/talk/media/base/yuvframegenerator.h
@@ -12,7 +12,7 @@
 #ifndef TALK_MEDIA_BASE_YUVFRAMEGENERATOR_H_
 #define TALK_MEDIA_BASE_YUVFRAMEGENERATOR_H_
 
-#include "talk/base/basictypes.h"
+#include "webrtc/base/basictypes.h"
 
 namespace cricket {
 
diff --git a/talk/media/devices/carbonvideorenderer.cc b/talk/media/devices/carbonvideorenderer.cc
index 71abf2629a..a0b4870450 100644
--- a/talk/media/devices/carbonvideorenderer.cc
+++ b/talk/media/devices/carbonvideorenderer.cc
@@ -27,7 +27,7 @@
 
 #include "talk/media/devices/carbonvideorenderer.h"
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/media/base/videocommon.h"
 #include "talk/media/base/videoframe.h"
 
@@ -65,7 +65,7 @@ OSStatus CarbonVideoRenderer::DrawEventHandler(EventHandlerCallRef handler,
 
 bool CarbonVideoRenderer::DrawFrame() {
   // Grab the image lock to make sure it is not changed why we'll draw it.
-  talk_base::CritScope cs(&image_crit_);
+  rtc::CritScope cs(&image_crit_);
 
   if (image_.get() == NULL) {
     // Nothing to draw, just return.
@@ -111,7 +111,7 @@ bool CarbonVideoRenderer::DrawFrame() {
 bool CarbonVideoRenderer::SetSize(int width, int height, int reserved) {
   if (width != image_width_ || height != image_height_) {
     // Grab the image lock while changing its size.
-    talk_base::CritScope cs(&image_crit_);
+    rtc::CritScope cs(&image_crit_);
     image_width_ = width;
     image_height_ = height;
     image_.reset(new uint8[width * height * 4]);
@@ -126,7 +126,7 @@ bool CarbonVideoRenderer::RenderFrame(const VideoFrame* frame) {
   }
   {
     // Grab the image lock so we are not trashing up the image being drawn.
-    talk_base::CritScope cs(&image_crit_);
+    rtc::CritScope cs(&image_crit_);
     frame->ConvertToRgbBuffer(cricket::FOURCC_ABGR,
                               image_.get(),
                               frame->GetWidth() * frame->GetHeight() * 4,
diff --git a/talk/media/devices/carbonvideorenderer.h b/talk/media/devices/carbonvideorenderer.h
index 6c52fcfc69..5cfc9ae356 100644
--- a/talk/media/devices/carbonvideorenderer.h
+++ b/talk/media/devices/carbonvideorenderer.h
@@ -31,8 +31,8 @@
 
 #include <Carbon/Carbon.h>
 
-#include "talk/base/criticalsection.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/videorenderer.h"
 
 namespace cricket {
@@ -57,8 +57,8 @@ class CarbonVideoRenderer : public VideoRenderer {
   static OSStatus DrawEventHandler(EventHandlerCallRef handler,
                                    EventRef event,
                                    void* data);
-  talk_base::scoped_ptr<uint8[]> image_;
-  talk_base::CriticalSection image_crit_;
+  rtc::scoped_ptr<uint8[]> image_;
+  rtc::CriticalSection image_crit_;
   int image_width_;
   int image_height_;
   int x_;
diff --git a/talk/media/devices/devicemanager.cc b/talk/media/devices/devicemanager.cc
index 75b935ce59..c331adced4 100644
--- a/talk/media/devices/devicemanager.cc
+++ b/talk/media/devices/devicemanager.cc
@@ -27,13 +27,13 @@
 
 #include "talk/media/devices/devicemanager.h"
 
-#include "talk/base/fileutils.h"
-#include "talk/base/logging.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
-#include "talk/base/windowpicker.h"
-#include "talk/base/windowpickerfactory.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/windowpicker.h"
+#include "webrtc/base/windowpickerfactory.h"
 #include "talk/media/base/mediacommon.h"
 #include "talk/media/devices/deviceinfo.h"
 #include "talk/media/devices/filevideocapturer.h"
@@ -54,7 +54,7 @@ namespace {
 bool StringMatchWithWildcard(
     const std::pair<const std::basic_string<char>, cricket::VideoFormat> key,
     const std::string& val) {
-  return talk_base::string_match(val.c_str(), key.first.c_str());
+  return rtc::string_match(val.c_str(), key.first.c_str());
 }
 
 }  // namespace
@@ -86,7 +86,7 @@ class DefaultVideoCapturerFactory : public VideoCapturerFactory {
 DeviceManager::DeviceManager()
     : initialized_(false),
       device_video_capturer_factory_(new DefaultVideoCapturerFactory),
-      window_picker_(talk_base::WindowPickerFactory::CreateWindowPicker()) {
+      window_picker_(rtc::WindowPickerFactory::CreateWindowPicker()) {
 }
 
 DeviceManager::~DeviceManager() {
@@ -187,7 +187,7 @@ bool DeviceManager::GetVideoCaptureDevice(const std::string& name,
 
 bool DeviceManager::GetFakeVideoCaptureDevice(const std::string& name,
                                               Device* out) const {
-  if (talk_base::Filesystem::IsFile(name)) {
+  if (rtc::Filesystem::IsFile(name)) {
     *out = FileVideoCapturer::CreateFileVideoCapturerDevice(name);
     return true;
   }
@@ -242,7 +242,7 @@ VideoCapturer* DeviceManager::ConstructFakeVideoCapturer(
       return NULL;
     }
     LOG(LS_INFO) << "Created file video capturer " << device.name;
-    capturer->set_repeat(talk_base::kForever);
+    capturer->set_repeat(rtc::kForever);
     return capturer;
   }
 
@@ -255,14 +255,14 @@ VideoCapturer* DeviceManager::ConstructFakeVideoCapturer(
 }
 
 bool DeviceManager::GetWindows(
-    std::vector<talk_base::WindowDescription>* descriptions) {
+    std::vector<rtc::WindowDescription>* descriptions) {
   if (!window_picker_) {
     return false;
   }
   return window_picker_->GetWindowList(descriptions);
 }
 
-VideoCapturer* DeviceManager::CreateWindowCapturer(talk_base::WindowId window) {
+VideoCapturer* DeviceManager::CreateWindowCapturer(rtc::WindowId window) {
 #if defined(WINDOW_CAPTURER_NAME)
   WINDOW_CAPTURER_NAME* window_capturer = new WINDOW_CAPTURER_NAME();
   if (!window_capturer->Init(window)) {
@@ -276,7 +276,7 @@ VideoCapturer* DeviceManager::CreateWindowCapturer(talk_base::WindowId window) {
 }
 
 bool DeviceManager::GetDesktops(
-    std::vector<talk_base::DesktopDescription>* descriptions) {
+    std::vector<rtc::DesktopDescription>* descriptions) {
   if (!window_picker_) {
     return false;
   }
@@ -284,7 +284,7 @@ bool DeviceManager::GetDesktops(
 }
 
 VideoCapturer* DeviceManager::CreateDesktopCapturer(
-    talk_base::DesktopId desktop) {
+    rtc::DesktopId desktop) {
 #if defined(DESKTOP_CAPTURER_NAME)
   DESKTOP_CAPTURER_NAME* desktop_capturer = new DESKTOP_CAPTURER_NAME();
   if (!desktop_capturer->Init(desktop.index())) {
diff --git a/talk/media/devices/devicemanager.h b/talk/media/devices/devicemanager.h
index f6099f36d2..01073480e8 100644
--- a/talk/media/devices/devicemanager.h
+++ b/talk/media/devices/devicemanager.h
@@ -32,13 +32,13 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/window.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/window.h"
 #include "talk/media/base/videocommon.h"
 
-namespace talk_base {
+namespace rtc {
 
 class DesktopDescription;
 class WindowDescription;
@@ -54,7 +54,7 @@ struct Device {
   Device() {}
   Device(const std::string& first, int second)
       : name(first),
-        id(talk_base::ToString(second)) {
+        id(rtc::ToString(second)) {
   }
   Device(const std::string& first, const std::string& second)
       : name(first), id(second) {}
@@ -108,13 +108,13 @@ class DeviceManagerInterface {
   virtual VideoCapturer* CreateVideoCapturer(const Device& device) const = 0;
 
   virtual bool GetWindows(
-      std::vector<talk_base::WindowDescription>* descriptions) = 0;
-  virtual VideoCapturer* CreateWindowCapturer(talk_base::WindowId window) = 0;
+      std::vector<rtc::WindowDescription>* descriptions) = 0;
+  virtual VideoCapturer* CreateWindowCapturer(rtc::WindowId window) = 0;
 
   virtual bool GetDesktops(
-      std::vector<talk_base::DesktopDescription>* descriptions) = 0;
+      std::vector<rtc::DesktopDescription>* descriptions) = 0;
   virtual VideoCapturer* CreateDesktopCapturer(
-      talk_base::DesktopId desktop) = 0;
+      rtc::DesktopId desktop) = 0;
 
   sigslot::signal0<> SignalDevicesChange;
 
@@ -171,12 +171,12 @@ class DeviceManager : public DeviceManagerInterface {
   virtual VideoCapturer* CreateVideoCapturer(const Device& device) const;
 
   virtual bool GetWindows(
-      std::vector<talk_base::WindowDescription>* descriptions);
-  virtual VideoCapturer* CreateWindowCapturer(talk_base::WindowId window);
+      std::vector<rtc::WindowDescription>* descriptions);
+  virtual VideoCapturer* CreateWindowCapturer(rtc::WindowId window);
 
   virtual bool GetDesktops(
-      std::vector<talk_base::DesktopDescription>* descriptions);
-  virtual VideoCapturer* CreateDesktopCapturer(talk_base::DesktopId desktop);
+      std::vector<rtc::DesktopDescription>* descriptions);
+  virtual VideoCapturer* CreateDesktopCapturer(rtc::DesktopId desktop);
 
   // The exclusion_list MUST be a NULL terminated list.
   static bool FilterDevices(std::vector<Device>* devices,
@@ -205,10 +205,10 @@ class DeviceManager : public DeviceManagerInterface {
   VideoCapturer* ConstructFakeVideoCapturer(const Device& device) const;
 
   bool initialized_;
-  talk_base::scoped_ptr<VideoCapturerFactory> device_video_capturer_factory_;
+  rtc::scoped_ptr<VideoCapturerFactory> device_video_capturer_factory_;
   std::map<std::string, VideoFormat> max_formats_;
-  talk_base::scoped_ptr<DeviceWatcher> watcher_;
-  talk_base::scoped_ptr<talk_base::WindowPicker> window_picker_;
+  rtc::scoped_ptr<DeviceWatcher> watcher_;
+  rtc::scoped_ptr<rtc::WindowPicker> window_picker_;
 };
 
 }  // namespace cricket
diff --git a/talk/media/devices/devicemanager_unittest.cc b/talk/media/devices/devicemanager_unittest.cc
index d8564eaaf7..3bc0241d80 100644
--- a/talk/media/devices/devicemanager_unittest.cc
+++ b/talk/media/devices/devicemanager_unittest.cc
@@ -28,18 +28,18 @@
 #include "talk/media/devices/devicemanager.h"
 
 #ifdef WIN32
-#include "talk/base/win32.h"
+#include "webrtc/base/win32.h"
 #include <objbase.h>
 #endif
 #include <string>
 
-#include "talk/base/fileutils.h"
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stream.h"
-#include "talk/base/windowpickerfactory.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/windowpickerfactory.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/base/testutils.h"
 #include "talk/media/devices/filevideocapturer.h"
@@ -47,12 +47,12 @@
 
 #ifdef LINUX
 // TODO(juberti): Figure out why this doesn't compile on Windows.
-#include "talk/base/fileutils_mock.h"
+#include "webrtc/base/fileutils_mock.h"
 #endif  // LINUX
 
-using talk_base::Pathname;
-using talk_base::FileTimeType;
-using talk_base::scoped_ptr;
+using rtc::Pathname;
+using rtc::FileTimeType;
+using rtc::scoped_ptr;
 using cricket::Device;
 using cricket::DeviceManager;
 using cricket::DeviceManagerFactory;
@@ -290,17 +290,17 @@ TEST(DeviceManagerTest, GetVideoCaptureDevices_K2_6) {
   devices.push_back("/dev/video5");
   cricket::V4LLookup::SetV4LLookup(new FakeV4LLookup(devices));
 
-  std::vector<talk_base::FakeFileSystem::File> files;
-  files.push_back(talk_base::FakeFileSystem::File("/dev/video0", ""));
-  files.push_back(talk_base::FakeFileSystem::File("/dev/video5", ""));
-  files.push_back(talk_base::FakeFileSystem::File(
+  std::vector<rtc::FakeFileSystem::File> files;
+  files.push_back(rtc::FakeFileSystem::File("/dev/video0", ""));
+  files.push_back(rtc::FakeFileSystem::File("/dev/video5", ""));
+  files.push_back(rtc::FakeFileSystem::File(
       "/sys/class/video4linux/video0/name", "Video Device 1"));
-  files.push_back(talk_base::FakeFileSystem::File(
+  files.push_back(rtc::FakeFileSystem::File(
       "/sys/class/video4linux/video1/model", "Bad Device"));
   files.push_back(
-      talk_base::FakeFileSystem::File("/sys/class/video4linux/video5/model",
+      rtc::FakeFileSystem::File("/sys/class/video4linux/video5/model",
                                       "Video Device 2"));
-  talk_base::FilesystemScope fs(new talk_base::FakeFileSystem(files));
+  rtc::FilesystemScope fs(new rtc::FakeFileSystem(files));
 
   scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
   std::vector<Device> video_ins;
@@ -317,19 +317,19 @@ TEST(DeviceManagerTest, GetVideoCaptureDevices_K2_4) {
   devices.push_back("/dev/video5");
   cricket::V4LLookup::SetV4LLookup(new FakeV4LLookup(devices));
 
-  std::vector<talk_base::FakeFileSystem::File> files;
-  files.push_back(talk_base::FakeFileSystem::File("/dev/video0", ""));
-  files.push_back(talk_base::FakeFileSystem::File("/dev/video5", ""));
-  files.push_back(talk_base::FakeFileSystem::File(
+  std::vector<rtc::FakeFileSystem::File> files;
+  files.push_back(rtc::FakeFileSystem::File("/dev/video0", ""));
+  files.push_back(rtc::FakeFileSystem::File("/dev/video5", ""));
+  files.push_back(rtc::FakeFileSystem::File(
           "/proc/video/dev/video0",
           "param1: value1\nname: Video Device 1\n param2: value2\n"));
-  files.push_back(talk_base::FakeFileSystem::File(
+  files.push_back(rtc::FakeFileSystem::File(
           "/proc/video/dev/video1",
           "param1: value1\nname: Bad Device\n param2: value2\n"));
-  files.push_back(talk_base::FakeFileSystem::File(
+  files.push_back(rtc::FakeFileSystem::File(
           "/proc/video/dev/video5",
           "param1: value1\nname:   Video Device 2\n param2: value2\n"));
-  talk_base::FilesystemScope fs(new talk_base::FakeFileSystem(files));
+  rtc::FilesystemScope fs(new rtc::FakeFileSystem(files));
 
   scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
   std::vector<Device> video_ins;
@@ -346,11 +346,11 @@ TEST(DeviceManagerTest, GetVideoCaptureDevices_KUnknown) {
   devices.push_back("/dev/video5");
   cricket::V4LLookup::SetV4LLookup(new FakeV4LLookup(devices));
 
-  std::vector<talk_base::FakeFileSystem::File> files;
-  files.push_back(talk_base::FakeFileSystem::File("/dev/video0", ""));
-  files.push_back(talk_base::FakeFileSystem::File("/dev/video1", ""));
-  files.push_back(talk_base::FakeFileSystem::File("/dev/video5", ""));
-  talk_base::FilesystemScope fs(new talk_base::FakeFileSystem(files));
+  std::vector<rtc::FakeFileSystem::File> files;
+  files.push_back(rtc::FakeFileSystem::File("/dev/video0", ""));
+  files.push_back(rtc::FakeFileSystem::File("/dev/video1", ""));
+  files.push_back(rtc::FakeFileSystem::File("/dev/video5", ""));
+  rtc::FilesystemScope fs(new rtc::FakeFileSystem(files));
 
   scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
   std::vector<Device> video_ins;
@@ -365,13 +365,13 @@ TEST(DeviceManagerTest, GetVideoCaptureDevices_KUnknown) {
 // TODO(noahric): These are flaky on windows on headless machines.
 #ifndef WIN32
 TEST(DeviceManagerTest, GetWindows) {
-  if (!talk_base::WindowPickerFactory::IsSupported()) {
+  if (!rtc::WindowPickerFactory::IsSupported()) {
     LOG(LS_INFO) << "skipping test: window capturing is not supported with "
                  << "current configuration.";
     return;
   }
   scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
-  std::vector<talk_base::WindowDescription> descriptions;
+  std::vector<rtc::WindowDescription> descriptions;
   EXPECT_TRUE(dm->Init());
   if (!dm->GetWindows(&descriptions) || descriptions.empty()) {
     LOG(LS_INFO) << "skipping test: window capturing. Does not have any "
@@ -384,17 +384,17 @@ TEST(DeviceManagerTest, GetWindows) {
   // TODO(hellner): creating a window capturer and immediately deleting it
   // results in "Continuous Build and Test Mainline - Mac opt" failure (crash).
   // Remove the following line as soon as this has been resolved.
-  talk_base::Thread::Current()->ProcessMessages(1);
+  rtc::Thread::Current()->ProcessMessages(1);
 }
 
 TEST(DeviceManagerTest, GetDesktops) {
-  if (!talk_base::WindowPickerFactory::IsSupported()) {
+  if (!rtc::WindowPickerFactory::IsSupported()) {
     LOG(LS_INFO) << "skipping test: desktop capturing is not supported with "
                  << "current configuration.";
     return;
   }
   scoped_ptr<DeviceManagerInterface> dm(DeviceManagerFactory::Create());
-  std::vector<talk_base::DesktopDescription> descriptions;
+  std::vector<rtc::DesktopDescription> descriptions;
   EXPECT_TRUE(dm->Init());
   if (!dm->GetDesktops(&descriptions) || descriptions.empty()) {
     LOG(LS_INFO) << "skipping test: desktop capturing. Does not have any "
diff --git a/talk/media/devices/dummydevicemanager_unittest.cc b/talk/media/devices/dummydevicemanager_unittest.cc
index 1abf1ea7a4..86b5352fa0 100644
--- a/talk/media/devices/dummydevicemanager_unittest.cc
+++ b/talk/media/devices/dummydevicemanager_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/devices/dummydevicemanager.h"
 
 using cricket::Device;
diff --git a/talk/media/devices/fakedevicemanager.h b/talk/media/devices/fakedevicemanager.h
index 0dbed43aff..5fc37158af 100644
--- a/talk/media/devices/fakedevicemanager.h
+++ b/talk/media/devices/fakedevicemanager.h
@@ -31,8 +31,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/window.h"
-#include "talk/base/windowpicker.h"
+#include "webrtc/base/window.h"
+#include "webrtc/base/windowpicker.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/base/mediacommon.h"
 #include "talk/media/devices/devicemanager.h"
@@ -98,35 +98,35 @@ class FakeDeviceManager : public DeviceManagerInterface {
     return new FakeVideoCapturer();
   }
   virtual bool GetWindows(
-      std::vector<talk_base::WindowDescription>* descriptions) {
+      std::vector<rtc::WindowDescription>* descriptions) {
     descriptions->clear();
     const uint32_t id = 1u;  // Note that 0 is not a valid ID.
-    const talk_base::WindowId window_id =
-        talk_base::WindowId::Cast(id);
+    const rtc::WindowId window_id =
+        rtc::WindowId::Cast(id);
     std::string title = "FakeWindow";
-    talk_base::WindowDescription window_description(window_id, title);
+    rtc::WindowDescription window_description(window_id, title);
     descriptions->push_back(window_description);
     return true;
   }
-  virtual VideoCapturer* CreateWindowCapturer(talk_base::WindowId window) {
+  virtual VideoCapturer* CreateWindowCapturer(rtc::WindowId window) {
     if (!window.IsValid()) {
       return NULL;
     }
     return new FakeVideoCapturer;
   }
   virtual bool GetDesktops(
-      std::vector<talk_base::DesktopDescription>* descriptions) {
+      std::vector<rtc::DesktopDescription>* descriptions) {
     descriptions->clear();
     const int id = 0;
     const int valid_index = 0;
-    const talk_base::DesktopId desktop_id =
-        talk_base::DesktopId::Cast(id, valid_index);
+    const rtc::DesktopId desktop_id =
+        rtc::DesktopId::Cast(id, valid_index);
     std::string title = "FakeDesktop";
-    talk_base::DesktopDescription desktop_description(desktop_id, title);
+    rtc::DesktopDescription desktop_description(desktop_id, title);
     descriptions->push_back(desktop_description);
     return true;
   }
-  virtual VideoCapturer* CreateDesktopCapturer(talk_base::DesktopId desktop) {
+  virtual VideoCapturer* CreateDesktopCapturer(rtc::DesktopId desktop) {
     if (!desktop.IsValid()) {
       return NULL;
     }
diff --git a/talk/media/devices/filevideocapturer.cc b/talk/media/devices/filevideocapturer.cc
index e79783faac..dcb776f6b3 100644
--- a/talk/media/devices/filevideocapturer.cc
+++ b/talk/media/devices/filevideocapturer.cc
@@ -27,10 +27,10 @@
 
 #include "talk/media/devices/filevideocapturer.h"
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/criticalsection.h"
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 
 namespace cricket {
 
@@ -53,7 +53,7 @@ void VideoRecorder::Stop() {
 }
 
 bool VideoRecorder::RecordFrame(const CapturedFrame& frame) {
-  if (talk_base::SS_CLOSED == video_file_.GetState()) {
+  if (rtc::SS_CLOSED == video_file_.GetState()) {
     LOG(LS_ERROR) << "File not opened yet";
     return false;
   }
@@ -66,7 +66,7 @@ bool VideoRecorder::RecordFrame(const CapturedFrame& frame) {
 
   if (write_header_) {
     // Convert the frame header to bytebuffer.
-    talk_base::ByteBuffer buffer;
+    rtc::ByteBuffer buffer;
     buffer.WriteUInt32(frame.width);
     buffer.WriteUInt32(frame.height);
     buffer.WriteUInt32(frame.fourcc);
@@ -77,7 +77,7 @@ bool VideoRecorder::RecordFrame(const CapturedFrame& frame) {
     buffer.WriteUInt32(size);
 
     // Write the bytebuffer to file.
-    if (talk_base::SR_SUCCESS != video_file_.Write(buffer.Data(),
+    if (rtc::SR_SUCCESS != video_file_.Write(buffer.Data(),
                                                    buffer.Length(),
                                                    NULL,
                                                    NULL)) {
@@ -86,7 +86,7 @@ bool VideoRecorder::RecordFrame(const CapturedFrame& frame) {
     }
   }
   // Write the frame data to file.
-  if (talk_base::SR_SUCCESS != video_file_.Write(frame.data,
+  if (rtc::SR_SUCCESS != video_file_.Write(frame.data,
                                                  size,
                                                  NULL,
                                                  NULL)) {
@@ -102,7 +102,7 @@ bool VideoRecorder::RecordFrame(const CapturedFrame& frame) {
 // frames from a file.
 ///////////////////////////////////////////////////////////////////////
 class FileVideoCapturer::FileReadThread
-    : public talk_base::Thread, public talk_base::MessageHandler {
+    : public rtc::Thread, public rtc::MessageHandler {
  public:
   explicit FileReadThread(FileVideoCapturer* capturer)
       : capturer_(capturer),
@@ -123,12 +123,12 @@ class FileVideoCapturer::FileReadThread
       Thread::Run();
     }
 
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     finished_ = true;
   }
 
   // Override virtual method of parent MessageHandler. Context: Worker Thread.
-  virtual void OnMessage(talk_base::Message* /*pmsg*/) {
+  virtual void OnMessage(rtc::Message* /*pmsg*/) {
     int waiting_time_ms = 0;
     if (capturer_ && capturer_->ReadFrame(false, &waiting_time_ms)) {
       PostDelayed(waiting_time_ms, this);
@@ -139,13 +139,13 @@ class FileVideoCapturer::FileReadThread
 
   // Check if Run() is finished.
   bool Finished() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return finished_;
   }
 
  private:
   FileVideoCapturer* capturer_;
-  mutable talk_base::CriticalSection crit_;
+  mutable rtc::CriticalSection crit_;
   bool finished_;
 
   DISALLOW_COPY_AND_ASSIGN(FileReadThread);
@@ -188,7 +188,7 @@ bool FileVideoCapturer::Init(const Device& device) {
   }
   // Read the first frame's header to determine the supported format.
   CapturedFrame frame;
-  if (talk_base::SR_SUCCESS != ReadFrameHeader(&frame)) {
+  if (rtc::SR_SUCCESS != ReadFrameHeader(&frame)) {
     LOG(LS_ERROR) << "Failed to read the first frame header";
     video_file_.Close();
     return false;
@@ -230,7 +230,7 @@ CaptureState FileVideoCapturer::Start(const VideoFormat& capture_format) {
     return CS_FAILED;
   }
 
-  if (talk_base::SS_CLOSED == video_file_.GetState()) {
+  if (rtc::SS_CLOSED == video_file_.GetState()) {
     LOG(LS_ERROR) << "File not opened yet";
     return CS_NO_DEVICE;
   } else if (!video_file_.SetPosition(0)) {
@@ -242,7 +242,7 @@ CaptureState FileVideoCapturer::Start(const VideoFormat& capture_format) {
   // Create a thread to read the file.
   file_read_thread_ = new FileReadThread(this);
   start_time_ns_ = kNumNanoSecsPerMilliSec *
-      static_cast<int64>(talk_base::Time());
+      static_cast<int64>(rtc::Time());
   bool ret = file_read_thread_->Start();
   if (ret) {
     LOG(LS_INFO) << "File video capturer '" << GetId() << "' started";
@@ -275,13 +275,13 @@ bool FileVideoCapturer::GetPreferredFourccs(std::vector<uint32>* fourccs) {
   return true;
 }
 
-talk_base::StreamResult FileVideoCapturer::ReadFrameHeader(
+rtc::StreamResult FileVideoCapturer::ReadFrameHeader(
     CapturedFrame* frame) {
   // We first read kFrameHeaderSize bytes from the file stream to a memory
   // buffer, then construct a bytebuffer from the memory buffer, and finally
   // read the frame header from the bytebuffer.
   char header[CapturedFrame::kFrameHeaderSize];
-  talk_base::StreamResult sr;
+  rtc::StreamResult sr;
   size_t bytes_read;
   int error;
   sr = video_file_.Read(header,
@@ -290,11 +290,11 @@ talk_base::StreamResult FileVideoCapturer::ReadFrameHeader(
                         &error);
   LOG(LS_VERBOSE) << "Read frame header: stream_result = " << sr
                   << ", bytes read = " << bytes_read << ", error = " << error;
-  if (talk_base::SR_SUCCESS == sr) {
+  if (rtc::SR_SUCCESS == sr) {
     if (CapturedFrame::kFrameHeaderSize != bytes_read) {
-      return talk_base::SR_EOS;
+      return rtc::SR_EOS;
     }
-    talk_base::ByteBuffer buffer(header, CapturedFrame::kFrameHeaderSize);
+    rtc::ByteBuffer buffer(header, CapturedFrame::kFrameHeaderSize);
     buffer.ReadUInt32(reinterpret_cast<uint32*>(&frame->width));
     buffer.ReadUInt32(reinterpret_cast<uint32*>(&frame->height));
     buffer.ReadUInt32(&frame->fourcc);
@@ -310,7 +310,7 @@ talk_base::StreamResult FileVideoCapturer::ReadFrameHeader(
 
 // Executed in the context of FileReadThread.
 bool FileVideoCapturer::ReadFrame(bool first_frame, int* wait_time_ms) {
-  uint32 start_read_time_ms = talk_base::Time();
+  uint32 start_read_time_ms = rtc::Time();
 
   // 1. Signal the previously read frame to downstream.
   if (!first_frame) {
@@ -321,14 +321,14 @@ bool FileVideoCapturer::ReadFrame(bool first_frame, int* wait_time_ms) {
   }
 
   // 2. Read the next frame.
-  if (talk_base::SS_CLOSED == video_file_.GetState()) {
+  if (rtc::SS_CLOSED == video_file_.GetState()) {
     LOG(LS_ERROR) << "File not opened yet";
     return false;
   }
   // 2.1 Read the frame header.
-  talk_base::StreamResult result = ReadFrameHeader(&captured_frame_);
-  if (talk_base::SR_EOS == result) {  // Loop back if repeat.
-    if (repeat_ != talk_base::kForever) {
+  rtc::StreamResult result = ReadFrameHeader(&captured_frame_);
+  if (rtc::SR_EOS == result) {  // Loop back if repeat.
+    if (repeat_ != rtc::kForever) {
       if (repeat_ > 0) {
         --repeat_;
       } else {
@@ -340,7 +340,7 @@ bool FileVideoCapturer::ReadFrame(bool first_frame, int* wait_time_ms) {
       result = ReadFrameHeader(&captured_frame_);
     }
   }
-  if (talk_base::SR_SUCCESS != result) {
+  if (rtc::SR_SUCCESS != result) {
     LOG(LS_ERROR) << "Failed to read the frame header";
     return false;
   }
@@ -351,7 +351,7 @@ bool FileVideoCapturer::ReadFrame(bool first_frame, int* wait_time_ms) {
     captured_frame_.data = new char[frame_buffer_size_];
   }
   // 2.3 Read the frame adata.
-  if (talk_base::SR_SUCCESS != video_file_.Read(captured_frame_.data,
+  if (rtc::SR_SUCCESS != video_file_.Read(captured_frame_.data,
                                                 captured_frame_.data_size,
                                                 NULL, NULL)) {
     LOG(LS_ERROR) << "Failed to read frame data";
@@ -370,7 +370,7 @@ bool FileVideoCapturer::ReadFrame(bool first_frame, int* wait_time_ms) {
         GetCaptureFormat()->interval :
         captured_frame_.time_stamp - last_frame_timestamp_ns_;
     int interval_ms = static_cast<int>(interval_ns / kNumNanoSecsPerMilliSec);
-    interval_ms -= talk_base::Time() - start_read_time_ms;
+    interval_ms -= rtc::Time() - start_read_time_ms;
     if (interval_ms > 0) {
       *wait_time_ms = interval_ms;
     }
diff --git a/talk/media/devices/filevideocapturer.h b/talk/media/devices/filevideocapturer.h
index e3e39b40da..e6bd9b47fd 100644
--- a/talk/media/devices/filevideocapturer.h
+++ b/talk/media/devices/filevideocapturer.h
@@ -37,11 +37,11 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/stream.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/videocapturer.h"
 
-namespace talk_base {
+namespace rtc {
 class FileStream;
 }
 
@@ -65,7 +65,7 @@ class VideoRecorder {
   bool RecordFrame(const CapturedFrame& frame);
 
  private:
-  talk_base::FileStream video_file_;
+  rtc::FileStream video_file_;
   bool write_header_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRecorder);
@@ -80,7 +80,7 @@ class FileVideoCapturer : public VideoCapturer {
   // Determines if the given device is actually a video file, to be captured
   // with a FileVideoCapturer.
   static bool IsFileVideoCapturerDevice(const Device& device) {
-    return talk_base::starts_with(device.id.c_str(), kVideoFileDevicePrefix);
+    return rtc::starts_with(device.id.c_str(), kVideoFileDevicePrefix);
   }
 
   // Creates a fake device for the given filename.
@@ -91,7 +91,7 @@ class FileVideoCapturer : public VideoCapturer {
   }
 
   // Set how many times to repeat reading the file. Repeat forever if the
-  // parameter is talk_base::kForever(-1); no repeat if the parameter is 0 or
+  // parameter is rtc::kForever(-1); no repeat if the parameter is 0 or
   // less than -1.
   void set_repeat(int repeat) { repeat_ = repeat; }
 
@@ -120,7 +120,7 @@ class FileVideoCapturer : public VideoCapturer {
   virtual bool GetPreferredFourccs(std::vector<uint32>* fourccs);
 
   // Read the frame header from the file stream, video_file_.
-  talk_base::StreamResult ReadFrameHeader(CapturedFrame* frame);
+  rtc::StreamResult ReadFrameHeader(CapturedFrame* frame);
 
   // Read a frame and determine how long to wait for the next frame. If the
   // frame is read successfully, Set the output parameter, wait_time_ms and
@@ -138,7 +138,7 @@ class FileVideoCapturer : public VideoCapturer {
   class FileReadThread;  // Forward declaration, defined in .cc.
 
   static const char* kVideoFileDevicePrefix;
-  talk_base::FileStream video_file_;
+  rtc::FileStream video_file_;
   CapturedFrame captured_frame_;
   // The number of bytes allocated buffer for captured_frame_.data.
   uint32 frame_buffer_size_;
diff --git a/talk/media/devices/filevideocapturer_unittest.cc b/talk/media/devices/filevideocapturer_unittest.cc
index 610d4f120a..be416c0f04 100644
--- a/talk/media/devices/filevideocapturer_unittest.cc
+++ b/talk/media/devices/filevideocapturer_unittest.cc
@@ -30,9 +30,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/testutils.h"
 #include "talk/media/devices/filevideocapturer.h"
 
@@ -82,7 +82,7 @@ class FileVideoCapturerTest : public testing::Test {
     bool resolution_changed_;
   };
 
-  talk_base::scoped_ptr<cricket::FileVideoCapturer> capturer_;
+  rtc::scoped_ptr<cricket::FileVideoCapturer> capturer_;
   cricket::VideoFormat capture_format_;
 };
 
@@ -158,7 +158,7 @@ TEST_F(FileVideoCapturerTest, TestRepeatForever) {
   VideoCapturerListener listener;
   capturer_->SignalFrameCaptured.connect(
       &listener, &VideoCapturerListener::OnFrameCaptured);
-  capturer_->set_repeat(talk_base::kForever);
+  capturer_->set_repeat(rtc::kForever);
   capture_format_ = capturer_->GetSupportedFormats()->at(0);
   capture_format_.interval = cricket::VideoFormat::FpsToInterval(50);
   EXPECT_EQ(cricket::CS_RUNNING, capturer_->Start(capture_format_));
diff --git a/talk/media/devices/gdivideorenderer.cc b/talk/media/devices/gdivideorenderer.cc
index 9633eb6d8e..3d01b9a1cd 100755
--- a/talk/media/devices/gdivideorenderer.cc
+++ b/talk/media/devices/gdivideorenderer.cc
@@ -29,9 +29,9 @@
 
 #include "talk/media/devices/gdivideorenderer.h"
 
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/thread.h"
-#include "talk/base/win32window.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/win32window.h"
 #include "talk/media/base/videocommon.h"
 #include "talk/media/base/videoframe.h"
 
@@ -41,7 +41,7 @@ namespace cricket {
 // Definition of private class VideoWindow. We use a worker thread to manage
 // the window.
 /////////////////////////////////////////////////////////////////////////////
-class GdiVideoRenderer::VideoWindow : public talk_base::Win32Window {
+class GdiVideoRenderer::VideoWindow : public rtc::Win32Window {
  public:
   VideoWindow(int x, int y, int width, int height);
   virtual ~VideoWindow();
@@ -58,14 +58,14 @@ class GdiVideoRenderer::VideoWindow : public talk_base::Win32Window {
   bool RenderFrame(const VideoFrame* frame);
 
  protected:
-  // Override virtual method of talk_base::Win32Window. Context: worker Thread.
+  // Override virtual method of rtc::Win32Window. Context: worker Thread.
   virtual bool OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
                          LRESULT& result);
 
  private:
   enum { kSetSizeMsg = WM_USER, kRenderFrameMsg};
 
-  class WindowThread : public talk_base::Thread {
+  class WindowThread : public rtc::Thread {
    public:
     explicit WindowThread(VideoWindow* window) : window_(window) {}
 
@@ -73,7 +73,7 @@ class GdiVideoRenderer::VideoWindow : public talk_base::Win32Window {
       Stop();
     }
 
-    // Override virtual method of talk_base::Thread. Context: worker Thread.
+    // Override virtual method of rtc::Thread. Context: worker Thread.
     virtual void Run() {
       // Initialize the window
       if (!window_ || !window_->Initialize()) {
@@ -98,8 +98,8 @@ class GdiVideoRenderer::VideoWindow : public talk_base::Win32Window {
   void OnRenderFrame(const VideoFrame* frame);
 
   BITMAPINFO bmi_;
-  talk_base::scoped_ptr<uint8[]> image_;
-  talk_base::scoped_ptr<WindowThread> window_thread_;
+  rtc::scoped_ptr<uint8[]> image_;
+  rtc::scoped_ptr<WindowThread> window_thread_;
   // The initial position of the window.
   int initial_x_;
   int initial_y_;
@@ -180,7 +180,7 @@ bool GdiVideoRenderer::VideoWindow::OnMessage(UINT uMsg, WPARAM wParam,
 }
 
 bool GdiVideoRenderer::VideoWindow::Initialize() {
-  if (!talk_base::Win32Window::Create(
+  if (!rtc::Win32Window::Create(
       NULL, L"Video Renderer",
       WS_OVERLAPPEDWINDOW | WS_SIZEBOX,
       WS_EX_APPWINDOW,
diff --git a/talk/media/devices/gdivideorenderer.h b/talk/media/devices/gdivideorenderer.h
index da3897d994..fc817c9456 100755
--- a/talk/media/devices/gdivideorenderer.h
+++ b/talk/media/devices/gdivideorenderer.h
@@ -30,7 +30,7 @@
 #define TALK_MEDIA_DEVICES_GDIVIDEORENDERER_H_
 
 #ifdef WIN32
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/videorenderer.h"
 
 namespace cricket {
@@ -48,7 +48,7 @@ class GdiVideoRenderer : public VideoRenderer {
 
  private:
   class VideoWindow;  // forward declaration, defined in the .cc file
-  talk_base::scoped_ptr<VideoWindow> window_;
+  rtc::scoped_ptr<VideoWindow> window_;
   // The initial position of the window.
   int initial_x_;
   int initial_y_;
diff --git a/talk/media/devices/gtkvideorenderer.h b/talk/media/devices/gtkvideorenderer.h
index 744c19f490..a6a3def3f1 100755
--- a/talk/media/devices/gtkvideorenderer.h
+++ b/talk/media/devices/gtkvideorenderer.h
@@ -29,8 +29,8 @@
 #ifndef TALK_MEDIA_DEVICES_GTKVIDEORENDERER_H_
 #define TALK_MEDIA_DEVICES_GTKVIDEORENDERER_H_
 
-#include "talk/base/basictypes.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/videorenderer.h"
 
 typedef struct _GtkWidget GtkWidget;  // forward declaration, defined in gtk.h
@@ -56,7 +56,7 @@ class GtkVideoRenderer : public VideoRenderer {
   // Check if the window has been closed.
   bool IsClosed() const;
 
-  talk_base::scoped_ptr<uint8[]> image_;
+  rtc::scoped_ptr<uint8[]> image_;
   GtkWidget* window_;
   GtkWidget* draw_area_;
   // The initial position of the window.
diff --git a/talk/media/devices/libudevsymboltable.cc b/talk/media/devices/libudevsymboltable.cc
index 20154e1fca..351a1e7f5e 100644
--- a/talk/media/devices/libudevsymboltable.cc
+++ b/talk/media/devices/libudevsymboltable.cc
@@ -29,20 +29,20 @@
 
 #include <dlfcn.h>
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 
 namespace cricket {
 
 #define LATE_BINDING_SYMBOL_TABLE_CLASS_NAME LIBUDEV_SYMBOLS_CLASS_NAME
 #define LATE_BINDING_SYMBOL_TABLE_SYMBOLS_LIST LIBUDEV_SYMBOLS_LIST
 #define LATE_BINDING_SYMBOL_TABLE_DLL_NAME "libudev.so.0"
-#include "talk/base/latebindingsymboltable.cc.def"
+#include "webrtc/base/latebindingsymboltable.cc.def"
 #undef LATE_BINDING_SYMBOL_TABLE_CLASS_NAME
 #undef LATE_BINDING_SYMBOL_TABLE_SYMBOLS_LIST
 #undef LATE_BINDING_SYMBOL_TABLE_DLL_NAME
 
-bool IsWrongLibUDevAbiVersion(talk_base::DllHandle libudev_0) {
-  talk_base::DllHandle libudev_1 = dlopen("libudev.so.1",
+bool IsWrongLibUDevAbiVersion(rtc::DllHandle libudev_0) {
+  rtc::DllHandle libudev_1 = dlopen("libudev.so.1",
                                           RTLD_NOW|RTLD_LOCAL|RTLD_NOLOAD);
   bool unsafe_symlink = (libudev_0 == libudev_1);
   if (unsafe_symlink) {
diff --git a/talk/media/devices/libudevsymboltable.h b/talk/media/devices/libudevsymboltable.h
index aa8c590351..f764cd263d 100644
--- a/talk/media/devices/libudevsymboltable.h
+++ b/talk/media/devices/libudevsymboltable.h
@@ -30,7 +30,7 @@
 
 #include <libudev.h>
 
-#include "talk/base/latebindingsymboltable.h"
+#include "webrtc/base/latebindingsymboltable.h"
 
 namespace cricket {
 
@@ -62,7 +62,7 @@ namespace cricket {
 
 #define LATE_BINDING_SYMBOL_TABLE_CLASS_NAME LIBUDEV_SYMBOLS_CLASS_NAME
 #define LATE_BINDING_SYMBOL_TABLE_SYMBOLS_LIST LIBUDEV_SYMBOLS_LIST
-#include "talk/base/latebindingsymboltable.h.def"
+#include "webrtc/base/latebindingsymboltable.h.def"
 #undef LATE_BINDING_SYMBOL_TABLE_CLASS_NAME
 #undef LATE_BINDING_SYMBOL_TABLE_SYMBOLS_LIST
 
@@ -72,7 +72,7 @@ namespace cricket {
 // it has caused crashes in the wild. This function checks if the DllHandle that
 // we got back for libudev.so.0 is actually for libudev.so.1. If so, the library
 // cannot safely be used.
-bool IsWrongLibUDevAbiVersion(talk_base::DllHandle libudev_0);
+bool IsWrongLibUDevAbiVersion(rtc::DllHandle libudev_0);
 
 }  // namespace cricket
 
diff --git a/talk/media/devices/linuxdeviceinfo.cc b/talk/media/devices/linuxdeviceinfo.cc
index b1bc9ddb1f..2aef463166 100644
--- a/talk/media/devices/linuxdeviceinfo.cc
+++ b/talk/media/devices/linuxdeviceinfo.cc
@@ -27,7 +27,7 @@
 
 #include "talk/media/devices/deviceinfo.h"
 
-#include "talk/base/common.h"  // for ASSERT
+#include "webrtc/base/common.h"  // for ASSERT
 #include "talk/media/devices/libudevsymboltable.h"
 
 namespace cricket {
@@ -94,7 +94,7 @@ class ScopedUdevEnumerate {
 
 bool GetUsbProperty(const Device& device, const char* property_name,
                     std::string* property) {
-  talk_base::scoped_ptr<ScopedLibUdev> libudev_context(ScopedLibUdev::Create());
+  rtc::scoped_ptr<ScopedLibUdev> libudev_context(ScopedLibUdev::Create());
   if (!libudev_context) {
     return false;
   }
diff --git a/talk/media/devices/linuxdevicemanager.cc b/talk/media/devices/linuxdevicemanager.cc
index 8e58d99da1..53eed80d64 100644
--- a/talk/media/devices/linuxdevicemanager.cc
+++ b/talk/media/devices/linuxdevicemanager.cc
@@ -28,14 +28,14 @@
 #include "talk/media/devices/linuxdevicemanager.h"
 
 #include <unistd.h>
-#include "talk/base/fileutils.h"
-#include "talk/base/linux.h"
-#include "talk/base/logging.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/physicalsocketserver.h"
-#include "talk/base/stream.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/linux.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/physicalsocketserver.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/mediacommon.h"
 #include "talk/media/devices/libudevsymboltable.h"
 #include "talk/media/devices/v4llookup.h"
@@ -52,7 +52,7 @@ DeviceManagerInterface* DeviceManagerFactory::Create() {
 
 class LinuxDeviceWatcher
     : public DeviceWatcher,
-      private talk_base::Dispatcher {
+      private rtc::Dispatcher {
  public:
   explicit LinuxDeviceWatcher(DeviceManagerInterface* dm);
   virtual ~LinuxDeviceWatcher();
@@ -135,10 +135,10 @@ enum MetaType { M2_4, M2_6, NONE };
 
 static void ScanDeviceDirectory(const std::string& devdir,
                                 std::vector<Device>* devices) {
-  talk_base::scoped_ptr<talk_base::DirectoryIterator> directoryIterator(
-      talk_base::Filesystem::IterateDirectory());
+  rtc::scoped_ptr<rtc::DirectoryIterator> directoryIterator(
+      rtc::Filesystem::IterateDirectory());
 
-  if (directoryIterator->Iterate(talk_base::Pathname(devdir))) {
+  if (directoryIterator->Iterate(rtc::Pathname(devdir))) {
     do {
       std::string filename = directoryIterator->Name();
       std::string device_name = devdir + filename;
@@ -155,11 +155,11 @@ static void ScanDeviceDirectory(const std::string& devdir,
 static std::string GetVideoDeviceNameK2_6(const std::string& device_meta_path) {
   std::string device_name;
 
-  talk_base::scoped_ptr<talk_base::FileStream> device_meta_stream(
-      talk_base::Filesystem::OpenFile(device_meta_path, "r"));
+  rtc::scoped_ptr<rtc::FileStream> device_meta_stream(
+      rtc::Filesystem::OpenFile(device_meta_path, "r"));
 
   if (device_meta_stream) {
-    if (device_meta_stream->ReadLine(&device_name) != talk_base::SR_SUCCESS) {
+    if (device_meta_stream->ReadLine(&device_name) != rtc::SR_SUCCESS) {
       LOG(LS_ERROR) << "Failed to read V4L2 device meta " << device_meta_path;
     }
     device_meta_stream->Close();
@@ -179,20 +179,20 @@ static std::string Trim(const std::string& s, const std::string& drop = " \t") {
 }
 
 static std::string GetVideoDeviceNameK2_4(const std::string& device_meta_path) {
-  talk_base::ConfigParser::MapVector all_values;
+  rtc::ConfigParser::MapVector all_values;
 
-  talk_base::ConfigParser config_parser;
-  talk_base::FileStream* file_stream =
-      talk_base::Filesystem::OpenFile(device_meta_path, "r");
+  rtc::ConfigParser config_parser;
+  rtc::FileStream* file_stream =
+      rtc::Filesystem::OpenFile(device_meta_path, "r");
 
   if (file_stream == NULL) return "";
 
   config_parser.Attach(file_stream);
   config_parser.Parse(&all_values);
 
-  for (talk_base::ConfigParser::MapVector::iterator i = all_values.begin();
+  for (rtc::ConfigParser::MapVector::iterator i = all_values.begin();
       i != all_values.end(); ++i) {
-    talk_base::ConfigParser::SimpleMap::iterator device_name_i =
+    rtc::ConfigParser::SimpleMap::iterator device_name_i =
         i->find("name");
 
     if (device_name_i != i->end()) {
@@ -244,8 +244,8 @@ static void ScanV4L2Devices(std::vector<Device>* devices) {
   MetaType meta;
   std::string metadata_dir;
 
-  talk_base::scoped_ptr<talk_base::DirectoryIterator> directoryIterator(
-      talk_base::Filesystem::IterateDirectory());
+  rtc::scoped_ptr<rtc::DirectoryIterator> directoryIterator(
+      rtc::Filesystem::IterateDirectory());
 
   // Try and guess kernel version
   if (directoryIterator->Iterate(kVideoMetaPathK2_6)) {
@@ -302,10 +302,10 @@ LinuxDeviceWatcher::LinuxDeviceWatcher(DeviceManagerInterface* dm)
 LinuxDeviceWatcher::~LinuxDeviceWatcher() {
 }
 
-static talk_base::PhysicalSocketServer* CurrentSocketServer() {
-  talk_base::SocketServer* ss =
-      talk_base::ThreadManager::Instance()->WrapCurrentThread()->socketserver();
-  return reinterpret_cast<talk_base::PhysicalSocketServer*>(ss);
+static rtc::PhysicalSocketServer* CurrentSocketServer() {
+  rtc::SocketServer* ss =
+      rtc::ThreadManager::Instance()->WrapCurrentThread()->socketserver();
+  return reinterpret_cast<rtc::PhysicalSocketServer*>(ss);
 }
 
 bool LinuxDeviceWatcher::Start() {
@@ -369,7 +369,7 @@ void LinuxDeviceWatcher::Stop() {
 }
 
 uint32 LinuxDeviceWatcher::GetRequestedEvents() {
-  return talk_base::DE_READ;
+  return rtc::DE_READ;
 }
 
 void LinuxDeviceWatcher::OnPreEvent(uint32 ff) {
diff --git a/talk/media/devices/linuxdevicemanager.h b/talk/media/devices/linuxdevicemanager.h
index d8f1665de2..651dd6ff6f 100644
--- a/talk/media/devices/linuxdevicemanager.h
+++ b/talk/media/devices/linuxdevicemanager.h
@@ -31,8 +31,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/sigslot.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/media/devices/devicemanager.h"
 #include "talk/sound/soundsystemfactory.h"
 
diff --git a/talk/media/devices/macdevicemanager.cc b/talk/media/devices/macdevicemanager.cc
index 805558836d..fa25b1f18f 100644
--- a/talk/media/devices/macdevicemanager.cc
+++ b/talk/media/devices/macdevicemanager.cc
@@ -30,9 +30,9 @@
 #include <CoreAudio/CoreAudio.h>
 #include <QuickTime/QuickTime.h>
 
-#include "talk/base/logging.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/mediacommon.h"
 
 class DeviceWatcherImpl;
@@ -119,7 +119,7 @@ static bool GetAudioDeviceIDs(bool input,
   }
 
   size_t num_devices = propsize / sizeof(AudioDeviceID);
-  talk_base::scoped_ptr<AudioDeviceID[]> device_ids(
+  rtc::scoped_ptr<AudioDeviceID[]> device_ids(
       new AudioDeviceID[num_devices]);
 
   err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices,
diff --git a/talk/media/devices/macdevicemanager.h b/talk/media/devices/macdevicemanager.h
index 25fe4fcaf5..161e308d97 100644
--- a/talk/media/devices/macdevicemanager.h
+++ b/talk/media/devices/macdevicemanager.h
@@ -31,8 +31,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/sigslot.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/media/devices/devicemanager.h"
 
 namespace cricket {
diff --git a/talk/media/devices/macdevicemanagermm.mm b/talk/media/devices/macdevicemanagermm.mm
index fdde91fa52..3091ec455f 100644
--- a/talk/media/devices/macdevicemanagermm.mm
+++ b/talk/media/devices/macdevicemanagermm.mm
@@ -35,7 +35,7 @@
 #import <assert.h>
 #import <QTKit/QTKit.h>
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 
 @interface DeviceWatcherImpl : NSObject {
  @private
diff --git a/talk/media/devices/mobiledevicemanager.cc b/talk/media/devices/mobiledevicemanager.cc
index a08911b913..f9ff35baca 100644
--- a/talk/media/devices/mobiledevicemanager.cc
+++ b/talk/media/devices/mobiledevicemanager.cc
@@ -47,7 +47,7 @@ MobileDeviceManager::~MobileDeviceManager() {}
 
 bool MobileDeviceManager::GetVideoCaptureDevices(std::vector<Device>* devs) {
   devs->clear();
-  talk_base::scoped_ptr<webrtc::VideoCaptureModule::DeviceInfo> info(
+  rtc::scoped_ptr<webrtc::VideoCaptureModule::DeviceInfo> info(
       webrtc::VideoCaptureFactory::CreateDeviceInfo(0));
   if (!info)
     return false;
diff --git a/talk/media/devices/v4llookup.cc b/talk/media/devices/v4llookup.cc
index 76eafa7169..8b44a807af 100644
--- a/talk/media/devices/v4llookup.cc
+++ b/talk/media/devices/v4llookup.cc
@@ -18,7 +18,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 
 namespace cricket {
 
diff --git a/talk/media/devices/win32devicemanager.cc b/talk/media/devices/win32devicemanager.cc
index 071f111791..668270efd1 100644
--- a/talk/media/devices/win32devicemanager.cc
+++ b/talk/media/devices/win32devicemanager.cc
@@ -38,11 +38,11 @@
 #include <functiondiscoverykeys_devpkey.h>
 #include <uuids.h>
 
-#include "talk/base/logging.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
-#include "talk/base/win32.h"  // ToUtf8
-#include "talk/base/win32window.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/win32.h"  // ToUtf8
+#include "webrtc/base/win32window.h"
 #include "talk/media/base/mediacommon.h"
 #ifdef HAVE_LOGITECH_HEADERS
 #include "third_party/logitech/files/logitechquickcam.h"
@@ -56,7 +56,7 @@ DeviceManagerInterface* DeviceManagerFactory::Create() {
 
 class Win32DeviceWatcher
     : public DeviceWatcher,
-      public talk_base::Win32Window {
+      public rtc::Win32Window {
  public:
   explicit Win32DeviceWatcher(Win32DeviceManager* dm);
   virtual ~Win32DeviceWatcher();
@@ -151,7 +151,7 @@ bool Win32DeviceManager::GetAudioDevices(bool input,
                                          std::vector<Device>* devs) {
   devs->clear();
 
-  if (talk_base::IsWindowsVistaOrLater()) {
+  if (rtc::IsWindowsVistaOrLater()) {
     if (!GetCoreAudioDevices(input, devs))
       return false;
   } else {
@@ -199,11 +199,11 @@ bool GetDevices(const CLSID& catid, std::vector<Device>* devices) {
         std::string name_str, path_str;
         if (SUCCEEDED(bag->Read(kFriendlyName, &name, 0)) &&
             name.vt == VT_BSTR) {
-          name_str = talk_base::ToUtf8(name.bstrVal);
+          name_str = rtc::ToUtf8(name.bstrVal);
           // Get the device id if one exists.
           if (SUCCEEDED(bag->Read(kDevicePath, &path, 0)) &&
               path.vt == VT_BSTR) {
-            path_str = talk_base::ToUtf8(path.bstrVal);
+            path_str = rtc::ToUtf8(path.bstrVal);
           }
 
           devices->push_back(Device(name_str, path_str));
@@ -224,7 +224,7 @@ HRESULT GetStringProp(IPropertyStore* bag, PROPERTYKEY key, std::string* out) {
   HRESULT hr = bag->GetValue(key, &var);
   if (SUCCEEDED(hr)) {
     if (var.pwszVal)
-      *out = talk_base::ToUtf8(var.pwszVal);
+      *out = rtc::ToUtf8(var.pwszVal);
     else
       hr = E_FAIL;
   }
@@ -312,8 +312,8 @@ bool GetWaveDevices(bool input, std::vector<Device>* devs) {
       WAVEINCAPS caps;
       if (waveInGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR &&
           caps.wChannels > 0) {
-        devs->push_back(Device(talk_base::ToUtf8(caps.szPname),
-                               talk_base::ToString(i)));
+        devs->push_back(Device(rtc::ToUtf8(caps.szPname),
+                               rtc::ToString(i)));
       }
     }
   } else {
@@ -322,7 +322,7 @@ bool GetWaveDevices(bool input, std::vector<Device>* devs) {
       WAVEOUTCAPS caps;
       if (waveOutGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR &&
           caps.wChannels > 0) {
-        devs->push_back(Device(talk_base::ToUtf8(caps.szPname), i));
+        devs->push_back(Device(rtc::ToUtf8(caps.szPname), i));
       }
     }
   }
diff --git a/talk/media/devices/win32devicemanager.h b/talk/media/devices/win32devicemanager.h
index 4854ec07bd..d93159013e 100644
--- a/talk/media/devices/win32devicemanager.h
+++ b/talk/media/devices/win32devicemanager.h
@@ -31,8 +31,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/sigslot.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/media/devices/devicemanager.h"
 
 namespace cricket {
diff --git a/talk/media/devices/yuvframescapturer.cc b/talk/media/devices/yuvframescapturer.cc
index 648094bf43..0aa3b53c3e 100644
--- a/talk/media/devices/yuvframescapturer.cc
+++ b/talk/media/devices/yuvframescapturer.cc
@@ -1,9 +1,9 @@
 #include "talk/media/devices/yuvframescapturer.h"
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/criticalsection.h"
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 
 #include "webrtc/system_wrappers/interface/clock.h"
 
@@ -13,7 +13,7 @@ namespace cricket {
 // frames.
 ///////////////////////////////////////////////////////////////////////
 class YuvFramesCapturer::YuvFramesThread
-    : public talk_base::Thread, public talk_base::MessageHandler {
+    : public rtc::Thread, public rtc::MessageHandler {
  public:
   explicit YuvFramesThread(YuvFramesCapturer* capturer)
       : capturer_(capturer),
@@ -35,12 +35,12 @@ class YuvFramesCapturer::YuvFramesThread
       Thread::Run();
     }
 
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     finished_ = true;
   }
 
   // Override virtual method of parent MessageHandler. Context: Worker Thread.
-  virtual void OnMessage(talk_base::Message* /*pmsg*/) {
+  virtual void OnMessage(rtc::Message* /*pmsg*/) {
     int waiting_time_ms = 0;
     if (capturer_) {
       capturer_->ReadFrame(false);
@@ -52,13 +52,13 @@ class YuvFramesCapturer::YuvFramesThread
 
   // Check if Run() is finished.
   bool Finished() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return finished_;
   }
 
  private:
   YuvFramesCapturer* capturer_;
-  mutable talk_base::CriticalSection crit_;
+  mutable rtc::CriticalSection crit_;
   bool finished_;
 
   DISALLOW_COPY_AND_ASSIGN(YuvFramesThread);
@@ -113,7 +113,7 @@ CaptureState YuvFramesCapturer::Start(const VideoFormat& capture_format) {
   SetCaptureFormat(&capture_format);
 
   barcode_reference_timestamp_millis_ =
-      static_cast<int64>(talk_base::Time()) * 1000;
+      static_cast<int64>(rtc::Time()) * 1000;
   // Create a thread to generate frames.
   frames_generator_thread = new YuvFramesThread(this);
   bool ret = frames_generator_thread->Start();
@@ -166,7 +166,7 @@ int32 YuvFramesCapturer::GetBarcodeValue() {
        frame_index_ % barcode_interval_ != 0) {
      return -1;
   }
-  int64 now_millis = static_cast<int64>(talk_base::Time()) * 1000;
+  int64 now_millis = static_cast<int64>(rtc::Time()) * 1000;
   return static_cast<int32>(now_millis - barcode_reference_timestamp_millis_);
 }
 
diff --git a/talk/media/devices/yuvframescapturer.h b/talk/media/devices/yuvframescapturer.h
index 7886525840..52eec589f3 100644
--- a/talk/media/devices/yuvframescapturer.h
+++ b/talk/media/devices/yuvframescapturer.h
@@ -4,13 +4,13 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/stream.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/yuvframegenerator.h"
 
 
-namespace talk_base {
+namespace rtc {
 class FileStream;
 }
 
@@ -31,7 +31,7 @@ class YuvFramesCapturer : public VideoCapturer {
     return Device(id.str(), id.str());
   }
   static bool IsYuvFramesCapturerDevice(const Device& device) {
-    return talk_base::starts_with(device.id.c_str(), kYuvFrameDeviceName);
+    return rtc::starts_with(device.id.c_str(), kYuvFrameDeviceName);
   }
 
   void Init();
diff --git a/talk/media/other/linphonemediaengine.cc b/talk/media/other/linphonemediaengine.cc
index 3b97c0b9f0..fabb31654d 100644
--- a/talk/media/other/linphonemediaengine.cc
+++ b/talk/media/other/linphonemediaengine.cc
@@ -38,11 +38,11 @@ extern "C" {
 
 #include "talk/media/other/linphonemediaengine.h"
 
-#include "talk/base/buffer.h"
-#include "talk/base/event.h"
-#include "talk/base/logging.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/event.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/stream.h"
 #include "talk/media/base/rtpdump.h"
 
 #ifndef WIN32
@@ -137,11 +137,11 @@ LinphoneVoiceChannel::LinphoneVoiceChannel(LinphoneMediaEngine*eng)
       ring_stream_(0)
 {
 
-  talk_base::Thread *thread = talk_base::ThreadManager::CurrentThread();
-  talk_base::SocketServer *ss = thread->socketserver();
+  rtc::Thread *thread = rtc::ThreadManager::CurrentThread();
+  rtc::SocketServer *ss = thread->socketserver();
   socket_.reset(ss->CreateAsyncSocket(SOCK_DGRAM));
 
-  socket_->Bind(talk_base::SocketAddress("localhost",3000));
+  socket_->Bind(rtc::SocketAddress("localhost",3000));
   socket_->SignalReadEvent.connect(this, &LinphoneVoiceChannel::OnIncomingData);
 
 }
@@ -216,7 +216,7 @@ bool LinphoneVoiceChannel::SetSend(SendFlags flag) {
   return true;
 }
 
-void LinphoneVoiceChannel::OnPacketReceived(talk_base::Buffer* packet) {
+void LinphoneVoiceChannel::OnPacketReceived(rtc::Buffer* packet) {
   const void* data = packet->data();
   int len = packet->length();
   uint8 buf[2048];
@@ -227,7 +227,7 @@ void LinphoneVoiceChannel::OnPacketReceived(talk_base::Buffer* packet) {
    */
   int payloadtype = buf[1] & 0x7f;
   if (play_ && payloadtype != 13)
-    socket_->SendTo(buf, len, talk_base::SocketAddress("localhost",2000));
+    socket_->SendTo(buf, len, rtc::SocketAddress("localhost",2000));
 }
 
 void LinphoneVoiceChannel::StartRing(bool bIncomingCall)
@@ -263,12 +263,12 @@ void LinphoneVoiceChannel::StopRing()
   }
 }
 
-void LinphoneVoiceChannel::OnIncomingData(talk_base::AsyncSocket *s)
+void LinphoneVoiceChannel::OnIncomingData(rtc::AsyncSocket *s)
 {
   char *buf[2048];
   int len;
   len = s->Recv(buf, sizeof(buf));
-  talk_base::Buffer packet(buf, len);
+  rtc::Buffer packet(buf, len);
   if (network_interface_ && !mute_)
     network_interface_->SendPacket(&packet);
 }
diff --git a/talk/media/other/linphonemediaengine.h b/talk/media/other/linphonemediaengine.h
index db3e69f6bc..7c49c167d6 100644
--- a/talk/media/other/linphonemediaengine.h
+++ b/talk/media/other/linphonemediaengine.h
@@ -37,12 +37,12 @@ extern "C" {
 #include <mediastreamer2/mediastream.h>
 }
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/mediaengine.h"
 
-namespace talk_base {
+namespace rtc {
 class StreamInterface;
 }
 
@@ -140,8 +140,8 @@ class LinphoneVoiceChannel : public VoiceMediaChannel {
   virtual bool GetStats(VoiceMediaInfo* info) { return true; }
 
   // Implement pure virtual methods of MediaChannel.
-  virtual void OnPacketReceived(talk_base::Buffer* packet);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet) {}
+  virtual void OnPacketReceived(rtc::Buffer* packet);
+  virtual void OnRtcpReceived(rtc::Buffer* packet) {}
   virtual void SetSendSsrc(uint32 id) {}  // TODO: change RTP packet?
   virtual bool SetRtcpCName(const std::string& cname) { return true; }
   virtual bool Mute(bool on) { return mute_; }
@@ -163,8 +163,8 @@ class LinphoneVoiceChannel : public VoiceMediaChannel {
   AudioStream *audio_stream_;
   LinphoneMediaEngine *engine_;
   RingStream* ring_stream_;
-  talk_base::scoped_ptr<talk_base::AsyncSocket> socket_;
-  void OnIncomingData(talk_base::AsyncSocket *s);
+  rtc::scoped_ptr<rtc::AsyncSocket> socket_;
+  void OnIncomingData(rtc::AsyncSocket *s);
 
   DISALLOW_COPY_AND_ASSIGN(LinphoneVoiceChannel);
 };
diff --git a/talk/media/sctp/sctpdataengine.cc b/talk/media/sctp/sctpdataengine.cc
index 3647d21292..eff18a88fa 100644
--- a/talk/media/sctp/sctpdataengine.cc
+++ b/talk/media/sctp/sctpdataengine.cc
@@ -32,10 +32,10 @@
 #include <sstream>
 #include <vector>
 
-#include "talk/base/buffer.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/safe_conversions.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/safe_conversions.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/streamparams.h"
@@ -102,8 +102,8 @@ std::string ListArray(const uint16* array, int num_elems) {
 }  // namespace
 
 namespace cricket {
-typedef talk_base::ScopedMessageData<SctpInboundPacket> InboundPacketMessage;
-typedef talk_base::ScopedMessageData<talk_base::Buffer> OutboundPacketMessage;
+typedef rtc::ScopedMessageData<SctpInboundPacket> InboundPacketMessage;
+typedef rtc::ScopedMessageData<rtc::Buffer> OutboundPacketMessage;
 
 // TODO(ldixon): Find where this is defined, and also check is Sctp really
 // respects this.
@@ -111,11 +111,11 @@ static const size_t kSctpMtu = 1280;
 
 enum {
   MSG_SCTPINBOUNDPACKET = 1,   // MessageData is SctpInboundPacket
-  MSG_SCTPOUTBOUNDPACKET = 2,  // MessageData is talk_base:Buffer
+  MSG_SCTPOUTBOUNDPACKET = 2,  // MessageData is rtc:Buffer
 };
 
 struct SctpInboundPacket {
-  talk_base::Buffer buffer;
+  rtc::Buffer buffer;
   ReceiveDataParams params;
   // The |flags| parameter is used by SCTP to distinguish notification packets
   // from other types of packets.
@@ -187,7 +187,7 @@ static int OnSctpOutboundPacket(void* addr, void* data, size_t length,
                   << "; set_df: " << std::hex << static_cast<int>(set_df);
   // Note: We have to copy the data; the caller will delete it.
   OutboundPacketMessage* msg =
-      new OutboundPacketMessage(new talk_base::Buffer(data, length));
+      new OutboundPacketMessage(new rtc::Buffer(data, length));
   channel->worker_thread()->Post(channel, MSG_SCTPOUTBOUNDPACKET, msg);
   return 0;
 }
@@ -206,7 +206,7 @@ static int OnSctpInboundPacket(struct socket* sock, union sctp_sockstore addr,
   // memory cleanup. But this does simplify code.
   const SctpDataMediaChannel::PayloadProtocolIdentifier ppid =
       static_cast<SctpDataMediaChannel::PayloadProtocolIdentifier>(
-          talk_base::HostToNetwork32(rcv.rcv_ppid));
+          rtc::HostToNetwork32(rcv.rcv_ppid));
   cricket::DataMessageType type = cricket::DMT_NONE;
   if (!GetDataMediaType(ppid, &type) && !(flags & MSG_NOTIFICATION)) {
     // It's neither a notification nor a recognized data packet.  Drop it.
@@ -287,7 +287,7 @@ SctpDataEngine::~SctpDataEngine() {
       if (usrsctp_finish() == 0)
         return;
 
-      talk_base::Thread::SleepMs(10);
+      rtc::Thread::SleepMs(10);
     }
     LOG(LS_ERROR) << "Failed to shutdown usrsctp.";
   }
@@ -298,10 +298,10 @@ DataMediaChannel* SctpDataEngine::CreateChannel(
   if (data_channel_type != DCT_SCTP) {
     return NULL;
   }
-  return new SctpDataMediaChannel(talk_base::Thread::Current());
+  return new SctpDataMediaChannel(rtc::Thread::Current());
 }
 
-SctpDataMediaChannel::SctpDataMediaChannel(talk_base::Thread* thread)
+SctpDataMediaChannel::SctpDataMediaChannel(rtc::Thread* thread)
     : worker_thread_(thread),
       local_port_(kSctpDefaultPort),
       remote_port_(kSctpDefaultPort),
@@ -322,7 +322,7 @@ sockaddr_conn SctpDataMediaChannel::GetSctpSockAddr(int port) {
   sconn.sconn_len = sizeof(sockaddr_conn);
 #endif
   // Note: conversion from int to uint16_t happens here.
-  sconn.sconn_port = talk_base::HostToNetwork16(port);
+  sconn.sconn_port = rtc::HostToNetwork16(port);
   sconn.sconn_addr = this;
   return sconn;
 }
@@ -501,7 +501,7 @@ bool SctpDataMediaChannel::RemoveRecvStream(uint32 ssrc) {
 
 bool SctpDataMediaChannel::SendData(
     const SendDataParams& params,
-    const talk_base::Buffer& payload,
+    const rtc::Buffer& payload,
     SendDataResult* result) {
   if (result) {
     // Preset |result| to assume an error.  If SendData succeeds, we'll
@@ -530,7 +530,7 @@ bool SctpDataMediaChannel::SendData(
   struct sctp_sendv_spa spa = {0};
   spa.sendv_flags |= SCTP_SEND_SNDINFO_VALID;
   spa.sendv_sndinfo.snd_sid = params.ssrc;
-  spa.sendv_sndinfo.snd_ppid = talk_base::HostToNetwork32(
+  spa.sendv_sndinfo.snd_ppid = rtc::HostToNetwork32(
       GetPpid(params.type));
 
   // Ordered implies reliable.
@@ -551,7 +551,7 @@ bool SctpDataMediaChannel::SendData(
   send_res = usrsctp_sendv(sock_, payload.data(),
                            static_cast<size_t>(payload.length()),
                            NULL, 0, &spa,
-                           talk_base::checked_cast<socklen_t>(sizeof(spa)),
+                           rtc::checked_cast<socklen_t>(sizeof(spa)),
                            SCTP_SENDV_SPA, 0);
   if (send_res < 0) {
     if (errno == SCTP_EWOULDBLOCK) {
@@ -573,7 +573,7 @@ bool SctpDataMediaChannel::SendData(
 
 // Called by network interface when a packet has been received.
 void SctpDataMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   LOG(LS_VERBOSE) << debug_name_ << "->OnPacketReceived(...): " << " length="
                   << packet->length() << ", sending: " << sending_;
   // Only give receiving packets to usrsctp after if connected. This enables two
@@ -613,7 +613,7 @@ void SctpDataMediaChannel::OnInboundPacketFromSctpToChannel(
 }
 
 void SctpDataMediaChannel::OnDataFromSctpToChannel(
-    const ReceiveDataParams& params, talk_base::Buffer* buffer) {
+    const ReceiveDataParams& params, rtc::Buffer* buffer) {
   if (receiving_) {
     LOG(LS_VERBOSE) << debug_name_ << "->OnDataFromSctpToChannel(...): "
                     << "Posting with length: " << buffer->length()
@@ -682,7 +682,7 @@ bool SctpDataMediaChannel::ResetStream(uint32 ssrc) {
   return true;
 }
 
-void SctpDataMediaChannel::OnNotificationFromSctp(talk_base::Buffer* buffer) {
+void SctpDataMediaChannel::OnNotificationFromSctp(rtc::Buffer* buffer) {
   const sctp_notification& notification =
       reinterpret_cast<const sctp_notification&>(*buffer->data());
   ASSERT(notification.sn_header.sn_length == buffer->length());
@@ -857,7 +857,7 @@ static bool GetCodecIntParameter(const std::vector<DataCodec>& codecs,
   for (size_t i = 0; i < codecs.size(); ++i) {
     if (codecs[i].Matches(match_pattern)) {
       if (codecs[i].GetParam(param, &value)) {
-        *dest = talk_base::FromString<int>(value);
+        *dest = rtc::FromString<int>(value);
         return true;
       }
     }
@@ -878,7 +878,7 @@ bool SctpDataMediaChannel::SetRecvCodecs(const std::vector<DataCodec>& codecs) {
 }
 
 void SctpDataMediaChannel::OnPacketFromSctpToNetwork(
-    talk_base::Buffer* buffer) {
+    rtc::Buffer* buffer) {
   if (buffer->length() > kSctpMtu) {
     LOG(LS_ERROR) << debug_name_ << "->OnPacketFromSctpToNetwork(...): "
                   << "SCTP seems to have made a packet that is bigger "
@@ -905,7 +905,7 @@ bool SctpDataMediaChannel::SendQueuedStreamResets() {
       &reset_stream_buf[0]);
   resetp->srs_assoc_id = SCTP_ALL_ASSOC;
   resetp->srs_flags = SCTP_STREAM_RESET_INCOMING | SCTP_STREAM_RESET_OUTGOING;
-  resetp->srs_number_streams = talk_base::checked_cast<uint16_t>(num_streams);
+  resetp->srs_number_streams = rtc::checked_cast<uint16_t>(num_streams);
   int result_idx = 0;
   for (StreamSet::iterator it = queued_reset_streams_.begin();
        it != queued_reset_streams_.end(); ++it) {
@@ -914,7 +914,7 @@ bool SctpDataMediaChannel::SendQueuedStreamResets() {
 
   int ret = usrsctp_setsockopt(
       sock_, IPPROTO_SCTP, SCTP_RESET_STREAMS, resetp,
-      talk_base::checked_cast<socklen_t>(reset_stream_buf.size()));
+      rtc::checked_cast<socklen_t>(reset_stream_buf.size()));
   if (ret < 0) {
     LOG_ERRNO(LS_ERROR) << debug_name_ << "Failed to send a stream reset for "
                         << num_streams << " streams";
@@ -927,16 +927,16 @@ bool SctpDataMediaChannel::SendQueuedStreamResets() {
   return true;
 }
 
-void SctpDataMediaChannel::OnMessage(talk_base::Message* msg) {
+void SctpDataMediaChannel::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_SCTPINBOUNDPACKET: {
-      talk_base::scoped_ptr<InboundPacketMessage> pdata(
+      rtc::scoped_ptr<InboundPacketMessage> pdata(
           static_cast<InboundPacketMessage*>(msg->pdata));
       OnInboundPacketFromSctpToChannel(pdata->data().get());
       break;
     }
     case MSG_SCTPOUTBOUNDPACKET: {
-      talk_base::scoped_ptr<OutboundPacketMessage> pdata(
+      rtc::scoped_ptr<OutboundPacketMessage> pdata(
           static_cast<OutboundPacketMessage*>(msg->pdata));
       OnPacketFromSctpToNetwork(pdata->data().get());
       break;
diff --git a/talk/media/sctp/sctpdataengine.h b/talk/media/sctp/sctpdataengine.h
index 2e8beecd13..179505902c 100644
--- a/talk/media/sctp/sctpdataengine.h
+++ b/talk/media/sctp/sctpdataengine.h
@@ -41,8 +41,8 @@ enum PreservedErrno {
 };
 }  // namespace cricket
 
-#include "talk/base/buffer.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/mediaengine.h"
@@ -107,7 +107,7 @@ class SctpDataEngine : public DataEngineInterface {
 struct SctpInboundPacket;
 
 class SctpDataMediaChannel : public DataMediaChannel,
-                             public talk_base::MessageHandler {
+                             public rtc::MessageHandler {
  public:
   // DataMessageType is used for the SCTP "Payload Protocol Identifier", as
   // defined in http://tools.ietf.org/html/rfc4960#section-14.4
@@ -132,7 +132,7 @@ class SctpDataMediaChannel : public DataMediaChannel,
 
   // Given a thread which will be used to post messages (received data) to this
   // SctpDataMediaChannel instance.
-  explicit SctpDataMediaChannel(talk_base::Thread* thread);
+  explicit SctpDataMediaChannel(rtc::Thread* thread);
   virtual ~SctpDataMediaChannel();
 
   // When SetSend is set to true, connects. When set to false, disconnects.
@@ -149,19 +149,19 @@ class SctpDataMediaChannel : public DataMediaChannel,
 
   // Called when Sctp gets data. The data may be a notification or data for
   // OnSctpInboundData. Called from the worker thread.
-  virtual void OnMessage(talk_base::Message* msg);
+  virtual void OnMessage(rtc::Message* msg);
   // Send data down this channel (will be wrapped as SCTP packets then given to
   // sctp that will then post the network interface by OnMessage).
   // Returns true iff successful data somewhere on the send-queue/network.
   virtual bool SendData(const SendDataParams& params,
-                        const talk_base::Buffer& payload,
+                        const rtc::Buffer& payload,
                         SendDataResult* result = NULL);
   // A packet is received from the network interface. Posted to OnMessage.
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time);
 
   // Exposed to allow Post call from c-callbacks.
-  talk_base::Thread* worker_thread() const { return worker_thread_; }
+  rtc::Thread* worker_thread() const { return worker_thread_; }
 
   // TODO(ldixon): add a DataOptions class to mediachannel.h
   virtual bool SetOptions(int options) { return false; }
@@ -180,8 +180,8 @@ class SctpDataMediaChannel : public DataMediaChannel,
       const std::vector<RtpHeaderExtension>& extensions) { return true; }
   virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs);
   virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time) {}
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time) {}
   virtual void OnReadyToSend(bool ready) {}
 
   // Helper for debugging.
@@ -213,19 +213,19 @@ class SctpDataMediaChannel : public DataMediaChannel,
   bool ResetStream(uint32 ssrc);
 
   // Called by OnMessage to send packet on the network.
-  void OnPacketFromSctpToNetwork(talk_base::Buffer* buffer);
+  void OnPacketFromSctpToNetwork(rtc::Buffer* buffer);
   // Called by OnMessage to decide what to do with the packet.
   void OnInboundPacketFromSctpToChannel(SctpInboundPacket* packet);
   void OnDataFromSctpToChannel(const ReceiveDataParams& params,
-                               talk_base::Buffer* buffer);
-  void OnNotificationFromSctp(talk_base::Buffer* buffer);
+                               rtc::Buffer* buffer);
+  void OnNotificationFromSctp(rtc::Buffer* buffer);
   void OnNotificationAssocChange(const sctp_assoc_change& change);
 
   void OnStreamResetEvent(const struct sctp_stream_reset_event* evt);
 
   // Responsible for marshalling incoming data to the channels listeners, and
   // outgoing data to the network interface.
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* worker_thread_;
   // The local and remote SCTP port to use. These are passed along the wire
   // and the listener and connector must be using the same port. It is not
   // related to the ports at the IP level.  If set to -1, we default to
diff --git a/talk/media/sctp/sctpdataengine_unittest.cc b/talk/media/sctp/sctpdataengine_unittest.cc
index cf410e5aca..a656603cea 100644
--- a/talk/media/sctp/sctpdataengine_unittest.cc
+++ b/talk/media/sctp/sctpdataengine_unittest.cc
@@ -31,16 +31,16 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/bind.h"
-#include "talk/base/buffer.h"
-#include "talk/base/criticalsection.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/messagehandler.h"
-#include "talk/base/messagequeue.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/bind.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/sctp/sctpdataengine.h"
@@ -52,9 +52,9 @@ enum {
 // Fake NetworkInterface that sends/receives sctp packets.  The one in
 // talk/media/base/fakenetworkinterface.h only works with rtp/rtcp.
 class SctpFakeNetworkInterface : public cricket::MediaChannel::NetworkInterface,
-                                 public talk_base::MessageHandler {
+                                 public rtc::MessageHandler {
  public:
-  explicit SctpFakeNetworkInterface(talk_base::Thread* thread)
+  explicit SctpFakeNetworkInterface(rtc::Thread* thread)
     : thread_(thread),
       dest_(NULL) {
   }
@@ -63,15 +63,15 @@ class SctpFakeNetworkInterface : public cricket::MediaChannel::NetworkInterface,
 
  protected:
   // Called to send raw packet down the wire (e.g. SCTP an packet).
-  virtual bool SendPacket(talk_base::Buffer* packet,
-                          talk_base::DiffServCodePoint dscp) {
+  virtual bool SendPacket(rtc::Buffer* packet,
+                          rtc::DiffServCodePoint dscp) {
     LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::SendPacket";
 
     // TODO(ldixon): Can/should we use Buffer.TransferTo here?
     // Note: this assignment does a deep copy of data from packet.
-    talk_base::Buffer* buffer = new talk_base::Buffer(packet->data(),
+    rtc::Buffer* buffer = new rtc::Buffer(packet->data(),
                                                       packet->length());
-    thread_->Post(this, MSG_PACKET, talk_base::WrapMessageData(buffer));
+    thread_->Post(this, MSG_PACKET, rtc::WrapMessageData(buffer));
     LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::SendPacket, Posted message.";
     return true;
   }
@@ -79,13 +79,13 @@ class SctpFakeNetworkInterface : public cricket::MediaChannel::NetworkInterface,
   // Called when a raw packet has been recieved. This passes the data to the
   // code that will interpret the packet. e.g. to get the content payload from
   // an SCTP packet.
-  virtual void OnMessage(talk_base::Message* msg) {
+  virtual void OnMessage(rtc::Message* msg) {
     LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::OnMessage";
-    talk_base::scoped_ptr<talk_base::Buffer> buffer(
-        static_cast<talk_base::TypedMessageData<talk_base::Buffer*>*>(
+    rtc::scoped_ptr<rtc::Buffer> buffer(
+        static_cast<rtc::TypedMessageData<rtc::Buffer*>*>(
             msg->pdata)->data());
     if (dest_) {
-      dest_->OnPacketReceived(buffer.get(), talk_base::PacketTime());
+      dest_->OnPacketReceived(buffer.get(), rtc::PacketTime());
     }
     delete msg->pdata;
   }
@@ -93,23 +93,23 @@ class SctpFakeNetworkInterface : public cricket::MediaChannel::NetworkInterface,
   // Unsupported functions required to exist by NetworkInterface.
   // TODO(ldixon): Refactor parent NetworkInterface class so these are not
   // required. They are RTC specific and should be in an appropriate subclass.
-  virtual bool SendRtcp(talk_base::Buffer* packet,
-                        talk_base::DiffServCodePoint dscp) {
+  virtual bool SendRtcp(rtc::Buffer* packet,
+                        rtc::DiffServCodePoint dscp) {
     LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SendRtcp.";
     return false;
   }
-  virtual int SetOption(SocketType type, talk_base::Socket::Option opt,
+  virtual int SetOption(SocketType type, rtc::Socket::Option opt,
                         int option) {
     LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SetOption.";
     return 0;
   }
-  virtual void SetDefaultDSCPCode(talk_base::DiffServCodePoint dscp) {
+  virtual void SetDefaultDSCPCode(rtc::DiffServCodePoint dscp) {
     LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SetOption.";
   }
 
  private:
   // Not owned by this class.
-  talk_base::Thread* thread_;
+  rtc::Thread* thread_;
   cricket::DataMediaChannel* dest_;
 };
 
@@ -219,11 +219,11 @@ class SctpDataMediaChannelTest : public testing::Test,
   // usrsctp uses the NSS random number generator on non-Android platforms,
   // so we need to initialize SSL.
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   virtual void SetUp() {
@@ -231,8 +231,8 @@ class SctpDataMediaChannelTest : public testing::Test,
   }
 
   void SetupConnectedChannels() {
-    net1_.reset(new SctpFakeNetworkInterface(talk_base::Thread::Current()));
-    net2_.reset(new SctpFakeNetworkInterface(talk_base::Thread::Current()));
+    net1_.reset(new SctpFakeNetworkInterface(rtc::Thread::Current()));
+    net2_.reset(new SctpFakeNetworkInterface(rtc::Thread::Current()));
     recv1_.reset(new SctpFakeDataReceiver());
     recv2_.reset(new SctpFakeDataReceiver());
     chan1_.reset(CreateChannel(net1_.get(), recv1_.get()));
@@ -294,7 +294,7 @@ class SctpDataMediaChannelTest : public testing::Test,
     cricket::SendDataParams params;
     params.ssrc = ssrc;
 
-    return chan->SendData(params, talk_base::Buffer(
+    return chan->SendData(params, rtc::Buffer(
         &msg[0], msg.length()), result);
   }
 
@@ -306,10 +306,10 @@ class SctpDataMediaChannelTest : public testing::Test,
   }
 
   bool ProcessMessagesUntilIdle() {
-    talk_base::Thread* thread = talk_base::Thread::Current();
+    rtc::Thread* thread = rtc::Thread::Current();
     while (!thread->empty()) {
-      talk_base::Message msg;
-      if (thread->Get(&msg, talk_base::kForever)) {
+      rtc::Message msg;
+      if (thread->Get(&msg, rtc::kForever)) {
         thread->Dispatch(&msg);
       }
     }
@@ -322,13 +322,13 @@ class SctpDataMediaChannelTest : public testing::Test,
   SctpFakeDataReceiver* receiver2() { return recv2_.get(); }
 
  private:
-  talk_base::scoped_ptr<cricket::SctpDataEngine> engine_;
-  talk_base::scoped_ptr<SctpFakeNetworkInterface> net1_;
-  talk_base::scoped_ptr<SctpFakeNetworkInterface> net2_;
-  talk_base::scoped_ptr<SctpFakeDataReceiver> recv1_;
-  talk_base::scoped_ptr<SctpFakeDataReceiver> recv2_;
-  talk_base::scoped_ptr<cricket::SctpDataMediaChannel> chan1_;
-  talk_base::scoped_ptr<cricket::SctpDataMediaChannel> chan2_;
+  rtc::scoped_ptr<cricket::SctpDataEngine> engine_;
+  rtc::scoped_ptr<SctpFakeNetworkInterface> net1_;
+  rtc::scoped_ptr<SctpFakeNetworkInterface> net2_;
+  rtc::scoped_ptr<SctpFakeDataReceiver> recv1_;
+  rtc::scoped_ptr<SctpFakeDataReceiver> recv2_;
+  rtc::scoped_ptr<cricket::SctpDataMediaChannel> chan1_;
+  rtc::scoped_ptr<cricket::SctpDataMediaChannel> chan2_;
 };
 
 // Verifies that SignalReadyToSend is fired.
@@ -398,7 +398,7 @@ TEST_F(SctpDataMediaChannelTest, SendDataBlocked) {
 
   for (size_t i = 0; i < 100; ++i) {
     channel1()->SendData(
-        params, talk_base::Buffer(&buffer[0], buffer.size()), &result);
+        params, rtc::Buffer(&buffer[0], buffer.size()), &result);
     if (result == cricket::SDR_BLOCK)
       break;
   }
diff --git a/talk/media/webrtc/fakewebrtccommon.h b/talk/media/webrtc/fakewebrtccommon.h
index dc663070ba..d1c2320035 100644
--- a/talk/media/webrtc/fakewebrtccommon.h
+++ b/talk/media/webrtc/fakewebrtccommon.h
@@ -28,7 +28,7 @@
 #ifndef TALK_SESSION_PHONE_FAKEWEBRTCCOMMON_H_
 #define TALK_SESSION_PHONE_FAKEWEBRTCCOMMON_H_
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 
 namespace cricket {
 
diff --git a/talk/media/webrtc/fakewebrtcdeviceinfo.h b/talk/media/webrtc/fakewebrtcdeviceinfo.h
index 585f31e9ee..2d015de456 100644
--- a/talk/media/webrtc/fakewebrtcdeviceinfo.h
+++ b/talk/media/webrtc/fakewebrtcdeviceinfo.h
@@ -28,7 +28,7 @@
 
 #include <vector>
 
-#include "talk/base/stringutils.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/webrtc/webrtcvideocapturer.h"
 
 // Fake class for mocking out webrtc::VideoCaptureModule::DeviceInfo.
@@ -64,12 +64,12 @@ class FakeWebRtcDeviceInfo : public webrtc::VideoCaptureModule::DeviceInfo {
                                 uint32_t product_id_len) {
     Device* dev = GetDeviceByIndex(device_num);
     if (!dev) return -1;
-    talk_base::strcpyn(reinterpret_cast<char*>(device_name), device_name_len,
+    rtc::strcpyn(reinterpret_cast<char*>(device_name), device_name_len,
                        dev->name.c_str());
-    talk_base::strcpyn(reinterpret_cast<char*>(device_id), device_id_len,
+    rtc::strcpyn(reinterpret_cast<char*>(device_id), device_id_len,
                        dev->id.c_str());
     if (product_id) {
-      talk_base::strcpyn(reinterpret_cast<char*>(product_id), product_id_len,
+      rtc::strcpyn(reinterpret_cast<char*>(product_id), product_id_len,
                          dev->product.c_str());
     }
     return 0;
diff --git a/talk/media/webrtc/fakewebrtcvideoengine.h b/talk/media/webrtc/fakewebrtcvideoengine.h
index 528ada56b6..3a619bd8ac 100644
--- a/talk/media/webrtc/fakewebrtcvideoengine.h
+++ b/talk/media/webrtc/fakewebrtcvideoengine.h
@@ -32,9 +32,9 @@
 #include <set>
 #include <vector>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/gunit.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/webrtc/fakewebrtccommon.h"
 #include "talk/media/webrtc/webrtcvideodecoderfactory.h"
@@ -742,7 +742,7 @@ class FakeWebRtcVideoEngine
     } else {
       out_codec.codecType = webrtc::kVideoCodecUnknown;
     }
-    talk_base::strcpyn(out_codec.plName, sizeof(out_codec.plName),
+    rtc::strcpyn(out_codec.plName, sizeof(out_codec.plName),
                        c.name.c_str());
     out_codec.plType = c.id;
     out_codec.width = c.width;
@@ -1032,7 +1032,7 @@ class FakeWebRtcVideoEngine
   WEBRTC_FUNC_CONST(GetRTCPCName, (const int channel,
                                    char rtcp_cname[KMaxRTCPCNameLength])) {
     WEBRTC_CHECK_CHANNEL(channel);
-    talk_base::strcpyn(rtcp_cname, KMaxRTCPCNameLength,
+    rtc::strcpyn(rtcp_cname, KMaxRTCPCNameLength,
                        channels_.find(channel)->second->cname_.c_str());
     return 0;
   }
diff --git a/talk/media/webrtc/fakewebrtcvoiceengine.h b/talk/media/webrtc/fakewebrtcvoiceengine.h
index 49b78bc5c6..d95acb7b63 100644
--- a/talk/media/webrtc/fakewebrtcvoiceengine.h
+++ b/talk/media/webrtc/fakewebrtcvoiceengine.h
@@ -32,9 +32,9 @@
 #include <map>
 #include <vector>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/gunit.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/rtputils.h"
 #include "talk/media/base/voiceprocessor.h"
@@ -501,7 +501,7 @@ class FakeWebRtcVoiceEngine
     }
     const cricket::AudioCodec& c(*codecs_[index]);
     codec.pltype = c.id;
-    talk_base::strcpyn(codec.plname, sizeof(codec.plname), c.name.c_str());
+    rtc::strcpyn(codec.plname, sizeof(codec.plname), c.name.c_str());
     codec.plfreq = c.clockrate;
     codec.pacsize = 0;
     codec.channels = c.channels;
diff --git a/talk/media/webrtc/webrtcmediaengine.h b/talk/media/webrtc/webrtcmediaengine.h
index 6ca39e7dcf..701417c001 100644
--- a/talk/media/webrtc/webrtcmediaengine.h
+++ b/talk/media/webrtc/webrtcmediaengine.h
@@ -68,7 +68,7 @@ class WebRtcMediaEngine : public cricket::MediaEngineInterface {
   virtual ~WebRtcMediaEngine() {
     DestroyWebRtcMediaEngine(delegate_);
   }
-  virtual bool Init(talk_base::Thread* worker_thread) OVERRIDE {
+  virtual bool Init(rtc::Thread* worker_thread) OVERRIDE {
     return delegate_->Init(worker_thread);
   }
   virtual void Terminate() OVERRIDE {
@@ -145,7 +145,7 @@ class WebRtcMediaEngine : public cricket::MediaEngineInterface {
   virtual void SetVideoLogging(int min_sev, const char* filter) OVERRIDE {
     delegate_->SetVideoLogging(min_sev, filter);
   }
-  virtual bool StartAecDump(talk_base::PlatformFile file) OVERRIDE {
+  virtual bool StartAecDump(rtc::PlatformFile file) OVERRIDE {
     return delegate_->StartAecDump(file);
   }
   virtual bool RegisterVoiceProcessor(
diff --git a/talk/media/webrtc/webrtcpassthroughrender.cc b/talk/media/webrtc/webrtcpassthroughrender.cc
index b4e78b44e8..0c6029d73e 100644
--- a/talk/media/webrtc/webrtcpassthroughrender.cc
+++ b/talk/media/webrtc/webrtcpassthroughrender.cc
@@ -27,8 +27,8 @@
 
 #include "talk/media/webrtc/webrtcpassthroughrender.h"
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
 
 namespace cricket {
 
@@ -45,7 +45,7 @@ class PassthroughStream: public webrtc::VideoRenderCallback {
   }
   virtual int32_t RenderFrame(const uint32_t stream_id,
                               webrtc::I420VideoFrame& videoFrame) {
-    talk_base::CritScope cs(&stream_critical_);
+    rtc::CritScope cs(&stream_critical_);
     // Send frame for rendering directly
     if (running_ && renderer_) {
       renderer_->RenderFrame(stream_id, videoFrame);
@@ -53,19 +53,19 @@ class PassthroughStream: public webrtc::VideoRenderCallback {
     return 0;
   }
   int32_t SetRenderer(VideoRenderCallback* renderer) {
-    talk_base::CritScope cs(&stream_critical_);
+    rtc::CritScope cs(&stream_critical_);
     renderer_ = renderer;
     return 0;
   }
 
   int32_t StartRender() {
-    talk_base::CritScope cs(&stream_critical_);
+    rtc::CritScope cs(&stream_critical_);
     running_ = true;
     return 0;
   }
 
   int32_t StopRender() {
-    talk_base::CritScope cs(&stream_critical_);
+    rtc::CritScope cs(&stream_critical_);
     running_ = false;
     return 0;
   }
@@ -73,7 +73,7 @@ class PassthroughStream: public webrtc::VideoRenderCallback {
  private:
   uint32_t stream_id_;
   VideoRenderCallback* renderer_;
-  talk_base::CriticalSection stream_critical_;
+  rtc::CriticalSection stream_critical_;
   bool running_;
 };
 
@@ -94,7 +94,7 @@ webrtc::VideoRenderCallback* WebRtcPassthroughRender::AddIncomingRenderStream(
     const uint32_t zOrder,
     const float left, const float top,
     const float right, const float bottom) {
-  talk_base::CritScope cs(&render_critical_);
+  rtc::CritScope cs(&render_critical_);
   // Stream already exist.
   if (FindStream(stream_id) != NULL) {
     LOG(LS_ERROR) << "AddIncomingRenderStream - Stream already exists: "
@@ -110,7 +110,7 @@ webrtc::VideoRenderCallback* WebRtcPassthroughRender::AddIncomingRenderStream(
 
 int32_t WebRtcPassthroughRender::DeleteIncomingRenderStream(
     const uint32_t stream_id) {
-  talk_base::CritScope cs(&render_critical_);
+  rtc::CritScope cs(&render_critical_);
   PassthroughStream* stream = FindStream(stream_id);
   if (stream == NULL) {
     LOG_FIND_STREAM_ERROR("DeleteIncomingRenderStream", stream_id);
@@ -124,7 +124,7 @@ int32_t WebRtcPassthroughRender::DeleteIncomingRenderStream(
 int32_t WebRtcPassthroughRender::AddExternalRenderCallback(
     const uint32_t stream_id,
     webrtc::VideoRenderCallback* render_object) {
-  talk_base::CritScope cs(&render_critical_);
+  rtc::CritScope cs(&render_critical_);
   PassthroughStream* stream = FindStream(stream_id);
   if (stream == NULL) {
     LOG_FIND_STREAM_ERROR("AddExternalRenderCallback", stream_id);
@@ -143,7 +143,7 @@ webrtc::RawVideoType WebRtcPassthroughRender::PreferredVideoType() const {
 }
 
 int32_t WebRtcPassthroughRender::StartRender(const uint32_t stream_id) {
-  talk_base::CritScope cs(&render_critical_);
+  rtc::CritScope cs(&render_critical_);
   PassthroughStream* stream = FindStream(stream_id);
   if (stream == NULL) {
     LOG_FIND_STREAM_ERROR("StartRender", stream_id);
@@ -153,7 +153,7 @@ int32_t WebRtcPassthroughRender::StartRender(const uint32_t stream_id) {
 }
 
 int32_t WebRtcPassthroughRender::StopRender(const uint32_t stream_id) {
-  talk_base::CritScope cs(&render_critical_);
+  rtc::CritScope cs(&render_critical_);
   PassthroughStream* stream = FindStream(stream_id);
   if (stream == NULL) {
     LOG_FIND_STREAM_ERROR("StopRender", stream_id);
diff --git a/talk/media/webrtc/webrtcpassthroughrender.h b/talk/media/webrtc/webrtcpassthroughrender.h
index e09182ff66..a43277678d 100644
--- a/talk/media/webrtc/webrtcpassthroughrender.h
+++ b/talk/media/webrtc/webrtcpassthroughrender.h
@@ -30,7 +30,7 @@
 
 #include <map>
 
-#include "talk/base/criticalsection.h"
+#include "webrtc/base/criticalsection.h"
 #include "webrtc/modules/video_render/include/video_render.h"
 
 namespace cricket {
@@ -56,12 +56,12 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
   virtual int32_t Process() { return 0; }
 
   virtual void* Window() {
-    talk_base::CritScope cs(&render_critical_);
+    rtc::CritScope cs(&render_critical_);
     return window_;
   }
 
   virtual int32_t ChangeWindow(void* window) {
-    talk_base::CritScope cs(&render_critical_);
+    rtc::CritScope cs(&render_critical_);
     window_ = window;
     return 0;
   }
@@ -204,7 +204,7 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
 
   void* window_;
   StreamMap stream_render_map_;
-  talk_base::CriticalSection render_critical_;
+  rtc::CriticalSection render_critical_;
 };
 }  // namespace cricket
 
diff --git a/talk/media/webrtc/webrtcpassthroughrender_unittest.cc b/talk/media/webrtc/webrtcpassthroughrender_unittest.cc
index 4eb2892517..542916183f 100644
--- a/talk/media/webrtc/webrtcpassthroughrender_unittest.cc
+++ b/talk/media/webrtc/webrtcpassthroughrender_unittest.cc
@@ -4,7 +4,7 @@
 
 #include <string>
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/testutils.h"
 #include "talk/media/webrtc/webrtcpassthroughrender.h"
 
@@ -67,7 +67,7 @@ class WebRtcPassthroughRenderTest : public testing::Test {
   }
 
  private:
-  talk_base::scoped_ptr<cricket::WebRtcPassthroughRender> renderer_;
+  rtc::scoped_ptr<cricket::WebRtcPassthroughRender> renderer_;
 };
 
 TEST_F(WebRtcPassthroughRenderTest, Streams) {
diff --git a/talk/media/webrtc/webrtctexturevideoframe.cc b/talk/media/webrtc/webrtctexturevideoframe.cc
index 08f63a549c..ba7cf5e5d2 100644
--- a/talk/media/webrtc/webrtctexturevideoframe.cc
+++ b/talk/media/webrtc/webrtctexturevideoframe.cc
@@ -27,9 +27,9 @@
 
 #include "talk/media/webrtc/webrtctexturevideoframe.h"
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stream.h"
 
 #define UNIMPLEMENTED \
   LOG(LS_ERROR) << "Call to unimplemented function "<< __FUNCTION__; \
@@ -137,10 +137,10 @@ void WebRtcTextureVideoFrame::CopyToFrame(VideoFrame* dst) const {
   UNIMPLEMENTED;
 }
 
-talk_base::StreamResult WebRtcTextureVideoFrame::Write(
-    talk_base::StreamInterface* stream, int* error) {
+rtc::StreamResult WebRtcTextureVideoFrame::Write(
+    rtc::StreamInterface* stream, int* error) {
   UNIMPLEMENTED;
-  return talk_base::SR_ERROR;
+  return rtc::SR_ERROR;
 }
 void WebRtcTextureVideoFrame::StretchToPlanes(
     uint8* dst_y, uint8* dst_u, uint8* dst_v, int32 dst_pitch_y,
diff --git a/talk/media/webrtc/webrtctexturevideoframe.h b/talk/media/webrtc/webrtctexturevideoframe.h
index 691c814255..76c25eeb0d 100644
--- a/talk/media/webrtc/webrtctexturevideoframe.h
+++ b/talk/media/webrtc/webrtctexturevideoframe.h
@@ -28,8 +28,8 @@
 #ifndef TALK_MEDIA_WEBRTC_WEBRTCTEXTUREVIDEOFRAME_H_
 #define TALK_MEDIA_WEBRTC_WEBRTCTEXTUREVIDEOFRAME_H_
 
-#include "talk/base/refcount.h"
-#include "talk/base/scoped_ref_ptr.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 #include "talk/media/base/videoframe.h"
 #include "webrtc/common_video/interface/native_handle.h"
 
@@ -81,7 +81,7 @@ class WebRtcTextureVideoFrame : public VideoFrame {
       uint8* dst_y, uint8* dst_u, uint8* dst_v,
       int32 dst_pitch_y, int32 dst_pitch_u, int32 dst_pitch_v) const;
   virtual void CopyToFrame(VideoFrame* target) const;
-  virtual talk_base::StreamResult Write(talk_base::StreamInterface* stream,
+  virtual rtc::StreamResult Write(rtc::StreamInterface* stream,
                                         int* error);
   virtual void StretchToPlanes(
       uint8* y, uint8* u, uint8* v, int32 pitchY, int32 pitchU, int32 pitchV,
@@ -101,7 +101,7 @@ class WebRtcTextureVideoFrame : public VideoFrame {
 
  private:
   // The handle of the underlying video frame.
-  talk_base::scoped_refptr<webrtc::NativeHandle> handle_;
+  rtc::scoped_refptr<webrtc::NativeHandle> handle_;
   int width_;
   int height_;
   int64 elapsed_time_;
diff --git a/talk/media/webrtc/webrtctexturevideoframe_unittest.cc b/talk/media/webrtc/webrtctexturevideoframe_unittest.cc
index 9ac16da87d..8f5561a4a5 100644
--- a/talk/media/webrtc/webrtctexturevideoframe_unittest.cc
+++ b/talk/media/webrtc/webrtctexturevideoframe_unittest.cc
@@ -27,7 +27,7 @@
 
 #include "talk/media/webrtc/webrtctexturevideoframe.h"
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/videocommon.h"
 
 class NativeHandleImpl : public webrtc::NativeHandle {
diff --git a/talk/media/webrtc/webrtcvideocapturer.cc b/talk/media/webrtc/webrtcvideocapturer.cc
index eb52b9304e..d341d12053 100644
--- a/talk/media/webrtc/webrtcvideocapturer.cc
+++ b/talk/media/webrtc/webrtcvideocapturer.cc
@@ -32,13 +32,13 @@
 #endif
 
 #ifdef HAVE_WEBRTC_VIDEO
-#include "talk/base/criticalsection.h"
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/media/webrtc/webrtcvideoframe.h"
 
-#include "talk/base/win32.h"  // Need this to #include the impl files.
+#include "webrtc/base/win32.h"  // Need this to #include the impl files.
 #include "webrtc/modules/video_capture/include/video_capture_factory.h"
 
 namespace cricket {
@@ -252,7 +252,7 @@ CaptureState WebRtcVideoCapturer::Start(const VideoFormat& capture_format) {
     return CS_NO_DEVICE;
   }
 
-  talk_base::CritScope cs(&critical_section_stopping_);
+  rtc::CritScope cs(&critical_section_stopping_);
   // TODO(hellner): weird to return failure when it is in fact actually running.
   if (IsRunning()) {
     LOG(LS_ERROR) << "The capturer is already running";
@@ -268,7 +268,7 @@ CaptureState WebRtcVideoCapturer::Start(const VideoFormat& capture_format) {
   }
 
   std::string camera_id(GetId());
-  uint32 start = talk_base::Time();
+  uint32 start = rtc::Time();
   module_->RegisterCaptureDataCallback(*this);
   if (module_->StartCapture(cap) != 0) {
     LOG(LS_ERROR) << "Camera '" << camera_id << "' failed to start";
@@ -277,7 +277,7 @@ CaptureState WebRtcVideoCapturer::Start(const VideoFormat& capture_format) {
 
   LOG(LS_INFO) << "Camera '" << camera_id << "' started with format "
                << capture_format.ToString() << ", elapsed time "
-               << talk_base::TimeSince(start) << " ms";
+               << rtc::TimeSince(start) << " ms";
 
   captured_frames_ = 0;
   SetCaptureState(CS_RUNNING);
@@ -290,9 +290,9 @@ CaptureState WebRtcVideoCapturer::Start(const VideoFormat& capture_format) {
 // controlling the camera is reversed: system frame -> OnIncomingCapturedFrame;
 // Stop -> system stop camera).
 void WebRtcVideoCapturer::Stop() {
-  talk_base::CritScope cs(&critical_section_stopping_);
+  rtc::CritScope cs(&critical_section_stopping_);
   if (IsRunning()) {
-    talk_base::Thread::Current()->Clear(this);
+    rtc::Thread::Current()->Clear(this);
     module_->StopCapture();
     module_->DeRegisterCaptureDataCallback();
 
@@ -331,7 +331,7 @@ void WebRtcVideoCapturer::OnIncomingCapturedFrame(const int32_t id,
   // the same lock. Due to the reversed order, we have to try-lock in order to
   // avoid a potential deadlock. Besides, if we can't enter because we're
   // stopping, we may as well drop the frame.
-  talk_base::TryCritScope cs(&critical_section_stopping_);
+  rtc::TryCritScope cs(&critical_section_stopping_);
   if (!cs.locked() || !IsRunning()) {
     // Capturer has been stopped or is in the process of stopping.
     return;
@@ -373,7 +373,7 @@ WebRtcCapturedFrame::WebRtcCapturedFrame(const webrtc::I420VideoFrame& sample,
   pixel_width = 1;
   pixel_height = 1;
   // Convert units from VideoFrame RenderTimeMs to CapturedFrame (nanoseconds).
-  elapsed_time = sample.render_time_ms() * talk_base::kNumNanosecsPerMillisec;
+  elapsed_time = sample.render_time_ms() * rtc::kNumNanosecsPerMillisec;
   time_stamp = elapsed_time;
   data_size = length;
   data = buffer;
diff --git a/talk/media/webrtc/webrtcvideocapturer.h b/talk/media/webrtc/webrtcvideocapturer.h
index cefad5629f..ef84fe5d5c 100644
--- a/talk/media/webrtc/webrtcvideocapturer.h
+++ b/talk/media/webrtc/webrtcvideocapturer.h
@@ -31,8 +31,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/criticalsection.h"
-#include "talk/base/messagehandler.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/messagehandler.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/webrtc/webrtcvideoframe.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
@@ -86,13 +86,13 @@ class WebRtcVideoCapturer : public VideoCapturer,
   virtual void OnCaptureDelayChanged(const int32_t id,
                                      const int32_t delay);
 
-  talk_base::scoped_ptr<WebRtcVcmFactoryInterface> factory_;
+  rtc::scoped_ptr<WebRtcVcmFactoryInterface> factory_;
   webrtc::VideoCaptureModule* module_;
   int captured_frames_;
   std::vector<uint8_t> capture_buffer_;
 
   // Critical section to avoid Stop during an OnIncomingCapturedFrame callback.
-  talk_base::CriticalSection critical_section_stopping_;
+  rtc::CriticalSection critical_section_stopping_;
 };
 
 struct WebRtcCapturedFrame : public CapturedFrame {
diff --git a/talk/media/webrtc/webrtcvideocapturer_unittest.cc b/talk/media/webrtc/webrtcvideocapturer_unittest.cc
index 226aa4b333..494ec2bc02 100644
--- a/talk/media/webrtc/webrtcvideocapturer_unittest.cc
+++ b/talk/media/webrtc/webrtcvideocapturer_unittest.cc
@@ -25,10 +25,10 @@
 
 #include <stdio.h>
 #include <vector>
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/testutils.h"
 #include "talk/media/base/videocommon.h"
 #include "talk/media/webrtc/fakewebrtcvcmfactory.h"
@@ -59,7 +59,7 @@ class WebRtcVideoCapturerTest : public testing::Test {
 
  protected:
   FakeWebRtcVcmFactory* factory_;  // owned by capturer_
-  talk_base::scoped_ptr<cricket::WebRtcVideoCapturer> capturer_;
+  rtc::scoped_ptr<cricket::WebRtcVideoCapturer> capturer_;
   cricket::VideoCapturerListener listener_;
 };
 
diff --git a/talk/media/webrtc/webrtcvideodecoderfactory.h b/talk/media/webrtc/webrtcvideodecoderfactory.h
index 483bca7d39..ce26f0e786 100644
--- a/talk/media/webrtc/webrtcvideodecoderfactory.h
+++ b/talk/media/webrtc/webrtcvideodecoderfactory.h
@@ -28,7 +28,7 @@
 #ifndef TALK_MEDIA_WEBRTC_WEBRTCVIDEODECODERFACTORY_H_
 #define TALK_MEDIA_WEBRTC_WEBRTCVIDEODECODERFACTORY_H_
 
-#include "talk/base/refcount.h"
+#include "webrtc/base/refcount.h"
 #include "webrtc/common_types.h"
 
 namespace webrtc {
diff --git a/talk/media/webrtc/webrtcvideoencoderfactory.h b/talk/media/webrtc/webrtcvideoencoderfactory.h
index a84430963b..22f673945b 100644
--- a/talk/media/webrtc/webrtcvideoencoderfactory.h
+++ b/talk/media/webrtc/webrtcvideoencoderfactory.h
@@ -28,7 +28,7 @@
 #ifndef TALK_MEDIA_WEBRTC_WEBRTCVIDEOENCODERFACTORY_H_
 #define TALK_MEDIA_WEBRTC_WEBRTCVIDEOENCODERFACTORY_H_
 
-#include "talk/base/refcount.h"
+#include "webrtc/base/refcount.h"
 #include "talk/media/base/codec.h"
 #include "webrtc/common_types.h"
 
diff --git a/talk/media/webrtc/webrtcvideoengine.cc b/talk/media/webrtc/webrtcvideoengine.cc
index 0161de8b45..1491a9f0c8 100644
--- a/talk/media/webrtc/webrtcvideoengine.cc
+++ b/talk/media/webrtc/webrtcvideoengine.cc
@@ -35,15 +35,15 @@
 #include <math.h>
 #include <set>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/buffer.h"
-#include "talk/base/byteorder.h"
-#include "talk/base/common.h"
-#include "talk/base/cpumonitor.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/thread.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/cpumonitor.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/rtputils.h"
 #include "talk/media/base/streamparams.h"
@@ -82,7 +82,7 @@ const int kMaxVideoBitrate = 2000;
 const int kCpuMonitorPeriodMs = 2000;  // 2 seconds.
 
 
-static const int kDefaultLogSeverity = talk_base::LS_WARNING;
+static const int kDefaultLogSeverity = rtc::LS_WARNING;
 
 static const int kDefaultNumberOfTemporalLayers = 1;  // 1:1
 
@@ -105,7 +105,7 @@ static int GetExternalVideoPayloadType(int index) {
   return kExternalVideoPayloadTypeBase + index;
 }
 
-static void LogMultiline(talk_base::LoggingSeverity sev, char* text) {
+static void LogMultiline(rtc::LoggingSeverity sev, char* text) {
   const char* delim = "\r\n";
   // TODO(fbarchard): Fix strtok lint warning.
   for (char* tok = strtok(text, delim); tok; tok = strtok(NULL, delim)) {
@@ -117,13 +117,13 @@ static void LogMultiline(talk_base::LoggingSeverity sev, char* text) {
 static int SeverityToFilter(int severity) {
   int filter = webrtc::kTraceNone;
   switch (severity) {
-    case talk_base::LS_VERBOSE:
+    case rtc::LS_VERBOSE:
       filter |= webrtc::kTraceAll;
-    case talk_base::LS_INFO:
+    case rtc::LS_INFO:
       filter |= (webrtc::kTraceStateInfo | webrtc::kTraceInfo);
-    case talk_base::LS_WARNING:
+    case rtc::LS_WARNING:
       filter |= (webrtc::kTraceTerseInfo | webrtc::kTraceWarning);
-    case talk_base::LS_ERROR:
+    case rtc::LS_ERROR:
       filter |= (webrtc::kTraceError | webrtc::kTraceCritical);
   }
   return filter;
@@ -134,8 +134,8 @@ static const bool kNotSending = false;
 // Default video dscp value.
 // See http://tools.ietf.org/html/rfc2474 for details
 // See also http://tools.ietf.org/html/draft-jennings-rtcweb-qos-00
-static const talk_base::DiffServCodePoint kVideoDscpValue =
-    talk_base::DSCP_AF41;
+static const rtc::DiffServCodePoint kVideoDscpValue =
+    rtc::DSCP_AF41;
 
 static bool IsNackEnabled(const VideoCodec& codec) {
   return codec.HasFeedbackParam(FeedbackParam(kRtcpFbParamNack,
@@ -148,7 +148,7 @@ static bool IsRembEnabled(const VideoCodec& codec) {
                                               kParamValueEmpty));
 }
 
-struct FlushBlackFrameData : public talk_base::MessageData {
+struct FlushBlackFrameData : public rtc::MessageData {
   FlushBlackFrameData(uint32 s, int64 t) : ssrc(s), timestamp(t) {
   }
   uint32 ssrc;
@@ -170,7 +170,7 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer {
   }
 
   void SetRenderer(VideoRenderer* renderer) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     renderer_ = renderer;
     // FrameSizeChange may have already been called when renderer was not set.
     // If so we should call SetSize here.
@@ -190,7 +190,7 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer {
   // Implementation of webrtc::ExternalRenderer.
   virtual int FrameSizeChange(unsigned int width, unsigned int height,
                               unsigned int /*number_of_streams*/) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     width_ = width;
     height_ = height;
     LOG(LS_INFO) << "WebRtcRenderAdapter (channel " << channel_id_
@@ -211,7 +211,7 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer {
                            int64_t ntp_time_ms,
                            int64_t render_time,
                            void* handle) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     if (capture_start_rtp_time_stamp_ < 0) {
       capture_start_rtp_time_stamp_ = rtp_time_stamp;
     }
@@ -230,10 +230,10 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer {
     }
     // Convert elapsed_time_ms to ns timestamp.
     int64 elapsed_time_ns =
-        elapsed_time_ms * talk_base::kNumNanosecsPerMillisec;
+        elapsed_time_ms * rtc::kNumNanosecsPerMillisec;
     // Convert milisecond render time to ns timestamp.
     int64 render_time_ns = render_time *
-        talk_base::kNumNanosecsPerMillisec;
+        rtc::kNumNanosecsPerMillisec;
     // Note that here we send the |elapsed_time_ns| to renderer as the
     // cricket::VideoFrame's elapsed_time_ and the |render_time_ns| as the
     // cricket::VideoFrame's time_stamp_.
@@ -273,38 +273,38 @@ class WebRtcRenderAdapter : public webrtc::ExternalRenderer {
   }
 
   unsigned int width() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return width_;
   }
 
   unsigned int height() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return height_;
   }
 
   int framerate() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return static_cast<int>(frame_rate_tracker_.units_second());
   }
 
   VideoRenderer* renderer() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return renderer_;
   }
 
   int64 capture_start_ntp_time_ms() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return capture_start_ntp_time_ms_;
   }
 
  private:
-  talk_base::CriticalSection crit_;
+  rtc::CriticalSection crit_;
   VideoRenderer* renderer_;
   int channel_id_;
   unsigned int width_;
   unsigned int height_;
-  talk_base::RateTracker frame_rate_tracker_;
-  talk_base::TimestampWrapAroundHandler rtp_ts_wraparound_handler_;
+  rtc::RateTracker frame_rate_tracker_;
+  rtc::TimestampWrapAroundHandler rtp_ts_wraparound_handler_;
   int64 capture_start_rtp_time_stamp_;
   int64 capture_start_ntp_time_ms_;
 };
@@ -330,7 +330,7 @@ class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver {
   virtual void IncomingRate(const int videoChannel,
                             const unsigned int framerate,
                             const unsigned int bitrate) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     ASSERT(video_channel_ == videoChannel);
     framerate_ = framerate;
     bitrate_ = bitrate;
@@ -343,7 +343,7 @@ class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver {
                              int jitter_buffer_ms,
                              int min_playout_delay_ms,
                              int render_delay_ms) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     decode_ms_ = decode_ms;
     max_decode_ms_ = max_decode_ms;
     current_delay_ms_ = current_delay_ms;
@@ -357,7 +357,7 @@ class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver {
 
   // Populate |rinfo| based on previously-set data in |*this|.
   void ExportTo(VideoReceiverInfo* rinfo) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     rinfo->framerate_rcvd = framerate_;
     rinfo->decode_ms = decode_ms_;
     rinfo->max_decode_ms = max_decode_ms_;
@@ -369,7 +369,7 @@ class WebRtcDecoderObserver : public webrtc::ViEDecoderObserver {
   }
 
  private:
-  mutable talk_base::CriticalSection crit_;
+  mutable rtc::CriticalSection crit_;
   int video_channel_;
   int framerate_;
   int bitrate_;
@@ -395,33 +395,33 @@ class WebRtcEncoderObserver : public webrtc::ViEEncoderObserver {
   virtual void OutgoingRate(const int videoChannel,
                             const unsigned int framerate,
                             const unsigned int bitrate) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     ASSERT(video_channel_ == videoChannel);
     framerate_ = framerate;
     bitrate_ = bitrate;
   }
 
   virtual void SuspendChange(int video_channel, bool is_suspended) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     ASSERT(video_channel_ == video_channel);
     suspended_ = is_suspended;
   }
 
   int framerate() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return framerate_;
   }
   int bitrate() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return bitrate_;
   }
   bool suspended() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return suspended_;
   }
 
  private:
-  mutable talk_base::CriticalSection crit_;
+  mutable rtc::CriticalSection crit_;
   int video_channel_;
   int framerate_;
   int bitrate_;
@@ -433,35 +433,35 @@ class WebRtcLocalStreamInfo {
   WebRtcLocalStreamInfo()
       : width_(0), height_(0), elapsed_time_(-1), time_stamp_(-1) {}
   size_t width() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return width_;
   }
   size_t height() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return height_;
   }
   int64 elapsed_time() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return elapsed_time_;
   }
   int64 time_stamp() const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return time_stamp_;
   }
   int framerate() {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     return static_cast<int>(rate_tracker_.units_second());
   }
   void GetLastFrameInfo(
       size_t* width, size_t* height, int64* elapsed_time) const {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     *width = width_;
     *height = height_;
     *elapsed_time = elapsed_time_;
   }
 
   void UpdateFrame(const VideoFrame* frame) {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
 
     width_ = frame->GetWidth();
     height_ = frame->GetHeight();
@@ -472,12 +472,12 @@ class WebRtcLocalStreamInfo {
   }
 
  private:
-  mutable talk_base::CriticalSection crit_;
+  mutable rtc::CriticalSection crit_;
   size_t width_;
   size_t height_;
   int64 elapsed_time_;
   int64 time_stamp_;
-  talk_base::RateTracker rate_tracker_;
+  rtc::RateTracker rate_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcLocalStreamInfo);
 };
@@ -534,7 +534,7 @@ class WebRtcOveruseObserver : public webrtc::CpuOveruseObserver {
   // adapter know what resolution the request is based on. Helps eliminate stale
   // data, race conditions.
   virtual void OveruseDetected() OVERRIDE {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     if (!enabled_) {
       return;
     }
@@ -543,7 +543,7 @@ class WebRtcOveruseObserver : public webrtc::CpuOveruseObserver {
   }
 
   virtual void NormalUsage() OVERRIDE {
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     if (!enabled_) {
       return;
     }
@@ -553,7 +553,7 @@ class WebRtcOveruseObserver : public webrtc::CpuOveruseObserver {
 
   void Enable(bool enable) {
     LOG(LS_INFO) << "WebRtcOveruseObserver enable: " << enable;
-    talk_base::CritScope cs(&crit_);
+    rtc::CritScope cs(&crit_);
     enabled_ = enable;
   }
 
@@ -562,7 +562,7 @@ class WebRtcOveruseObserver : public webrtc::CpuOveruseObserver {
  private:
   CoordinatedVideoAdapter* video_adapter_;
   bool enabled_;
-  talk_base::CriticalSection crit_;
+  rtc::CriticalSection crit_;
 };
 
 
@@ -571,7 +571,7 @@ class WebRtcVideoChannelSendInfo : public sigslot::has_slots<> {
   typedef std::map<int, webrtc::VideoEncoder*> EncoderMap;  // key: payload type
   WebRtcVideoChannelSendInfo(int channel_id, int capture_id,
                              webrtc::ViEExternalCapture* external_capture,
-                             talk_base::CpuMonitor* cpu_monitor)
+                             rtc::CpuMonitor* cpu_monitor)
       : channel_id_(channel_id),
         capture_id_(capture_id),
         sending_(false),
@@ -812,14 +812,14 @@ class WebRtcVideoChannelSendInfo : public sigslot::has_slots<> {
 
   VideoFormat video_format_;
 
-  talk_base::scoped_ptr<StreamParams> stream_params_;
+  rtc::scoped_ptr<StreamParams> stream_params_;
 
   WebRtcLocalStreamInfo local_stream_info_;
 
   int64 interval_;
 
-  talk_base::CpuMonitor* cpu_monitor_;
-  talk_base::scoped_ptr<WebRtcOveruseObserver> overuse_observer_;
+  rtc::CpuMonitor* cpu_monitor_;
+  rtc::scoped_ptr<WebRtcOveruseObserver> overuse_observer_;
 
   int old_adaptation_changes_;
 
@@ -893,26 +893,26 @@ static bool GetCpuOveruseOptions(const VideoOptions& options,
 
 WebRtcVideoEngine::WebRtcVideoEngine() {
   Construct(new ViEWrapper(), new ViETraceWrapper(), NULL,
-      new talk_base::CpuMonitor(NULL));
+      new rtc::CpuMonitor(NULL));
 }
 
 WebRtcVideoEngine::WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
                                      ViEWrapper* vie_wrapper,
-                                     talk_base::CpuMonitor* cpu_monitor) {
+                                     rtc::CpuMonitor* cpu_monitor) {
   Construct(vie_wrapper, new ViETraceWrapper(), voice_engine, cpu_monitor);
 }
 
 WebRtcVideoEngine::WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
                                      ViEWrapper* vie_wrapper,
                                      ViETraceWrapper* tracing,
-                                     talk_base::CpuMonitor* cpu_monitor) {
+                                     rtc::CpuMonitor* cpu_monitor) {
   Construct(vie_wrapper, tracing, voice_engine, cpu_monitor);
 }
 
 void WebRtcVideoEngine::Construct(ViEWrapper* vie_wrapper,
                                   ViETraceWrapper* tracing,
                                   WebRtcVoiceEngine* voice_engine,
-                                  talk_base::CpuMonitor* cpu_monitor) {
+                                  rtc::CpuMonitor* cpu_monitor) {
   LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine";
   worker_thread_ = NULL;
   vie_wrapper_.reset(vie_wrapper);
@@ -972,7 +972,7 @@ WebRtcVideoEngine::~WebRtcVideoEngine() {
   ASSERT(SignalMediaFrame.is_empty());
 }
 
-bool WebRtcVideoEngine::Init(talk_base::Thread* worker_thread) {
+bool WebRtcVideoEngine::Init(rtc::Thread* worker_thread) {
   LOG(LS_INFO) << "WebRtcVideoEngine::Init";
   worker_thread_ = worker_thread;
   ASSERT(worker_thread_ != NULL);
@@ -1013,7 +1013,7 @@ bool WebRtcVideoEngine::InitVideoEngine() {
   }
 
   LOG(LS_INFO) << "WebRtc VideoEngine Version:";
-  LogMultiline(talk_base::LS_INFO, buffer);
+  LogMultiline(rtc::LS_INFO, buffer);
 
   // Hook up to VoiceEngine for sync purposes, if supplied.
   if (!voice_engine_) {
@@ -1177,7 +1177,7 @@ bool WebRtcVideoEngine::CanSendCodec(const VideoCodec& requested,
     out->name = requested.name;
     out->preference = requested.preference;
     out->params = requested.params;
-    out->framerate = talk_base::_min(requested.framerate, local_max->framerate);
+    out->framerate = rtc::_min(requested.framerate, local_max->framerate);
     out->width = 0;
     out->height = 0;
     out->params = requested.params;
@@ -1248,7 +1248,7 @@ bool WebRtcVideoEngine::ConvertFromCricketVideoCodec(
       if (_stricmp(in_codec.name.c_str(), codecs[i].name.c_str()) == 0) {
         out_codec->codecType = codecs[i].type;
         out_codec->plType = GetExternalVideoPayloadType(static_cast<int>(i));
-        talk_base::strcpyn(out_codec->plName, sizeof(out_codec->plName),
+        rtc::strcpyn(out_codec->plName, sizeof(out_codec->plName),
                            codecs[i].name.c_str(), codecs[i].name.length());
         found = true;
         break;
@@ -1259,7 +1259,7 @@ bool WebRtcVideoEngine::ConvertFromCricketVideoCodec(
   // Is this an RTX codec? Handled separately here since webrtc doesn't handle
   // them as webrtc::VideoCodec internally.
   if (!found && _stricmp(in_codec.name.c_str(), kRtxCodecName) == 0) {
-    talk_base::strcpyn(out_codec->plName, sizeof(out_codec->plName),
+    rtc::strcpyn(out_codec->plName, sizeof(out_codec->plName),
                        in_codec.name.c_str(), in_codec.name.length());
     out_codec->plType = in_codec.id;
     found = true;
@@ -1308,12 +1308,12 @@ bool WebRtcVideoEngine::ConvertFromCricketVideoCodec(
 }
 
 void WebRtcVideoEngine::RegisterChannel(WebRtcVideoMediaChannel *channel) {
-  talk_base::CritScope cs(&channels_crit_);
+  rtc::CritScope cs(&channels_crit_);
   channels_.push_back(channel);
 }
 
 void WebRtcVideoEngine::UnregisterChannel(WebRtcVideoMediaChannel *channel) {
-  talk_base::CritScope cs(&channels_crit_);
+  rtc::CritScope cs(&channels_crit_);
   channels_.erase(std::remove(channels_.begin(), channels_.end(), channel),
                   channels_.end());
 }
@@ -1347,7 +1347,7 @@ void WebRtcVideoEngine::SetTraceFilter(int filter) {
 void WebRtcVideoEngine::SetTraceOptions(const std::string& options) {
   // Set WebRTC trace file.
   std::vector<std::string> opts;
-  talk_base::tokenize(options, ' ', '"', '"', &opts);
+  rtc::tokenize(options, ' ', '"', '"', &opts);
   std::vector<std::string>::iterator tracefile =
       std::find(opts.begin(), opts.end(), "tracefile");
   if (tracefile != opts.end() && ++tracefile != opts.end()) {
@@ -1441,21 +1441,21 @@ bool WebRtcVideoEngine::ShouldIgnoreTrace(const std::string& trace) {
 }
 
 int WebRtcVideoEngine::GetNumOfChannels() {
-  talk_base::CritScope cs(&channels_crit_);
+  rtc::CritScope cs(&channels_crit_);
   return static_cast<int>(channels_.size());
 }
 
 void WebRtcVideoEngine::Print(webrtc::TraceLevel level, const char* trace,
                               int length) {
-  talk_base::LoggingSeverity sev = talk_base::LS_VERBOSE;
+  rtc::LoggingSeverity sev = rtc::LS_VERBOSE;
   if (level == webrtc::kTraceError || level == webrtc::kTraceCritical)
-    sev = talk_base::LS_ERROR;
+    sev = rtc::LS_ERROR;
   else if (level == webrtc::kTraceWarning)
-    sev = talk_base::LS_WARNING;
+    sev = rtc::LS_WARNING;
   else if (level == webrtc::kTraceStateInfo || level == webrtc::kTraceInfo)
-    sev = talk_base::LS_INFO;
+    sev = rtc::LS_INFO;
   else if (level == webrtc::kTraceTerseInfo)
-    sev = talk_base::LS_INFO;
+    sev = rtc::LS_INFO;
 
   // Skip past boilerplate prefix text
   if (length < 72) {
@@ -2696,7 +2696,7 @@ bool WebRtcVideoMediaChannel::RequestIntraFrame() {
 }
 
 void WebRtcVideoMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   // Pick which channel to send this packet to. If this packet doesn't match
   // any multiplexed streams, just send it to the default channel. Otherwise,
   // send it to the specific decoder instance for that stream.
@@ -2724,7 +2724,7 @@ void WebRtcVideoMediaChannel::OnPacketReceived(
 }
 
 void WebRtcVideoMediaChannel::OnRtcpReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
 // Sending channels need all RTCP packets with feedback information.
 // Even sender reports can contain attached report blocks.
 // Receiving channels need sender reports in order to create
@@ -2842,7 +2842,7 @@ bool WebRtcVideoMediaChannel::SetSendRtpHeaderExtensions(
     // Extension closer to the network, @ socket level before sending.
     // Pushing the extension id to socket layer.
     MediaChannel::SetOption(NetworkInterface::ST_RTP,
-                            talk_base::Socket::OPT_RTP_SENDTIME_EXTN_ID,
+                            rtc::Socket::OPT_RTP_SENDTIME_EXTN_ID,
                             send_time_extension->id);
   }
 
@@ -3020,7 +3020,7 @@ bool WebRtcVideoMediaChannel::SetOptions(const VideoOptions &options) {
     }
   }
   if (dscp_option_changed) {
-    talk_base::DiffServCodePoint dscp = talk_base::DSCP_DEFAULT;
+    rtc::DiffServCodePoint dscp = rtc::DSCP_DEFAULT;
     if (options_.dscp.GetWithDefaultIfUnset(false))
       dscp = kVideoDscpValue;
     LOG(LS_INFO) << "DSCP is " << dscp;
@@ -3080,14 +3080,14 @@ void WebRtcVideoMediaChannel::SetInterface(NetworkInterface* iface) {
   MediaChannel::SetInterface(iface);
   // Set the RTP recv/send buffer to a bigger size
   MediaChannel::SetOption(NetworkInterface::ST_RTP,
-                          talk_base::Socket::OPT_RCVBUF,
+                          rtc::Socket::OPT_RCVBUF,
                           kVideoRtpBufferSize);
 
     // TODO(sriniv): Remove or re-enable this.
     // As part of b/8030474, send-buffer is size now controlled through
     // portallocator flags.
     // network_interface_->SetOption(NetworkInterface::ST_RTP,
-    //                              talk_base::Socket::OPT_SNDBUF,
+    //                              rtc::Socket::OPT_SNDBUF,
     //                              kVideoRtpBufferSize);
 }
 
@@ -3194,7 +3194,7 @@ bool WebRtcVideoMediaChannel::SendFrame(
     return false;
   }
   const VideoFrame* frame_out = frame;
-  talk_base::scoped_ptr<VideoFrame> processed_frame;
+  rtc::scoped_ptr<VideoFrame> processed_frame;
   // TODO(hellner): Remove the need for disabling mute when screencasting.
   const bool mute = (send_channel->muted() && !is_screencast);
   send_channel->ProcessFrame(*frame_out, mute, processed_frame.use());
@@ -3223,7 +3223,7 @@ bool WebRtcVideoMediaChannel::SendFrame(
   // If the frame timestamp is 0, we will use the deliver time.
   const int64 frame_timestamp = frame->GetTimeStamp();
   if (frame_timestamp != 0) {
-    if (abs(time(NULL) - frame_timestamp / talk_base::kNumNanosecsPerSec) >
+    if (abs(time(NULL) - frame_timestamp / rtc::kNumNanosecsPerSec) >
             kTimestampDeltaInSecondsForWarning) {
       LOG(LS_WARNING) << "Frame timestamp differs by more than "
                       << kTimestampDeltaInSecondsForWarning << " seconds from "
@@ -3231,7 +3231,7 @@ bool WebRtcVideoMediaChannel::SendFrame(
     }
 
     timestamp_ntp_ms =
-        talk_base::UnixTimestampNanosecsToNtpMillisecs(frame_timestamp);
+        rtc::UnixTimestampNanosecsToNtpMillisecs(frame_timestamp);
   }
 #endif
 
@@ -3385,7 +3385,7 @@ bool WebRtcVideoMediaChannel::ConfigureReceiving(int channel_id,
     }
   }
 
-  talk_base::scoped_ptr<WebRtcVideoChannelRecvInfo> channel_info(
+  rtc::scoped_ptr<WebRtcVideoChannelRecvInfo> channel_info(
       new WebRtcVideoChannelRecvInfo(channel_id));
 
   // Install a render adapter.
@@ -3495,7 +3495,7 @@ bool WebRtcVideoMediaChannel::ConfigureSending(int channel_id,
     LOG_RTCERR2(ConnectCaptureDevice, vie_capture, channel_id);
     return false;
   }
-  talk_base::scoped_ptr<WebRtcVideoChannelSendInfo> send_channel(
+  rtc::scoped_ptr<WebRtcVideoChannelSendInfo> send_channel(
       new WebRtcVideoChannelSendInfo(channel_id, vie_capture,
                                      external_capture,
                                      engine()->cpu_monitor()));
@@ -4014,7 +4014,7 @@ void WebRtcVideoMediaChannel::MaybeChangeBitrates(
 
 }
 
-void WebRtcVideoMediaChannel::OnMessage(talk_base::Message* msg) {
+void WebRtcVideoMediaChannel::OnMessage(rtc::Message* msg) {
   FlushBlackFrameData* black_frame_data =
       static_cast<FlushBlackFrameData*>(msg->pdata);
   FlushBlackFrame(black_frame_data->ssrc, black_frame_data->timestamp);
@@ -4023,14 +4023,14 @@ void WebRtcVideoMediaChannel::OnMessage(talk_base::Message* msg) {
 
 int WebRtcVideoMediaChannel::SendPacket(int channel, const void* data,
                                         int len) {
-  talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+  rtc::Buffer packet(data, len, kMaxRtpPacketLen);
   return MediaChannel::SendPacket(&packet) ? len : -1;
 }
 
 int WebRtcVideoMediaChannel::SendRTCPPacket(int channel,
                                             const void* data,
                                             int len) {
-  talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+  rtc::Buffer packet(data, len, kMaxRtpPacketLen);
   return MediaChannel::SendRtcp(&packet) ? len : -1;
 }
 
@@ -4042,7 +4042,7 @@ void WebRtcVideoMediaChannel::QueueBlackFrame(uint32 ssrc, int64 timestamp,
         timestamp);
     const int delay_ms = static_cast<int>(
         2 * cricket::VideoFormat::FpsToInterval(framerate) *
-        talk_base::kNumMillisecsPerSec / talk_base::kNumNanosecsPerSec);
+        rtc::kNumMillisecsPerSec / rtc::kNumNanosecsPerSec);
     worker_thread()->PostDelayed(delay_ms, this, 0, black_frame_data);
   }
 }
@@ -4052,7 +4052,7 @@ void WebRtcVideoMediaChannel::FlushBlackFrame(uint32 ssrc, int64 timestamp) {
   if (!send_channel) {
     return;
   }
-  talk_base::scoped_ptr<const VideoFrame> black_frame_ptr;
+  rtc::scoped_ptr<const VideoFrame> black_frame_ptr;
 
   const WebRtcLocalStreamInfo* channel_stream_info =
       send_channel->local_stream_info();
diff --git a/talk/media/webrtc/webrtcvideoengine.h b/talk/media/webrtc/webrtcvideoengine.h
index 360f1d1270..f467b97579 100644
--- a/talk/media/webrtc/webrtcvideoengine.h
+++ b/talk/media/webrtc/webrtcvideoengine.h
@@ -31,7 +31,7 @@
 #include <map>
 #include <vector>
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/videocommon.h"
 #include "talk/media/webrtc/webrtccommon.h"
@@ -54,9 +54,9 @@ class ViEExternalCapture;
 class ViERTP_RTCP;
 }
 
-namespace talk_base {
+namespace rtc {
 class CpuMonitor;
-}  // namespace talk_base
+}  // namespace rtc
 
 namespace cricket {
 
@@ -93,15 +93,15 @@ class WebRtcVideoEngine : public sigslot::has_slots<>,
   // TODO(juberti): Remove the 3-arg ctor once fake tracing is implemented.
   WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
                     ViEWrapper* vie_wrapper,
-                    talk_base::CpuMonitor* cpu_monitor);
+                    rtc::CpuMonitor* cpu_monitor);
   WebRtcVideoEngine(WebRtcVoiceEngine* voice_engine,
                     ViEWrapper* vie_wrapper,
                     ViETraceWrapper* tracing,
-                    talk_base::CpuMonitor* cpu_monitor);
+                    rtc::CpuMonitor* cpu_monitor);
   ~WebRtcVideoEngine();
 
   // Basic video engine implementation.
-  bool Init(talk_base::Thread* worker_thread);
+  bool Init(rtc::Thread* worker_thread);
   void Terminate();
 
   int GetCapabilities();
@@ -149,7 +149,7 @@ class WebRtcVideoEngine : public sigslot::has_slots<>,
   bool IsExternalEncoderCodecType(webrtc::VideoCodecType type) const;
 
   // Functions called by WebRtcVideoMediaChannel.
-  talk_base::Thread* worker_thread() { return worker_thread_; }
+  rtc::Thread* worker_thread() { return worker_thread_; }
   ViEWrapper* vie() { return vie_wrapper_.get(); }
   const VideoFormat& default_codec_format() const {
     return default_codec_format_;
@@ -168,7 +168,7 @@ class WebRtcVideoEngine : public sigslot::has_slots<>,
 
   VideoFormat GetStartCaptureFormat() const { return default_codec_format_; }
 
-  talk_base::CpuMonitor* cpu_monitor() { return cpu_monitor_.get(); }
+  rtc::CpuMonitor* cpu_monitor() { return cpu_monitor_.get(); }
 
  protected:
   // When a video processor registers with the engine.
@@ -194,7 +194,7 @@ class WebRtcVideoEngine : public sigslot::has_slots<>,
   void Construct(ViEWrapper* vie_wrapper,
                  ViETraceWrapper* tracing,
                  WebRtcVoiceEngine* voice_engine,
-                 talk_base::CpuMonitor* cpu_monitor);
+                 rtc::CpuMonitor* cpu_monitor);
   bool SetDefaultCodec(const VideoCodec& codec);
   bool RebuildCodecList(const VideoCodec& max_codec);
   void SetTraceFilter(int filter);
@@ -208,12 +208,12 @@ class WebRtcVideoEngine : public sigslot::has_slots<>,
   // WebRtcVideoEncoderFactory::Observer implementation.
   virtual void OnCodecsAvailable();
 
-  talk_base::Thread* worker_thread_;
-  talk_base::scoped_ptr<ViEWrapper> vie_wrapper_;
+  rtc::Thread* worker_thread_;
+  rtc::scoped_ptr<ViEWrapper> vie_wrapper_;
   bool vie_wrapper_base_initialized_;
-  talk_base::scoped_ptr<ViETraceWrapper> tracing_;
+  rtc::scoped_ptr<ViETraceWrapper> tracing_;
   WebRtcVoiceEngine* voice_engine_;
-  talk_base::scoped_ptr<webrtc::VideoRender> render_module_;
+  rtc::scoped_ptr<webrtc::VideoRender> render_module_;
   WebRtcVideoEncoderFactory* encoder_factory_;
   WebRtcVideoDecoderFactory* decoder_factory_;
   std::vector<VideoCodec> video_codecs_;
@@ -221,7 +221,7 @@ class WebRtcVideoEngine : public sigslot::has_slots<>,
   VideoFormat default_codec_format_;
 
   bool initialized_;
-  talk_base::CriticalSection channels_crit_;
+  rtc::CriticalSection channels_crit_;
   VideoChannels channels_;
 
   bool capture_started_;
@@ -229,10 +229,10 @@ class WebRtcVideoEngine : public sigslot::has_slots<>,
   int local_renderer_h_;
   VideoRenderer* local_renderer_;
 
-  talk_base::scoped_ptr<talk_base::CpuMonitor> cpu_monitor_;
+  rtc::scoped_ptr<rtc::CpuMonitor> cpu_monitor_;
 };
 
-class WebRtcVideoMediaChannel : public talk_base::MessageHandler,
+class WebRtcVideoMediaChannel : public rtc::MessageHandler,
                                 public VideoMediaChannel,
                                 public webrtc::Transport {
  public:
@@ -267,10 +267,10 @@ class WebRtcVideoMediaChannel : public talk_base::MessageHandler,
   virtual bool SendIntraFrame();
   virtual bool RequestIntraFrame();
 
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time);
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time);
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time);
   virtual void OnReadyToSend(bool ready);
   virtual bool MuteStream(uint32 ssrc, bool on);
   virtual bool SetRecvRtpHeaderExtensions(
@@ -303,7 +303,7 @@ class WebRtcVideoMediaChannel : public talk_base::MessageHandler,
   void OnLocalFrameFormat(VideoCapturer* capturer, const VideoFormat* format) {
   }
 
-  virtual void OnMessage(talk_base::Message* msg);
+  virtual void OnMessage(rtc::Message* msg);
 
  protected:
   int GetLastEngineError() { return engine()->GetLastEngineError(); }
@@ -389,7 +389,7 @@ class WebRtcVideoMediaChannel : public talk_base::MessageHandler,
   }
   bool RemoveCapturer(uint32 ssrc);
 
-  talk_base::MessageQueue* worker_thread() { return engine_->worker_thread(); }
+  rtc::MessageQueue* worker_thread() { return engine_->worker_thread(); }
   void QueueBlackFrame(uint32 ssrc, int64 timestamp, int framerate);
   void FlushBlackFrame(uint32 ssrc, int64 timestamp);
 
@@ -449,7 +449,7 @@ class WebRtcVideoMediaChannel : public talk_base::MessageHandler,
 
   // Global send side state.
   SendChannelMap send_channels_;
-  talk_base::scoped_ptr<webrtc::VideoCodec> send_codec_;
+  rtc::scoped_ptr<webrtc::VideoCodec> send_codec_;
   int send_rtx_type_;
   int send_red_type_;
   int send_fec_type_;
diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc
index aeba897d1c..0bf3b51c3d 100644
--- a/talk/media/webrtc/webrtcvideoengine2.cc
+++ b/talk/media/webrtc/webrtcvideoengine2.cc
@@ -32,9 +32,9 @@
 #include <string>
 
 #include "libyuv/convert_from.h"
-#include "talk/base/buffer.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videorenderer.h"
 #include "talk/media/webrtc/constants.h"
@@ -251,18 +251,18 @@ bool WebRtcVideoEncoderFactory2::SupportsCodec(const VideoCodec& codec) {
 
 WebRtcVideoEngine2::WebRtcVideoEngine2() {
   // Construct without a factory or voice engine.
-  Construct(NULL, NULL, new talk_base::CpuMonitor(NULL));
+  Construct(NULL, NULL, new rtc::CpuMonitor(NULL));
 }
 
 WebRtcVideoEngine2::WebRtcVideoEngine2(
     WebRtcVideoChannelFactory* channel_factory) {
   // Construct without a voice engine.
-  Construct(channel_factory, NULL, new talk_base::CpuMonitor(NULL));
+  Construct(channel_factory, NULL, new rtc::CpuMonitor(NULL));
 }
 
 void WebRtcVideoEngine2::Construct(WebRtcVideoChannelFactory* channel_factory,
                                    WebRtcVoiceEngine* voice_engine,
-                                   talk_base::CpuMonitor* cpu_monitor) {
+                                   rtc::CpuMonitor* cpu_monitor) {
   LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2";
   worker_thread_ = NULL;
   voice_engine_ = voice_engine;
@@ -290,7 +290,7 @@ WebRtcVideoEngine2::~WebRtcVideoEngine2() {
   }
 }
 
-bool WebRtcVideoEngine2::Init(talk_base::Thread* worker_thread) {
+bool WebRtcVideoEngine2::Init(rtc::Thread* worker_thread) {
   LOG(LS_INFO) << "WebRtcVideoEngine2::Init";
   worker_thread_ = worker_thread;
   ASSERT(worker_thread_ != NULL);
@@ -435,7 +435,7 @@ bool WebRtcVideoEngine2::CanSendCodec(const VideoCodec& requested,
   out->preference = requested.preference;
   out->params = requested.params;
   out->framerate =
-      talk_base::_min(requested.framerate, matching_codec.framerate);
+      rtc::_min(requested.framerate, matching_codec.framerate);
   out->params = requested.params;
   out->feedback_params = requested.feedback_params;
   out->width = requested.width;
@@ -559,11 +559,11 @@ class WebRtcVideoRenderFrame : public VideoFrame {
 
   virtual int64 GetElapsedTime() const OVERRIDE {
     // Convert millisecond render time to ns timestamp.
-    return frame_->render_time_ms() * talk_base::kNumNanosecsPerMillisec;
+    return frame_->render_time_ms() * rtc::kNumNanosecsPerMillisec;
   }
   virtual int64 GetTimeStamp() const OVERRIDE {
     // Convert 90K rtp timestamp to ns timestamp.
-    return (frame_->timestamp() / 90) * talk_base::kNumNanosecsPerMillisec;
+    return (frame_->timestamp() / 90) * rtc::kNumNanosecsPerMillisec;
   }
   virtual void SetElapsedTime(int64 elapsed_time) OVERRIDE { UNIMPLEMENTED; }
   virtual void SetTimeStamp(int64 time_stamp) OVERRIDE { UNIMPLEMENTED; }
@@ -1102,8 +1102,8 @@ bool WebRtcVideoChannel2::RequestIntraFrame() {
 }
 
 void WebRtcVideoChannel2::OnPacketReceived(
-    talk_base::Buffer* packet,
-    const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet,
+    const rtc::PacketTime& packet_time) {
   const webrtc::PacketReceiver::DeliveryStatus delivery_result =
       call_->Receiver()->DeliverPacket(
           reinterpret_cast<const uint8_t*>(packet->data()), packet->length());
@@ -1142,8 +1142,8 @@ void WebRtcVideoChannel2::OnPacketReceived(
 }
 
 void WebRtcVideoChannel2::OnRtcpReceived(
-    talk_base::Buffer* packet,
-    const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet,
+    const rtc::PacketTime& packet_time) {
   if (call_->Receiver()->DeliverPacket(
           reinterpret_cast<const uint8_t*>(packet->data()), packet->length()) !=
       webrtc::PacketReceiver::DELIVERY_OK) {
@@ -1228,14 +1228,14 @@ void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
   MediaChannel::SetInterface(iface);
   // Set the RTP recv/send buffer to a bigger size
   MediaChannel::SetOption(NetworkInterface::ST_RTP,
-                          talk_base::Socket::OPT_RCVBUF,
+                          rtc::Socket::OPT_RCVBUF,
                           kVideoRtpBufferSize);
 
   // TODO(sriniv): Remove or re-enable this.
   // As part of b/8030474, send-buffer is size now controlled through
   // portallocator flags.
   // network_interface_->SetOption(NetworkInterface::ST_RTP,
-  //                              talk_base::Socket::OPT_SNDBUF,
+  //                              rtc::Socket::OPT_SNDBUF,
   //                              kVideoRtpBufferSize);
 }
 
@@ -1243,17 +1243,17 @@ void WebRtcVideoChannel2::UpdateAspectRatio(int ratio_w, int ratio_h) {
   // TODO(pbos): Implement.
 }
 
-void WebRtcVideoChannel2::OnMessage(talk_base::Message* msg) {
+void WebRtcVideoChannel2::OnMessage(rtc::Message* msg) {
   // Ignored.
 }
 
 bool WebRtcVideoChannel2::SendRtp(const uint8_t* data, size_t len) {
-  talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+  rtc::Buffer packet(data, len, kMaxRtpPacketLen);
   return MediaChannel::SendPacket(&packet);
 }
 
 bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
-  talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+  rtc::Buffer packet(data, len, kMaxRtpPacketLen);
   return MediaChannel::SendRtcp(&packet);
 }
 
@@ -1363,7 +1363,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
                   << frame->GetHeight();
   bool is_screencast = capturer->IsScreencast();
   // Lock before copying, can be called concurrently when swapping input source.
-  talk_base::CritScope frame_cs(&frame_lock_);
+  rtc::CritScope frame_cs(&frame_lock_);
   if (!muted_) {
     ConvertToI420VideoFrame(*frame, &video_frame_);
   } else {
@@ -1371,7 +1371,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
     CreateBlackFrame(&video_frame_, 1, 1);
     is_screencast = false;
   }
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   if (stream_ == NULL) {
     LOG(LS_WARNING) << "Capturer inputting frames before send codecs are "
                        "configured, dropping.";
@@ -1400,7 +1400,7 @@ bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetCapturer(
   }
 
   {
-    talk_base::CritScope cs(&lock_);
+    rtc::CritScope cs(&lock_);
 
     if (capturer == NULL) {
       if (stream_ != NULL) {
@@ -1438,7 +1438,7 @@ bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
     return false;
   }
 
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   if (format.width == 0 && format.height == 0) {
     LOG(LS_INFO)
         << "0x0 resolution selected. Captured frames will be dropped for ssrc: "
@@ -1455,14 +1455,14 @@ bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::MuteStream(bool mute) {
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   bool was_muted = muted_;
   muted_ = mute;
   return was_muted != mute;
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   if (capturer_ == NULL) {
     return false;
   }
@@ -1473,7 +1473,7 @@ bool WebRtcVideoChannel2::WebRtcVideoSendStream::DisconnectCapturer() {
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
     const VideoOptions& options) {
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   VideoCodecSettings codec_settings;
   if (parameters_.codec_settings.Get(&codec_settings)) {
     SetCodecAndOptions(codec_settings, options);
@@ -1483,7 +1483,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetOptions(
 }
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec(
     const VideoCodecSettings& codec_settings) {
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   SetCodecAndOptions(codec_settings, parameters_.options);
 }
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
@@ -1533,7 +1533,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpExtensions(
     const std::vector<webrtc::RtpExtension>& rtp_extensions) {
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   parameters_.config.rtp.extensions = rtp_extensions;
   RecreateWebRtcStream();
 }
@@ -1570,14 +1570,14 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(int width,
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   assert(stream_ != NULL);
   stream_->Start();
   sending_ = true;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   if (stream_ != NULL) {
     stream_->Stop();
   }
@@ -1587,7 +1587,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
 VideoSenderInfo
 WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() {
   VideoSenderInfo info;
-  talk_base::CritScope cs(&lock_);
+  rtc::CritScope cs(&lock_);
   for (size_t i = 0; i < parameters_.config.rtp.ssrcs.size(); ++i) {
     info.add_ssrc(parameters_.config.rtp.ssrcs[i]);
   }
@@ -1729,7 +1729,7 @@ void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
     const webrtc::I420VideoFrame& frame,
     int time_to_render_ms) {
-  talk_base::CritScope crit(&renderer_lock_);
+  rtc::CritScope crit(&renderer_lock_);
   if (renderer_ == NULL) {
     LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoRenderer.";
     return;
@@ -1748,7 +1748,7 @@ void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRenderer(
     cricket::VideoRenderer* renderer) {
-  talk_base::CritScope crit(&renderer_lock_);
+  rtc::CritScope crit(&renderer_lock_);
   renderer_ = renderer;
   if (renderer_ != NULL && last_width_ != -1) {
     SetSize(last_width_, last_height_);
@@ -1758,13 +1758,13 @@ void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRenderer(
 VideoRenderer* WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetRenderer() {
   // TODO(pbos): Remove GetRenderer and all uses of it, it's thread-unsafe by
   // design.
-  talk_base::CritScope crit(&renderer_lock_);
+  rtc::CritScope crit(&renderer_lock_);
   return renderer_;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSize(int width,
                                                             int height) {
-  talk_base::CritScope crit(&renderer_lock_);
+  rtc::CritScope crit(&renderer_lock_);
   if (!renderer_->SetSize(width, height, 0)) {
     LOG(LS_ERROR) << "Could not set renderer size.";
   }
@@ -1785,7 +1785,7 @@ WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo() {
   info.framerate_decoded = stats.decode_frame_rate;
   info.framerate_output = stats.render_frame_rate;
 
-  talk_base::CritScope frame_cs(&renderer_lock_);
+  rtc::CritScope frame_cs(&renderer_lock_);
   info.frame_width = last_width_;
   info.frame_height = last_height_;
 
diff --git a/talk/media/webrtc/webrtcvideoengine2.h b/talk/media/webrtc/webrtcvideoengine2.h
index 79371ab4cc..a718e9c61a 100644
--- a/talk/media/webrtc/webrtcvideoengine2.h
+++ b/talk/media/webrtc/webrtcvideoengine2.h
@@ -32,8 +32,8 @@
 #include <vector>
 #include <string>
 
-#include "talk/base/cpumonitor.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/cpumonitor.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/mediaengine.h"
 #include "talk/media/webrtc/webrtcvideochannelfactory.h"
 #include "webrtc/common_video/interface/i420_video_frame.h"
@@ -53,10 +53,10 @@ class VideoSendStreamInput;
 class VideoReceiveStream;
 }
 
-namespace talk_base {
+namespace rtc {
 class CpuMonitor;
 class Thread;
-}  // namespace talk_base
+}  // namespace rtc
 
 namespace cricket {
 
@@ -114,7 +114,7 @@ class WebRtcVideoEngine2 : public sigslot::has_slots<> {
   ~WebRtcVideoEngine2();
 
   // Basic video engine implementation.
-  bool Init(talk_base::Thread* worker_thread);
+  bool Init(rtc::Thread* worker_thread);
   void Terminate();
 
   int GetCapabilities();
@@ -151,16 +151,16 @@ class WebRtcVideoEngine2 : public sigslot::has_slots<> {
 
   VideoFormat GetStartCaptureFormat() const { return default_codec_format_; }
 
-  talk_base::CpuMonitor* cpu_monitor() { return cpu_monitor_.get(); }
+  rtc::CpuMonitor* cpu_monitor() { return cpu_monitor_.get(); }
 
   virtual WebRtcVideoEncoderFactory2* GetVideoEncoderFactory();
 
  private:
   void Construct(WebRtcVideoChannelFactory* channel_factory,
                  WebRtcVoiceEngine* voice_engine,
-                 talk_base::CpuMonitor* cpu_monitor);
+                 rtc::CpuMonitor* cpu_monitor);
 
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* worker_thread_;
   WebRtcVoiceEngine* voice_engine_;
   std::vector<VideoCodec> video_codecs_;
   std::vector<RtpHeaderExtension> rtp_header_extensions_;
@@ -172,14 +172,14 @@ class WebRtcVideoEngine2 : public sigslot::has_slots<> {
 
   // Critical section to protect the media processor register/unregister
   // while processing a frame
-  talk_base::CriticalSection signal_media_critical_;
+  rtc::CriticalSection signal_media_critical_;
 
-  talk_base::scoped_ptr<talk_base::CpuMonitor> cpu_monitor_;
+  rtc::scoped_ptr<rtc::CpuMonitor> cpu_monitor_;
   WebRtcVideoChannelFactory* channel_factory_;
   WebRtcVideoEncoderFactory2 default_video_encoder_factory_;
 };
 
-class WebRtcVideoChannel2 : public talk_base::MessageHandler,
+class WebRtcVideoChannel2 : public rtc::MessageHandler,
                             public VideoMediaChannel,
                             public webrtc::newapi::Transport {
  public:
@@ -214,11 +214,11 @@ class WebRtcVideoChannel2 : public talk_base::MessageHandler,
   virtual bool SendIntraFrame() OVERRIDE;
   virtual bool RequestIntraFrame() OVERRIDE;
 
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time)
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time)
       OVERRIDE;
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time)
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time)
       OVERRIDE;
   virtual void OnReadyToSend(bool ready) OVERRIDE;
   virtual bool MuteStream(uint32 ssrc, bool mute) OVERRIDE;
@@ -239,7 +239,7 @@ class WebRtcVideoChannel2 : public talk_base::MessageHandler,
   virtual void SetInterface(NetworkInterface* iface) OVERRIDE;
   virtual void UpdateAspectRatio(int ratio_w, int ratio_h) OVERRIDE;
 
-  virtual void OnMessage(talk_base::Message* msg) OVERRIDE;
+  virtual void OnMessage(rtc::Message* msg) OVERRIDE;
 
   // Implemented for VideoMediaChannelTest.
   bool sending() const { return sending_; }
@@ -314,7 +314,7 @@ class WebRtcVideoChannel2 : public talk_base::MessageHandler,
     webrtc::Call* const call_;
     WebRtcVideoEncoderFactory2* const encoder_factory_;
 
-    talk_base::CriticalSection lock_;
+    rtc::CriticalSection lock_;
     webrtc::VideoSendStream* stream_ GUARDED_BY(lock_);
     VideoSendStreamParameters parameters_ GUARDED_BY(lock_);
 
@@ -323,7 +323,7 @@ class WebRtcVideoChannel2 : public talk_base::MessageHandler,
     bool muted_ GUARDED_BY(lock_);
     VideoFormat format_ GUARDED_BY(lock_);
 
-    talk_base::CriticalSection frame_lock_;
+    rtc::CriticalSection frame_lock_;
     webrtc::I420VideoFrame video_frame_ GUARDED_BY(frame_lock_);
   };
 
@@ -358,7 +358,7 @@ class WebRtcVideoChannel2 : public talk_base::MessageHandler,
     webrtc::VideoReceiveStream* stream_;
     webrtc::VideoReceiveStream::Config config_;
 
-    talk_base::CriticalSection renderer_lock_;
+    rtc::CriticalSection renderer_lock_;
     cricket::VideoRenderer* renderer_ GUARDED_BY(renderer_lock_);
     int last_width_ GUARDED_BY(renderer_lock_);
     int last_height_ GUARDED_BY(renderer_lock_);
@@ -384,7 +384,7 @@ class WebRtcVideoChannel2 : public talk_base::MessageHandler,
 
   uint32_t rtcp_receiver_report_ssrc_;
   bool sending_;
-  talk_base::scoped_ptr<webrtc::Call> call_;
+  rtc::scoped_ptr<webrtc::Call> call_;
   uint32_t default_send_ssrc_;
   uint32_t default_recv_ssrc_;
   VideoRenderer* default_renderer_;
diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.cc b/talk/media/webrtc/webrtcvideoengine2_unittest.cc
index 8747dbe832..1ce41a7a4b 100644
--- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc
+++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc
@@ -28,8 +28,8 @@
 #include <map>
 #include <vector>
 
-#include "talk/base/gunit.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/testutils.h"
 #include "talk/media/base/videoengine_unittest.h"
 #include "talk/media/webrtc/webrtcvideoengine2.h"
@@ -192,7 +192,7 @@ webrtc::VideoCodec FakeCall::GetEmptyVideoCodec() {
 webrtc::VideoCodec FakeCall::GetVideoCodecVp8() {
   webrtc::VideoCodec vp8_codec = GetEmptyVideoCodec();
   vp8_codec.codecType = webrtc::kVideoCodecVP8;
-  talk_base::strcpyn(vp8_codec.plName, ARRAY_SIZE(vp8_codec.plName),
+  rtc::strcpyn(vp8_codec.plName, ARRAY_SIZE(vp8_codec.plName),
       kVp8Codec.name.c_str());
   vp8_codec.plType = kVp8Codec.id;
 
@@ -203,7 +203,7 @@ webrtc::VideoCodec FakeCall::GetVideoCodecVp9() {
   webrtc::VideoCodec vp9_codec = GetEmptyVideoCodec();
   // TODO(pbos): Add a correct codecType when webrtc has one.
   vp9_codec.codecType = webrtc::kVideoCodecVP8;
-  talk_base::strcpyn(vp9_codec.plName, ARRAY_SIZE(vp9_codec.plName),
+  rtc::strcpyn(vp9_codec.plName, ARRAY_SIZE(vp9_codec.plName),
       kVp9Codec.name.c_str());
   vp9_codec.plType = kVp9Codec.id;
 
@@ -339,7 +339,7 @@ class WebRtcVideoEngine2Test : public testing::Test {
 };
 
 TEST_F(WebRtcVideoEngine2Test, CreateChannel) {
-  talk_base::scoped_ptr<VideoMediaChannel> channel(engine_.CreateChannel(NULL));
+  rtc::scoped_ptr<VideoMediaChannel> channel(engine_.CreateChannel(NULL));
   ASSERT_TRUE(channel.get() != NULL) << "Could not create channel.";
   EXPECT_TRUE(factory_.GetFakeChannel(channel.get()) != NULL)
       << "Channel not created through factory.";
@@ -347,7 +347,7 @@ TEST_F(WebRtcVideoEngine2Test, CreateChannel) {
 
 TEST_F(WebRtcVideoEngine2Test, CreateChannelWithVoiceEngine) {
   VoiceMediaChannel* voice_channel = reinterpret_cast<VoiceMediaChannel*>(0x42);
-  talk_base::scoped_ptr<VideoMediaChannel> channel(
+  rtc::scoped_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(voice_channel));
   ASSERT_TRUE(channel.get() != NULL) << "Could not create channel.";
 
@@ -445,7 +445,7 @@ TEST_F(WebRtcVideoEngine2Test, SupportsAbsoluteSenderTimeHeaderExtension) {
 }
 
 TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
-  talk_base::scoped_ptr<VideoMediaChannel> channel(engine_.CreateChannel(NULL));
+  rtc::scoped_ptr<VideoMediaChannel> channel(engine_.CreateChannel(NULL));
 
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
 
@@ -734,7 +734,7 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
     EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
   }
 
-  talk_base::scoped_ptr<VideoMediaChannel> channel_;
+  rtc::scoped_ptr<VideoMediaChannel> channel_;
   FakeWebRtcVideoChannel2* fake_channel_;
   uint32 last_ssrc_;
 };
diff --git a/talk/media/webrtc/webrtcvideoengine_unittest.cc b/talk/media/webrtc/webrtcvideoengine_unittest.cc
index f4d45820c1..9993a9ee59 100644
--- a/talk/media/webrtc/webrtcvideoengine_unittest.cc
+++ b/talk/media/webrtc/webrtcvideoengine_unittest.cc
@@ -25,11 +25,11 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/fakecpumonitor.h"
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/fakecpumonitor.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stream.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/fakemediaprocessor.h"
 #include "talk/media/base/fakenetworkinterface.h"
@@ -99,8 +99,8 @@ class WebRtcVideoEngineTestFake : public testing::Test,
  public:
   WebRtcVideoEngineTestFake()
       : vie_(kVideoCodecs, ARRAY_SIZE(kVideoCodecs)),
-        cpu_monitor_(new talk_base::FakeCpuMonitor(
-            talk_base::Thread::Current())),
+        cpu_monitor_(new rtc::FakeCpuMonitor(
+            rtc::Thread::Current())),
         engine_(NULL,  // cricket::WebRtcVoiceEngine
                 new FakeViEWrapper(&vie_), cpu_monitor_),
         channel_(NULL),
@@ -108,7 +108,7 @@ class WebRtcVideoEngineTestFake : public testing::Test,
         last_error_(cricket::VideoMediaChannel::ERROR_NONE) {
   }
   bool SetupEngine() {
-    bool result = engine_.Init(talk_base::Thread::Current());
+    bool result = engine_.Init(rtc::Thread::Current());
     if (result) {
       channel_ = engine_.CreateChannel(voice_channel_);
       channel_->SignalMediaError.connect(this,
@@ -252,7 +252,7 @@ class WebRtcVideoEngineTestFake : public testing::Test,
     EXPECT_EQ(100, gcodec.plType);
     EXPECT_EQ(width, gcodec.width);
     EXPECT_EQ(height, gcodec.height);
-    EXPECT_EQ(talk_base::_min(start_bitrate, max_bitrate), gcodec.startBitrate);
+    EXPECT_EQ(rtc::_min(start_bitrate, max_bitrate), gcodec.startBitrate);
     EXPECT_EQ(max_bitrate, gcodec.maxBitrate);
     EXPECT_EQ(min_bitrate, gcodec.minBitrate);
     EXPECT_EQ(fps, gcodec.maxFramerate);
@@ -272,7 +272,7 @@ class WebRtcVideoEngineTestFake : public testing::Test,
   cricket::FakeWebRtcVideoEngine vie_;
   cricket::FakeWebRtcVideoDecoderFactory decoder_factory_;
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
-  talk_base::FakeCpuMonitor* cpu_monitor_;
+  rtc::FakeCpuMonitor* cpu_monitor_;
   cricket::WebRtcVideoEngine engine_;
   cricket::WebRtcVideoMediaChannel* channel_;
   cricket::WebRtcVoiceMediaChannel* voice_channel_;
@@ -307,7 +307,7 @@ class WebRtcVideoMediaChannelTest
 // Tests that our stub library "works".
 TEST_F(WebRtcVideoEngineTestFake, StartupShutdown) {
   EXPECT_FALSE(vie_.IsInited());
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   EXPECT_TRUE(vie_.IsInited());
   engine_.Terminate();
 }
@@ -315,16 +315,16 @@ TEST_F(WebRtcVideoEngineTestFake, StartupShutdown) {
 // Tests that webrtc logs are logged when they should be.
 TEST_F(WebRtcVideoEngineTest, WebRtcShouldLog) {
   const char webrtc_log[] = "WebRtcVideoEngineTest.WebRtcShouldLog";
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
-  engine_.SetLogging(talk_base::LS_INFO, "");
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
+  engine_.SetLogging(rtc::LS_INFO, "");
   std::string str;
-  talk_base::StringStream stream(str);
-  talk_base::LogMessage::AddLogToStream(&stream, talk_base::LS_INFO);
-  EXPECT_EQ(talk_base::LS_INFO, talk_base::LogMessage::GetLogToStream(&stream));
+  rtc::StringStream stream(str);
+  rtc::LogMessage::AddLogToStream(&stream, rtc::LS_INFO);
+  EXPECT_EQ(rtc::LS_INFO, rtc::LogMessage::GetLogToStream(&stream));
   webrtc::Trace::Add(webrtc::kTraceStateInfo, webrtc::kTraceUndefined, 0,
                      webrtc_log);
-  talk_base::Thread::Current()->ProcessMessages(100);
-  talk_base::LogMessage::RemoveLogToStream(&stream);
+  rtc::Thread::Current()->ProcessMessages(100);
+  rtc::LogMessage::RemoveLogToStream(&stream);
   // Access |str| after LogMessage is done with it to avoid data racing.
   EXPECT_NE(std::string::npos, str.find(webrtc_log));
 }
@@ -332,25 +332,25 @@ TEST_F(WebRtcVideoEngineTest, WebRtcShouldLog) {
 // Tests that webrtc logs are not logged when they should't be.
 TEST_F(WebRtcVideoEngineTest, WebRtcShouldNotLog) {
   const char webrtc_log[] = "WebRtcVideoEngineTest.WebRtcShouldNotLog";
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   // WebRTC should never be logged lower than LS_INFO.
-  engine_.SetLogging(talk_base::LS_WARNING, "");
+  engine_.SetLogging(rtc::LS_WARNING, "");
   std::string str;
-  talk_base::StringStream stream(str);
+  rtc::StringStream stream(str);
   // Make sure that WebRTC is not logged, even at lowest severity
-  talk_base::LogMessage::AddLogToStream(&stream, talk_base::LS_SENSITIVE);
-  EXPECT_EQ(talk_base::LS_SENSITIVE,
-            talk_base::LogMessage::GetLogToStream(&stream));
+  rtc::LogMessage::AddLogToStream(&stream, rtc::LS_SENSITIVE);
+  EXPECT_EQ(rtc::LS_SENSITIVE,
+            rtc::LogMessage::GetLogToStream(&stream));
   webrtc::Trace::Add(webrtc::kTraceStateInfo, webrtc::kTraceUndefined, 0,
                      webrtc_log);
-  talk_base::Thread::Current()->ProcessMessages(10);
+  rtc::Thread::Current()->ProcessMessages(10);
   EXPECT_EQ(std::string::npos, str.find(webrtc_log));
-  talk_base::LogMessage::RemoveLogToStream(&stream);
+  rtc::LogMessage::RemoveLogToStream(&stream);
 }
 
 // Tests that we can create and destroy a channel.
 TEST_F(WebRtcVideoEngineTestFake, CreateChannel) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel(voice_channel_);
   EXPECT_TRUE(channel_ != NULL);
   EXPECT_EQ(1, engine_.GetNumOfChannels());
@@ -362,7 +362,7 @@ TEST_F(WebRtcVideoEngineTestFake, CreateChannel) {
 // Tests that we properly handle failures in CreateChannel.
 TEST_F(WebRtcVideoEngineTestFake, CreateChannelFail) {
   vie_.set_fail_create_channel(true);
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel(voice_channel_);
   EXPECT_TRUE(channel_ == NULL);
 }
@@ -370,7 +370,7 @@ TEST_F(WebRtcVideoEngineTestFake, CreateChannelFail) {
 // Tests that we properly handle failures in AllocateExternalCaptureDevice.
 TEST_F(WebRtcVideoEngineTestFake, AllocateExternalCaptureDeviceFail) {
   vie_.set_fail_alloc_capturer(true);
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel(voice_channel_);
   EXPECT_TRUE(channel_ == NULL);
 }
@@ -767,9 +767,9 @@ TEST_F(WebRtcVideoEngineTestFake, TestReceiveRtxOneStream) {
   memset(data, 0, sizeof(data));
   data[0] = 0x80;
   data[1] = rtx_codec.id;
-  talk_base::SetBE32(&data[8], kRtxSsrcs1[0]);
-  talk_base::Buffer packet(data, kDataLength);
-  talk_base::PacketTime packet_time;
+  rtc::SetBE32(&data[8], kRtxSsrcs1[0]);
+  rtc::Buffer packet(data, kDataLength);
+  rtc::PacketTime packet_time;
   channel_->OnPacketReceived(&packet, packet_time);
   EXPECT_EQ(rtx_codec.id, vie_.GetLastRecvdPayloadType(channel_num));
 }
@@ -803,9 +803,9 @@ TEST_F(WebRtcVideoEngineTestFake, TestReceiveRtxThreeStreams) {
   memset(data, 0, sizeof(data));
   data[0] = 0x80;
   data[1] = rtx_codec.id;
-  talk_base::SetBE32(&data[8], kRtxSsrcs3[1]);
-  talk_base::Buffer packet(data, kDataLength);
-  talk_base::PacketTime packet_time;
+  rtc::SetBE32(&data[8], kRtxSsrcs3[1]);
+  rtc::Buffer packet(data, kDataLength);
+  rtc::PacketTime packet_time;
   channel_->OnPacketReceived(&packet, packet_time);
   EXPECT_NE(rtx_codec.id, vie_.GetLastRecvdPayloadType(channel_num[0]));
   EXPECT_EQ(rtx_codec.id, vie_.GetLastRecvdPayloadType(channel_num[1]));
@@ -2141,10 +2141,10 @@ TEST_F(WebRtcVideoEngineTestFake, CaptureFrameTimestampToNtpTimestamp) {
   EXPECT_TRUE(channel_->SetSendCodecs(codec_list));
   EXPECT_TRUE(channel_->SetSend(true));
 
-  int64 timestamp = time(NULL) * talk_base::kNumNanosecsPerSec;
+  int64 timestamp = time(NULL) * rtc::kNumNanosecsPerSec;
   SendI420ScreencastFrameWithTimestamp(
       kVP8Codec.width, kVP8Codec.height, timestamp);
-  EXPECT_EQ(talk_base::UnixTimestampNanosecsToNtpMillisecs(timestamp),
+  EXPECT_EQ(rtc::UnixTimestampNanosecsToNtpMillisecs(timestamp),
       vie_.GetCaptureLastTimestamp(capture_id));
 
   SendI420ScreencastFrameWithTimestamp(kVP8Codec.width, kVP8Codec.height, 0);
@@ -2219,7 +2219,7 @@ TEST_F(WebRtcVideoEngineTest, RtxCodecHasAptSet) {
 }
 
 TEST_F(WebRtcVideoEngineTest, StartupShutdown) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   engine_.Terminate();
 }
 
@@ -2234,7 +2234,7 @@ TEST_F(WebRtcVideoEngineTest, DISABLED_CheckCoInitialize) {
 #endif
 
 TEST_F(WebRtcVideoEngineTest, CreateChannel) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   cricket::VideoMediaChannel* channel = engine_.CreateChannel(NULL);
   EXPECT_TRUE(channel != NULL);
   delete channel;
@@ -2383,20 +2383,20 @@ TEST_F(WebRtcVideoMediaChannelTest, AddRemoveCapturerMultipleSources) {
 
 // This test verifies DSCP settings are properly applied on video media channel.
 TEST_F(WebRtcVideoMediaChannelTest, TestSetDscpOptions) {
-  talk_base::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
+  rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
       new cricket::FakeNetworkInterface);
   channel_->SetInterface(network_interface.get());
   cricket::VideoOptions options;
   options.dscp.Set(true);
   EXPECT_TRUE(channel_->SetOptions(options));
-  EXPECT_EQ(talk_base::DSCP_AF41, network_interface->dscp());
+  EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
   // Verify previous value is not modified if dscp option is not set.
   cricket::VideoOptions options1;
   EXPECT_TRUE(channel_->SetOptions(options1));
-  EXPECT_EQ(talk_base::DSCP_AF41, network_interface->dscp());
+  EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
   options.dscp.Set(false);
   EXPECT_TRUE(channel_->SetOptions(options));
-  EXPECT_EQ(talk_base::DSCP_DEFAULT, network_interface->dscp());
+  EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
   channel_->SetInterface(NULL);
 }
 
diff --git a/talk/media/webrtc/webrtcvideoframe.cc b/talk/media/webrtc/webrtcvideoframe.cc
index 1cc6fe9712..ff52ec6ce1 100644
--- a/talk/media/webrtc/webrtcvideoframe.cc
+++ b/talk/media/webrtc/webrtcvideoframe.cc
@@ -30,7 +30,7 @@
 #include "libyuv/convert.h"
 #include "libyuv/convert_from.h"
 #include "libyuv/planar_functions.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/media/base/videocommon.h"
 
@@ -56,7 +56,7 @@ class WebRtcVideoFrame::FrameBuffer {
   const webrtc::VideoFrame* frame() const;
 
  private:
-  talk_base::scoped_ptr<uint8[]> owned_data_;
+  rtc::scoped_ptr<uint8[]> owned_data_;
   webrtc::VideoFrame video_frame_;
 };
 
@@ -157,7 +157,7 @@ bool WebRtcVideoFrame::InitToBlack(int w, int h, size_t pixel_width,
 void WebRtcVideoFrame::Alias(
     uint8* buffer, size_t buffer_size, int w, int h, size_t pixel_width,
     size_t pixel_height, int64 elapsed_time, int64 time_stamp, int rotation) {
-  talk_base::scoped_refptr<RefCountedBuffer> video_buffer(
+  rtc::scoped_refptr<RefCountedBuffer> video_buffer(
       new RefCountedBuffer());
   video_buffer->Alias(buffer, buffer_size);
   Attach(video_buffer.get(), buffer_size, w, h, pixel_width, pixel_height,
@@ -324,7 +324,7 @@ bool WebRtcVideoFrame::Reset(
   }
 
   size_t desired_size = SizeOf(new_width, new_height);
-  talk_base::scoped_refptr<RefCountedBuffer> video_buffer(
+  rtc::scoped_refptr<RefCountedBuffer> video_buffer(
       new RefCountedBuffer(desired_size));
   // Since the libyuv::ConvertToI420 will handle the rotation, so the
   // new frame's rotation should always be 0.
@@ -368,7 +368,7 @@ void WebRtcVideoFrame::InitToEmptyBuffer(int w, int h, size_t pixel_width,
                                          size_t pixel_height,
                                          int64 elapsed_time, int64 time_stamp) {
   size_t buffer_size = VideoFrame::SizeOf(w, h);
-  talk_base::scoped_refptr<RefCountedBuffer> video_buffer(
+  rtc::scoped_refptr<RefCountedBuffer> video_buffer(
       new RefCountedBuffer(buffer_size));
   Attach(video_buffer.get(), buffer_size, w, h, pixel_width, pixel_height,
          elapsed_time, time_stamp, 0);
diff --git a/talk/media/webrtc/webrtcvideoframe.h b/talk/media/webrtc/webrtcvideoframe.h
index 4ba7ab65b5..faa14f78ff 100644
--- a/talk/media/webrtc/webrtcvideoframe.h
+++ b/talk/media/webrtc/webrtcvideoframe.h
@@ -28,9 +28,9 @@
 #ifndef TALK_MEDIA_WEBRTCVIDEOFRAME_H_
 #define TALK_MEDIA_WEBRTCVIDEOFRAME_H_
 
-#include "talk/base/buffer.h"
-#include "talk/base/refcount.h"
-#include "talk/base/scoped_ref_ptr.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/base/scoped_ref_ptr.h"
 #include "talk/media/base/videoframe.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/interface/module_common_types.h"
@@ -108,7 +108,7 @@ class WebRtcVideoFrame : public VideoFrame {
 
  private:
   class FrameBuffer;
-  typedef talk_base::RefCountedObject<FrameBuffer> RefCountedBuffer;
+  typedef rtc::RefCountedObject<FrameBuffer> RefCountedBuffer;
 
   void Attach(RefCountedBuffer* video_buffer, size_t buffer_size, int w, int h,
               size_t pixel_width, size_t pixel_height, int64 elapsed_time,
@@ -120,7 +120,7 @@ class WebRtcVideoFrame : public VideoFrame {
   void InitToEmptyBuffer(int w, int h, size_t pixel_width, size_t pixel_height,
                          int64 elapsed_time, int64 time_stamp);
 
-  talk_base::scoped_refptr<RefCountedBuffer> video_buffer_;
+  rtc::scoped_refptr<RefCountedBuffer> video_buffer_;
   bool is_black_;
   size_t pixel_width_;
   size_t pixel_height_;
diff --git a/talk/media/webrtc/webrtcvideoframe_unittest.cc b/talk/media/webrtc/webrtcvideoframe_unittest.cc
index e63c5d5e56..42b106ccc4 100644
--- a/talk/media/webrtc/webrtcvideoframe_unittest.cc
+++ b/talk/media/webrtc/webrtcvideoframe_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/flags.h"
+#include "webrtc/base/flags.h"
 #include "talk/media/base/videoframe_unittest.h"
 #include "talk/media/webrtc/webrtcvideoframe.h"
 
@@ -53,7 +53,7 @@ class WebRtcVideoFrameTest : public VideoFrameTest<cricket::WebRtcVideoFrame> {
     captured_frame.height = frame_height;
     captured_frame.data_size = (frame_width * frame_height) +
         ((frame_width + 1) / 2) * ((frame_height + 1) / 2) * 2;
-    talk_base::scoped_ptr<uint8[]> captured_frame_buffer(
+    rtc::scoped_ptr<uint8[]> captured_frame_buffer(
         new uint8[captured_frame.data_size]);
     captured_frame.data = captured_frame_buffer.get();
 
diff --git a/talk/media/webrtc/webrtcvie.h b/talk/media/webrtc/webrtcvie.h
index 9550962e5d..bb1bd80e66 100644
--- a/talk/media/webrtc/webrtcvie.h
+++ b/talk/media/webrtc/webrtcvie.h
@@ -29,7 +29,7 @@
 #ifndef TALK_MEDIA_WEBRTCVIE_H_
 #define TALK_MEDIA_WEBRTCVIE_H_
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/media/webrtc/webrtccommon.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/interface/module_common_types.h"
diff --git a/talk/media/webrtc/webrtcvoe.h b/talk/media/webrtc/webrtcvoe.h
index bc8358d9b4..1bb8504d3a 100644
--- a/talk/media/webrtc/webrtcvoe.h
+++ b/talk/media/webrtc/webrtcvoe.h
@@ -29,7 +29,7 @@
 #ifndef TALK_MEDIA_WEBRTCVOE_H_
 #define TALK_MEDIA_WEBRTCVOE_H_
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/media/webrtc/webrtccommon.h"
 
 #include "webrtc/common_types.h"
diff --git a/talk/media/webrtc/webrtcvoiceengine.cc b/talk/media/webrtc/webrtcvoiceengine.cc
index d48b9bad46..8faa46bb26 100644
--- a/talk/media/webrtc/webrtcvoiceengine.cc
+++ b/talk/media/webrtc/webrtcvoiceengine.cc
@@ -38,13 +38,13 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/base64.h"
-#include "talk/base/byteorder.h"
-#include "talk/base/common.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/base64.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/audiorenderer.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/streamparams.h"
@@ -122,7 +122,7 @@ static const int kOpusMaxBitrate = 510000;
 // Default audio dscp value.
 // See http://tools.ietf.org/html/rfc2474 for details.
 // See also http://tools.ietf.org/html/draft-jennings-rtcweb-qos-00
-static const talk_base::DiffServCodePoint kAudioDscpValue = talk_base::DSCP_EF;
+static const rtc::DiffServCodePoint kAudioDscpValue = rtc::DSCP_EF;
 
 // Ensure we open the file in a writeable path on ChromeOS and Android. This
 // workaround can be removed when it's possible to specify a filename for audio
@@ -155,7 +155,7 @@ static std::string ToString(const webrtc::CodecInst& codec) {
   return ss.str();
 }
 
-static void LogMultiline(talk_base::LoggingSeverity sev, char* text) {
+static void LogMultiline(rtc::LoggingSeverity sev, char* text) {
   const char* delim = "\r\n";
   for (char* tok = strtok(text, delim); tok; tok = strtok(NULL, delim)) {
     LOG_V(sev) << tok;
@@ -166,13 +166,13 @@ static void LogMultiline(talk_base::LoggingSeverity sev, char* text) {
 static int SeverityToFilter(int severity) {
   int filter = webrtc::kTraceNone;
   switch (severity) {
-    case talk_base::LS_VERBOSE:
+    case rtc::LS_VERBOSE:
       filter |= webrtc::kTraceAll;
-    case talk_base::LS_INFO:
+    case rtc::LS_INFO:
       filter |= (webrtc::kTraceStateInfo | webrtc::kTraceInfo);
-    case talk_base::LS_WARNING:
+    case rtc::LS_WARNING:
       filter |= (webrtc::kTraceTerseInfo | webrtc::kTraceWarning);
-    case talk_base::LS_ERROR:
+    case rtc::LS_ERROR:
       filter |= (webrtc::kTraceError | webrtc::kTraceCritical);
   }
   return filter;
@@ -328,7 +328,7 @@ class WebRtcSoundclipMedia : public SoundclipMedia {
  private:
   WebRtcVoiceEngine *engine_;
   int webrtc_channel_;
-  talk_base::scoped_ptr<WebRtcSoundclipStream> stream_;
+  rtc::scoped_ptr<WebRtcSoundclipStream> stream_;
 };
 
 WebRtcVoiceEngine::WebRtcVoiceEngine()
@@ -475,11 +475,11 @@ void WebRtcVoiceEngine::ConstructCodecs() {
           // Only add fmtp parameters that differ from the spec.
           if (kPreferredMinPTime != kOpusDefaultMinPTime) {
             codec.params[kCodecParamMinPTime] =
-                talk_base::ToString(kPreferredMinPTime);
+                rtc::ToString(kPreferredMinPTime);
           }
           if (kPreferredMaxPTime != kOpusDefaultMaxPTime) {
             codec.params[kCodecParamMaxPTime] =
-                talk_base::ToString(kPreferredMaxPTime);
+                rtc::ToString(kPreferredMaxPTime);
           }
           // TODO(hellner): Add ptime, sprop-stereo, stereo and useinbandfec
           // when they can be set to values other than the default.
@@ -518,7 +518,7 @@ WebRtcVoiceEngine::~WebRtcVoiceEngine() {
   tracing_->SetTraceCallback(NULL);
 }
 
-bool WebRtcVoiceEngine::Init(talk_base::Thread* worker_thread) {
+bool WebRtcVoiceEngine::Init(rtc::Thread* worker_thread) {
   LOG(LS_INFO) << "WebRtcVoiceEngine::Init";
   bool res = InitInternal();
   if (res) {
@@ -533,7 +533,7 @@ bool WebRtcVoiceEngine::Init(talk_base::Thread* worker_thread) {
 bool WebRtcVoiceEngine::InitInternal() {
   // Temporarily turn logging level up for the Init call
   int old_filter = log_filter_;
-  int extended_filter = log_filter_ | SeverityToFilter(talk_base::LS_INFO);
+  int extended_filter = log_filter_ | SeverityToFilter(rtc::LS_INFO);
   SetTraceFilter(extended_filter);
   SetTraceOptions("");
 
@@ -551,7 +551,7 @@ bool WebRtcVoiceEngine::InitInternal() {
   char buffer[1024] = "";
   voe_wrapper_->base()->GetVersion(buffer);
   LOG(LS_INFO) << "WebRtc VoiceEngine Version:";
-  LogMultiline(talk_base::LS_INFO, buffer);
+  LogMultiline(rtc::LS_INFO, buffer);
 
   // Save the default AGC configuration settings. This must happen before
   // calling SetOptions or the default will be overwritten.
@@ -956,9 +956,9 @@ struct ResumeEntry {
 bool WebRtcVoiceEngine::SetDevices(const Device* in_device,
                                    const Device* out_device) {
 #if !defined(IOS)
-  int in_id = in_device ? talk_base::FromString<int>(in_device->id) :
+  int in_id = in_device ? rtc::FromString<int>(in_device->id) :
       kDefaultAudioDeviceId;
-  int out_id = out_device ? talk_base::FromString<int>(out_device->id) :
+  int out_id = out_device ? rtc::FromString<int>(out_device->id) :
       kDefaultAudioDeviceId;
   // The device manager uses -1 as the default device, which was the case for
   // VoE 3.5. VoE 4.0, however, uses 0 as the default in Linux and Mac.
@@ -1251,7 +1251,7 @@ void WebRtcVoiceEngine::SetTraceFilter(int filter) {
 void WebRtcVoiceEngine::SetTraceOptions(const std::string& options) {
   // Set encrypted trace file.
   std::vector<std::string> opts;
-  talk_base::tokenize(options, ' ', '"', '"', &opts);
+  rtc::tokenize(options, ' ', '"', '"', &opts);
   std::vector<std::string>::iterator tracefile =
       std::find(opts.begin(), opts.end(), "tracefile");
   if (tracefile != opts.end() && ++tracefile != opts.end()) {
@@ -1269,7 +1269,7 @@ void WebRtcVoiceEngine::SetTraceOptions(const std::string& options) {
   std::vector<std::string>::iterator tracefilter =
       std::find(opts.begin(), opts.end(), "tracefilter");
   if (tracefilter != opts.end() && ++tracefilter != opts.end()) {
-    if (!tracing_->SetTraceFilter(talk_base::FromString<int>(*tracefilter))) {
+    if (!tracing_->SetTraceFilter(rtc::FromString<int>(*tracefilter))) {
       LOG_RTCERR1(SetTraceFilter, *tracefilter);
     }
   }
@@ -1316,15 +1316,15 @@ bool WebRtcVoiceEngine::ShouldIgnoreTrace(const std::string& trace) {
 
 void WebRtcVoiceEngine::Print(webrtc::TraceLevel level, const char* trace,
                               int length) {
-  talk_base::LoggingSeverity sev = talk_base::LS_VERBOSE;
+  rtc::LoggingSeverity sev = rtc::LS_VERBOSE;
   if (level == webrtc::kTraceError || level == webrtc::kTraceCritical)
-    sev = talk_base::LS_ERROR;
+    sev = rtc::LS_ERROR;
   else if (level == webrtc::kTraceWarning)
-    sev = talk_base::LS_WARNING;
+    sev = rtc::LS_WARNING;
   else if (level == webrtc::kTraceStateInfo || level == webrtc::kTraceInfo)
-    sev = talk_base::LS_INFO;
+    sev = rtc::LS_INFO;
   else if (level == webrtc::kTraceTerseInfo)
-    sev = talk_base::LS_INFO;
+    sev = rtc::LS_INFO;
 
   // Skip past boilerplate prefix text
   if (length < 72) {
@@ -1340,7 +1340,7 @@ void WebRtcVoiceEngine::Print(webrtc::TraceLevel level, const char* trace,
 }
 
 void WebRtcVoiceEngine::CallbackOnError(int channel_num, int err_code) {
-  talk_base::CritScope lock(&channels_cs_);
+  rtc::CritScope lock(&channels_cs_);
   WebRtcVoiceMediaChannel* channel = NULL;
   uint32 ssrc = 0;
   LOG(LS_WARNING) << "VoiceEngine error " << err_code << " reported on channel "
@@ -1400,12 +1400,12 @@ bool WebRtcVoiceEngine::FindChannelNumFromSsrc(
 }
 
 void WebRtcVoiceEngine::RegisterChannel(WebRtcVoiceMediaChannel *channel) {
-  talk_base::CritScope lock(&channels_cs_);
+  rtc::CritScope lock(&channels_cs_);
   channels_.push_back(channel);
 }
 
 void WebRtcVoiceEngine::UnregisterChannel(WebRtcVoiceMediaChannel *channel) {
-  talk_base::CritScope lock(&channels_cs_);
+  rtc::CritScope lock(&channels_cs_);
   ChannelList::iterator i = std::find(channels_.begin(),
                                       channels_.end(),
                                       channel);
@@ -1471,11 +1471,11 @@ bool WebRtcVoiceEngine::SetAudioDeviceModule(webrtc::AudioDeviceModule* adm,
   return true;
 }
 
-bool WebRtcVoiceEngine::StartAecDump(talk_base::PlatformFile file) {
-  FILE* aec_dump_file_stream = talk_base::FdopenPlatformFileForWriting(file);
+bool WebRtcVoiceEngine::StartAecDump(rtc::PlatformFile file) {
+  FILE* aec_dump_file_stream = rtc::FdopenPlatformFileForWriting(file);
   if (!aec_dump_file_stream) {
     LOG(LS_ERROR) << "Could not open AEC dump file stream.";
-    if (!talk_base::ClosePlatformFile(file))
+    if (!rtc::ClosePlatformFile(file))
       LOG(LS_WARNING) << "Could not close file.";
     return false;
   }
@@ -1507,7 +1507,7 @@ bool WebRtcVoiceEngine::RegisterProcessor(
 
   webrtc::ProcessingTypes processing_type;
   {
-    talk_base::CritScope cs(&signal_media_critical_);
+    rtc::CritScope cs(&signal_media_critical_);
     if (direction == MPD_RX) {
       processing_type = webrtc::kPlaybackAllChannelsMixed;
       if (SignalRxMediaFrame.is_empty()) {
@@ -1572,7 +1572,7 @@ bool WebRtcVoiceEngine::UnregisterProcessorChannel(
 
   int deregister_id = -1;
   {
-    talk_base::CritScope cs(&signal_media_critical_);
+    rtc::CritScope cs(&signal_media_critical_);
     if ((processor_direction & channel_direction) != 0 && !signal->is_empty()) {
       signal->disconnect(voice_processor);
       int channel_id = -1;
@@ -1628,7 +1628,7 @@ void WebRtcVoiceEngine::Process(int channel,
                                 int length,
                                 int sampling_freq,
                                 bool is_stereo) {
-    talk_base::CritScope cs(&signal_media_critical_);
+    rtc::CritScope cs(&signal_media_critical_);
     AudioFrame frame(audio10ms, length, sampling_freq, is_stereo);
     if (type == webrtc::kPlaybackAllChannelsMixed) {
       SignalRxMediaFrame(rx_processor_ssrc_, MPD_RX, &frame);
@@ -1695,7 +1695,7 @@ class WebRtcVoiceMediaChannel::WebRtcVoiceChannelRenderer
   // This method is called on the libjingle worker thread.
   // TODO(xians): Make sure Start() is called only once.
   void Start(AudioRenderer* renderer) {
-    talk_base::CritScope lock(&lock_);
+    rtc::CritScope lock(&lock_);
     ASSERT(renderer != NULL);
     if (renderer_ != NULL) {
       ASSERT(renderer_ == renderer);
@@ -1713,7 +1713,7 @@ class WebRtcVoiceMediaChannel::WebRtcVoiceChannelRenderer
   // callback will be received after this method.
   // This method is called on the libjingle worker thread.
   void Stop() {
-    talk_base::CritScope lock(&lock_);
+    rtc::CritScope lock(&lock_);
     if (renderer_ == NULL)
       return;
 
@@ -1740,7 +1740,7 @@ class WebRtcVoiceMediaChannel::WebRtcVoiceChannelRenderer
   // Callback from the |renderer_| when it is going away. In case Start() has
   // never been called, this callback won't be triggered.
   virtual void OnClose() OVERRIDE {
-    talk_base::CritScope lock(&lock_);
+    rtc::CritScope lock(&lock_);
     // Set |renderer_| to NULL to make sure no more callback will get into
     // the renderer.
     renderer_ = NULL;
@@ -1759,7 +1759,7 @@ class WebRtcVoiceMediaChannel::WebRtcVoiceChannelRenderer
   AudioRenderer* renderer_;
 
   // Protects |renderer_| in Start(), Stop() and OnClose().
-  talk_base::CriticalSection lock_;
+  rtc::CriticalSection lock_;
 };
 
 // WebRtcVoiceMediaChannel
@@ -1880,7 +1880,7 @@ bool WebRtcVoiceMediaChannel::SetOptions(const AudioOptions& options) {
     }
   }
   if (dscp_option_changed) {
-    talk_base::DiffServCodePoint dscp = talk_base::DSCP_DEFAULT;
+    rtc::DiffServCodePoint dscp = rtc::DSCP_DEFAULT;
     if (options_.dscp.GetWithDefaultIfUnset(false))
       dscp = kAudioDscpValue;
     if (MediaChannel::SetDscp(dscp) != 0) {
@@ -2595,7 +2595,7 @@ bool WebRtcVoiceMediaChannel::RemoveSendStream(uint32 ssrc) {
 }
 
 bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
-  talk_base::CritScope lock(&receive_channels_cs_);
+  rtc::CritScope lock(&receive_channels_cs_);
 
   if (!VERIFY(sp.ssrcs.size() == 1))
     return false;
@@ -2713,7 +2713,7 @@ bool WebRtcVoiceMediaChannel::ConfigureRecvChannel(int channel) {
 }
 
 bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32 ssrc) {
-  talk_base::CritScope lock(&receive_channels_cs_);
+  rtc::CritScope lock(&receive_channels_cs_);
   ChannelMap::iterator it = receive_channels_.find(ssrc);
   if (it == receive_channels_.end()) {
     LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc
@@ -2831,7 +2831,7 @@ int WebRtcVoiceMediaChannel::GetOutputLevel() {
   for (ChannelMap::iterator it = receive_channels_.begin();
        it != receive_channels_.end(); ++it) {
     int level = GetOutputLevel(it->second->channel());
-    highest = talk_base::_max(level, highest);
+    highest = rtc::_max(level, highest);
   }
   return highest;
 }
@@ -2863,7 +2863,7 @@ void WebRtcVoiceMediaChannel::SetTypingDetectionParameters(int time_window,
 
 bool WebRtcVoiceMediaChannel::SetOutputScaling(
     uint32 ssrc, double left, double right) {
-  talk_base::CritScope lock(&receive_channels_cs_);
+  rtc::CritScope lock(&receive_channels_cs_);
   // Collect the channels to scale the output volume.
   std::vector<int> channels;
   if (0 == ssrc) {  // Collect all channels, including the default one.
@@ -2886,7 +2886,7 @@ bool WebRtcVoiceMediaChannel::SetOutputScaling(
 
   // Scale the output volume for the collected channels. We first normalize to
   // scale the volume and then set the left and right pan.
-  float scale = static_cast<float>(talk_base::_max(left, right));
+  float scale = static_cast<float>(rtc::_max(left, right));
   if (scale > 0.0001f) {
     left /= scale;
     right /= scale;
@@ -2915,7 +2915,7 @@ bool WebRtcVoiceMediaChannel::GetOutputScaling(
     uint32 ssrc, double* left, double* right) {
   if (!left || !right) return false;
 
-  talk_base::CritScope lock(&receive_channels_cs_);
+  rtc::CritScope lock(&receive_channels_cs_);
   // Determine which channel based on ssrc.
   int channel = (0 == ssrc) ? voe_channel() : GetReceiveChannelNum(ssrc);
   if (channel == -1) {
@@ -3048,7 +3048,7 @@ bool WebRtcVoiceMediaChannel::InsertDtmf(uint32 ssrc, int event,
 }
 
 void WebRtcVoiceMediaChannel::OnPacketReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   // Pick which channel to send this packet to. If this packet doesn't match
   // any multiplexed streams, just send it to the default channel. Otherwise,
   // send it to the specific decoder instance for that stream.
@@ -3082,7 +3082,7 @@ void WebRtcVoiceMediaChannel::OnPacketReceived(
 }
 
 void WebRtcVoiceMediaChannel::OnRtcpReceived(
-    talk_base::Buffer* packet, const talk_base::PacketTime& packet_time) {
+    rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
   // Sending channels need all RTCP packets with feedback information.
   // Even sender reports can contain attached report blocks.
   // Receiving channels need sender reports in order to create
@@ -3388,7 +3388,7 @@ void WebRtcVoiceMediaChannel::GetLastMediaError(
 }
 
 bool WebRtcVoiceMediaChannel::FindSsrc(int channel_num, uint32* ssrc) {
-  talk_base::CritScope lock(&receive_channels_cs_);
+  rtc::CritScope lock(&receive_channels_cs_);
   ASSERT(ssrc != NULL);
   if (channel_num == -1 && send_ != SEND_NOTHING) {
     // Sometimes the VoiceEngine core will throw error with channel_num = -1.
@@ -3470,9 +3470,9 @@ bool WebRtcVoiceMediaChannel::GetRedSendCodec(const AudioCodec& red_codec,
   if (it != red_codec.params.end()) {
     red_params = it->second;
     std::vector<std::string> red_pts;
-    if (talk_base::split(red_params, '/', &red_pts) != 2 ||
+    if (rtc::split(red_params, '/', &red_pts) != 2 ||
         red_pts[0] != red_pts[1] ||
-        !talk_base::FromString(red_pts[0], &red_pt)) {
+        !rtc::FromString(red_pts[0], &red_pt)) {
       LOG(LS_WARNING) << "RED params " << red_params << " not supported.";
       return false;
     }
@@ -3549,7 +3549,7 @@ uint32 WebRtcVoiceMediaChannel::ParseSsrc(const void* data, size_t len,
   size_t ssrc_pos = (!rtcp) ? 8 : 4;
   uint32 ssrc = 0;
   if (len >= (ssrc_pos + sizeof(ssrc))) {
-    ssrc = talk_base::GetBE32(static_cast<const char*>(data) + ssrc_pos);
+    ssrc = rtc::GetBE32(static_cast<const char*>(data) + ssrc_pos);
   }
   return ssrc;
 }
diff --git a/talk/media/webrtc/webrtcvoiceengine.h b/talk/media/webrtc/webrtcvoiceengine.h
index efc388fc33..38053e9078 100644
--- a/talk/media/webrtc/webrtcvoiceengine.h
+++ b/talk/media/webrtc/webrtcvoiceengine.h
@@ -33,11 +33,11 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/buffer.h"
-#include "talk/base/byteorder.h"
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stream.h"
 #include "talk/media/base/rtputils.h"
 #include "talk/media/webrtc/webrtccommon.h"
 #include "talk/media/webrtc/webrtcexport.h"
@@ -64,7 +64,7 @@ class WebRtcSoundclipStream : public webrtc::InStream {
   virtual int Rewind();
 
  private:
-  talk_base::MemoryStream mem_;
+  rtc::MemoryStream mem_;
   bool loop_;
 };
 
@@ -97,7 +97,7 @@ class WebRtcVoiceEngine
                     VoEWrapper* voe_wrapper_sc,
                     VoETraceWrapper* tracing);
   ~WebRtcVoiceEngine();
-  bool Init(talk_base::Thread* worker_thread);
+  bool Init(rtc::Thread* worker_thread);
   void Terminate();
 
   int GetCapabilities();
@@ -173,7 +173,7 @@ class WebRtcVoiceEngine
                             webrtc::AudioDeviceModule* adm_sc);
 
   // Starts AEC dump using existing file.
-  bool StartAecDump(talk_base::PlatformFile file);
+  bool StartAecDump(rtc::PlatformFile file);
 
   // Check whether the supplied trace should be ignored.
   bool ShouldIgnoreTrace(const std::string& trace);
@@ -230,14 +230,14 @@ class WebRtcVoiceEngine
   FrameSignal SignalRxMediaFrame;
   FrameSignal SignalTxMediaFrame;
 
-  static const int kDefaultLogSeverity = talk_base::LS_WARNING;
+  static const int kDefaultLogSeverity = rtc::LS_WARNING;
 
   // The primary instance of WebRtc VoiceEngine.
-  talk_base::scoped_ptr<VoEWrapper> voe_wrapper_;
+  rtc::scoped_ptr<VoEWrapper> voe_wrapper_;
   // A secondary instance, for playing out soundclips (on the 'ring' device).
-  talk_base::scoped_ptr<VoEWrapper> voe_wrapper_sc_;
+  rtc::scoped_ptr<VoEWrapper> voe_wrapper_sc_;
   bool voe_wrapper_sc_initialized_;
-  talk_base::scoped_ptr<VoETraceWrapper> tracing_;
+  rtc::scoped_ptr<VoETraceWrapper> tracing_;
   // The external audio device manager
   webrtc::AudioDeviceModule* adm_;
   webrtc::AudioDeviceModule* adm_sc_;
@@ -247,12 +247,12 @@ class WebRtcVoiceEngine
   std::vector<AudioCodec> codecs_;
   std::vector<RtpHeaderExtension> rtp_header_extensions_;
   bool desired_local_monitor_enable_;
-  talk_base::scoped_ptr<WebRtcMonitorStream> monitor_;
+  rtc::scoped_ptr<WebRtcMonitorStream> monitor_;
   SoundclipList soundclips_;
   ChannelList channels_;
   // channels_ can be read from WebRtc callback thread. We need a lock on that
   // callback as well as the RegisterChannel/UnregisterChannel.
-  talk_base::CriticalSection channels_cs_;
+  rtc::CriticalSection channels_cs_;
   webrtc::AgcConfig default_agc_config_;
 
   webrtc::Config voe_config_;
@@ -275,7 +275,7 @@ class WebRtcVoiceEngine
   uint32 tx_processor_ssrc_;
   uint32 rx_processor_ssrc_;
 
-  talk_base::CriticalSection signal_media_critical_;
+  rtc::CriticalSection signal_media_critical_;
 };
 
 // WebRtcMediaChannel is a class that implements the common WebRtc channel
@@ -292,7 +292,7 @@ class WebRtcMediaChannel : public T, public webrtc::Transport {
  protected:
   // implements Transport interface
   virtual int SendPacket(int channel, const void *data, int len) {
-    talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+    rtc::Buffer packet(data, len, kMaxRtpPacketLen);
     if (!T::SendPacket(&packet)) {
       return -1;
     }
@@ -300,7 +300,7 @@ class WebRtcMediaChannel : public T, public webrtc::Transport {
   }
 
   virtual int SendRTCPPacket(int channel, const void *data, int len) {
-    talk_base::Buffer packet(data, len, kMaxRtpPacketLen);
+    rtc::Buffer packet(data, len, kMaxRtpPacketLen);
     return T::SendRtcp(&packet) ? len : -1;
   }
 
@@ -353,10 +353,10 @@ class WebRtcVoiceMediaChannel
   virtual bool CanInsertDtmf();
   virtual bool InsertDtmf(uint32 ssrc, int event, int duration, int flags);
 
-  virtual void OnPacketReceived(talk_base::Buffer* packet,
-                                const talk_base::PacketTime& packet_time);
-  virtual void OnRtcpReceived(talk_base::Buffer* packet,
-                              const talk_base::PacketTime& packet_time);
+  virtual void OnPacketReceived(rtc::Buffer* packet,
+                                const rtc::PacketTime& packet_time);
+  virtual void OnRtcpReceived(rtc::Buffer* packet,
+                              const rtc::PacketTime& packet_time);
   virtual void OnReadyToSend(bool ready) {}
   virtual bool MuteStream(uint32 ssrc, bool on);
   virtual bool SetStartSendBandwidth(int bps);
@@ -423,11 +423,11 @@ class WebRtcVoiceMediaChannel
     int channel_id,
     const std::vector<RtpHeaderExtension>& extensions);
 
-  talk_base::scoped_ptr<WebRtcSoundclipStream> ringback_tone_;
+  rtc::scoped_ptr<WebRtcSoundclipStream> ringback_tone_;
   std::set<int> ringback_channels_;  // channels playing ringback
   std::vector<AudioCodec> recv_codecs_;
   std::vector<AudioCodec> send_codecs_;
-  talk_base::scoped_ptr<webrtc::CodecInst> send_codec_;
+  rtc::scoped_ptr<webrtc::CodecInst> send_codec_;
   bool send_bw_setting_;
   int send_bw_bps_;
   AudioOptions options_;
@@ -456,7 +456,7 @@ class WebRtcVoiceMediaChannel
   std::vector<RtpHeaderExtension> receive_extensions_;
   // Do not lock this on the VoE media processor thread; potential for deadlock
   // exists.
-  mutable talk_base::CriticalSection receive_channels_cs_;
+  mutable rtc::CriticalSection receive_channels_cs_;
 };
 
 }  // namespace cricket
diff --git a/talk/media/webrtc/webrtcvoiceengine_unittest.cc b/talk/media/webrtc/webrtcvoiceengine_unittest.cc
index 2575b65950..3786a8a420 100644
--- a/talk/media/webrtc/webrtcvoiceengine_unittest.cc
+++ b/talk/media/webrtc/webrtcvoiceengine_unittest.cc
@@ -26,12 +26,12 @@
  */
 
 #ifdef WIN32
-#include "talk/base/win32.h"
+#include "webrtc/base/win32.h"
 #include <objbase.h>
 #endif
 
-#include "talk/base/byteorder.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakemediaprocessor.h"
@@ -140,7 +140,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     options_adjust_agc_.adjust_agc_delta.Set(-10);
   }
   bool SetupEngineWithoutStream() {
-    if (!engine_.Init(talk_base::Thread::Current())) {
+    if (!engine_.Init(rtc::Thread::Current())) {
       return false;
     }
     channel_ = engine_.CreateChannel();
@@ -166,8 +166,8 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     EXPECT_EQ(0, voe_.GetLocalSSRC(default_channel_num, default_send_ssrc));
   }
   void DeliverPacket(const void* data, int len) {
-    talk_base::Buffer packet(data, len);
-    channel_->OnPacketReceived(&packet, talk_base::PacketTime());
+    rtc::Buffer packet(data, len);
+    channel_->OnPacketReceived(&packet, rtc::PacketTime());
   }
   virtual void TearDown() {
     delete soundclip_;
@@ -176,7 +176,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
   }
 
   void TestInsertDtmf(uint32 ssrc, bool caller) {
-    EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+    EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
     channel_ = engine_.CreateChannel();
     EXPECT_TRUE(channel_ != NULL);
     if (caller) {
@@ -351,7 +351,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
 TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) {
   EXPECT_FALSE(voe_.IsInited());
   EXPECT_FALSE(voe_sc_.IsInited());
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   EXPECT_TRUE(voe_.IsInited());
   // The soundclip engine is lazily initialized.
   EXPECT_FALSE(voe_sc_.IsInited());
@@ -362,7 +362,7 @@ TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) {
 
 // Tests that we can create and destroy a channel.
 TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel();
   EXPECT_TRUE(channel_ != NULL);
 }
@@ -370,7 +370,7 @@ TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) {
 // Tests that we properly handle failures in CreateChannel.
 TEST_F(WebRtcVoiceEngineTestFake, CreateChannelFail) {
   voe_.set_fail_create_channel(true);
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel();
   EXPECT_TRUE(channel_ == NULL);
 }
@@ -439,13 +439,13 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) {
   codecs[2].id = 126;
   EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
   webrtc::CodecInst gcodec;
-  talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
+  rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
   gcodec.plfreq = 16000;
   gcodec.channels = 1;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
   EXPECT_EQ(106, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
-  talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname),
+  rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname),
       "telephone-event");
   gcodec.plfreq = 8000;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
@@ -557,13 +557,13 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) {
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst gcodec;
-  talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
+  rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
   gcodec.plfreq = 16000;
   gcodec.channels = 1;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
   EXPECT_EQ(106, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
-  talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname),
+  rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname),
       "telephone-event");
   gcodec.plfreq = 8000;
   gcodec.channels = 1;
@@ -585,7 +585,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) {
 
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst gcodec;
-  talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
+  rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
   gcodec.plfreq = 16000;
   gcodec.channels = 1;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
@@ -686,7 +686,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) {
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel();
   EXPECT_TRUE(channel_ != NULL);
   EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
@@ -1048,7 +1048,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) {
 
 // Test that we can enable NACK with opus as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel();
   EXPECT_TRUE(channel_ != NULL);
 
@@ -1434,7 +1434,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
 
 // Test that we set VAD and DTMF types correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel();
   EXPECT_TRUE(channel_ != NULL);
 
@@ -1551,7 +1551,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCaller) {
 
 // Test that we set up RED correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCallee) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel();
   EXPECT_TRUE(channel_ != NULL);
 
@@ -2127,7 +2127,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) {
 
 TEST_F(WebRtcVoiceEngineTestFake, TraceFilterViaTraceOptions) {
   EXPECT_TRUE(SetupEngine());
-  engine_.SetLogging(talk_base::LS_INFO, "");
+  engine_.SetLogging(rtc::LS_INFO, "");
   EXPECT_EQ(
       // Info:
       webrtc::kTraceStateInfo | webrtc::kTraceInfo |
@@ -2138,8 +2138,8 @@ TEST_F(WebRtcVoiceEngineTestFake, TraceFilterViaTraceOptions) {
       static_cast<int>(trace_wrapper_->filter_));
   // Now set it explicitly
   std::string filter =
-      "tracefilter " + talk_base::ToString(webrtc::kTraceDefault);
-  engine_.SetLogging(talk_base::LS_VERBOSE, filter.c_str());
+      "tracefilter " + rtc::ToString(webrtc::kTraceDefault);
+  engine_.SetLogging(rtc::LS_VERBOSE, filter.c_str());
   EXPECT_EQ(static_cast<unsigned int>(webrtc::kTraceDefault),
             trace_wrapper_->filter_);
 }
@@ -2222,7 +2222,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
 // Test that the local SSRC is the same on sending and receiving channels if the
 // receive channel is created before the send channel.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel();
   EXPECT_TRUE(channel_->SetOptions(options_conference_));
 
@@ -2263,7 +2263,7 @@ TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
   char packets[4][sizeof(kPcmuFrame)];
   for (size_t i = 0; i < ARRAY_SIZE(packets); ++i) {
     memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame));
-    talk_base::SetBE32(packets[i] + 8, static_cast<uint32>(i));
+    rtc::SetBE32(packets[i] + 8, static_cast<uint32>(i));
   }
   EXPECT_TRUE(voe_.CheckNoPacket(channel_num1));
   EXPECT_TRUE(voe_.CheckNoPacket(channel_num2));
@@ -2327,7 +2327,7 @@ TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) {
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst gcodec;
-  talk_base::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "CELT");
+  rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "CELT");
   gcodec.plfreq = 32000;
   gcodec.channels = 2;
   EXPECT_EQ(-1, voe_.GetRecPayloadType(channel_num2, gcodec));
@@ -2438,14 +2438,14 @@ TEST_F(WebRtcVoiceEngineTestFake, PlayRingbackWithMultipleStreams) {
   // Send a packet with SSRC 2; the tone should stop.
   char packet[sizeof(kPcmuFrame)];
   memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame));
-  talk_base::SetBE32(packet + 8, 2);
+  rtc::SetBE32(packet + 8, 2);
   DeliverPacket(packet, sizeof(packet));
   EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
 }
 
 // Tests creating soundclips, and make sure they come from the right engine.
 TEST_F(WebRtcVoiceEngineTestFake, CreateSoundclip) {
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   EXPECT_FALSE(voe_sc_.IsInited());
   soundclip_ = engine_.CreateSoundclip();
   EXPECT_TRUE(voe_sc_.IsInited());
@@ -2466,14 +2466,14 @@ TEST_F(WebRtcVoiceEngineTestFake, CreateSoundclip) {
 // Tests playing out a fake sound.
 TEST_F(WebRtcVoiceEngineTestFake, PlaySoundclip) {
   static const char kZeroes[16000] = {};
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   soundclip_ = engine_.CreateSoundclip();
   ASSERT_TRUE(soundclip_ != NULL);
   EXPECT_TRUE(soundclip_->PlaySound(kZeroes, sizeof(kZeroes), 0));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, MediaEngineCallbackOnError) {
-  talk_base::scoped_ptr<ChannelErrorListener> listener;
+  rtc::scoped_ptr<ChannelErrorListener> listener;
   cricket::WebRtcVoiceMediaChannel* media_channel;
   unsigned int ssrc = 0;
 
@@ -2779,7 +2779,7 @@ TEST_F(WebRtcVoiceEngineTestFake, InitDoesNotOverwriteDefaultAgcConfig) {
   set_config.digitalCompressionGaindB = 9;
   set_config.limiterEnable = true;
   EXPECT_EQ(0, voe_.SetAgcConfig(set_config));
-  EXPECT_TRUE(engine_.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
 
   webrtc::AgcConfig config = {0};
   EXPECT_EQ(0, voe_.GetAgcConfig(config));
@@ -2791,9 +2791,9 @@ TEST_F(WebRtcVoiceEngineTestFake, InitDoesNotOverwriteDefaultAgcConfig) {
 
 TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
   EXPECT_TRUE(SetupEngine());
-  talk_base::scoped_ptr<cricket::VoiceMediaChannel> channel1(
+  rtc::scoped_ptr<cricket::VoiceMediaChannel> channel1(
       engine_.CreateChannel());
-  talk_base::scoped_ptr<cricket::VoiceMediaChannel> channel2(
+  rtc::scoped_ptr<cricket::VoiceMediaChannel> channel2(
       engine_.CreateChannel());
 
   // Have to add a stream to make SetSend work.
@@ -2911,22 +2911,22 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
 // This test verifies DSCP settings are properly applied on voice media channel.
 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
   EXPECT_TRUE(SetupEngine());
-  talk_base::scoped_ptr<cricket::VoiceMediaChannel> channel(
+  rtc::scoped_ptr<cricket::VoiceMediaChannel> channel(
       engine_.CreateChannel());
-  talk_base::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
+  rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
       new cricket::FakeNetworkInterface);
   channel->SetInterface(network_interface.get());
   cricket::AudioOptions options;
   options.dscp.Set(true);
   EXPECT_TRUE(channel->SetOptions(options));
-  EXPECT_EQ(talk_base::DSCP_EF, network_interface->dscp());
+  EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
   // Verify previous value is not modified if dscp option is not set.
   cricket::AudioOptions options1;
   EXPECT_TRUE(channel->SetOptions(options1));
-  EXPECT_EQ(talk_base::DSCP_EF, network_interface->dscp());
+  EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
   options.dscp.Set(false);
   EXPECT_TRUE(channel->SetOptions(options));
-  EXPECT_EQ(talk_base::DSCP_DEFAULT, network_interface->dscp());
+  EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
 }
 
 TEST(WebRtcVoiceEngineTest, TestDefaultOptionsBeforeInit) {
@@ -2993,31 +2993,31 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOutputScaling) {
 // Tests that the library initializes and shuts down properly.
 TEST(WebRtcVoiceEngineTest, StartupShutdown) {
   cricket::WebRtcVoiceEngine engine;
-  EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   cricket::VoiceMediaChannel* channel = engine.CreateChannel();
   EXPECT_TRUE(channel != NULL);
   delete channel;
   engine.Terminate();
 
   // Reinit to catch regression where VoiceEngineObserver reference is lost
-  EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   engine.Terminate();
 }
 
 // Tests that the logging from the library is cleartext.
 TEST(WebRtcVoiceEngineTest, DISABLED_HasUnencryptedLogging) {
   cricket::WebRtcVoiceEngine engine;
-  talk_base::scoped_ptr<talk_base::MemoryStream> stream(
-      new talk_base::MemoryStream);
+  rtc::scoped_ptr<rtc::MemoryStream> stream(
+      new rtc::MemoryStream);
   size_t size = 0;
   bool cleartext = true;
-  talk_base::LogMessage::AddLogToStream(stream.get(), talk_base::LS_VERBOSE);
-  engine.SetLogging(talk_base::LS_VERBOSE, "");
-  EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
+  rtc::LogMessage::AddLogToStream(stream.get(), rtc::LS_VERBOSE);
+  engine.SetLogging(rtc::LS_VERBOSE, "");
+  EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   EXPECT_TRUE(stream->GetSize(&size));
   EXPECT_GT(size, 0U);
   engine.Terminate();
-  talk_base::LogMessage::RemoveLogToStream(stream.get());
+  rtc::LogMessage::RemoveLogToStream(stream.get());
   const char* buf = stream->GetBuffer();
   for (size_t i = 0; i < size && cleartext; ++i) {
     int ch = static_cast<int>(buf[i]);
@@ -3032,13 +3032,13 @@ TEST(WebRtcVoiceEngineTest, DISABLED_HasUnencryptedLogging) {
 // when initiating the engine.
 TEST(WebRtcVoiceEngineTest, HasNoMonitorThread) {
   cricket::WebRtcVoiceEngine engine;
-  talk_base::scoped_ptr<talk_base::MemoryStream> stream(
-      new talk_base::MemoryStream);
-  talk_base::LogMessage::AddLogToStream(stream.get(), talk_base::LS_VERBOSE);
-  engine.SetLogging(talk_base::LS_VERBOSE, "");
-  EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
+  rtc::scoped_ptr<rtc::MemoryStream> stream(
+      new rtc::MemoryStream);
+  rtc::LogMessage::AddLogToStream(stream.get(), rtc::LS_VERBOSE);
+  engine.SetLogging(rtc::LS_VERBOSE, "");
+  EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   engine.Terminate();
-  talk_base::LogMessage::RemoveLogToStream(stream.get());
+  rtc::LogMessage::RemoveLogToStream(stream.get());
 
   size_t size = 0;
   EXPECT_TRUE(stream->GetSize(&size));
@@ -3128,7 +3128,7 @@ TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) {
 // Tests that VoE supports at least 32 channels
 TEST(WebRtcVoiceEngineTest, Has32Channels) {
   cricket::WebRtcVoiceEngine engine;
-  EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
 
   cricket::VoiceMediaChannel* channels[32];
   int num_channels = 0;
@@ -3154,7 +3154,7 @@ TEST(WebRtcVoiceEngineTest, Has32Channels) {
 // Test that we set our preferred codecs properly.
 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
   cricket::WebRtcVoiceEngine engine;
-  EXPECT_TRUE(engine.Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   cricket::WebRtcVoiceMediaChannel channel(&engine);
   EXPECT_TRUE(channel.SetRecvCodecs(engine.codecs()));
 }
@@ -3168,9 +3168,9 @@ TEST(WebRtcVoiceEngineTest, CoInitialize) {
   EXPECT_EQ(S_OK, CoInitializeEx(NULL, COINIT_MULTITHREADED));
 
   // Engine should start even with COM already inited.
-  EXPECT_TRUE(engine->Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine->Init(rtc::Thread::Current()));
   engine->Terminate();
-  EXPECT_TRUE(engine->Init(talk_base::Thread::Current()));
+  EXPECT_TRUE(engine->Init(rtc::Thread::Current()));
   engine->Terminate();
 
   // Refcount after terminate should be 1 (in reality 3); test if it is nonzero.
diff --git a/talk/p2p/base/asyncstuntcpsocket.cc b/talk/p2p/base/asyncstuntcpsocket.cc
index 8bcfa3ad27..74288f8e0c 100644
--- a/talk/p2p/base/asyncstuntcpsocket.cc
+++ b/talk/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/talk/p2p/base/asyncstuntcpsocket.h b/talk/p2p/base/asyncstuntcpsocket.h
index bef8e98090..b63c0b5408 100644
--- a/talk/p2p/base/asyncstuntcpsocket.h
+++ b/talk/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/talk/p2p/base/asyncstuntcpsocket_unittest.cc b/talk/p2p/base/asyncstuntcpsocket_unittest.cc
index f3261df52d..3796c5132f 100644
--- a/talk/p2p/base/asyncstuntcpsocket_unittest.cc
+++ b/talk/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/talk/p2p/base/basicpacketsocketfactory.cc b/talk/p2p/base/basicpacketsocketfactory.cc
index 758d492899..75a7055366 100644
--- a/talk/p2p/base/basicpacketsocketfactory.cc
+++ b/talk/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/talk/p2p/base/basicpacketsocketfactory.h b/talk/p2p/base/basicpacketsocketfactory.h
index 27963c9f45..b1bae3582d 100644
--- a/talk/p2p/base/basicpacketsocketfactory.h
+++ b/talk/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/talk/p2p/base/candidate.h b/talk/p2p/base/candidate.h
index d6abdb0428..56174bdcc0 100644
--- a/talk/p2p/base/candidate.h
+++ b/talk/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/talk/p2p/base/common.h b/talk/p2p/base/common.h
index 5a38180d65..a33e9e0bff 100644
--- a/talk/p2p/base/common.h
+++ b/talk/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/talk/p2p/base/dtlstransport.h b/talk/p2p/base/dtlstransport.h
index 641f57275d..318c14af90 100644
--- a/talk/p2p/base/dtlstransport.h
+++ b/talk/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/talk/p2p/base/dtlstransportchannel.cc b/talk/p2p/base/dtlstransportchannel.cc
index 416e6e9328..85da4a9144 100644
--- a/talk/p2p/base/dtlstransportchannel.cc
+++ b/talk/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/talk/p2p/base/dtlstransportchannel.h b/talk/p2p/base/dtlstransportchannel.h
index 232d400c65..c4082d323b 100644
--- a/talk/p2p/base/dtlstransportchannel.h
+++ b/talk/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/talk/p2p/base/dtlstransportchannel_unittest.cc b/talk/p2p/base/dtlstransportchannel_unittest.cc
index 5727ac4cf7..ce4951aa8f 100644
--- a/talk/p2p/base/dtlstransportchannel_unittest.cc
+++ b/talk/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/talk/p2p/base/fakesession.h b/talk/p2p/base/fakesession.h
index f2c5b84d76..67b4cd9297 100644
--- a/talk/p2p/base/fakesession.h
+++ b/talk/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/talk/p2p/base/p2ptransport.cc b/talk/p2p/base/p2ptransport.cc
index 7f53cff494..89d2564c5f 100644
--- a/talk/p2p/base/p2ptransport.cc
+++ b/talk/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/talk/p2p/base/p2ptransport.h b/talk/p2p/base/p2ptransport.h
index f2b10f89ba..500bb9bd99 100644
--- a/talk/p2p/base/p2ptransport.h
+++ b/talk/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/talk/p2p/base/p2ptransportchannel.cc b/talk/p2p/base/p2ptransportchannel.cc
index 2e1160f0f9..8e56f158aa 100644
--- a/talk/p2p/base/p2ptransportchannel.cc
+++ b/talk/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/talk/p2p/base/p2ptransportchannel.h b/talk/p2p/base/p2ptransportchannel.h
index 09dabd5677..b1c1607043 100644
--- a/talk/p2p/base/p2ptransportchannel.h
+++ b/talk/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/talk/p2p/base/p2ptransportchannel_unittest.cc b/talk/p2p/base/p2ptransportchannel_unittest.cc
index f65f502dc0..79796cf58a 100644
--- a/talk/p2p/base/p2ptransportchannel_unittest.cc
+++ b/talk/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/talk/p2p/base/packetsocketfactory.h b/talk/p2p/base/packetsocketfactory.h
index e985b37faa..6b82682d61 100644
--- a/talk/p2p/base/packetsocketfactory.h
+++ b/talk/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/talk/p2p/base/parsing.cc b/talk/p2p/base/parsing.cc
index ebe05968f7..1d7bf3ed6d 100644
--- a/talk/p2p/base/parsing.cc
+++ b/talk/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/talk/p2p/base/parsing.h b/talk/p2p/base/parsing.h
index c82005660a..fc6862d056 100644
--- a/talk/p2p/base/parsing.h
+++ b/talk/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/talk/p2p/base/port.cc b/talk/p2p/base/port.cc
index cf0f203e2c..0d3a5cdd9f 100644
--- a/talk/p2p/base/port.cc
+++ b/talk/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/talk/p2p/base/port.h b/talk/p2p/base/port.h
index 96132645dd..0071a03b34 100644
--- a/talk/p2p/base/port.h
+++ b/talk/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/talk/p2p/base/port_unittest.cc b/talk/p2p/base/port_unittest.cc
index f4f9935ff8..e4f37a9e0d 100644
--- a/talk/p2p/base/port_unittest.cc
+++ b/talk/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/talk/p2p/base/portallocator.h b/talk/p2p/base/portallocator.h
index ade9c7a04c..6bea077700 100644
--- a/talk/p2p/base/portallocator.h
+++ b/talk/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/talk/p2p/base/portallocatorsessionproxy.cc b/talk/p2p/base/portallocatorsessionproxy.cc
index d804bdc684..f7e36686cf 100644
--- a/talk/p2p/base/portallocatorsessionproxy.cc
+++ b/talk/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/talk/p2p/base/portallocatorsessionproxy.h b/talk/p2p/base/portallocatorsessionproxy.h
index 990ea8a03a..659c7301be 100644
--- a/talk/p2p/base/portallocatorsessionproxy.h
+++ b/talk/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/talk/p2p/base/portallocatorsessionproxy_unittest.cc b/talk/p2p/base/portallocatorsessionproxy_unittest.cc
index 689fb968d5..95864d40b7 100644
--- a/talk/p2p/base/portallocatorsessionproxy_unittest.cc
+++ b/talk/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/talk/p2p/base/portinterface.h b/talk/p2p/base/portinterface.h
index 5ebf653987..a36c2b1db8 100644
--- a/talk/p2p/base/portinterface.h
+++ b/talk/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/talk/p2p/base/portproxy.cc b/talk/p2p/base/portproxy.cc
index 43bb747c96..841cd858bc 100644
--- a/talk/p2p/base/portproxy.cc
+++ b/talk/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/talk/p2p/base/portproxy.h b/talk/p2p/base/portproxy.h
index d138dc3614..da555cce6e 100644
--- a/talk/p2p/base/portproxy.h
+++ b/talk/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/talk/p2p/base/pseudotcp.cc b/talk/p2p/base/pseudotcp.cc
index 3925637a30..9a944f06fb 100644
--- a/talk/p2p/base/pseudotcp.cc
+++ b/talk/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/talk/p2p/base/pseudotcp.h b/talk/p2p/base/pseudotcp.h
index edd861b1c3..46e9d3b0f3 100644
--- a/talk/p2p/base/pseudotcp.h
+++ b/talk/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/talk/p2p/base/pseudotcp_unittest.cc b/talk/p2p/base/pseudotcp_unittest.cc
index e18159ea9e..8ca3ce1a32 100644
--- a/talk/p2p/base/pseudotcp_unittest.cc
+++ b/talk/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/talk/p2p/base/rawtransport.cc b/talk/p2p/base/rawtransport.cc
index fe4f3a2bb8..60f8879271 100644
--- a/talk/p2p/base/rawtransport.cc
+++ b/talk/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/talk/p2p/base/rawtransport.h b/talk/p2p/base/rawtransport.h
index 6bb04fe063..3a20ef56cc 100644
--- a/talk/p2p/base/rawtransport.h
+++ b/talk/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/talk/p2p/base/rawtransportchannel.cc b/talk/p2p/base/rawtransportchannel.cc
index 37478ca4b5..4df069202e 100644
--- a/talk/p2p/base/rawtransportchannel.cc
+++ b/talk/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/talk/p2p/base/rawtransportchannel.h b/talk/p2p/base/rawtransportchannel.h
index 52085c04fa..43c25e5a90 100644
--- a/talk/p2p/base/rawtransportchannel.h
+++ b/talk/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/talk/p2p/base/relayport.cc b/talk/p2p/base/relayport.cc
index 23571ea5fa..78bf65a812 100644
--- a/talk/p2p/base/relayport.cc
+++ b/talk/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/talk/p2p/base/relayport.h b/talk/p2p/base/relayport.h
index 140c80fe06..f22d045855 100644
--- a/talk/p2p/base/relayport.h
+++ b/talk/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/talk/p2p/base/relayport_unittest.cc b/talk/p2p/base/relayport_unittest.cc
index 987fd1e396..f7b7fa7e37 100644
--- a/talk/p2p/base/relayport_unittest.cc
+++ b/talk/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/talk/p2p/base/relayserver.cc b/talk/p2p/base/relayserver.cc
index 3dd8506571..b5d1ac6e0e 100644
--- a/talk/p2p/base/relayserver.cc
+++ b/talk/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/talk/p2p/base/relayserver.h b/talk/p2p/base/relayserver.h
index 922a256221..5a5b5e2b7c 100644
--- a/talk/p2p/base/relayserver.h
+++ b/talk/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/talk/p2p/base/relayserver_unittest.cc b/talk/p2p/base/relayserver_unittest.cc
index 239f644b47..43d288d8ed 100644
--- a/talk/p2p/base/relayserver_unittest.cc
+++ b/talk/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/talk/p2p/base/session.cc b/talk/p2p/base/session.cc
index 0eefe6c2e2..6c98fe16f3 100644
--- a/talk/p2p/base/session.cc
+++ b/talk/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/talk/p2p/base/session.h b/talk/p2p/base/session.h
index 4f99f163f7..2c6c252d0e 100644
--- a/talk/p2p/base/session.h
+++ b/talk/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/talk/p2p/base/session_unittest.cc b/talk/p2p/base/session_unittest.cc
index 1c08bf18dd..758c5e9b91 100644
--- a/talk/p2p/base/session_unittest.cc
+++ b/talk/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/talk/p2p/base/sessiondescription.h b/talk/p2p/base/sessiondescription.h
index d33b4c366f..8d56a96222 100644
--- a/talk/p2p/base/sessiondescription.h
+++ b/talk/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/talk/p2p/base/sessionmanager.cc b/talk/p2p/base/sessionmanager.cc
index 15b745239d..a8782c4503 100644
--- a/talk/p2p/base/sessionmanager.cc
+++ b/talk/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/talk/p2p/base/sessionmanager.h b/talk/p2p/base/sessionmanager.h
index d88e0503e3..55cf78d4e0 100644
--- a/talk/p2p/base/sessionmanager.h
+++ b/talk/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/talk/p2p/base/sessionmessages.cc b/talk/p2p/base/sessionmessages.cc
index 7a03d76506..a542dfd1b6 100644
--- a/talk/p2p/base/sessionmessages.cc
+++ b/talk/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/talk/p2p/base/sessionmessages.h b/talk/p2p/base/sessionmessages.h
index 5cd565c42d..d11c4603b4 100644
--- a/talk/p2p/base/sessionmessages.h
+++ b/talk/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/talk/p2p/base/stun.cc b/talk/p2p/base/stun.cc
index 6331ba9ebd..be96b76403 100644
--- a/talk/p2p/base/stun.cc
+++ b/talk/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/talk/p2p/base/stun.h b/talk/p2p/base/stun.h
index 6416e5156e..b22b51ed6d 100644
--- a/talk/p2p/base/stun.h
+++ b/talk/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/talk/p2p/base/stun_unittest.cc b/talk/p2p/base/stun_unittest.cc
index 71d87500e9..05a0f6cc6a 100644
--- a/talk/p2p/base/stun_unittest.cc
+++ b/talk/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/talk/p2p/base/stunport.cc b/talk/p2p/base/stunport.cc
index 9155c6d701..57c7850c82 100644
--- a/talk/p2p/base/stunport.cc
+++ b/talk/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/talk/p2p/base/stunport.h b/talk/p2p/base/stunport.h
index 367db22cfe..d5457ba168 100644
--- a/talk/p2p/base/stunport.h
+++ b/talk/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/talk/p2p/base/stunport_unittest.cc b/talk/p2p/base/stunport_unittest.cc
index 0965712f05..8d2c7cf627 100644
--- a/talk/p2p/base/stunport_unittest.cc
+++ b/talk/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/talk/p2p/base/stunrequest.cc b/talk/p2p/base/stunrequest.cc
index b3b1118c40..148718f256 100644
--- a/talk/p2p/base/stunrequest.cc
+++ b/talk/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/talk/p2p/base/stunrequest.h b/talk/p2p/base/stunrequest.h
index f2c85b3c1a..8e6fbf28b9 100644
--- a/talk/p2p/base/stunrequest.h
+++ b/talk/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/talk/p2p/base/stunrequest_unittest.cc b/talk/p2p/base/stunrequest_unittest.cc
index 508660c849..6d6ecad41b 100644
--- a/talk/p2p/base/stunrequest_unittest.cc
+++ b/talk/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/talk/p2p/base/stunserver.cc b/talk/p2p/base/stunserver.cc
index ee6c64376b..d9633f0f6c 100644
--- a/talk/p2p/base/stunserver.cc
+++ b/talk/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/talk/p2p/base/stunserver.h b/talk/p2p/base/stunserver.h
index c5d12e1d15..e5d72bc625 100644
--- a/talk/p2p/base/stunserver.h
+++ b/talk/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/talk/p2p/base/stunserver_unittest.cc b/talk/p2p/base/stunserver_unittest.cc
index a6f56a5176..1c26e22b4c 100644
--- a/talk/p2p/base/stunserver_unittest.cc
+++ b/talk/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/talk/p2p/base/tcpport.cc b/talk/p2p/base/tcpport.cc
index 069323a3cd..f6d9ae6ecd 100644
--- a/talk/p2p/base/tcpport.cc
+++ b/talk/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/talk/p2p/base/tcpport.h b/talk/p2p/base/tcpport.h
index c152ec0d38..8d1b963eab 100644
--- a/talk/p2p/base/tcpport.h
+++ b/talk/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/talk/p2p/base/testrelayserver.h b/talk/p2p/base/testrelayserver.h
index 29e9fe42e9..c6fdf73a77 100644
--- a/talk/p2p/base/testrelayserver.h
+++ b/talk/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/talk/p2p/base/teststunserver.h b/talk/p2p/base/teststunserver.h
index 67bac21c02..131ce6912a 100644
--- a/talk/p2p/base/teststunserver.h
+++ b/talk/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/talk/p2p/base/testturnserver.h b/talk/p2p/base/testturnserver.h
index 7a3c83f3fa..3b7f765f0a 100644
--- a/talk/p2p/base/testturnserver.h
+++ b/talk/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/talk/p2p/base/transport.cc b/talk/p2p/base/transport.cc
index 2996487c41..825142a130 100644
--- a/talk/p2p/base/transport.cc
+++ b/talk/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/talk/p2p/base/transport.h b/talk/p2p/base/transport.h
index 5a4b75feb3..0ce12e7c81 100644
--- a/talk/p2p/base/transport.h
+++ b/talk/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/talk/p2p/base/transport_unittest.cc b/talk/p2p/base/transport_unittest.cc
index a83d2566d4..f605bbcaf1 100644
--- a/talk/p2p/base/transport_unittest.cc
+++ b/talk/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/talk/p2p/base/transportchannel.h b/talk/p2p/base/transportchannel.h
index c548c1c8c1..b8043206cd 100644
--- a/talk/p2p/base/transportchannel.h
+++ b/talk/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/talk/p2p/base/transportchannelimpl.h b/talk/p2p/base/transportchannelimpl.h
index 25c3121886..fde980b6e8 100644
--- a/talk/p2p/base/transportchannelimpl.h
+++ b/talk/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/talk/p2p/base/transportchannelproxy.cc b/talk/p2p/base/transportchannelproxy.cc
index fdcc509d34..28d7ff415a 100644
--- a/talk/p2p/base/transportchannelproxy.cc
+++ b/talk/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/talk/p2p/base/transportchannelproxy.h b/talk/p2p/base/transportchannelproxy.h
index cb38c7bc49..2a1d21a51b 100644
--- a/talk/p2p/base/transportchannelproxy.h
+++ b/talk/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/talk/p2p/base/transportdescription.h b/talk/p2p/base/transportdescription.h
index a8233a61f3..5891ca6a35 100644
--- a/talk/p2p/base/transportdescription.h
+++ b/talk/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/talk/p2p/base/transportdescriptionfactory.cc b/talk/p2p/base/transportdescriptionfactory.cc
index c8fb0b34f8..0d6308e39f 100644
--- a/talk/p2p/base/transportdescriptionfactory.cc
+++ b/talk/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/talk/p2p/base/transportdescriptionfactory.h b/talk/p2p/base/transportdescriptionfactory.h
index 53dd238dbe..84f25ac453 100644
--- a/talk/p2p/base/transportdescriptionfactory.h
+++ b/talk/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/talk/p2p/base/transportdescriptionfactory_unittest.cc b/talk/p2p/base/transportdescriptionfactory_unittest.cc
index 8d9a73f56f..ade331d950 100644
--- a/talk/p2p/base/transportdescriptionfactory_unittest.cc
+++ b/talk/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/talk/p2p/base/transportinfo.h b/talk/p2p/base/transportinfo.h
index ad8b6a29b3..aab022cfd2 100644
--- a/talk/p2p/base/transportinfo.h
+++ b/talk/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/talk/p2p/base/turnport.cc b/talk/p2p/base/turnport.cc
index de0875aac7..7255a2b58e 100644
--- a/talk/p2p/base/turnport.cc
+++ b/talk/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/talk/p2p/base/turnport.h b/talk/p2p/base/turnport.h
index 456644ad69..d58e75df0a 100644
--- a/talk/p2p/base/turnport.h
+++ b/talk/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/talk/p2p/base/turnport_unittest.cc b/talk/p2p/base/turnport_unittest.cc
index cc6d283954..99bd598362 100644
--- a/talk/p2p/base/turnport_unittest.cc
+++ b/talk/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/talk/p2p/base/turnserver.cc b/talk/p2p/base/turnserver.cc
index 4d7f39e8f1..a6cafe0153 100644
--- a/talk/p2p/base/turnserver.cc
+++ b/talk/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/talk/p2p/base/turnserver.h b/talk/p2p/base/turnserver.h
index 2c33cdb4b7..faf41fe3d5 100644
--- a/talk/p2p/base/turnserver.h
+++ b/talk/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/talk/p2p/client/autoportallocator.h b/talk/p2p/client/autoportallocator.h
index 4ec324bc1b..c6271d0104 100644
--- a/talk/p2p/client/autoportallocator.h
+++ b/talk/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/talk/p2p/client/basicportallocator.cc b/talk/p2p/client/basicportallocator.cc
index 46fbf4994b..0a3fab16de 100644
--- a/talk/p2p/client/basicportallocator.cc
+++ b/talk/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/talk/p2p/client/basicportallocator.h b/talk/p2p/client/basicportallocator.h
index aee6135efc..ca1deab6e2 100644
--- a/talk/p2p/client/basicportallocator.h
+++ b/talk/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/talk/p2p/client/connectivitychecker.cc b/talk/p2p/client/connectivitychecker.cc
index facb01e036..dd8673a640 100644
--- a/talk/p2p/client/connectivitychecker.cc
+++ b/talk/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/talk/p2p/client/connectivitychecker.h b/talk/p2p/client/connectivitychecker.h
index 3f10c57627..b4423c4c11 100644
--- a/talk/p2p/client/connectivitychecker.h
+++ b/talk/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/talk/p2p/client/connectivitychecker_unittest.cc b/talk/p2p/client/connectivitychecker_unittest.cc
index 8d6fa9df77..d1a652545c 100644
--- a/talk/p2p/client/connectivitychecker_unittest.cc
+++ b/talk/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/talk/p2p/client/fakeportallocator.h b/talk/p2p/client/fakeportallocator.h
index 5375e50156..d54f644822 100644
--- a/talk/p2p/client/fakeportallocator.h
+++ b/talk/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/talk/p2p/client/httpportallocator.cc b/talk/p2p/client/httpportallocator.cc
index 1529770c78..31c9b5195e 100644
--- a/talk/p2p/client/httpportallocator.cc
+++ b/talk/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/talk/p2p/client/httpportallocator.h b/talk/p2p/client/httpportallocator.h
index a0ef3b722d..7ace94385a 100644
--- a/talk/p2p/client/httpportallocator.h
+++ b/talk/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/talk/p2p/client/portallocator_unittest.cc b/talk/p2p/client/portallocator_unittest.cc
index 760d16820c..bddf0c3c50 100644
--- a/talk/p2p/client/portallocator_unittest.cc
+++ b/talk/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/talk/p2p/client/sessionsendtask.h b/talk/p2p/client/sessionsendtask.h
index 6c7508a572..208386e8f4 100644
--- a/talk/p2p/client/sessionsendtask.h
+++ b/talk/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/talk/p2p/client/socketmonitor.cc b/talk/p2p/client/socketmonitor.cc
index e0c75d48c0..1924c7079f 100644
--- a/talk/p2p/client/socketmonitor.cc
+++ b/talk/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/talk/p2p/client/socketmonitor.h b/talk/p2p/client/socketmonitor.h
index f24ad663d0..dd540c8702 100644
--- a/talk/p2p/client/socketmonitor.h
+++ b/talk/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_;
 };
diff --git a/talk/session/media/audiomonitor.cc b/talk/session/media/audiomonitor.cc
index c3a2eb0cb4..dc4a42a8de 100644
--- a/talk/session/media/audiomonitor.cc
+++ b/talk/session/media/audiomonitor.cc
@@ -37,7 +37,7 @@ const uint32 MSG_MONITOR_STOP = 3;
 const uint32 MSG_MONITOR_SIGNAL = 4;
 
 AudioMonitor::AudioMonitor(VoiceChannel *voice_channel,
-                           talk_base::Thread *monitor_thread) {
+                           rtc::Thread *monitor_thread) {
   voice_channel_ = voice_channel;
   monitoring_thread_ = monitor_thread;
   monitoring_ = false;
@@ -59,12 +59,12 @@ void AudioMonitor::Stop() {
   voice_channel_->worker_thread()->Post(this, MSG_MONITOR_STOP);
 }
 
-void AudioMonitor::OnMessage(talk_base::Message *message) {
-  talk_base::CritScope cs(&crit_);
+void AudioMonitor::OnMessage(rtc::Message *message) {
+  rtc::CritScope cs(&crit_);
 
   switch (message->message_id) {
   case MSG_MONITOR_START:
-    assert(talk_base::Thread::Current() == voice_channel_->worker_thread());
+    assert(rtc::Thread::Current() == voice_channel_->worker_thread());
     if (!monitoring_) {
       monitoring_ = true;
       PollVoiceChannel();
@@ -72,7 +72,7 @@ void AudioMonitor::OnMessage(talk_base::Message *message) {
     break;
 
   case MSG_MONITOR_STOP:
-    assert(talk_base::Thread::Current() == voice_channel_->worker_thread());
+    assert(rtc::Thread::Current() == voice_channel_->worker_thread());
     if (monitoring_) {
       monitoring_ = false;
       voice_channel_->worker_thread()->Clear(this);
@@ -80,13 +80,13 @@ void AudioMonitor::OnMessage(talk_base::Message *message) {
     break;
 
   case MSG_MONITOR_POLL:
-    assert(talk_base::Thread::Current() == voice_channel_->worker_thread());
+    assert(rtc::Thread::Current() == voice_channel_->worker_thread());
     PollVoiceChannel();
     break;
 
   case MSG_MONITOR_SIGNAL:
     {
-      assert(talk_base::Thread::Current() == monitoring_thread_);
+      assert(rtc::Thread::Current() == monitoring_thread_);
       AudioInfo info = audio_info_;
       crit_.Leave();
       SignalUpdate(this, info);
@@ -97,8 +97,8 @@ void AudioMonitor::OnMessage(talk_base::Message *message) {
 }
 
 void AudioMonitor::PollVoiceChannel() {
-  talk_base::CritScope cs(&crit_);
-  assert(talk_base::Thread::Current() == voice_channel_->worker_thread());
+  rtc::CritScope cs(&crit_);
+  assert(rtc::Thread::Current() == voice_channel_->worker_thread());
 
   // Gather connection infos
   audio_info_.input_level = voice_channel_->GetInputLevel_w();
@@ -114,7 +114,7 @@ VoiceChannel *AudioMonitor::voice_channel() {
   return voice_channel_;
 }
 
-talk_base::Thread *AudioMonitor::monitor_thread() {
+rtc::Thread *AudioMonitor::monitor_thread() {
   return monitoring_thread_;
 }
 
diff --git a/talk/session/media/audiomonitor.h b/talk/session/media/audiomonitor.h
index 5aff8fd1e6..632ba07492 100644
--- a/talk/session/media/audiomonitor.h
+++ b/talk/session/media/audiomonitor.h
@@ -28,8 +28,8 @@
 #ifndef TALK_SESSION_MEDIA_AUDIOMONITOR_H_
 #define TALK_SESSION_MEDIA_AUDIOMONITOR_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/port.h"
 #include <vector>
 
@@ -44,28 +44,28 @@ struct AudioInfo {
   StreamList active_streams; // ssrcs contributing to output_level
 };
 
-class AudioMonitor : public talk_base::MessageHandler,
+class AudioMonitor : public rtc::MessageHandler,
     public sigslot::has_slots<> {
  public:
-  AudioMonitor(VoiceChannel* voice_channel, talk_base::Thread *monitor_thread);
+  AudioMonitor(VoiceChannel* voice_channel, rtc::Thread *monitor_thread);
   ~AudioMonitor();
 
   void Start(int cms);
   void Stop();
 
   VoiceChannel* voice_channel();
-  talk_base::Thread *monitor_thread();
+  rtc::Thread *monitor_thread();
 
   sigslot::signal2<AudioMonitor*, const AudioInfo&> SignalUpdate;
 
  protected:
-  void OnMessage(talk_base::Message *message);
+  void OnMessage(rtc::Message *message);
   void PollVoiceChannel();
 
   AudioInfo audio_info_;
   VoiceChannel* voice_channel_;
-  talk_base::Thread* monitoring_thread_;
-  talk_base::CriticalSection crit_;
+  rtc::Thread* monitoring_thread_;
+  rtc::CriticalSection crit_;
   uint32 rate_;
   bool monitoring_;
 };
diff --git a/talk/session/media/bundlefilter.cc b/talk/session/media/bundlefilter.cc
index d3b51c4c40..5b23f11466 100755
--- a/talk/session/media/bundlefilter.cc
+++ b/talk/session/media/bundlefilter.cc
@@ -27,7 +27,7 @@
 
 #include "talk/session/media/bundlefilter.h"
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/media/base/rtputils.h"
 
 namespace cricket {
diff --git a/talk/session/media/bundlefilter.h b/talk/session/media/bundlefilter.h
index 34bc330734..9df742ab7d 100755
--- a/talk/session/media/bundlefilter.h
+++ b/talk/session/media/bundlefilter.h
@@ -31,7 +31,7 @@
 #include <set>
 #include <vector>
 
-#include "talk/base/basictypes.h"
+#include "webrtc/base/basictypes.h"
 #include "talk/media/base/streamparams.h"
 
 namespace cricket {
diff --git a/talk/session/media/bundlefilter_unittest.cc b/talk/session/media/bundlefilter_unittest.cc
index a3e58c1ecd..4cf6cb0655 100755
--- a/talk/session/media/bundlefilter_unittest.cc
+++ b/talk/session/media/bundlefilter_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/session/media/bundlefilter.h"
 
 using cricket::StreamParams;
diff --git a/talk/session/media/call.cc b/talk/session/media/call.cc
index 91fe146e95..fc22eb4408 100644
--- a/talk/session/media/call.cc
+++ b/talk/session/media/call.cc
@@ -26,10 +26,10 @@
  */
 
 #include <string>
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
-#include "talk/base/window.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/window.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/screencastid.h"
 #include "talk/p2p/base/parsing.h"
@@ -92,7 +92,7 @@ void AudioSourceProxy::OnMediaStreamsUpdate(Call* call, Session* session,
 }
 
 Call::Call(MediaSessionClient* session_client)
-    : id_(talk_base::CreateRandomId()),
+    : id_(rtc::CreateRandomId()),
       session_client_(session_client),
       local_renderer_(NULL),
       has_video_(false),
@@ -110,7 +110,7 @@ Call::~Call() {
     RemoveSession(session);
     session_client_->session_manager()->DestroySession(session);
   }
-  talk_base::Thread::Current()->Clear(this);
+  rtc::Thread::Current()->Clear(this);
 }
 
 Session* Call::InitiateSession(const buzz::Jid& to,
@@ -226,7 +226,7 @@ void Call::SetVideoRenderer(Session* session, uint32 ssrc,
   }
 }
 
-void Call::OnMessage(talk_base::Message* message) {
+void Call::OnMessage(rtc::Message* message) {
   switch (message->message_id) {
   case MSG_CHECKAUTODESTROY:
     // If no more sessions for this call, delete it
@@ -390,7 +390,7 @@ void Call::RemoveSession(Session* session) {
   SignalRemoveSession(this, session);
 
   // The call auto destroys when the last session is removed
-  talk_base::Thread::Current()->Post(this, MSG_CHECKAUTODESTROY);
+  rtc::Thread::Current()->Post(this, MSG_CHECKAUTODESTROY);
 }
 
 VoiceChannel* Call::GetVoiceChannel(Session* session) const {
@@ -458,7 +458,7 @@ void Call::MuteVideo(bool mute) {
 
 bool Call::SendData(Session* session,
                     const SendDataParams& params,
-                    const talk_base::Buffer& payload,
+                    const rtc::Buffer& payload,
                     SendDataResult* result) {
   DataChannel* data_channel = GetDataChannel(session);
   if (!data_channel) {
@@ -617,7 +617,7 @@ VideoContentDescription* Call::CreateVideoStreamUpdate(
 void Call::SendVideoStreamUpdate(
     Session* session, VideoContentDescription* video) {
   // Takes the ownership of |video|.
-  talk_base::scoped_ptr<VideoContentDescription> description(video);
+  rtc::scoped_ptr<VideoContentDescription> description(video);
   const ContentInfo* video_info =
       GetFirstVideoContent(session->local_description());
   if (video_info == NULL) {
@@ -652,7 +652,7 @@ void Call::ContinuePlayDTMF() {
 
     // Post a message to play the next tone or at least clear the playing_dtmf_
     // bit.
-    talk_base::Thread::Current()->PostDelayed(kDTMFDelay, this, MSG_PLAYDTMF);
+    rtc::Thread::Current()->PostDelayed(kDTMFDelay, this, MSG_PLAYDTMF);
   }
 }
 
@@ -794,7 +794,7 @@ void Call::OnMediaMonitor(VideoChannel* channel, const VideoMediaInfo& info) {
 
 void Call::OnDataReceived(DataChannel* channel,
                           const ReceiveDataParams& params,
-                          const talk_base::Buffer& payload) {
+                          const rtc::Buffer& payload) {
   SignalDataReceived(this, params, payload);
 }
 
diff --git a/talk/session/media/call.h b/talk/session/media/call.h
index 063447a7f7..e61fec82c1 100644
--- a/talk/session/media/call.h
+++ b/talk/session/media/call.h
@@ -33,7 +33,7 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/messagequeue.h"
+#include "webrtc/base/messagequeue.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/screencastid.h"
 #include "talk/media/base/streamparams.h"
@@ -80,7 +80,7 @@ class AudioSourceProxy: public AudioSourceContext, public sigslot::has_slots<> {
   Call* call_;
 };
 
-class Call : public talk_base::MessageHandler, public sigslot::has_slots<> {
+class Call : public rtc::MessageHandler, public sigslot::has_slots<> {
  public:
   explicit Call(MediaSessionClient* session_client);
   ~Call();
@@ -110,7 +110,7 @@ class Call : public talk_base::MessageHandler, public sigslot::has_slots<> {
   void MuteVideo(bool mute);
   bool SendData(Session* session,
                 const SendDataParams& params,
-                const talk_base::Buffer& payload,
+                const rtc::Buffer& payload,
                 SendDataResult* result);
   void PressDTMF(int event);
   bool StartScreencast(Session* session,
@@ -187,12 +187,12 @@ class Call : public talk_base::MessageHandler, public sigslot::has_slots<> {
                    const MediaStreams&> SignalMediaStreamsUpdate;
   sigslot::signal3<Call*,
                    const ReceiveDataParams&,
-                   const talk_base::Buffer&> SignalDataReceived;
+                   const rtc::Buffer&> SignalDataReceived;
 
   AudioSourceProxy* GetAudioSourceProxy();
 
  private:
-  void OnMessage(talk_base::Message* message);
+  void OnMessage(rtc::Message* message);
   void OnSessionState(BaseSession* base_session, BaseSession::State state);
   void OnSessionError(BaseSession* base_session, Session::Error error);
   void OnSessionInfoMessage(
@@ -219,7 +219,7 @@ class Call : public talk_base::MessageHandler, public sigslot::has_slots<> {
   void OnMediaMonitor(VideoChannel* channel, const VideoMediaInfo& info);
   void OnDataReceived(DataChannel* channel,
                       const ReceiveDataParams& params,
-                      const talk_base::Buffer& payload);
+                      const rtc::Buffer& payload);
   MediaStreams* GetMediaStreams(Session* session) const;
   void UpdateRemoteMediaStreams(Session* session,
                                 const ContentInfos& updated_contents,
@@ -300,7 +300,7 @@ class Call : public talk_base::MessageHandler, public sigslot::has_slots<> {
 
   VoiceMediaInfo last_voice_media_info_;
 
-  talk_base::scoped_ptr<AudioSourceProxy> audio_source_proxy_;
+  rtc::scoped_ptr<AudioSourceProxy> audio_source_proxy_;
 
   friend class MediaSessionClient;
 };
diff --git a/talk/session/media/channel.cc b/talk/session/media/channel.cc
index d705d4d54d..67bd2da5d9 100644
--- a/talk/session/media/channel.cc
+++ b/talk/session/media/channel.cc
@@ -27,12 +27,12 @@
 
 #include "talk/session/media/channel.h"
 
-#include "talk/base/bind.h"
-#include "talk/base/buffer.h"
-#include "talk/base/byteorder.h"
-#include "talk/base/common.h"
-#include "talk/base/dscp.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/bind.h"
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/dscp.h"
+#include "webrtc/base/logging.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/rtputils.h"
 #include "talk/p2p/base/transportchannel.h"
@@ -43,7 +43,7 @@
 
 namespace cricket {
 
-using talk_base::Bind;
+using rtc::Bind;
 
 enum {
   MSG_EARLYMEDIATIMEOUT = 1,
@@ -87,21 +87,21 @@ VideoChannel::ScreenCapturerFactory* CreateScreenCapturerFactory() {
   return new NullScreenCapturerFactory();
 }
 
-struct PacketMessageData : public talk_base::MessageData {
-  talk_base::Buffer packet;
-  talk_base::DiffServCodePoint dscp;
+struct PacketMessageData : public rtc::MessageData {
+  rtc::Buffer packet;
+  rtc::DiffServCodePoint dscp;
 };
 
-struct ScreencastEventMessageData : public talk_base::MessageData {
-  ScreencastEventMessageData(uint32 s, talk_base::WindowEvent we)
+struct ScreencastEventMessageData : public rtc::MessageData {
+  ScreencastEventMessageData(uint32 s, rtc::WindowEvent we)
       : ssrc(s),
         event(we) {
   }
   uint32 ssrc;
-  talk_base::WindowEvent event;
+  rtc::WindowEvent event;
 };
 
-struct VoiceChannelErrorMessageData : public talk_base::MessageData {
+struct VoiceChannelErrorMessageData : public rtc::MessageData {
   VoiceChannelErrorMessageData(uint32 in_ssrc,
                                VoiceMediaChannel::Error in_error)
       : ssrc(in_ssrc),
@@ -111,7 +111,7 @@ struct VoiceChannelErrorMessageData : public talk_base::MessageData {
   VoiceMediaChannel::Error error;
 };
 
-struct VideoChannelErrorMessageData : public talk_base::MessageData {
+struct VideoChannelErrorMessageData : public rtc::MessageData {
   VideoChannelErrorMessageData(uint32 in_ssrc,
                                VideoMediaChannel::Error in_error)
       : ssrc(in_ssrc),
@@ -121,7 +121,7 @@ struct VideoChannelErrorMessageData : public talk_base::MessageData {
   VideoMediaChannel::Error error;
 };
 
-struct DataChannelErrorMessageData : public talk_base::MessageData {
+struct DataChannelErrorMessageData : public rtc::MessageData {
   DataChannelErrorMessageData(uint32 in_ssrc,
                               DataMediaChannel::Error in_error)
       : ssrc(in_ssrc),
@@ -144,7 +144,7 @@ static const char* PacketType(bool rtcp) {
   return (!rtcp) ? "RTP" : "RTCP";
 }
 
-static bool ValidPacket(bool rtcp, const talk_base::Buffer* packet) {
+static bool ValidPacket(bool rtcp, const rtc::Buffer* packet) {
   // Check the packet size. We could check the header too if needed.
   return (packet &&
       packet->length() >= (!rtcp ? kMinRtpPacketLen : kMinRtcpPacketLen) &&
@@ -166,7 +166,7 @@ static const MediaContentDescription* GetContentDescription(
   return static_cast<const MediaContentDescription*>(cinfo->description);
 }
 
-BaseChannel::BaseChannel(talk_base::Thread* thread,
+BaseChannel::BaseChannel(rtc::Thread* thread,
                          MediaEngineInterface* media_engine,
                          MediaChannel* media_channel, BaseSession* session,
                          const std::string& content_name, bool rtcp)
@@ -189,12 +189,12 @@ BaseChannel::BaseChannel(talk_base::Thread* thread,
       dtls_keyed_(false),
       secure_required_(false),
       rtp_abs_sendtime_extn_id_(-1) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   LOG(LS_INFO) << "Created channel for " << content_name;
 }
 
 BaseChannel::~BaseChannel() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   Deinit();
   StopConnectionMonitor();
   FlushRtcpMessages();  // Send any outstanding RTCP packets.
@@ -296,7 +296,7 @@ bool BaseChannel::SetRemoteContent(const MediaContentDescription* content,
 void BaseChannel::StartConnectionMonitor(int cms) {
   socket_monitor_.reset(new SocketMonitor(transport_channel_,
                                           worker_thread(),
-                                          talk_base::Thread::Current()));
+                                          rtc::Thread::Current()));
   socket_monitor_->SignalUpdate.connect(
       this, &BaseChannel::OnConnectionMonitorUpdate);
   socket_monitor_->Start(cms);
@@ -343,17 +343,17 @@ bool BaseChannel::IsReadyToSend() const {
          was_ever_writable();
 }
 
-bool BaseChannel::SendPacket(talk_base::Buffer* packet,
-                             talk_base::DiffServCodePoint dscp) {
+bool BaseChannel::SendPacket(rtc::Buffer* packet,
+                             rtc::DiffServCodePoint dscp) {
   return SendPacket(false, packet, dscp);
 }
 
-bool BaseChannel::SendRtcp(talk_base::Buffer* packet,
-                           talk_base::DiffServCodePoint dscp) {
+bool BaseChannel::SendRtcp(rtc::Buffer* packet,
+                           rtc::DiffServCodePoint dscp) {
   return SendPacket(true, packet, dscp);
 }
 
-int BaseChannel::SetOption(SocketType type, talk_base::Socket::Option opt,
+int BaseChannel::SetOption(SocketType type, rtc::Socket::Option opt,
                            int value) {
   TransportChannel* channel = NULL;
   switch (type) {
@@ -379,15 +379,15 @@ void BaseChannel::OnWritableState(TransportChannel* channel) {
 
 void BaseChannel::OnChannelRead(TransportChannel* channel,
                                 const char* data, size_t len,
-                                const talk_base::PacketTime& packet_time,
+                                const rtc::PacketTime& packet_time,
                                 int flags) {
   // OnChannelRead gets called from P2PSocket; now pass data to MediaEngine
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // When using RTCP multiplexing we might get RTCP packets on the RTP
   // transport. We feed RTP traffic into the demuxer to determine if it is RTCP.
   bool rtcp = PacketIsRtcp(channel, data, len);
-  talk_base::Buffer packet(data, len);
+  rtc::Buffer packet(data, len);
   HandlePacket(rtcp, &packet, packet_time);
 }
 
@@ -421,8 +421,8 @@ bool BaseChannel::PacketIsRtcp(const TransportChannel* channel,
           rtcp_mux_filter_.DemuxRtcp(data, static_cast<int>(len)));
 }
 
-bool BaseChannel::SendPacket(bool rtcp, talk_base::Buffer* packet,
-                             talk_base::DiffServCodePoint dscp) {
+bool BaseChannel::SendPacket(bool rtcp, rtc::Buffer* packet,
+                             rtc::DiffServCodePoint dscp) {
   // SendPacket gets called from MediaEngine, typically on an encoder thread.
   // If the thread is not our worker thread, we will post to our worker
   // so that the real work happens on our worker. This avoids us having to
@@ -430,7 +430,7 @@ bool BaseChannel::SendPacket(bool rtcp, talk_base::Buffer* packet,
   // SRTP and the inner workings of the transport channels.
   // The only downside is that we can't return a proper failure code if
   // needed. Since UDP is unreliable anyway, this should be a non-issue.
-  if (talk_base::Thread::Current() != worker_thread_) {
+  if (rtc::Thread::Current() != worker_thread_) {
     // Avoid a copy by transferring the ownership of the packet data.
     int message_id = (!rtcp) ? MSG_RTPPACKET : MSG_RTCPPACKET;
     PacketMessageData* data = new PacketMessageData;
@@ -460,11 +460,11 @@ bool BaseChannel::SendPacket(bool rtcp, talk_base::Buffer* packet,
 
   // Signal to the media sink before protecting the packet.
   {
-    talk_base::CritScope cs(&signal_send_packet_cs_);
+    rtc::CritScope cs(&signal_send_packet_cs_);
     SignalSendPacketPreCrypto(packet->data(), packet->length(), rtcp);
   }
 
-  talk_base::PacketOptions options(dscp);
+  rtc::PacketOptions options(dscp);
   // Protect if needed.
   if (srtp_filter_.IsActive()) {
     bool res;
@@ -534,7 +534,7 @@ bool BaseChannel::SendPacket(bool rtcp, talk_base::Buffer* packet,
 
   // Signal to the media sink after protecting the packet.
   {
-    talk_base::CritScope cs(&signal_send_packet_cs_);
+    rtc::CritScope cs(&signal_send_packet_cs_);
     SignalSendPacketPostCrypto(packet->data(), packet->length(), rtcp);
   }
 
@@ -551,7 +551,7 @@ bool BaseChannel::SendPacket(bool rtcp, talk_base::Buffer* packet,
   return true;
 }
 
-bool BaseChannel::WantsPacket(bool rtcp, talk_base::Buffer* packet) {
+bool BaseChannel::WantsPacket(bool rtcp, rtc::Buffer* packet) {
   // Protect ourselves against crazy data.
   if (!ValidPacket(rtcp, packet)) {
     LOG(LS_ERROR) << "Dropping incoming " << content_name_ << " "
@@ -564,8 +564,8 @@ bool BaseChannel::WantsPacket(bool rtcp, talk_base::Buffer* packet) {
   return bundle_filter_.DemuxPacket(packet->data(), packet->length(), rtcp);
 }
 
-void BaseChannel::HandlePacket(bool rtcp, talk_base::Buffer* packet,
-                               const talk_base::PacketTime& packet_time) {
+void BaseChannel::HandlePacket(bool rtcp, rtc::Buffer* packet,
+                               const rtc::PacketTime& packet_time) {
   if (!WantsPacket(rtcp, packet)) {
     return;
   }
@@ -577,7 +577,7 @@ void BaseChannel::HandlePacket(bool rtcp, talk_base::Buffer* packet,
 
   // Signal to the media sink before unprotecting the packet.
   {
-    talk_base::CritScope cs(&signal_recv_packet_cs_);
+    rtc::CritScope cs(&signal_recv_packet_cs_);
     SignalRecvPacketPostCrypto(packet->data(), packet->length(), rtcp);
   }
 
@@ -628,7 +628,7 @@ void BaseChannel::HandlePacket(bool rtcp, talk_base::Buffer* packet,
 
   // Signal to the media sink after unprotecting the packet.
   {
-    talk_base::CritScope cs(&signal_recv_packet_cs_);
+    rtc::CritScope cs(&signal_recv_packet_cs_);
     SignalRecvPacketPreCrypto(packet->data(), packet->length(), rtcp);
   }
 
@@ -669,7 +669,7 @@ void BaseChannel::OnNewRemoteDescription(
 }
 
 void BaseChannel::EnableMedia_w() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (enabled_)
     return;
 
@@ -679,7 +679,7 @@ void BaseChannel::EnableMedia_w() {
 }
 
 void BaseChannel::DisableMedia_w() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (!enabled_)
     return;
 
@@ -689,7 +689,7 @@ void BaseChannel::DisableMedia_w() {
 }
 
 bool BaseChannel::MuteStream_w(uint32 ssrc, bool mute) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   bool ret = media_channel()->MuteStream(ssrc, mute);
   if (ret) {
     if (mute)
@@ -701,12 +701,12 @@ bool BaseChannel::MuteStream_w(uint32 ssrc, bool mute) {
 }
 
 bool BaseChannel::IsStreamMuted_w(uint32 ssrc) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   return muted_streams_.find(ssrc) != muted_streams_.end();
 }
 
 void BaseChannel::ChannelWritable_w() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (writable_)
     return;
 
@@ -832,13 +832,13 @@ bool BaseChannel::SetupDtlsSrtp(bool rtcp_channel) {
     &dtls_buffer[offset], SRTP_MASTER_KEY_SALT_LEN);
 
   std::vector<unsigned char> *send_key, *recv_key;
-  talk_base::SSLRole role;
+  rtc::SSLRole role;
   if (!channel->GetSslRole(&role)) {
     LOG(LS_WARNING) << "GetSslRole failed";
     return false;
   }
 
-  if (role == talk_base::SSL_SERVER) {
+  if (role == rtc::SSL_SERVER) {
     send_key = &server_write_key;
     recv_key = &client_write_key;
   } else {
@@ -873,7 +873,7 @@ bool BaseChannel::SetupDtlsSrtp(bool rtcp_channel) {
 }
 
 void BaseChannel::ChannelNotWritable_w() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   if (!writable_)
     return;
 
@@ -1022,7 +1022,7 @@ bool BaseChannel::SetRtcpMux_w(bool enable, ContentAction action,
 }
 
 bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
   if (!media_channel()->AddRecvStream(sp))
     return false;
 
@@ -1030,7 +1030,7 @@ bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
 }
 
 bool BaseChannel::RemoveRecvStream_w(uint32 ssrc) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
   bundle_filter_.RemoveStream(ssrc);
   return media_channel()->RemoveRecvStream(ssrc);
 }
@@ -1236,7 +1236,7 @@ void BaseChannel::MaybeCacheRtpAbsSendTimeHeaderExtension(
       send_time_extension ? send_time_extension->id : -1;
 }
 
-void BaseChannel::OnMessage(talk_base::Message *pmsg) {
+void BaseChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_RTPPACKET:
     case MSG_RTCPPACKET: {
@@ -1255,16 +1255,16 @@ void BaseChannel::OnMessage(talk_base::Message *pmsg) {
 void BaseChannel::FlushRtcpMessages() {
   // Flush all remaining RTCP messages. This should only be called in
   // destructor.
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
-  talk_base::MessageList rtcp_messages;
+  ASSERT(rtc::Thread::Current() == worker_thread_);
+  rtc::MessageList rtcp_messages;
   worker_thread_->Clear(this, MSG_RTCPPACKET, &rtcp_messages);
-  for (talk_base::MessageList::iterator it = rtcp_messages.begin();
+  for (rtc::MessageList::iterator it = rtcp_messages.begin();
        it != rtcp_messages.end(); ++it) {
     worker_thread_->Send(this, MSG_RTCPPACKET, it->pdata);
   }
 }
 
-VoiceChannel::VoiceChannel(talk_base::Thread* thread,
+VoiceChannel::VoiceChannel(rtc::Thread* thread,
                            MediaEngineInterface* media_engine,
                            VoiceMediaChannel* media_channel,
                            BaseSession* session,
@@ -1365,7 +1365,7 @@ bool VoiceChannel::GetStats(VoiceMediaInfo* stats) {
 
 void VoiceChannel::StartMediaMonitor(int cms) {
   media_monitor_.reset(new VoiceMediaMonitor(media_channel(), worker_thread(),
-      talk_base::Thread::Current()));
+      rtc::Thread::Current()));
   media_monitor_->SignalUpdate.connect(
       this, &VoiceChannel::OnMediaMonitorUpdate);
   media_monitor_->Start(cms);
@@ -1380,7 +1380,7 @@ void VoiceChannel::StopMediaMonitor() {
 }
 
 void VoiceChannel::StartAudioMonitor(int cms) {
-  audio_monitor_.reset(new AudioMonitor(this, talk_base::Thread::Current()));
+  audio_monitor_.reset(new AudioMonitor(this, rtc::Thread::Current()));
   audio_monitor_
     ->SignalUpdate.connect(this, &VoiceChannel::OnAudioMonitorUpdate);
   audio_monitor_->Start(cms);
@@ -1431,7 +1431,7 @@ void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) {
 
 void VoiceChannel::OnChannelRead(TransportChannel* channel,
                                  const char* data, size_t len,
-                                 const talk_base::PacketTime& packet_time,
+                                 const rtc::PacketTime& packet_time,
                                 int flags) {
   BaseChannel::OnChannelRead(channel, data, len, packet_time, flags);
 
@@ -1470,7 +1470,7 @@ const ContentInfo* VoiceChannel::GetFirstContent(
 bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
                                      ContentAction action,
                                      std::string* error_desc) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting local voice description";
 
   const AudioContentDescription* audio =
@@ -1508,7 +1508,7 @@ bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
 bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content,
                                       ContentAction action,
                                       std::string* error_desc) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting remote voice description";
 
   const AudioContentDescription* audio =
@@ -1559,12 +1559,12 @@ bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content,
 }
 
 bool VoiceChannel::SetRingbackTone_w(const void* buf, int len) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
   return media_channel()->SetRingbackTone(static_cast<const char*>(buf), len);
 }
 
 bool VoiceChannel::PlayRingbackTone_w(uint32 ssrc, bool play, bool loop) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
   if (play) {
     LOG(LS_INFO) << "Playing ringback tone, loop=" << loop;
   } else {
@@ -1595,7 +1595,7 @@ bool VoiceChannel::SetChannelOptions(const AudioOptions& options) {
                              media_channel(), options));
 }
 
-void VoiceChannel::OnMessage(talk_base::Message *pmsg) {
+void VoiceChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_EARLYMEDIATIMEOUT:
       HandleEarlyMediaTimeout();
@@ -1663,7 +1663,7 @@ void VoiceChannel::GetSrtpCiphers(std::vector<std::string>* ciphers) const {
   GetSupportedAudioCryptoSuites(ciphers);
 }
 
-VideoChannel::VideoChannel(talk_base::Thread* thread,
+VideoChannel::VideoChannel(rtc::Thread* thread,
                            MediaEngineInterface* media_engine,
                            VideoMediaChannel* media_channel,
                            BaseSession* session,
@@ -1675,7 +1675,7 @@ VideoChannel::VideoChannel(talk_base::Thread* thread,
       voice_channel_(voice_channel),
       renderer_(NULL),
       screencapture_factory_(CreateScreenCapturerFactory()),
-      previous_we_(talk_base::WE_CLOSE) {
+      previous_we_(rtc::WE_CLOSE) {
 }
 
 bool VideoChannel::Init() {
@@ -1809,7 +1809,7 @@ bool VideoChannel::GetStats(
 
 void VideoChannel::StartMediaMonitor(int cms) {
   media_monitor_.reset(new VideoMediaMonitor(media_channel(), worker_thread(),
-      talk_base::Thread::Current()));
+      rtc::Thread::Current()));
   media_monitor_->SignalUpdate.connect(
       this, &VideoChannel::OnMediaMonitorUpdate);
   media_monitor_->Start(cms);
@@ -1830,7 +1830,7 @@ const ContentInfo* VideoChannel::GetFirstContent(
 bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
                                      ContentAction action,
                                      std::string* error_desc) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting local video description";
 
   const VideoContentDescription* video =
@@ -1877,7 +1877,7 @@ bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
 bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content,
                                       ContentAction action,
                                       std::string* error_desc) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting remote video description";
 
   const VideoContentDescription* video =
@@ -2013,8 +2013,8 @@ void VideoChannel::SetScreenCaptureFactory_w(
 }
 
 void VideoChannel::OnScreencastWindowEvent_s(uint32 ssrc,
-                                             talk_base::WindowEvent we) {
-  ASSERT(signaling_thread() == talk_base::Thread::Current());
+                                             rtc::WindowEvent we) {
+  ASSERT(signaling_thread() == rtc::Thread::Current());
   SignalScreencastWindowEvent(ssrc, we);
 }
 
@@ -2023,7 +2023,7 @@ bool VideoChannel::SetChannelOptions(const VideoOptions &options) {
                              media_channel(), options));
 }
 
-void VideoChannel::OnMessage(talk_base::Message *pmsg) {
+void VideoChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_SCREENCASTWINDOWEVENT: {
       const ScreencastEventMessageData* data =
@@ -2059,7 +2059,7 @@ void VideoChannel::OnMediaMonitorUpdate(
 }
 
 void VideoChannel::OnScreencastWindowEvent(uint32 ssrc,
-                                           talk_base::WindowEvent event) {
+                                           rtc::WindowEvent event) {
   ScreencastEventMessageData* pdata =
       new ScreencastEventMessageData(ssrc, event);
   signaling_thread()->Post(this, MSG_SCREENCASTWINDOWEVENT, pdata);
@@ -2068,13 +2068,13 @@ void VideoChannel::OnScreencastWindowEvent(uint32 ssrc,
 void VideoChannel::OnStateChange(VideoCapturer* capturer, CaptureState ev) {
   // Map capturer events to window events. In the future we may want to simply
   // pass these events up directly.
-  talk_base::WindowEvent we;
+  rtc::WindowEvent we;
   if (ev == CS_STOPPED) {
-    we = talk_base::WE_CLOSE;
+    we = rtc::WE_CLOSE;
   } else if (ev == CS_PAUSED) {
-    we = talk_base::WE_MINIMIZE;
-  } else if (ev == CS_RUNNING && previous_we_ == talk_base::WE_MINIMIZE) {
-    we = talk_base::WE_RESTORE;
+    we = rtc::WE_MINIMIZE;
+  } else if (ev == CS_RUNNING && previous_we_ == rtc::WE_MINIMIZE) {
+    we = rtc::WE_RESTORE;
   } else {
     return;
   }
@@ -2137,7 +2137,7 @@ void VideoChannel::GetSrtpCiphers(std::vector<std::string>* ciphers) const {
   GetSupportedVideoCryptoSuites(ciphers);
 }
 
-DataChannel::DataChannel(talk_base::Thread* thread,
+DataChannel::DataChannel(rtc::Thread* thread,
                          DataMediaChannel* media_channel,
                          BaseSession* session,
                          const std::string& content_name,
@@ -2178,7 +2178,7 @@ bool DataChannel::Init() {
 }
 
 bool DataChannel::SendData(const SendDataParams& params,
-                           const talk_base::Buffer& payload,
+                           const rtc::Buffer& payload,
                            SendDataResult* result) {
   return InvokeOnWorker(Bind(&DataMediaChannel::SendData,
                              media_channel(), params, payload, result));
@@ -2189,7 +2189,7 @@ const ContentInfo* DataChannel::GetFirstContent(
   return GetFirstDataContent(sdesc);
 }
 
-bool DataChannel::WantsPacket(bool rtcp, talk_base::Buffer* packet) {
+bool DataChannel::WantsPacket(bool rtcp, rtc::Buffer* packet) {
   if (data_channel_type_ == DCT_SCTP) {
     // TODO(pthatcher): Do this in a more robust way by checking for
     // SCTP or DTLS.
@@ -2234,7 +2234,7 @@ bool DataChannel::SetDataChannelTypeFromContent(
 bool DataChannel::SetLocalContent_w(const MediaContentDescription* content,
                                     ContentAction action,
                                     std::string* error_desc) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
   LOG(LS_INFO) << "Setting local data description";
 
   const DataContentDescription* data =
@@ -2288,7 +2288,7 @@ bool DataChannel::SetLocalContent_w(const MediaContentDescription* content,
 bool DataChannel::SetRemoteContent_w(const MediaContentDescription* content,
                                      ContentAction action,
                                      std::string* error_desc) {
-  ASSERT(worker_thread() == talk_base::Thread::Current());
+  ASSERT(worker_thread() == rtc::Thread::Current());
 
   const DataContentDescription* data =
       static_cast<const DataContentDescription*>(content);
@@ -2377,7 +2377,7 @@ void DataChannel::ChangeState() {
   LOG(LS_INFO) << "Changing data state, recv=" << recv << " send=" << send;
 }
 
-void DataChannel::OnMessage(talk_base::Message *pmsg) {
+void DataChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_READYTOSENDDATA: {
       DataChannelReadyToSendMessageData* data =
@@ -2402,8 +2402,8 @@ void DataChannel::OnMessage(talk_base::Message *pmsg) {
       break;
     }
     case MSG_STREAMCLOSEDREMOTELY: {
-      talk_base::TypedMessageData<uint32>* data =
-          static_cast<talk_base::TypedMessageData<uint32>*>(pmsg->pdata);
+      rtc::TypedMessageData<uint32>* data =
+          static_cast<rtc::TypedMessageData<uint32>*>(pmsg->pdata);
       SignalStreamClosedRemotely(data->data());
       delete data;
       break;
@@ -2421,7 +2421,7 @@ void DataChannel::OnConnectionMonitorUpdate(
 
 void DataChannel::StartMediaMonitor(int cms) {
   media_monitor_.reset(new DataMediaMonitor(media_channel(), worker_thread(),
-      talk_base::Thread::Current()));
+      rtc::Thread::Current()));
   media_monitor_->SignalUpdate.connect(
       this, &DataChannel::OnMediaMonitorUpdate);
   media_monitor_->Start(cms);
@@ -2495,8 +2495,8 @@ bool DataChannel::ShouldSetupDtlsSrtp() const {
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32 sid) {
-  talk_base::TypedMessageData<uint32>* message =
-      new talk_base::TypedMessageData<uint32>(sid);
+  rtc::TypedMessageData<uint32>* message =
+      new rtc::TypedMessageData<uint32>(sid);
   signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message);
 }
 
diff --git a/talk/session/media/channel.h b/talk/session/media/channel.h
index 340caa7a66..2480f451e8 100644
--- a/talk/session/media/channel.h
+++ b/talk/session/media/channel.h
@@ -31,11 +31,11 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/asyncudpsocket.h"
-#include "talk/base/criticalsection.h"
-#include "talk/base/network.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/window.h"
+#include "webrtc/base/asyncudpsocket.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/network.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/window.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/mediaengine.h"
 #include "talk/media/base/screencastid.h"
@@ -73,10 +73,10 @@ enum SinkType {
 // NetworkInterface.
 
 class BaseChannel
-    : public talk_base::MessageHandler, public sigslot::has_slots<>,
+    : public rtc::MessageHandler, public sigslot::has_slots<>,
       public MediaChannel::NetworkInterface {
  public:
-  BaseChannel(talk_base::Thread* thread, MediaEngineInterface* media_engine,
+  BaseChannel(rtc::Thread* thread, MediaEngineInterface* media_engine,
               MediaChannel* channel, BaseSession* session,
               const std::string& content_name, bool rtcp);
   virtual ~BaseChannel();
@@ -86,7 +86,7 @@ class BaseChannel
   // done.
   void Deinit();
 
-  talk_base::Thread* worker_thread() const { return worker_thread_; }
+  rtc::Thread* worker_thread() const { return worker_thread_; }
   BaseSession* session() const { return session_; }
   const std::string& content_name() { return content_name_; }
   TransportChannel* transport_channel() const {
@@ -151,7 +151,7 @@ class BaseChannel
   void RegisterSendSink(T* sink,
                         void (T::*OnPacket)(const void*, size_t, bool),
                         SinkType type) {
-    talk_base::CritScope cs(&signal_send_packet_cs_);
+    rtc::CritScope cs(&signal_send_packet_cs_);
     if (SINK_POST_CRYPTO == type) {
       SignalSendPacketPostCrypto.disconnect(sink);
       SignalSendPacketPostCrypto.connect(sink, OnPacket);
@@ -163,7 +163,7 @@ class BaseChannel
 
   void UnregisterSendSink(sigslot::has_slots<>* sink,
                           SinkType type) {
-    talk_base::CritScope cs(&signal_send_packet_cs_);
+    rtc::CritScope cs(&signal_send_packet_cs_);
     if (SINK_POST_CRYPTO == type) {
       SignalSendPacketPostCrypto.disconnect(sink);
     } else {
@@ -172,7 +172,7 @@ class BaseChannel
   }
 
   bool HasSendSinks(SinkType type) {
-    talk_base::CritScope cs(&signal_send_packet_cs_);
+    rtc::CritScope cs(&signal_send_packet_cs_);
     if (SINK_POST_CRYPTO == type) {
       return !SignalSendPacketPostCrypto.is_empty();
     } else {
@@ -184,7 +184,7 @@ class BaseChannel
   void RegisterRecvSink(T* sink,
                         void (T::*OnPacket)(const void*, size_t, bool),
                         SinkType type) {
-    talk_base::CritScope cs(&signal_recv_packet_cs_);
+    rtc::CritScope cs(&signal_recv_packet_cs_);
     if (SINK_POST_CRYPTO == type) {
       SignalRecvPacketPostCrypto.disconnect(sink);
       SignalRecvPacketPostCrypto.connect(sink, OnPacket);
@@ -196,7 +196,7 @@ class BaseChannel
 
   void UnregisterRecvSink(sigslot::has_slots<>* sink,
                           SinkType type) {
-    talk_base::CritScope cs(&signal_recv_packet_cs_);
+    rtc::CritScope cs(&signal_recv_packet_cs_);
     if (SINK_POST_CRYPTO == type) {
       SignalRecvPacketPostCrypto.disconnect(sink);
     } else {
@@ -205,7 +205,7 @@ class BaseChannel
   }
 
   bool HasRecvSinks(SinkType type) {
-    talk_base::CritScope cs(&signal_recv_packet_cs_);
+    rtc::CritScope cs(&signal_recv_packet_cs_);
     if (SINK_POST_CRYPTO == type) {
       return !SignalRecvPacketPostCrypto.is_empty();
     } else {
@@ -244,35 +244,35 @@ class BaseChannel
   }
   bool IsReadyToReceive() const;
   bool IsReadyToSend() const;
-  talk_base::Thread* signaling_thread() { return session_->signaling_thread(); }
+  rtc::Thread* signaling_thread() { return session_->signaling_thread(); }
   SrtpFilter* srtp_filter() { return &srtp_filter_; }
   bool rtcp() const { return rtcp_; }
 
   void FlushRtcpMessages();
 
   // NetworkInterface implementation, called by MediaEngine
-  virtual bool SendPacket(talk_base::Buffer* packet,
-                          talk_base::DiffServCodePoint dscp);
-  virtual bool SendRtcp(talk_base::Buffer* packet,
-                        talk_base::DiffServCodePoint dscp);
-  virtual int SetOption(SocketType type, talk_base::Socket::Option o, int val);
+  virtual bool SendPacket(rtc::Buffer* packet,
+                          rtc::DiffServCodePoint dscp);
+  virtual bool SendRtcp(rtc::Buffer* packet,
+                        rtc::DiffServCodePoint dscp);
+  virtual int SetOption(SocketType type, rtc::Socket::Option o, int val);
 
   // From TransportChannel
   void OnWritableState(TransportChannel* channel);
   virtual void OnChannelRead(TransportChannel* channel,
                              const char* data,
                              size_t len,
-                             const talk_base::PacketTime& packet_time,
+                             const rtc::PacketTime& packet_time,
                              int flags);
   void OnReadyToSend(TransportChannel* channel);
 
   bool PacketIsRtcp(const TransportChannel* channel, const char* data,
                     size_t len);
-  bool SendPacket(bool rtcp, talk_base::Buffer* packet,
-                  talk_base::DiffServCodePoint dscp);
-  virtual bool WantsPacket(bool rtcp, talk_base::Buffer* packet);
-  void HandlePacket(bool rtcp, talk_base::Buffer* packet,
-                    const talk_base::PacketTime& packet_time);
+  bool SendPacket(bool rtcp, rtc::Buffer* packet,
+                  rtc::DiffServCodePoint dscp);
+  virtual bool WantsPacket(bool rtcp, rtc::Buffer* packet);
+  void HandlePacket(bool rtcp, rtc::Buffer* packet,
+                    const rtc::PacketTime& packet_time);
 
   // Apply the new local/remote session description.
   void OnNewLocalDescription(BaseSession* session, ContentAction action);
@@ -344,7 +344,7 @@ class BaseChannel
                     std::string* error_desc);
 
   // From MessageHandler
-  virtual void OnMessage(talk_base::Message* pmsg);
+  virtual void OnMessage(rtc::Message* pmsg);
 
   // Handled in derived classes
   // Get the SRTP ciphers to use for RTP media
@@ -363,10 +363,10 @@ class BaseChannel
   sigslot::signal3<const void*, size_t, bool> SignalSendPacketPostCrypto;
   sigslot::signal3<const void*, size_t, bool> SignalRecvPacketPreCrypto;
   sigslot::signal3<const void*, size_t, bool> SignalRecvPacketPostCrypto;
-  talk_base::CriticalSection signal_send_packet_cs_;
-  talk_base::CriticalSection signal_recv_packet_cs_;
+  rtc::CriticalSection signal_send_packet_cs_;
+  rtc::CriticalSection signal_recv_packet_cs_;
 
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* worker_thread_;
   MediaEngineInterface* media_engine_;
   BaseSession* session_;
   MediaChannel* media_channel_;
@@ -380,7 +380,7 @@ class BaseChannel
   SrtpFilter srtp_filter_;
   RtcpMuxFilter rtcp_mux_filter_;
   BundleFilter bundle_filter_;
-  talk_base::scoped_ptr<SocketMonitor> socket_monitor_;
+  rtc::scoped_ptr<SocketMonitor> socket_monitor_;
   bool enabled_;
   bool writable_;
   bool rtp_ready_to_send_;
@@ -399,7 +399,7 @@ class BaseChannel
 // and input/output level monitoring.
 class VoiceChannel : public BaseChannel {
  public:
-  VoiceChannel(talk_base::Thread* thread, MediaEngineInterface* media_engine,
+  VoiceChannel(rtc::Thread* thread, MediaEngineInterface* media_engine,
                VoiceMediaChannel* channel, BaseSession* session,
                const std::string& content_name, bool rtcp);
   ~VoiceChannel();
@@ -470,7 +470,7 @@ class VoiceChannel : public BaseChannel {
   // overrides from BaseChannel
   virtual void OnChannelRead(TransportChannel* channel,
                              const char* data, size_t len,
-                             const talk_base::PacketTime& packet_time,
+                             const rtc::PacketTime& packet_time,
                              int flags);
   virtual void ChangeState();
   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
@@ -487,7 +487,7 @@ class VoiceChannel : public BaseChannel {
   bool SetOutputScaling_w(uint32 ssrc, double left, double right);
   bool GetStats_w(VoiceMediaInfo* stats);
 
-  virtual void OnMessage(talk_base::Message* pmsg);
+  virtual void OnMessage(rtc::Message* pmsg);
   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
   virtual void OnConnectionMonitorUpdate(
       SocketMonitor* monitor, const std::vector<ConnectionInfo>& infos);
@@ -500,9 +500,9 @@ class VoiceChannel : public BaseChannel {
 
   static const int kEarlyMediaTimeout = 1000;
   bool received_media_;
-  talk_base::scoped_ptr<VoiceMediaMonitor> media_monitor_;
-  talk_base::scoped_ptr<AudioMonitor> audio_monitor_;
-  talk_base::scoped_ptr<TypingMonitor> typing_monitor_;
+  rtc::scoped_ptr<VoiceMediaMonitor> media_monitor_;
+  rtc::scoped_ptr<AudioMonitor> audio_monitor_;
+  rtc::scoped_ptr<TypingMonitor> typing_monitor_;
 };
 
 // VideoChannel is a specialization for video.
@@ -516,7 +516,7 @@ class VideoChannel : public BaseChannel {
     virtual ~ScreenCapturerFactory() {}
   };
 
-  VideoChannel(talk_base::Thread* thread, MediaEngineInterface* media_engine,
+  VideoChannel(rtc::Thread* thread, MediaEngineInterface* media_engine,
                VideoMediaChannel* channel, BaseSession* session,
                const std::string& content_name, bool rtcp,
                VoiceChannel* voice_channel);
@@ -545,7 +545,7 @@ class VideoChannel : public BaseChannel {
   void StartMediaMonitor(int cms);
   void StopMediaMonitor();
   sigslot::signal2<VideoChannel*, const VideoMediaInfo&> SignalMediaMonitor;
-  sigslot::signal2<uint32, talk_base::WindowEvent> SignalScreencastWindowEvent;
+  sigslot::signal2<uint32, rtc::WindowEvent> SignalScreencastWindowEvent;
 
   bool SendIntraFrame();
   bool RequestIntraFrame();
@@ -581,21 +581,21 @@ class VideoChannel : public BaseChannel {
 
   VideoCapturer* AddScreencast_w(uint32 ssrc, const ScreencastId& id);
   bool RemoveScreencast_w(uint32 ssrc);
-  void OnScreencastWindowEvent_s(uint32 ssrc, talk_base::WindowEvent we);
+  void OnScreencastWindowEvent_s(uint32 ssrc, rtc::WindowEvent we);
   bool IsScreencasting_w() const;
   void GetScreencastDetails_w(ScreencastDetailsData* d) const;
   void SetScreenCaptureFactory_w(
       ScreenCapturerFactory* screencapture_factory);
   bool GetStats_w(VideoMediaInfo* stats);
 
-  virtual void OnMessage(talk_base::Message* pmsg);
+  virtual void OnMessage(rtc::Message* pmsg);
   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
   virtual void OnConnectionMonitorUpdate(
       SocketMonitor* monitor, const std::vector<ConnectionInfo>& infos);
   virtual void OnMediaMonitorUpdate(
       VideoMediaChannel* media_channel, const VideoMediaInfo& info);
   virtual void OnScreencastWindowEvent(uint32 ssrc,
-                                       talk_base::WindowEvent event);
+                                       rtc::WindowEvent event);
   virtual void OnStateChange(VideoCapturer* capturer, CaptureState ev);
   bool GetLocalSsrc(const VideoCapturer* capturer, uint32* ssrc);
 
@@ -604,17 +604,17 @@ class VideoChannel : public BaseChannel {
 
   VoiceChannel* voice_channel_;
   VideoRenderer* renderer_;
-  talk_base::scoped_ptr<ScreenCapturerFactory> screencapture_factory_;
+  rtc::scoped_ptr<ScreenCapturerFactory> screencapture_factory_;
   ScreencastMap screencast_capturers_;
-  talk_base::scoped_ptr<VideoMediaMonitor> media_monitor_;
+  rtc::scoped_ptr<VideoMediaMonitor> media_monitor_;
 
-  talk_base::WindowEvent previous_we_;
+  rtc::WindowEvent previous_we_;
 };
 
 // DataChannel is a specialization for data.
 class DataChannel : public BaseChannel {
  public:
-  DataChannel(talk_base::Thread* thread,
+  DataChannel(rtc::Thread* thread,
               DataMediaChannel* media_channel,
               BaseSession* session,
               const std::string& content_name,
@@ -623,7 +623,7 @@ class DataChannel : public BaseChannel {
   bool Init();
 
   virtual bool SendData(const SendDataParams& params,
-                        const talk_base::Buffer& payload,
+                        const rtc::Buffer& payload,
                         SendDataResult* result);
 
   void StartMediaMonitor(int cms);
@@ -641,7 +641,7 @@ class DataChannel : public BaseChannel {
       SignalMediaError;
   sigslot::signal3<DataChannel*,
                    const ReceiveDataParams&,
-                   const talk_base::Buffer&>
+                   const rtc::Buffer&>
       SignalDataReceived;
   // Signal for notifying when the channel becomes ready to send data.
   // That occurs when the channel is enabled, the transport is writable,
@@ -657,9 +657,9 @@ class DataChannel : public BaseChannel {
   }
 
  private:
-  struct SendDataMessageData : public talk_base::MessageData {
+  struct SendDataMessageData : public rtc::MessageData {
     SendDataMessageData(const SendDataParams& params,
-                        const talk_base::Buffer* payload,
+                        const rtc::Buffer* payload,
                         SendDataResult* result)
         : params(params),
           payload(payload),
@@ -668,12 +668,12 @@ class DataChannel : public BaseChannel {
     }
 
     const SendDataParams& params;
-    const talk_base::Buffer* payload;
+    const rtc::Buffer* payload;
     SendDataResult* result;
     bool succeeded;
   };
 
-  struct DataReceivedMessageData : public talk_base::MessageData {
+  struct DataReceivedMessageData : public rtc::MessageData {
     // We copy the data because the data will become invalid after we
     // handle DataMediaChannel::SignalDataReceived but before we fire
     // SignalDataReceived.
@@ -683,10 +683,10 @@ class DataChannel : public BaseChannel {
           payload(data, len) {
     }
     const ReceiveDataParams params;
-    const talk_base::Buffer payload;
+    const rtc::Buffer payload;
   };
 
-  typedef talk_base::TypedMessageData<bool> DataChannelReadyToSendMessageData;
+  typedef rtc::TypedMessageData<bool> DataChannelReadyToSendMessageData;
 
   // overrides from BaseChannel
   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
@@ -706,9 +706,9 @@ class DataChannel : public BaseChannel {
                                   ContentAction action,
                                   std::string* error_desc);
   virtual void ChangeState();
-  virtual bool WantsPacket(bool rtcp, talk_base::Buffer* packet);
+  virtual bool WantsPacket(bool rtcp, rtc::Buffer* packet);
 
-  virtual void OnMessage(talk_base::Message* pmsg);
+  virtual void OnMessage(rtc::Message* pmsg);
   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
   virtual void OnConnectionMonitorUpdate(
       SocketMonitor* monitor, const std::vector<ConnectionInfo>& infos);
@@ -722,7 +722,7 @@ class DataChannel : public BaseChannel {
   void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
   void OnStreamClosedRemotely(uint32 sid);
 
-  talk_base::scoped_ptr<DataMediaMonitor> media_monitor_;
+  rtc::scoped_ptr<DataMediaMonitor> media_monitor_;
   // TODO(pthatcher): Make a separate SctpDataChannel and
   // RtpDataChannel instead of using this.
   DataChannelType data_channel_type_;
diff --git a/talk/session/media/channel_unittest.cc b/talk/session/media/channel_unittest.cc
index cb0bdc05b0..cf0aad8dd9 100644
--- a/talk/session/media/channel_unittest.cc
+++ b/talk/session/media/channel_unittest.cc
@@ -23,15 +23,15 @@
 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include "talk/base/fileutils.h"
-#include "talk/base/gunit.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/signalthread.h"
-#include "talk/base/ssladapter.h"
-#include "talk/base/sslidentity.h"
-#include "talk/base/window.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/signalthread.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/sslidentity.h"
+#include "webrtc/base/window.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakertp.h"
 #include "talk/media/base/fakevideocapturer.h"
@@ -47,7 +47,7 @@
 #include "talk/session/media/typingmonitor.h"
 
 #define MAYBE_SKIP_TEST(feature)                    \
-  if (!(talk_base::SSLStreamAdapter::feature())) {  \
+  if (!(rtc::SSLStreamAdapter::feature())) {  \
     LOG(LS_INFO) << "Feature disabled... skipping"; \
     return;                                         \
   }
@@ -60,7 +60,7 @@ using cricket::FakeVoiceMediaChannel;
 using cricket::ScreencastId;
 using cricket::StreamParams;
 using cricket::TransportChannel;
-using talk_base::WindowId;
+using rtc::WindowId;
 
 static const cricket::AudioCodec kPcmuCodec(0, "PCMU", 64000, 8000, 1, 0);
 static const cricket::AudioCodec kPcmaCodec(8, "PCMA", 64000, 8000, 1, 0);
@@ -157,9 +157,9 @@ class DataTraits : public Traits<cricket::DataChannel,
 };
 
 
-talk_base::StreamInterface* Open(const std::string& path) {
-  return talk_base::Filesystem::OpenFile(
-      talk_base::Pathname(path), "wb");
+rtc::StreamInterface* Open(const std::string& path) {
+  return rtc::Filesystem::OpenFile(
+      rtc::Pathname(path), "wb");
 }
 
 // Base class for Voice/VideoChannel tests
@@ -186,38 +186,38 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
   }
 
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   void CreateChannels(int flags1, int flags2) {
     CreateChannels(new typename T::MediaChannel(NULL),
                    new typename T::MediaChannel(NULL),
-                   flags1, flags2, talk_base::Thread::Current());
+                   flags1, flags2, rtc::Thread::Current());
   }
   void CreateChannels(int flags) {
      CreateChannels(new typename T::MediaChannel(NULL),
                     new typename T::MediaChannel(NULL),
-                    flags, talk_base::Thread::Current());
+                    flags, rtc::Thread::Current());
   }
   void CreateChannels(int flags1, int flags2,
-                      talk_base::Thread* thread) {
+                      rtc::Thread* thread) {
     CreateChannels(new typename T::MediaChannel(NULL),
                    new typename T::MediaChannel(NULL),
                    flags1, flags2, thread);
   }
   void CreateChannels(int flags,
-                      talk_base::Thread* thread) {
+                      rtc::Thread* thread) {
     CreateChannels(new typename T::MediaChannel(NULL),
                    new typename T::MediaChannel(NULL),
                    flags, thread);
   }
   void CreateChannels(
       typename T::MediaChannel* ch1, typename T::MediaChannel* ch2,
-      int flags1, int flags2, talk_base::Thread* thread) {
+      int flags1, int flags2, rtc::Thread* thread) {
     media_channel1_ = ch1;
     media_channel2_ = ch2;
     channel1_.reset(CreateChannel(thread, &media_engine_, ch1, &session1_,
@@ -246,11 +246,11 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
     CopyContent(local_media_content2_, &remote_media_content2_);
 
     if (flags1 & DTLS) {
-      identity1_.reset(talk_base::SSLIdentity::Generate("session1"));
+      identity1_.reset(rtc::SSLIdentity::Generate("session1"));
       session1_.set_ssl_identity(identity1_.get());
     }
     if (flags2 & DTLS) {
-      identity2_.reset(talk_base::SSLIdentity::Generate("session2"));
+      identity2_.reset(rtc::SSLIdentity::Generate("session2"));
       session2_.set_ssl_identity(identity2_.get());
     }
 
@@ -271,7 +271,7 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
 
   void CreateChannels(
       typename T::MediaChannel* ch1, typename T::MediaChannel* ch2,
-      int flags, talk_base::Thread* thread) {
+      int flags, rtc::Thread* thread) {
     media_channel1_ = ch1;
     media_channel2_ = ch2;
 
@@ -304,7 +304,7 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
     }
   }
 
-  typename T::Channel* CreateChannel(talk_base::Thread* thread,
+  typename T::Channel* CreateChannel(rtc::Thread* thread,
                                      cricket::MediaEngineInterface* engine,
                                      typename T::MediaChannel* ch,
                                      cricket::BaseSession* session,
@@ -470,17 +470,17 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
   std::string CreateRtpData(uint32 ssrc, int sequence_number, int pl_type) {
     std::string data(rtp_packet_);
     // Set SSRC in the rtp packet copy.
-    talk_base::SetBE32(const_cast<char*>(data.c_str()) + 8, ssrc);
-    talk_base::SetBE16(const_cast<char*>(data.c_str()) + 2, sequence_number);
+    rtc::SetBE32(const_cast<char*>(data.c_str()) + 8, ssrc);
+    rtc::SetBE16(const_cast<char*>(data.c_str()) + 2, sequence_number);
     if (pl_type >= 0) {
-      talk_base::Set8(const_cast<char*>(data.c_str()), 1, pl_type);
+      rtc::Set8(const_cast<char*>(data.c_str()), 1, pl_type);
     }
     return data;
   }
   std::string CreateRtcpData(uint32 ssrc) {
     std::string data(rtcp_packet_);
     // Set SSRC in the rtcp packet copy.
-    talk_base::SetBE32(const_cast<char*>(data.c_str()) + 4, ssrc);
+    rtc::SetBE32(const_cast<char*>(data.c_str()) + 4, ssrc);
     return data;
   }
 
@@ -520,7 +520,7 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
      return sdesc;
   }
 
-  class CallThread : public talk_base::SignalThread {
+  class CallThread : public rtc::SignalThread {
    public:
     typedef bool (ChannelTest<T>::*Method)();
     CallThread(ChannelTest<T>* obj, Method method, bool* result)
@@ -1077,7 +1077,7 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
     };
     CreateChannels(new LastWordMediaChannel(), new LastWordMediaChannel(),
                    RTCP | RTCP_MUX, RTCP | RTCP_MUX,
-                   talk_base::Thread::Current());
+                   rtc::Thread::Current());
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_TRUE(SendTerminate());
@@ -1533,10 +1533,10 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
     EXPECT_FALSE(channel1_->HasSendSinks(cricket::SINK_PRE_CRYPTO));
     EXPECT_FALSE(channel1_->HasRecvSinks(cricket::SINK_PRE_CRYPTO));
 
-    talk_base::Pathname path;
-    EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path, true, NULL));
+    rtc::Pathname path;
+    EXPECT_TRUE(rtc::Filesystem::GetTemporaryFolder(path, true, NULL));
     path.SetFilename("sink-test.rtpdump");
-    talk_base::scoped_ptr<cricket::RtpDumpSink> sink(
+    rtc::scoped_ptr<cricket::RtpDumpSink> sink(
         new cricket::RtpDumpSink(Open(path.pathname())));
     sink->set_packet_filter(cricket::PF_ALL);
     EXPECT_TRUE(sink->Enable(true));
@@ -1562,27 +1562,27 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
     sink.reset();  // This will close the file.
 
     // Read the recorded file and verify two packets.
-    talk_base::scoped_ptr<talk_base::StreamInterface> stream(
-        talk_base::Filesystem::OpenFile(path, "rb"));
+    rtc::scoped_ptr<rtc::StreamInterface> stream(
+        rtc::Filesystem::OpenFile(path, "rb"));
 
     cricket::RtpDumpReader reader(stream.get());
     cricket::RtpDumpPacket packet;
-    EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
     std::string read_packet(reinterpret_cast<const char*>(&packet.data[0]),
         packet.data.size());
     EXPECT_EQ(rtp_packet_, read_packet);
 
-    EXPECT_EQ(talk_base::SR_SUCCESS, reader.ReadPacket(&packet));
+    EXPECT_EQ(rtc::SR_SUCCESS, reader.ReadPacket(&packet));
     size_t len = 0;
     packet.GetRtpHeaderLen(&len);
     EXPECT_EQ(len, packet.data.size());
     EXPECT_EQ(0, memcmp(&packet.data[0], rtp_packet_.c_str(), len));
 
-    EXPECT_EQ(talk_base::SR_EOS, reader.ReadPacket(&packet));
+    EXPECT_EQ(rtc::SR_EOS, reader.ReadPacket(&packet));
 
     // Delete the file for media recording.
     stream.reset();
-    EXPECT_TRUE(talk_base::Filesystem::DeleteFile(path));
+    EXPECT_TRUE(rtc::Filesystem::DeleteFile(path));
   }
 
   void TestSetContentFailure() {
@@ -1796,7 +1796,7 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
     // The next 1 sec failures will not trigger an error.
     EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
     // Wait for a while to ensure no message comes in.
-    talk_base::Thread::Current()->ProcessMessages(210);
+    rtc::Thread::Current()->ProcessMessages(210);
     EXPECT_EQ(T::MediaChannel::ERROR_NONE, error_);
     // The error will be triggered again.
     EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
@@ -1808,7 +1808,7 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
         channel2_->transport_channel();
     transport_channel->SignalReadPacket(
         transport_channel, reinterpret_cast<const char*>(kBadPacket),
-        sizeof(kBadPacket), talk_base::PacketTime(), 0);
+        sizeof(kBadPacket), rtc::PacketTime(), 0);
     EXPECT_EQ_WAIT(T::MediaChannel::ERROR_PLAY_SRTP_ERROR, error_, 500);
   }
 
@@ -1863,14 +1863,14 @@ class ChannelTest : public testing::Test, public sigslot::has_slots<> {
   // The media channels are owned by the voice channel objects below.
   typename T::MediaChannel* media_channel1_;
   typename T::MediaChannel* media_channel2_;
-  talk_base::scoped_ptr<typename T::Channel> channel1_;
-  talk_base::scoped_ptr<typename T::Channel> channel2_;
+  rtc::scoped_ptr<typename T::Channel> channel1_;
+  rtc::scoped_ptr<typename T::Channel> channel2_;
   typename T::Content local_media_content1_;
   typename T::Content local_media_content2_;
   typename T::Content remote_media_content1_;
   typename T::Content remote_media_content2_;
-  talk_base::scoped_ptr<talk_base::SSLIdentity> identity1_;
-  talk_base::scoped_ptr<talk_base::SSLIdentity> identity2_;
+  rtc::scoped_ptr<rtc::SSLIdentity> identity1_;
+  rtc::scoped_ptr<rtc::SSLIdentity> identity2_;
   // The RTP and RTCP packets to send in the tests.
   std::string rtp_packet_;
   std::string rtcp_packet_;
@@ -1895,7 +1895,7 @@ void ChannelTest<VoiceTraits>::CreateContent(
   if (flags & SECURE) {
     audio->AddCrypto(cricket::CryptoParams(
         1, cricket::CS_AES_CM_128_HMAC_SHA1_32,
-        "inline:" + talk_base::CreateRandomString(40), ""));
+        "inline:" + rtc::CreateRandomString(40), ""));
   }
 }
 
@@ -1956,7 +1956,7 @@ class VoiceChannelTest
 // override to add NULL parameter
 template<>
 cricket::VideoChannel* ChannelTest<VideoTraits>::CreateChannel(
-    talk_base::Thread* thread, cricket::MediaEngineInterface* engine,
+    rtc::Thread* thread, cricket::MediaEngineInterface* engine,
     cricket::FakeVideoMediaChannel* ch, cricket::BaseSession* session,
     bool rtcp) {
   cricket::VideoChannel* channel = new cricket::VideoChannel(
@@ -1985,7 +1985,7 @@ void ChannelTest<VideoTraits>::CreateContent(
   if (flags & SECURE) {
     video->AddCrypto(cricket::CryptoParams(
         1, cricket::CS_AES_CM_128_HMAC_SHA1_80,
-        "inline:" + talk_base::CreateRandomString(40), ""));
+        "inline:" + rtc::CreateRandomString(40), ""));
   }
 }
 
@@ -2214,7 +2214,7 @@ TEST_F(VoiceChannelTest, DISABLED_TestKeyboardMute) {
 
   // Typing doesn't mute automatically unless typing monitor has been installed
   media_channel1_->TriggerError(0, e);
-  talk_base::Thread::Current()->ProcessMessages(0);
+  rtc::Thread::Current()->ProcessMessages(0);
   EXPECT_EQ(e, error_);
   EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
   EXPECT_FALSE(mute_callback_recved_);
@@ -2223,7 +2223,7 @@ TEST_F(VoiceChannelTest, DISABLED_TestKeyboardMute) {
   o.mute_period = 1500;
   channel1_->StartTypingMonitor(o);
   media_channel1_->TriggerError(0, e);
-  talk_base::Thread::Current()->ProcessMessages(0);
+  rtc::Thread::Current()->ProcessMessages(0);
   EXPECT_TRUE(media_channel1_->IsStreamMuted(0));
   EXPECT_TRUE(mute_callback_recved_);
 }
@@ -2482,13 +2482,13 @@ TEST_F(VideoChannelTest, TestScreencastEvents) {
                  kTimeoutMs);
   screencapture_factory->window_capturer()->SignalStateChange(
       screencapture_factory->window_capturer(), cricket::CS_PAUSED);
-  EXPECT_EQ_WAIT(talk_base::WE_MINIMIZE, catcher.event(), kTimeoutMs);
+  EXPECT_EQ_WAIT(rtc::WE_MINIMIZE, catcher.event(), kTimeoutMs);
   screencapture_factory->window_capturer()->SignalStateChange(
       screencapture_factory->window_capturer(), cricket::CS_RUNNING);
-  EXPECT_EQ_WAIT(talk_base::WE_RESTORE, catcher.event(), kTimeoutMs);
+  EXPECT_EQ_WAIT(rtc::WE_RESTORE, catcher.event(), kTimeoutMs);
   screencapture_factory->window_capturer()->SignalStateChange(
       screencapture_factory->window_capturer(), cricket::CS_STOPPED);
-  EXPECT_EQ_WAIT(talk_base::WE_CLOSE, catcher.event(), kTimeoutMs);
+  EXPECT_EQ_WAIT(rtc::WE_CLOSE, catcher.event(), kTimeoutMs);
   EXPECT_TRUE(channel1_->RemoveScreencast(0));
   ASSERT_TRUE(screencapture_factory->window_capturer() == NULL);
 }
@@ -2748,7 +2748,7 @@ class DataChannelTest
 // Override to avoid engine channel parameter.
 template<>
 cricket::DataChannel* ChannelTest<DataTraits>::CreateChannel(
-    talk_base::Thread* thread, cricket::MediaEngineInterface* engine,
+    rtc::Thread* thread, cricket::MediaEngineInterface* engine,
     cricket::FakeDataMediaChannel* ch, cricket::BaseSession* session,
     bool rtcp) {
   cricket::DataChannel* channel = new cricket::DataChannel(
@@ -2771,7 +2771,7 @@ void ChannelTest<DataTraits>::CreateContent(
   if (flags & SECURE) {
     data->AddCrypto(cricket::CryptoParams(
         1, cricket::CS_AES_CM_128_HMAC_SHA1_32,
-        "inline:" + talk_base::CreateRandomString(40), ""));
+        "inline:" + rtc::CreateRandomString(40), ""));
   }
 }
 
@@ -2929,7 +2929,7 @@ TEST_F(DataChannelTest, TestSendData) {
   unsigned char data[] = {
     'f', 'o', 'o'
   };
-  talk_base::Buffer payload(data, 3);
+  rtc::Buffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
diff --git a/talk/session/media/channelmanager.cc b/talk/session/media/channelmanager.cc
index d933ea60bc..684e9a9c6c 100644
--- a/talk/session/media/channelmanager.cc
+++ b/talk/session/media/channelmanager.cc
@@ -33,12 +33,12 @@
 
 #include <algorithm>
 
-#include "talk/base/bind.h"
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/sigslotrepeater.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/bind.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/sigslotrepeater.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/capturemanager.h"
 #include "talk/media/base/hybriddataengine.h"
 #include "talk/media/base/rtpdataengine.h"
@@ -56,11 +56,11 @@ enum {
   MSG_VIDEOCAPTURESTATE = 1,
 };
 
-using talk_base::Bind;
+using rtc::Bind;
 
 static const int kNotSetOutputVolume = -1;
 
-struct CaptureStateParams : public talk_base::MessageData {
+struct CaptureStateParams : public rtc::MessageData {
   CaptureStateParams(cricket::VideoCapturer* c, cricket::CaptureState s)
       : capturer(c),
         state(s) {}
@@ -77,7 +77,7 @@ static DataEngineInterface* ConstructDataEngine() {
 }
 
 #if !defined(DISABLE_MEDIA_ENGINE_FACTORY)
-ChannelManager::ChannelManager(talk_base::Thread* worker_thread) {
+ChannelManager::ChannelManager(rtc::Thread* worker_thread) {
   Construct(MediaEngineFactory::Create(),
             ConstructDataEngine(),
             cricket::DeviceManagerFactory::Create(),
@@ -90,13 +90,13 @@ ChannelManager::ChannelManager(MediaEngineInterface* me,
                                DataEngineInterface* dme,
                                DeviceManagerInterface* dm,
                                CaptureManager* cm,
-                               talk_base::Thread* worker_thread) {
+                               rtc::Thread* worker_thread) {
   Construct(me, dme, dm, cm, worker_thread);
 }
 
 ChannelManager::ChannelManager(MediaEngineInterface* me,
                                DeviceManagerInterface* dm,
-                               talk_base::Thread* worker_thread) {
+                               rtc::Thread* worker_thread) {
   Construct(me,
             ConstructDataEngine(),
             dm,
@@ -108,13 +108,13 @@ void ChannelManager::Construct(MediaEngineInterface* me,
                                DataEngineInterface* dme,
                                DeviceManagerInterface* dm,
                                CaptureManager* cm,
-                               talk_base::Thread* worker_thread) {
+                               rtc::Thread* worker_thread) {
   media_engine_.reset(me);
   data_media_engine_.reset(dme);
   device_manager_.reset(dm);
   capture_manager_.reset(cm);
   initialized_ = false;
-  main_thread_ = talk_base::Thread::Current();
+  main_thread_ = rtc::Thread::Current();
   worker_thread_ = worker_thread;
   // Get the default audio options from the media engine.
   audio_options_ = media_engine_->GetAudioOptions();
@@ -297,7 +297,7 @@ void ChannelManager::Terminate() {
 }
 
 void ChannelManager::Terminate_w() {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   // Need to destroy the voice/video channels
   while (!video_channels_.empty()) {
     DestroyVideoChannel_w(video_channels_.back());
@@ -470,7 +470,7 @@ Soundclip* ChannelManager::CreateSoundclip() {
 
 Soundclip* ChannelManager::CreateSoundclip_w() {
   ASSERT(initialized_);
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
 
   SoundclipMedia* soundclip_media = media_engine_->CreateSoundclip();
   if (!soundclip_media) {
@@ -556,7 +556,7 @@ bool ChannelManager::SetAudioOptions(const std::string& in_name,
 bool ChannelManager::SetAudioOptions_w(
     const AudioOptions& options, int delay_offset,
     const Device* in_dev, const Device* out_dev) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(initialized_);
 
   // Set audio options
@@ -591,7 +591,7 @@ bool ChannelManager::SetEngineAudioOptions(const AudioOptions& options) {
 }
 
 bool ChannelManager::SetEngineAudioOptions_w(const AudioOptions& options) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(initialized_);
 
   return media_engine_->SetAudioOptions(options);
@@ -711,7 +711,7 @@ VideoCapturer* ChannelManager::CreateVideoCapturer() {
 }
 
 bool ChannelManager::SetCaptureDevice_w(const Device* cam_device) {
-  ASSERT(worker_thread_ == talk_base::Thread::Current());
+  ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(initialized_);
 
   if (!cam_device) {
@@ -900,7 +900,7 @@ void ChannelManager::OnVideoCaptureStateChange(VideoCapturer* capturer,
                      new CaptureStateParams(capturer, result));
 }
 
-void ChannelManager::OnMessage(talk_base::Message* message) {
+void ChannelManager::OnMessage(rtc::Message* message) {
   switch (message->message_id) {
     case MSG_VIDEOCAPTURESTATE: {
       CaptureStateParams* data =
@@ -962,7 +962,7 @@ VideoFormat ChannelManager::GetStartCaptureFormat() {
       Bind(&MediaEngineInterface::GetStartCaptureFormat, media_engine_.get()));
 }
 
-bool ChannelManager::StartAecDump(talk_base::PlatformFile file) {
+bool ChannelManager::StartAecDump(rtc::PlatformFile file) {
   return worker_thread_->Invoke<bool>(
       Bind(&MediaEngineInterface::StartAecDump, media_engine_.get(), file));
 }
diff --git a/talk/session/media/channelmanager.h b/talk/session/media/channelmanager.h
index e8d6c0e5e4..d74228096a 100644
--- a/talk/session/media/channelmanager.h
+++ b/talk/session/media/channelmanager.h
@@ -31,10 +31,10 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/criticalsection.h"
-#include "talk/base/fileutils.h"
-#include "talk/base/sigslotrepeater.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/sigslotrepeater.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/capturemanager.h"
 #include "talk/media/base/mediaengine.h"
 #include "talk/p2p/base/session.h"
@@ -55,12 +55,12 @@ class VoiceProcessor;
 // voice or just video channels.
 // ChannelManager also allows the application to discover what devices it has
 // using device manager.
-class ChannelManager : public talk_base::MessageHandler,
+class ChannelManager : public rtc::MessageHandler,
                        public sigslot::has_slots<> {
  public:
 #if !defined(DISABLE_MEDIA_ENGINE_FACTORY)
   // Creates the channel manager, and specifies the worker thread to use.
-  explicit ChannelManager(talk_base::Thread* worker);
+  explicit ChannelManager(rtc::Thread* worker);
 #endif
 
   // For testing purposes. Allows the media engine and data media
@@ -70,17 +70,17 @@ class ChannelManager : public talk_base::MessageHandler,
                  DataEngineInterface* dme,
                  DeviceManagerInterface* dm,
                  CaptureManager* cm,
-                 talk_base::Thread* worker);
+                 rtc::Thread* worker);
   // Same as above, but gives an easier default DataEngine.
   ChannelManager(MediaEngineInterface* me,
                  DeviceManagerInterface* dm,
-                 talk_base::Thread* worker);
+                 rtc::Thread* worker);
   ~ChannelManager();
 
   // Accessors for the worker thread, allowing it to be set after construction,
   // but before Init. set_worker_thread will return false if called after Init.
-  talk_base::Thread* worker_thread() const { return worker_thread_; }
-  bool set_worker_thread(talk_base::Thread* thread) {
+  rtc::Thread* worker_thread() const { return worker_thread_; }
+  bool set_worker_thread(rtc::Thread* thread) {
     if (initialized_) return false;
     worker_thread_ = thread;
     return true;
@@ -218,7 +218,7 @@ class ChannelManager : public talk_base::MessageHandler,
                                       const VideoFormat& max_format);
 
   // Starts AEC dump using existing file.
-  bool StartAecDump(talk_base::PlatformFile file);
+  bool StartAecDump(rtc::PlatformFile file);
 
   sigslot::repeater0<> SignalDevicesChange;
   sigslot::signal2<VideoCapturer*, CaptureState> SignalVideoCaptureStateChange;
@@ -251,7 +251,7 @@ class ChannelManager : public talk_base::MessageHandler,
                  DataEngineInterface* dme,
                  DeviceManagerInterface* dm,
                  CaptureManager* cm,
-                 talk_base::Thread* worker_thread);
+                 rtc::Thread* worker_thread);
   void Terminate_w();
   VoiceChannel* CreateVoiceChannel_w(
       BaseSession* session, const std::string& content_name, bool rtcp);
@@ -277,15 +277,15 @@ class ChannelManager : public talk_base::MessageHandler,
   bool UnregisterVideoProcessor_w(VideoCapturer* capturer,
                                   VideoProcessor* processor);
   bool IsScreencastRunning_w() const;
-  virtual void OnMessage(talk_base::Message *message);
+  virtual void OnMessage(rtc::Message *message);
 
-  talk_base::scoped_ptr<MediaEngineInterface> media_engine_;
-  talk_base::scoped_ptr<DataEngineInterface> data_media_engine_;
-  talk_base::scoped_ptr<DeviceManagerInterface> device_manager_;
-  talk_base::scoped_ptr<CaptureManager> capture_manager_;
+  rtc::scoped_ptr<MediaEngineInterface> media_engine_;
+  rtc::scoped_ptr<DataEngineInterface> data_media_engine_;
+  rtc::scoped_ptr<DeviceManagerInterface> device_manager_;
+  rtc::scoped_ptr<CaptureManager> capture_manager_;
   bool initialized_;
-  talk_base::Thread* main_thread_;
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* main_thread_;
+  rtc::Thread* worker_thread_;
 
   VoiceChannels voice_channels_;
   VideoChannels video_channels_;
diff --git a/talk/session/media/channelmanager_unittest.cc b/talk/session/media/channelmanager_unittest.cc
index 1923289489..f3018295d2 100644
--- a/talk/session/media/channelmanager_unittest.cc
+++ b/talk/session/media/channelmanager_unittest.cc
@@ -23,9 +23,9 @@
 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/fakecapturemanager.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakemediaprocessor.h"
@@ -62,7 +62,7 @@ class ChannelManagerTest : public testing::Test {
     fdm_ = new cricket::FakeDeviceManager();
     fcm_ = new cricket::FakeCaptureManager();
     cm_ = new cricket::ChannelManager(
-        fme_, fdme_, fdm_, fcm_, talk_base::Thread::Current());
+        fme_, fdme_, fdm_, fcm_, rtc::Thread::Current());
     session_ = new cricket::FakeSession(true);
 
     std::vector<std::string> in_device_list, out_device_list, vid_device_list;
@@ -87,7 +87,7 @@ class ChannelManagerTest : public testing::Test {
     fme_ = NULL;
   }
 
-  talk_base::Thread worker_;
+  rtc::Thread worker_;
   cricket::FakeMediaEngine* fme_;
   cricket::FakeDataEngine* fdme_;
   cricket::FakeDeviceManager* fdm_;
@@ -99,7 +99,7 @@ class ChannelManagerTest : public testing::Test {
 // Test that we startup/shutdown properly.
 TEST_F(ChannelManagerTest, StartupShutdown) {
   EXPECT_FALSE(cm_->initialized());
-  EXPECT_EQ(talk_base::Thread::Current(), cm_->worker_thread());
+  EXPECT_EQ(rtc::Thread::Current(), cm_->worker_thread());
   EXPECT_TRUE(cm_->Init());
   EXPECT_TRUE(cm_->initialized());
   cm_->Terminate();
@@ -110,13 +110,13 @@ TEST_F(ChannelManagerTest, StartupShutdown) {
 TEST_F(ChannelManagerTest, StartupShutdownOnThread) {
   worker_.Start();
   EXPECT_FALSE(cm_->initialized());
-  EXPECT_EQ(talk_base::Thread::Current(), cm_->worker_thread());
+  EXPECT_EQ(rtc::Thread::Current(), cm_->worker_thread());
   EXPECT_TRUE(cm_->set_worker_thread(&worker_));
   EXPECT_EQ(&worker_, cm_->worker_thread());
   EXPECT_TRUE(cm_->Init());
   EXPECT_TRUE(cm_->initialized());
   // Setting the worker thread while initialized should fail.
-  EXPECT_FALSE(cm_->set_worker_thread(talk_base::Thread::Current()));
+  EXPECT_FALSE(cm_->set_worker_thread(rtc::Thread::Current()));
   cm_->Terminate();
   EXPECT_FALSE(cm_->initialized());
 }
@@ -528,27 +528,27 @@ TEST_F(ChannelManagerTest, SetLocalRenderer) {
 // Test that logging options set before Init are applied properly,
 // and retained even after Init.
 TEST_F(ChannelManagerTest, SetLoggingBeforeInit) {
-  cm_->SetVoiceLogging(talk_base::LS_INFO, "test-voice");
-  cm_->SetVideoLogging(talk_base::LS_VERBOSE, "test-video");
-  EXPECT_EQ(talk_base::LS_INFO, fme_->voice_loglevel());
+  cm_->SetVoiceLogging(rtc::LS_INFO, "test-voice");
+  cm_->SetVideoLogging(rtc::LS_VERBOSE, "test-video");
+  EXPECT_EQ(rtc::LS_INFO, fme_->voice_loglevel());
   EXPECT_STREQ("test-voice", fme_->voice_logfilter().c_str());
-  EXPECT_EQ(talk_base::LS_VERBOSE, fme_->video_loglevel());
+  EXPECT_EQ(rtc::LS_VERBOSE, fme_->video_loglevel());
   EXPECT_STREQ("test-video", fme_->video_logfilter().c_str());
   EXPECT_TRUE(cm_->Init());
-  EXPECT_EQ(talk_base::LS_INFO, fme_->voice_loglevel());
+  EXPECT_EQ(rtc::LS_INFO, fme_->voice_loglevel());
   EXPECT_STREQ("test-voice", fme_->voice_logfilter().c_str());
-  EXPECT_EQ(talk_base::LS_VERBOSE, fme_->video_loglevel());
+  EXPECT_EQ(rtc::LS_VERBOSE, fme_->video_loglevel());
   EXPECT_STREQ("test-video", fme_->video_logfilter().c_str());
 }
 
 // Test that logging options set after Init are applied properly.
 TEST_F(ChannelManagerTest, SetLogging) {
   EXPECT_TRUE(cm_->Init());
-  cm_->SetVoiceLogging(talk_base::LS_INFO, "test-voice");
-  cm_->SetVideoLogging(talk_base::LS_VERBOSE, "test-video");
-  EXPECT_EQ(talk_base::LS_INFO, fme_->voice_loglevel());
+  cm_->SetVoiceLogging(rtc::LS_INFO, "test-voice");
+  cm_->SetVideoLogging(rtc::LS_VERBOSE, "test-video");
+  EXPECT_EQ(rtc::LS_INFO, fme_->voice_loglevel());
   EXPECT_STREQ("test-voice", fme_->voice_logfilter().c_str());
-  EXPECT_EQ(talk_base::LS_VERBOSE, fme_->video_loglevel());
+  EXPECT_EQ(rtc::LS_VERBOSE, fme_->video_loglevel());
   EXPECT_STREQ("test-video", fme_->video_logfilter().c_str());
 }
 
diff --git a/talk/session/media/currentspeakermonitor.cc b/talk/session/media/currentspeakermonitor.cc
index 8965cde958..900ec1e0ba 100644
--- a/talk/session/media/currentspeakermonitor.cc
+++ b/talk/session/media/currentspeakermonitor.cc
@@ -27,7 +27,7 @@
 
 #include "talk/session/media/currentspeakermonitor.h"
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/media/base/streamparams.h"
 #include "talk/session/media/audiomonitor.h"
 #include "talk/session/media/mediamessages.h"
@@ -183,7 +183,7 @@ void CurrentSpeakerMonitor::OnAudioMonitor(
 
   // We avoid over-switching by disabling switching for a period of time after
   // a switch is done.
-  uint32 now = talk_base::Time();
+  uint32 now = rtc::Time();
   if (earliest_permitted_switch_time_ <= now &&
       current_speaker_ssrc_ != loudest_speaker_ssrc) {
     current_speaker_ssrc_ = loudest_speaker_ssrc;
diff --git a/talk/session/media/currentspeakermonitor.h b/talk/session/media/currentspeakermonitor.h
index 8e05c8e677..0397a6d944 100644
--- a/talk/session/media/currentspeakermonitor.h
+++ b/talk/session/media/currentspeakermonitor.h
@@ -33,8 +33,8 @@
 
 #include <map>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/sigslot.h"
 
 namespace cricket {
 
diff --git a/talk/session/media/currentspeakermonitor_unittest.cc b/talk/session/media/currentspeakermonitor_unittest.cc
index b65611f6d0..8798f86f13 100644
--- a/talk/session/media/currentspeakermonitor_unittest.cc
+++ b/talk/session/media/currentspeakermonitor_unittest.cc
@@ -25,8 +25,8 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/thread.h"
 #include "talk/session/media/call.h"
 #include "talk/session/media/currentspeakermonitor.h"
 
@@ -165,7 +165,7 @@ TEST_F(CurrentSpeakerMonitorTest, SpeakerChange) {
   EXPECT_EQ(num_changes_, 1);
 
   // Wait so the changes don't come so rapidly.
-  talk_base::Thread::SleepMs(kSleepTimeBetweenSwitches);
+  rtc::Thread::SleepMs(kSleepTimeBetweenSwitches);
 
   info.active_streams.push_back(std::make_pair(kSsrc1, 9));
   info.active_streams.push_back(std::make_pair(kSsrc2, 1));
@@ -201,7 +201,7 @@ TEST_F(CurrentSpeakerMonitorTest, InterwordSilence) {
   EXPECT_EQ(num_changes_, 1);
 
   // Wait so the changes don't come so rapidly.
-  talk_base::Thread::SleepMs(kSleepTimeBetweenSwitches);
+  rtc::Thread::SleepMs(kSleepTimeBetweenSwitches);
 
   info.active_streams.push_back(std::make_pair(kSsrc1, 3));
   info.active_streams.push_back(std::make_pair(kSsrc2, 0));
diff --git a/talk/session/media/externalhmac.cc b/talk/session/media/externalhmac.cc
index 470668d765..82d316dffc 100644
--- a/talk/session/media/externalhmac.cc
+++ b/talk/session/media/externalhmac.cc
@@ -37,7 +37,7 @@
 #include "third_party/libsrtp/include/srtp.h"
 #endif  // SRTP_RELATIVE_PATH
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 
 // Begin test case 0 */
 static const uint8_t kExternalHmacTestCase0Key[20] = {
diff --git a/talk/session/media/externalhmac.h b/talk/session/media/externalhmac.h
index 287d9680a7..0ab1919ab5 100644
--- a/talk/session/media/externalhmac.h
+++ b/talk/session/media/externalhmac.h
@@ -46,7 +46,7 @@
 // crypto_kernel_replace_auth_type function.
 #if defined(HAVE_SRTP) && defined(ENABLE_EXTERNAL_AUTH)
 
-#include "talk/base/basictypes.h"
+#include "webrtc/base/basictypes.h"
 #ifdef SRTP_RELATIVE_PATH
 #include "auth.h"  // NOLINT
 #else
diff --git a/talk/session/media/mediamessages.cc b/talk/session/media/mediamessages.cc
index 45c6c7965f..933c1ee95f 100644
--- a/talk/session/media/mediamessages.cc
+++ b/talk/session/media/mediamessages.cc
@@ -31,8 +31,8 @@
 
 #include "talk/session/media/mediamessages.h"
 
-#include "talk/base/logging.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/parsing.h"
 #include "talk/session/media/mediasessionclient.h"
@@ -49,7 +49,7 @@ void AddStream(std::vector<StreamParams>* streams, const StreamParams& stream) {
 }
 
 bool ParseSsrc(const std::string& string, uint32* ssrc) {
-  return talk_base::FromString(string, ssrc);
+  return rtc::FromString(string, ssrc);
 }
 
 // Builds a <view> element according to the following spec:
diff --git a/talk/session/media/mediamessages.h b/talk/session/media/mediamessages.h
index dcb48a85a3..032bca8c6c 100644
--- a/talk/session/media/mediamessages.h
+++ b/talk/session/media/mediamessages.h
@@ -39,7 +39,7 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/basictypes.h"
+#include "webrtc/base/basictypes.h"
 #include "talk/media/base/mediachannel.h"  // For RtpHeaderExtension
 #include "talk/media/base/streamparams.h"
 #include "talk/p2p/base/parsing.h"
diff --git a/talk/session/media/mediamessages_unittest.cc b/talk/session/media/mediamessages_unittest.cc
index c7c81c3d2e..0700801f3f 100644
--- a/talk/session/media/mediamessages_unittest.cc
+++ b/talk/session/media/mediamessages_unittest.cc
@@ -30,8 +30,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/session/media/mediasessionclient.h"
 #include "talk/xmllite/xmlelement.h"
@@ -161,7 +161,7 @@ class MediaMessagesTest : public testing::Test {
     return size;
   }
 
-  talk_base::scoped_ptr<cricket::SessionDescription> remote_description_;
+  rtc::scoped_ptr<cricket::SessionDescription> remote_description_;
 };
 
 }  // anonymous namespace
@@ -170,7 +170,7 @@ class MediaMessagesTest : public testing::Test {
 TEST_F(MediaMessagesTest, ViewNoneToFromXml) {
   buzz::XmlElement* expected_view_elem =
       buzz::XmlElement::ForStr(kViewVideoNoneXml);
-  talk_base::scoped_ptr<buzz::XmlElement> action_elem(
+  rtc::scoped_ptr<buzz::XmlElement> action_elem(
       new buzz::XmlElement(QN_JINGLE));
 
   EXPECT_FALSE(cricket::IsJingleViewRequest(action_elem.get()));
@@ -197,7 +197,7 @@ TEST_F(MediaMessagesTest, ViewNoneToFromXml) {
 
 // Test serializing/deserializing an a simple vga <view> message.
 TEST_F(MediaMessagesTest, ViewVgaToFromXml) {
-  talk_base::scoped_ptr<buzz::XmlElement> action_elem(
+  rtc::scoped_ptr<buzz::XmlElement> action_elem(
       new buzz::XmlElement(QN_JINGLE));
   buzz::XmlElement* expected_view_elem1 =
       buzz::XmlElement::ForStr(ViewVideoStaticVgaXml("1234"));
@@ -238,7 +238,7 @@ TEST_F(MediaMessagesTest, ViewVgaToFromXml) {
 
 // Test deserializing bad view XML.
 TEST_F(MediaMessagesTest, ParseBadViewXml) {
-  talk_base::scoped_ptr<buzz::XmlElement> action_elem(
+  rtc::scoped_ptr<buzz::XmlElement> action_elem(
       new buzz::XmlElement(QN_JINGLE));
   buzz::XmlElement* view_elem =
       buzz::XmlElement::ForStr(ViewVideoStaticVgaXml("not-an-ssrc"));
@@ -253,7 +253,7 @@ TEST_F(MediaMessagesTest, ParseBadViewXml) {
 
 // Test serializing/deserializing typical streams xml.
 TEST_F(MediaMessagesTest, StreamsToFromXml) {
-  talk_base::scoped_ptr<buzz::XmlElement> expected_streams_elem(
+  rtc::scoped_ptr<buzz::XmlElement> expected_streams_elem(
       buzz::XmlElement::ForStr(
           StreamsXml(
               StreamXml("nick1", "stream1", "101", "102",
@@ -267,7 +267,7 @@ TEST_F(MediaMessagesTest, StreamsToFromXml) {
   expected_streams.push_back(CreateStream("nick2", "stream2", 201U, 202U,
                                           "semantics2", "type2", "display2"));
 
-  talk_base::scoped_ptr<buzz::XmlElement> actual_desc_elem(
+  rtc::scoped_ptr<buzz::XmlElement> actual_desc_elem(
       new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
   cricket::WriteJingleStreams(expected_streams, actual_desc_elem.get());
 
@@ -276,7 +276,7 @@ TEST_F(MediaMessagesTest, StreamsToFromXml) {
   ASSERT_TRUE(actual_streams_elem != NULL);
   EXPECT_EQ(expected_streams_elem->Str(), actual_streams_elem->Str());
 
-  talk_base::scoped_ptr<buzz::XmlElement> expected_desc_elem(
+  rtc::scoped_ptr<buzz::XmlElement> expected_desc_elem(
       new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
   expected_desc_elem->AddElement(new buzz::XmlElement(
       *expected_streams_elem));
@@ -293,14 +293,14 @@ TEST_F(MediaMessagesTest, StreamsToFromXml) {
 
 // Test deserializing bad streams xml.
 TEST_F(MediaMessagesTest, StreamsFromBadXml) {
-  talk_base::scoped_ptr<buzz::XmlElement> streams_elem(
+  rtc::scoped_ptr<buzz::XmlElement> streams_elem(
       buzz::XmlElement::ForStr(
           StreamsXml(
               StreamXml("nick1", "name1", "101", "not-an-ssrc",
                         "semantics1", "type1", "display1"),
               StreamXml("nick2", "name2", "202", "not-an-ssrc",
                         "semantics2", "type2", "display2"))));
-  talk_base::scoped_ptr<buzz::XmlElement> desc_elem(
+  rtc::scoped_ptr<buzz::XmlElement> desc_elem(
       new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
   desc_elem->AddElement(new buzz::XmlElement(*streams_elem));
 
@@ -312,7 +312,7 @@ TEST_F(MediaMessagesTest, StreamsFromBadXml) {
 
 // Test serializing/deserializing typical RTP Header Extension xml.
 TEST_F(MediaMessagesTest, HeaderExtensionsToFromXml) {
-  talk_base::scoped_ptr<buzz::XmlElement> expected_desc_elem(
+  rtc::scoped_ptr<buzz::XmlElement> expected_desc_elem(
       buzz::XmlElement::ForStr(
           HeaderExtensionsXml(
               HeaderExtensionXml("abc", "123"),
@@ -322,7 +322,7 @@ TEST_F(MediaMessagesTest, HeaderExtensionsToFromXml) {
   expected_hdrexts.push_back(RtpHeaderExtension("abc", 123));
   expected_hdrexts.push_back(RtpHeaderExtension("def", 456));
 
-  talk_base::scoped_ptr<buzz::XmlElement> actual_desc_elem(
+  rtc::scoped_ptr<buzz::XmlElement> actual_desc_elem(
       new buzz::XmlElement(QN_JINGLE_RTP_CONTENT));
   cricket::WriteJingleRtpHeaderExtensions(expected_hdrexts, actual_desc_elem.get());
 
@@ -343,7 +343,7 @@ TEST_F(MediaMessagesTest, HeaderExtensionsFromBadXml) {
   std::vector<cricket::RtpHeaderExtension> actual_hdrexts;
   cricket::ParseError parse_error;
 
-  talk_base::scoped_ptr<buzz::XmlElement> desc_elem(
+  rtc::scoped_ptr<buzz::XmlElement> desc_elem(
       buzz::XmlElement::ForStr(
           HeaderExtensionsXml(
               HeaderExtensionXml("abc", "123"),
diff --git a/talk/session/media/mediamonitor.cc b/talk/session/media/mediamonitor.cc
index 844180eb87..6c74bf9268 100644
--- a/talk/session/media/mediamonitor.cc
+++ b/talk/session/media/mediamonitor.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/session/media/channelmanager.h"
 #include "talk/session/media/mediamonitor.h"
 
@@ -38,8 +38,8 @@ enum {
   MSG_MONITOR_SIGNAL = 4
 };
 
-MediaMonitor::MediaMonitor(talk_base::Thread* worker_thread,
-                           talk_base::Thread* monitor_thread)
+MediaMonitor::MediaMonitor(rtc::Thread* worker_thread,
+                           rtc::Thread* monitor_thread)
     : worker_thread_(worker_thread),
       monitor_thread_(monitor_thread), monitoring_(false), rate_(0) {
 }
@@ -62,12 +62,12 @@ void MediaMonitor::Stop() {
   rate_ = 0;
 }
 
-void MediaMonitor::OnMessage(talk_base::Message* message) {
-  talk_base::CritScope cs(&crit_);
+void MediaMonitor::OnMessage(rtc::Message* message) {
+  rtc::CritScope cs(&crit_);
 
   switch (message->message_id) {
   case MSG_MONITOR_START:
-    ASSERT(talk_base::Thread::Current() == worker_thread_);
+    ASSERT(rtc::Thread::Current() == worker_thread_);
     if (!monitoring_) {
       monitoring_ = true;
       PollMediaChannel();
@@ -75,7 +75,7 @@ void MediaMonitor::OnMessage(talk_base::Message* message) {
     break;
 
   case MSG_MONITOR_STOP:
-    ASSERT(talk_base::Thread::Current() == worker_thread_);
+    ASSERT(rtc::Thread::Current() == worker_thread_);
     if (monitoring_) {
       monitoring_ = false;
       worker_thread_->Clear(this);
@@ -83,20 +83,20 @@ void MediaMonitor::OnMessage(talk_base::Message* message) {
     break;
 
   case MSG_MONITOR_POLL:
-    ASSERT(talk_base::Thread::Current() == worker_thread_);
+    ASSERT(rtc::Thread::Current() == worker_thread_);
     PollMediaChannel();
     break;
 
   case MSG_MONITOR_SIGNAL:
-    ASSERT(talk_base::Thread::Current() == monitor_thread_);
+    ASSERT(rtc::Thread::Current() == monitor_thread_);
     Update();
     break;
   }
 }
 
 void MediaMonitor::PollMediaChannel() {
-  talk_base::CritScope cs(&crit_);
-  ASSERT(talk_base::Thread::Current() == worker_thread_);
+  rtc::CritScope cs(&crit_);
+  ASSERT(rtc::Thread::Current() == worker_thread_);
 
   GetStats();
 
diff --git a/talk/session/media/mediamonitor.h b/talk/session/media/mediamonitor.h
index a9ce889590..11dc419ed1 100644
--- a/talk/session/media/mediamonitor.h
+++ b/talk/session/media/mediamonitor.h
@@ -30,33 +30,33 @@
 #ifndef TALK_SESSION_MEDIA_MEDIAMONITOR_H_
 #define TALK_SESSION_MEDIA_MEDIAMONITOR_H_
 
-#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/media/base/mediachannel.h"
 
 namespace cricket {
 
 // The base MediaMonitor class, independent of voice and video.
-class MediaMonitor : public talk_base::MessageHandler,
+class MediaMonitor : public rtc::MessageHandler,
     public sigslot::has_slots<> {
  public:
-  MediaMonitor(talk_base::Thread* worker_thread,
-               talk_base::Thread* monitor_thread);
+  MediaMonitor(rtc::Thread* worker_thread,
+               rtc::Thread* monitor_thread);
   ~MediaMonitor();
 
   void Start(uint32 milliseconds);
   void Stop();
 
  protected:
-  void OnMessage(talk_base::Message *message);
+  void OnMessage(rtc::Message *message);
   void PollMediaChannel();
   virtual void GetStats() = 0;
   virtual void Update() = 0;
 
-  talk_base::CriticalSection crit_;
-  talk_base::Thread* worker_thread_;
-  talk_base::Thread* monitor_thread_;
+  rtc::CriticalSection crit_;
+  rtc::Thread* worker_thread_;
+  rtc::Thread* monitor_thread_;
   bool monitoring_;
   uint32 rate_;
 };
@@ -65,8 +65,8 @@ class MediaMonitor : public talk_base::MessageHandler,
 template<class MC, class MI>
 class MediaMonitorT : public MediaMonitor {
  public:
-  MediaMonitorT(MC* media_channel, talk_base::Thread* worker_thread,
-                talk_base::Thread* monitor_thread)
+  MediaMonitorT(MC* media_channel, rtc::Thread* worker_thread,
+                rtc::Thread* monitor_thread)
       : MediaMonitor(worker_thread, monitor_thread),
         media_channel_(media_channel) {}
   sigslot::signal2<MC*, const MI&> SignalUpdate;
diff --git a/talk/session/media/mediarecorder.cc b/talk/session/media/mediarecorder.cc
index 0aed63a2ca..8d9d7e58e5 100644
--- a/talk/session/media/mediarecorder.cc
+++ b/talk/session/media/mediarecorder.cc
@@ -31,9 +31,9 @@
 
 #include <string>
 
-#include "talk/base/fileutils.h"
-#include "talk/base/logging.h"
-#include "talk/base/pathutils.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/pathutils.h"
 #include "talk/media/base/rtpdump.h"
 
 
@@ -42,7 +42,7 @@ namespace cricket {
 ///////////////////////////////////////////////////////////////////////////
 // Implementation of RtpDumpSink.
 ///////////////////////////////////////////////////////////////////////////
-RtpDumpSink::RtpDumpSink(talk_base::StreamInterface* stream)
+RtpDumpSink::RtpDumpSink(rtc::StreamInterface* stream)
     : max_size_(INT_MAX),
       recording_(false),
       packet_filter_(PF_NONE) {
@@ -52,12 +52,12 @@ RtpDumpSink::RtpDumpSink(talk_base::StreamInterface* stream)
 RtpDumpSink::~RtpDumpSink() {}
 
 void RtpDumpSink::SetMaxSize(size_t size) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   max_size_ = size;
 }
 
 bool RtpDumpSink::Enable(bool enable) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
 
   recording_ = enable;
 
@@ -75,7 +75,7 @@ bool RtpDumpSink::Enable(bool enable) {
 }
 
 void RtpDumpSink::OnPacket(const void* data, size_t size, bool rtcp) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
 
   if (recording_ && writer_) {
     size_t current_size;
@@ -91,7 +91,7 @@ void RtpDumpSink::OnPacket(const void* data, size_t size, bool rtcp) {
 }
 
 void RtpDumpSink::set_packet_filter(int filter) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   packet_filter_ = filter;
   if (writer_) {
     writer_->set_packet_filter(packet_filter_);
@@ -99,7 +99,7 @@ void RtpDumpSink::set_packet_filter(int filter) {
 }
 
 void RtpDumpSink::Flush() {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   if (stream_) {
     stream_->Flush();
   }
@@ -111,7 +111,7 @@ void RtpDumpSink::Flush() {
 MediaRecorder::MediaRecorder() {}
 
 MediaRecorder::~MediaRecorder() {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   std::map<BaseChannel*, SinkPair*>::iterator itr;
   for (itr = sinks_.begin(); itr != sinks_.end(); ++itr) {
     delete itr->second;
@@ -119,15 +119,15 @@ MediaRecorder::~MediaRecorder() {
 }
 
 bool MediaRecorder::AddChannel(VoiceChannel* channel,
-                               talk_base::StreamInterface* send_stream,
-                               talk_base::StreamInterface* recv_stream,
+                               rtc::StreamInterface* send_stream,
+                               rtc::StreamInterface* recv_stream,
                                int filter) {
   return InternalAddChannel(channel, false, send_stream, recv_stream,
                             filter);
 }
 bool MediaRecorder::AddChannel(VideoChannel* channel,
-                               talk_base::StreamInterface* send_stream,
-                               talk_base::StreamInterface* recv_stream,
+                               rtc::StreamInterface* send_stream,
+                               rtc::StreamInterface* recv_stream,
                                int filter) {
   return InternalAddChannel(channel, true, send_stream, recv_stream,
                             filter);
@@ -135,14 +135,14 @@ bool MediaRecorder::AddChannel(VideoChannel* channel,
 
 bool MediaRecorder::InternalAddChannel(BaseChannel* channel,
                                        bool video_channel,
-                                       talk_base::StreamInterface* send_stream,
-                                       talk_base::StreamInterface* recv_stream,
+                                       rtc::StreamInterface* send_stream,
+                                       rtc::StreamInterface* recv_stream,
                                        int filter) {
   if (!channel) {
     return false;
   }
 
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   if (sinks_.end() != sinks_.find(channel)) {
     return false;  // The channel was added already.
   }
@@ -161,7 +161,7 @@ bool MediaRecorder::InternalAddChannel(BaseChannel* channel,
 
 void MediaRecorder::RemoveChannel(BaseChannel* channel,
                                   SinkType type) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   std::map<BaseChannel*, SinkPair*>::iterator itr = sinks_.find(channel);
   if (sinks_.end() != itr) {
     channel->UnregisterSendSink(itr->second->send_sink.get(), type);
@@ -174,7 +174,7 @@ void MediaRecorder::RemoveChannel(BaseChannel* channel,
 bool MediaRecorder::EnableChannel(
     BaseChannel* channel, bool enable_send, bool enable_recv,
     SinkType type) {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   std::map<BaseChannel*, SinkPair*>::iterator itr = sinks_.find(channel);
   if (sinks_.end() == itr) {
     return false;
@@ -213,7 +213,7 @@ bool MediaRecorder::EnableChannel(
 }
 
 void MediaRecorder::FlushSinks() {
-  talk_base::CritScope cs(&critical_section_);
+  rtc::CritScope cs(&critical_section_);
   std::map<BaseChannel*, SinkPair*>::iterator itr;
   for (itr = sinks_.begin(); itr != sinks_.end(); ++itr) {
     itr->second->send_sink->Flush();
diff --git a/talk/session/media/mediarecorder.h b/talk/session/media/mediarecorder.h
index df22e984dc..aba6cf10fc 100644
--- a/talk/session/media/mediarecorder.h
+++ b/talk/session/media/mediarecorder.h
@@ -31,13 +31,13 @@
 #include <map>
 #include <string>
 
-#include "talk/base/criticalsection.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/session/media/channel.h"
 #include "talk/session/media/mediasink.h"
 
-namespace talk_base {
+namespace rtc {
 class Pathname;
 class FileStream;
 }
@@ -54,7 +54,7 @@ class RtpDumpWriter;
 class RtpDumpSink : public MediaSinkInterface, public sigslot::has_slots<> {
  public:
   // Takes ownership of stream.
-  explicit RtpDumpSink(talk_base::StreamInterface* stream);
+  explicit RtpDumpSink(rtc::StreamInterface* stream);
   virtual ~RtpDumpSink();
 
   virtual void SetMaxSize(size_t size);
@@ -69,9 +69,9 @@ class RtpDumpSink : public MediaSinkInterface, public sigslot::has_slots<> {
   size_t max_size_;
   bool recording_;
   int packet_filter_;
-  talk_base::scoped_ptr<talk_base::StreamInterface> stream_;
-  talk_base::scoped_ptr<RtpDumpWriter> writer_;
-  talk_base::CriticalSection critical_section_;
+  rtc::scoped_ptr<rtc::StreamInterface> stream_;
+  rtc::scoped_ptr<RtpDumpWriter> writer_;
+  rtc::CriticalSection critical_section_;
 
   DISALLOW_COPY_AND_ASSIGN(RtpDumpSink);
 };
@@ -82,12 +82,12 @@ class MediaRecorder {
   virtual ~MediaRecorder();
 
   bool AddChannel(VoiceChannel* channel,
-                  talk_base::StreamInterface* send_stream,
-                  talk_base::StreamInterface* recv_stream,
+                  rtc::StreamInterface* send_stream,
+                  rtc::StreamInterface* recv_stream,
                   int filter);
   bool AddChannel(VideoChannel* channel,
-                  talk_base::StreamInterface* send_stream,
-                  talk_base::StreamInterface* recv_stream,
+                  rtc::StreamInterface* send_stream,
+                  rtc::StreamInterface* recv_stream,
                   int filter);
   void RemoveChannel(BaseChannel* channel, SinkType type);
   bool EnableChannel(BaseChannel* channel, bool enable_send, bool enable_recv,
@@ -98,18 +98,18 @@ class MediaRecorder {
   struct SinkPair {
     bool video_channel;
     int filter;
-    talk_base::scoped_ptr<RtpDumpSink> send_sink;
-    talk_base::scoped_ptr<RtpDumpSink> recv_sink;
+    rtc::scoped_ptr<RtpDumpSink> send_sink;
+    rtc::scoped_ptr<RtpDumpSink> recv_sink;
   };
 
   bool InternalAddChannel(BaseChannel* channel,
                           bool video_channel,
-                          talk_base::StreamInterface* send_stream,
-                          talk_base::StreamInterface* recv_stream,
+                          rtc::StreamInterface* send_stream,
+                          rtc::StreamInterface* recv_stream,
                           int filter);
 
   std::map<BaseChannel*, SinkPair*> sinks_;
-  talk_base::CriticalSection critical_section_;
+  rtc::CriticalSection critical_section_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaRecorder);
 };
diff --git a/talk/session/media/mediarecorder_unittest.cc b/talk/session/media/mediarecorder_unittest.cc
index 5155e6dd3a..2b3d892e26 100644
--- a/talk/session/media/mediarecorder_unittest.cc
+++ b/talk/session/media/mediarecorder_unittest.cc
@@ -25,11 +25,11 @@
 
 #include <string>
 
-#include "talk/base/bytebuffer.h"
-#include "talk/base/fileutils.h"
-#include "talk/base/gunit.h"
-#include "talk/base/pathutils.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/fileutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/pathutils.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/rtpdump.h"
 #include "talk/media/base/testutils.h"
@@ -39,9 +39,9 @@
 
 namespace cricket {
 
-talk_base::StreamInterface* Open(const std::string& path) {
-  return talk_base::Filesystem::OpenFile(
-      talk_base::Pathname(path), "wb");
+rtc::StreamInterface* Open(const std::string& path) {
+  return rtc::Filesystem::OpenFile(
+      rtc::Pathname(path), "wb");
 }
 
 /////////////////////////////////////////////////////////////////////////
@@ -50,7 +50,7 @@ talk_base::StreamInterface* Open(const std::string& path) {
 class RtpDumpSinkTest : public testing::Test {
  public:
   virtual void SetUp() {
-    EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path_, true, NULL));
+    EXPECT_TRUE(rtc::Filesystem::GetTemporaryFolder(path_, true, NULL));
     path_.SetFilename("sink-test.rtpdump");
     sink_.reset(new RtpDumpSink(Open(path_.pathname())));
 
@@ -62,30 +62,30 @@ class RtpDumpSinkTest : public testing::Test {
 
   virtual void TearDown() {
     stream_.reset();
-    EXPECT_TRUE(talk_base::Filesystem::DeleteFile(path_));
+    EXPECT_TRUE(rtc::Filesystem::DeleteFile(path_));
   }
 
  protected:
   void OnRtpPacket(const RawRtpPacket& raw) {
-    talk_base::ByteBuffer buf;
+    rtc::ByteBuffer buf;
     raw.WriteToByteBuffer(RtpTestUtility::kDefaultSsrc, &buf);
     sink_->OnPacket(buf.Data(), buf.Length(), false);
   }
 
-  talk_base::StreamResult ReadPacket(RtpDumpPacket* packet) {
+  rtc::StreamResult ReadPacket(RtpDumpPacket* packet) {
     if (!stream_.get()) {
       sink_.reset();  // This will close the file. So we can read it.
-      stream_.reset(talk_base::Filesystem::OpenFile(path_, "rb"));
+      stream_.reset(rtc::Filesystem::OpenFile(path_, "rb"));
       reader_.reset(new RtpDumpReader(stream_.get()));
     }
     return reader_->ReadPacket(packet);
   }
 
-  talk_base::Pathname path_;
-  talk_base::scoped_ptr<RtpDumpSink> sink_;
-  talk_base::ByteBuffer rtp_buf_[3];
-  talk_base::scoped_ptr<talk_base::StreamInterface> stream_;
-  talk_base::scoped_ptr<RtpDumpReader> reader_;
+  rtc::Pathname path_;
+  rtc::scoped_ptr<RtpDumpSink> sink_;
+  rtc::ByteBuffer rtp_buf_[3];
+  rtc::scoped_ptr<rtc::StreamInterface> stream_;
+  rtc::scoped_ptr<RtpDumpReader> reader_;
 };
 
 TEST_F(RtpDumpSinkTest, TestRtpDumpSink) {
@@ -97,7 +97,7 @@ TEST_F(RtpDumpSinkTest, TestRtpDumpSink) {
   // Enable the sink. The 2nd packet is written.
   EXPECT_TRUE(sink_->Enable(true));
   EXPECT_TRUE(sink_->IsEnabled());
-  EXPECT_TRUE(talk_base::Filesystem::IsFile(path_.pathname()));
+  EXPECT_TRUE(rtc::Filesystem::IsFile(path_.pathname()));
   OnRtpPacket(RtpTestUtility::kTestRawRtpPackets[1]);
 
   // Disable the sink. The 3rd packet is not written.
@@ -107,10 +107,10 @@ TEST_F(RtpDumpSinkTest, TestRtpDumpSink) {
 
   // Read the recorded file and verify it contains only the 2nd packet.
   RtpDumpPacket packet;
-  EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, ReadPacket(&packet));
   EXPECT_TRUE(RtpTestUtility::VerifyPacket(
       &packet, &RtpTestUtility::kTestRawRtpPackets[1], false));
-  EXPECT_EQ(talk_base::SR_EOS, ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, ReadPacket(&packet));
 }
 
 TEST_F(RtpDumpSinkTest, TestRtpDumpSinkMaxSize) {
@@ -128,10 +128,10 @@ TEST_F(RtpDumpSinkTest, TestRtpDumpSinkMaxSize) {
 
   // Read the recorded file and verify that it contains only the first packet.
   RtpDumpPacket packet;
-  EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, ReadPacket(&packet));
   EXPECT_TRUE(RtpTestUtility::VerifyPacket(
       &packet, &RtpTestUtility::kTestRawRtpPackets[0], false));
-  EXPECT_EQ(talk_base::SR_EOS, ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, ReadPacket(&packet));
 }
 
 TEST_F(RtpDumpSinkTest, TestRtpDumpSinkFilter) {
@@ -158,13 +158,13 @@ TEST_F(RtpDumpSinkTest, TestRtpDumpSinkFilter) {
   // Read the recorded file and verify the header of the first packet and
   // the whole packet for the second packet.
   RtpDumpPacket packet;
-  EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, ReadPacket(&packet));
   EXPECT_TRUE(RtpTestUtility::VerifyPacket(
       &packet, &RtpTestUtility::kTestRawRtpPackets[0], true));
-  EXPECT_EQ(talk_base::SR_SUCCESS, ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_SUCCESS, ReadPacket(&packet));
   EXPECT_TRUE(RtpTestUtility::VerifyPacket(
       &packet, &RtpTestUtility::kTestRawRtpPackets[1], false));
-  EXPECT_EQ(talk_base::SR_EOS, ReadPacket(&packet));
+  EXPECT_EQ(rtc::SR_EOS, ReadPacket(&packet));
 }
 
 /////////////////////////////////////////////////////////////////////////
@@ -174,7 +174,7 @@ void TestMediaRecorder(BaseChannel* channel,
                        FakeVideoMediaChannel* video_media_channel,
                        int filter) {
   // Create media recorder.
-  talk_base::scoped_ptr<MediaRecorder> recorder(new MediaRecorder);
+  rtc::scoped_ptr<MediaRecorder> recorder(new MediaRecorder);
   // Fail to EnableChannel before AddChannel.
   EXPECT_FALSE(recorder->EnableChannel(channel, true, true, SINK_PRE_CRYPTO));
   EXPECT_FALSE(channel->HasSendSinks(SINK_PRE_CRYPTO));
@@ -183,8 +183,8 @@ void TestMediaRecorder(BaseChannel* channel,
   EXPECT_FALSE(channel->HasRecvSinks(SINK_POST_CRYPTO));
 
   // Add the channel to the recorder.
-  talk_base::Pathname path;
-  EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path, true, NULL));
+  rtc::Pathname path;
+  EXPECT_TRUE(rtc::Filesystem::GetTemporaryFolder(path, true, NULL));
   path.SetFilename("send.rtpdump");
   std::string send_file = path.pathname();
   path.SetFilename("recv.rtpdump");
@@ -247,8 +247,8 @@ void TestMediaRecorder(BaseChannel* channel,
 
   // Delete all files.
   recorder.reset();
-  EXPECT_TRUE(talk_base::Filesystem::DeleteFile(send_file));
-  EXPECT_TRUE(talk_base::Filesystem::DeleteFile(recv_file));
+  EXPECT_TRUE(rtc::Filesystem::DeleteFile(send_file));
+  EXPECT_TRUE(rtc::Filesystem::DeleteFile(recv_file));
 }
 
 // Fisrt start recording header and then start recording media. Verify that
@@ -256,10 +256,10 @@ void TestMediaRecorder(BaseChannel* channel,
 void TestRecordHeaderAndMedia(BaseChannel* channel,
                               FakeVideoMediaChannel* video_media_channel) {
   // Create RTP header recorder.
-  talk_base::scoped_ptr<MediaRecorder> header_recorder(new MediaRecorder);
+  rtc::scoped_ptr<MediaRecorder> header_recorder(new MediaRecorder);
 
-  talk_base::Pathname path;
-  EXPECT_TRUE(talk_base::Filesystem::GetTemporaryFolder(path, true, NULL));
+  rtc::Pathname path;
+  EXPECT_TRUE(rtc::Filesystem::GetTemporaryFolder(path, true, NULL));
   path.SetFilename("send-header.rtpdump");
   std::string send_header_file = path.pathname();
   path.SetFilename("recv-header.rtpdump");
@@ -287,11 +287,11 @@ void TestRecordHeaderAndMedia(BaseChannel* channel,
   }
 
   // Verify that header files are created.
-  EXPECT_TRUE(talk_base::Filesystem::IsFile(send_header_file));
-  EXPECT_TRUE(talk_base::Filesystem::IsFile(recv_header_file));
+  EXPECT_TRUE(rtc::Filesystem::IsFile(send_header_file));
+  EXPECT_TRUE(rtc::Filesystem::IsFile(recv_header_file));
 
   // Create RTP header recorder.
-  talk_base::scoped_ptr<MediaRecorder> recorder(new MediaRecorder);
+  rtc::scoped_ptr<MediaRecorder> recorder(new MediaRecorder);
   path.SetFilename("send.rtpdump");
   std::string send_file = path.pathname();
   path.SetFilename("recv.rtpdump");
@@ -318,23 +318,23 @@ void TestRecordHeaderAndMedia(BaseChannel* channel,
   }
 
   // Verify that media files are created.
-  EXPECT_TRUE(talk_base::Filesystem::IsFile(send_file));
-  EXPECT_TRUE(talk_base::Filesystem::IsFile(recv_file));
+  EXPECT_TRUE(rtc::Filesystem::IsFile(send_file));
+  EXPECT_TRUE(rtc::Filesystem::IsFile(recv_file));
 
   // Delete all files.
   header_recorder.reset();
   recorder.reset();
-  EXPECT_TRUE(talk_base::Filesystem::DeleteFile(send_header_file));
-  EXPECT_TRUE(talk_base::Filesystem::DeleteFile(recv_header_file));
-  EXPECT_TRUE(talk_base::Filesystem::DeleteFile(send_file));
-  EXPECT_TRUE(talk_base::Filesystem::DeleteFile(recv_file));
+  EXPECT_TRUE(rtc::Filesystem::DeleteFile(send_header_file));
+  EXPECT_TRUE(rtc::Filesystem::DeleteFile(recv_header_file));
+  EXPECT_TRUE(rtc::Filesystem::DeleteFile(send_file));
+  EXPECT_TRUE(rtc::Filesystem::DeleteFile(recv_file));
 }
 
 TEST(MediaRecorderTest, TestMediaRecorderVoiceChannel) {
   // Create the voice channel.
   FakeSession session(true);
   FakeMediaEngine media_engine;
-  VoiceChannel channel(talk_base::Thread::Current(), &media_engine,
+  VoiceChannel channel(rtc::Thread::Current(), &media_engine,
                        new FakeVoiceMediaChannel(NULL), &session, "", false);
   EXPECT_TRUE(channel.Init());
   TestMediaRecorder(&channel, NULL, PF_RTPPACKET);
@@ -347,7 +347,7 @@ TEST(MediaRecorderTest, TestMediaRecorderVideoChannel) {
   FakeSession session(true);
   FakeMediaEngine media_engine;
   FakeVideoMediaChannel* media_channel = new FakeVideoMediaChannel(NULL);
-  VideoChannel channel(talk_base::Thread::Current(), &media_engine,
+  VideoChannel channel(rtc::Thread::Current(), &media_engine,
                        media_channel, &session, "", false, NULL);
   EXPECT_TRUE(channel.Init());
   TestMediaRecorder(&channel, media_channel, PF_RTPPACKET);
diff --git a/talk/session/media/mediasession.cc b/talk/session/media/mediasession.cc
index a5b1eb0c6f..a250632284 100644
--- a/talk/session/media/mediasession.cc
+++ b/talk/session/media/mediasession.cc
@@ -32,10 +32,10 @@
 #include <set>
 #include <utility>
 
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/cryptoparams.h"
 #include "talk/p2p/base/constants.h"
@@ -55,7 +55,7 @@ const char kInline[] = "inline:";
 
 namespace cricket {
 
-using talk_base::scoped_ptr;
+using rtc::scoped_ptr;
 
 // RTP Profile names
 // http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xml
@@ -89,7 +89,7 @@ static bool CreateCryptoParams(int tag, const std::string& cipher,
   std::string key;
   key.reserve(SRTP_MASTER_KEY_BASE64_LEN);
 
-  if (!talk_base::CreateRandomString(SRTP_MASTER_KEY_BASE64_LEN, &key)) {
+  if (!rtc::CreateRandomString(SRTP_MASTER_KEY_BASE64_LEN, &key)) {
     return false;
   }
   out->tag = tag;
@@ -236,7 +236,7 @@ static bool GenerateCname(const StreamParamsVec& params_vec,
   // Generate a random string for the RTCP CNAME, as stated in RFC 6222.
   // This string is only used for synchronization, and therefore is opaque.
   do {
-    if (!talk_base::CreateRandomString(16, cname)) {
+    if (!rtc::CreateRandomString(16, cname)) {
       ASSERT(false);
       return false;
     }
@@ -254,7 +254,7 @@ static void GenerateSsrcs(const StreamParamsVec& params_vec,
   for (int i = 0; i < num_ssrcs; i++) {
     uint32 candidate;
     do {
-      candidate = talk_base::CreateRandomNonZeroId();
+      candidate = rtc::CreateRandomNonZeroId();
     } while (GetStreamBySsrc(params_vec, candidate, NULL) ||
              std::count(ssrcs->begin(), ssrcs->end(), candidate) > 0);
     ssrcs->push_back(candidate);
@@ -270,7 +270,7 @@ static bool GenerateSctpSid(const StreamParamsVec& params_vec,
     return false;
   }
   while (true) {
-    uint32 candidate = talk_base::CreateRandomNonZeroId() % kMaxSctpSid;
+    uint32 candidate = rtc::CreateRandomNonZeroId() % kMaxSctpSid;
     if (!GetStreamBySsrc(params_vec, candidate, NULL)) {
       *sid = candidate;
       return true;
@@ -610,7 +610,7 @@ static bool IsRtpContent(SessionDescription* sdesc,
       return false;
     }
     is_rtp = media_desc->protocol().empty() ||
-             talk_base::starts_with(media_desc->protocol().data(),
+             rtc::starts_with(media_desc->protocol().data(),
                                     kMediaProtocolRtpPrefix);
   }
   return is_rtp;
@@ -820,7 +820,7 @@ static void FindCodecsToOffer(
     if (!FindMatchingCodec<C>(*offered_codecs, *it, NULL) && IsRtxCodec(*it)) {
       C rtx_codec = *it;
       int referenced_pl_type =
-          talk_base::FromString<int>(0,
+          rtc::FromString<int>(0,
               rtx_codec.params[kCodecParamAssociatedPayloadType]);
       new_rtx_codecs.insert(std::pair<int, C>(referenced_pl_type,
                                               rtx_codec));
@@ -843,7 +843,7 @@ static void FindCodecsToOffer(
       if (rtx_it != new_rtx_codecs.end()) {
         C& rtx_codec = rtx_it->second;
         rtx_codec.params[kCodecParamAssociatedPayloadType] =
-            talk_base::ToString(codec.id);
+            rtc::ToString(codec.id);
       }
     }
   }
@@ -1592,7 +1592,7 @@ bool MediaSessionDescriptionFactory::AddTransportOffer(
      return false;
   const TransportDescription* current_tdesc =
       GetTransportDescription(content_name, current_desc);
-  talk_base::scoped_ptr<TransportDescription> new_tdesc(
+  rtc::scoped_ptr<TransportDescription> new_tdesc(
       transport_desc_factory_->CreateOffer(transport_options, current_tdesc));
   bool ret = (new_tdesc.get() != NULL &&
       offer_desc->AddTransportInfo(TransportInfo(content_name, *new_tdesc)));
diff --git a/talk/session/media/mediasession.h b/talk/session/media/mediasession.h
index 5041de0a97..6abee3a179 100644
--- a/talk/session/media/mediasession.h
+++ b/talk/session/media/mediasession.h
@@ -34,7 +34,7 @@
 #include <vector>
 #include <algorithm>
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/cryptoparams.h"
diff --git a/talk/session/media/mediasession_unittest.cc b/talk/session/media/mediasession_unittest.cc
index b76cce48cf..78c162f809 100644
--- a/talk/session/media/mediasession_unittest.cc
+++ b/talk/session/media/mediasession_unittest.cc
@@ -28,10 +28,10 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/gunit.h"
-#include "talk/base/fakesslidentity.h"
-#include "talk/base/messagedigest.h"
-#include "talk/base/ssladapter.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/fakesslidentity.h"
+#include "webrtc/base/messagedigest.h"
+#include "webrtc/base/ssladapter.h"
 #include "talk/media/base/codec.h"
 #include "talk/media/base/testutils.h"
 #include "talk/p2p/base/constants.h"
@@ -198,11 +198,11 @@ class MediaSessionDescriptionFactoryTest : public testing::Test {
   }
 
   static void SetUpTestCase() {
-    talk_base::InitializeSSL();
+    rtc::InitializeSSL();
   }
 
   static void TearDownTestCase() {
-    talk_base::CleanupSSL();
+    rtc::CleanupSSL();
   }
 
   // Create a video StreamParamsVec object with:
@@ -252,8 +252,8 @@ class MediaSessionDescriptionFactoryTest : public testing::Test {
     const std::string current_video_pwd = "current_video_pwd";
     const std::string current_data_ufrag = "current_data_ufrag";
     const std::string current_data_pwd = "current_data_pwd";
-    talk_base::scoped_ptr<SessionDescription> current_desc;
-    talk_base::scoped_ptr<SessionDescription> desc;
+    rtc::scoped_ptr<SessionDescription> current_desc;
+    rtc::scoped_ptr<SessionDescription> desc;
     if (has_current_desc) {
       current_desc.reset(new SessionDescription());
       EXPECT_TRUE(current_desc->AddTransportInfo(
@@ -275,7 +275,7 @@ class MediaSessionDescriptionFactoryTest : public testing::Test {
     if (offer) {
       desc.reset(f1_.CreateOffer(options, current_desc.get()));
     } else {
-      talk_base::scoped_ptr<SessionDescription> offer;
+      rtc::scoped_ptr<SessionDescription> offer;
       offer.reset(f1_.CreateOffer(options, NULL));
       desc.reset(f1_.CreateAnswer(offer.get(), options, current_desc.get()));
     }
@@ -348,8 +348,8 @@ class MediaSessionDescriptionFactoryTest : public testing::Test {
     options.has_audio = true;
     options.has_video = true;
     options.data_channel_type = cricket::DCT_RTP;
-    talk_base::scoped_ptr<SessionDescription> ref_desc;
-    talk_base::scoped_ptr<SessionDescription> desc;
+    rtc::scoped_ptr<SessionDescription> ref_desc;
+    rtc::scoped_ptr<SessionDescription> desc;
     if (offer) {
       options.bundle_enabled = false;
       ref_desc.reset(f1_.CreateOffer(options, NULL));
@@ -399,7 +399,7 @@ class MediaSessionDescriptionFactoryTest : public testing::Test {
       cricket::MediaContentDirection expected_direction_in_answer) {
     MediaSessionOptions opts;
     opts.has_video = true;
-    talk_base::scoped_ptr<SessionDescription> offer(
+    rtc::scoped_ptr<SessionDescription> offer(
         f1_.CreateOffer(opts, NULL));
     ASSERT_TRUE(offer.get() != NULL);
     ContentInfo* ac_offer= offer->GetContentByName("audio");
@@ -413,7 +413,7 @@ class MediaSessionDescriptionFactoryTest : public testing::Test {
         static_cast<VideoContentDescription*>(vc_offer->description);
     vcd_offer->set_direction(direction_in_offer);
 
-    talk_base::scoped_ptr<SessionDescription> answer(
+    rtc::scoped_ptr<SessionDescription> answer(
         f2_.CreateAnswer(offer.get(), opts, NULL));
     const AudioContentDescription* acd_answer =
         GetFirstAudioContentDescription(answer.get());
@@ -441,14 +441,14 @@ class MediaSessionDescriptionFactoryTest : public testing::Test {
   MediaSessionDescriptionFactory f2_;
   TransportDescriptionFactory tdf1_;
   TransportDescriptionFactory tdf2_;
-  talk_base::FakeSSLIdentity id1_;
-  talk_base::FakeSSLIdentity id2_;
+  rtc::FakeSSLIdentity id1_;
+  rtc::FakeSSLIdentity id2_;
 };
 
 // Create a typical audio offer, and ensure it matches what we expect.
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOffer) {
   f1_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription> offer(
+  rtc::scoped_ptr<SessionDescription> offer(
       f1_.CreateOffer(MediaSessionOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
@@ -472,7 +472,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
   MediaSessionOptions opts;
   opts.has_video = true;
   f1_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
@@ -516,7 +516,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
   opts.has_video = true;
   opts.data_channel_type = cricket::DCT_RTP;
   opts.bundle_enabled = true;
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
   offer(f2_.CreateOffer(opts, NULL));
   const VideoContentDescription* vcd =
       GetFirstVideoContentDescription(offer.get());
@@ -546,8 +546,8 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   opts.has_video = false;
   opts.data_channel_type = cricket::DCT_NONE;
   opts.bundle_enabled = true;
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   MediaSessionOptions updated_opts;
@@ -555,7 +555,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   updated_opts.has_video = true;
   updated_opts.data_channel_type = cricket::DCT_RTP;
   updated_opts.bundle_enabled = true;
-  talk_base::scoped_ptr<SessionDescription> updated_offer(f1_.CreateOffer(
+  rtc::scoped_ptr<SessionDescription> updated_offer(f1_.CreateOffer(
       updated_opts, answer.get()));
 
   const AudioContentDescription* acd =
@@ -580,7 +580,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateRtpDataOffer) {
   MediaSessionOptions opts;
   opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
@@ -617,7 +617,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSctpDataOffer) {
   opts.bundle_enabled = true;
   opts.data_channel_type = cricket::DCT_SCTP;
   f1_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   EXPECT_TRUE(offer.get() != NULL);
   EXPECT_TRUE(offer->GetContentByName("data") != NULL);
 }
@@ -628,7 +628,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   MediaSessionOptions opts;
   opts.has_video = true;
   f1_.set_add_legacy_streams(false);
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
@@ -648,10 +648,10 @@ TEST_F(MediaSessionDescriptionFactoryTest,
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswer) {
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription> offer(
+  rtc::scoped_ptr<SessionDescription> offer(
       f1_.CreateOffer(MediaSessionOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
@@ -675,9 +675,9 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswer) {
   opts.has_video = true;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
@@ -708,9 +708,9 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswer) {
   opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("data");
@@ -768,7 +768,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   opts.has_audio = false;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ContentInfo* dc_offer= offer->GetContentByName("data");
   ASSERT_TRUE(dc_offer != NULL);
   DataContentDescription* dcd_offer =
@@ -777,7 +777,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   std::string protocol = "a weird unknown protocol";
   dcd_offer->set_protocol(protocol);
 
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const ContentInfo* dc_answer = answer->GetContentByName("data");
@@ -797,13 +797,13 @@ TEST_F(MediaSessionDescriptionFactoryTest, AudioOfferAnswerWithCryptoDisabled) {
   tdf1_.set_secure(SEC_DISABLED);
   tdf2_.set_secure(SEC_DISABLED);
 
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   const AudioContentDescription* offer_acd =
       GetFirstAudioContentDescription(offer.get());
   ASSERT_TRUE(offer_acd != NULL);
   EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf), offer_acd->protocol());
 
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const ContentInfo* ac_answer = answer->GetContentByName("audio");
@@ -827,9 +827,9 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithRtpExtensions) {
   f2_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension2));
   f2_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension2));
 
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtension1),
@@ -854,9 +854,9 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_add_legacy_streams(false);
   f2_.set_add_legacy_streams(false);
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
@@ -880,7 +880,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestPartial) {
   opts.has_video = true;
   opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
@@ -921,8 +921,8 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerRtcpMux) {
   answer_opts.data_channel_type = cricket::DCT_RTP;
   offer_opts.data_channel_type = cricket::DCT_RTP;
 
-  talk_base::scoped_ptr<SessionDescription> offer;
-  talk_base::scoped_ptr<SessionDescription> answer;
+  rtc::scoped_ptr<SessionDescription> offer;
+  rtc::scoped_ptr<SessionDescription> answer;
 
   offer_opts.rtcp_mux_enabled = true;
   answer_opts.rtcp_mux_enabled = true;
@@ -1001,10 +1001,10 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerRtcpMux) {
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerToVideo) {
   MediaSessionOptions opts;
   opts.has_video = true;
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* vc = answer->GetContentByName("video");
@@ -1018,10 +1018,10 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerToVideo) {
 TEST_F(MediaSessionDescriptionFactoryTest, TestCreateNoDataAnswerToDataOffer) {
   MediaSessionOptions opts;
   opts.data_channel_type = cricket::DCT_RTP;
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
   const ContentInfo* ac = answer->GetContentByName("audio");
   const ContentInfo* dc = answer->GetContentByName("data");
@@ -1037,7 +1037,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   MediaSessionOptions opts;
   opts.has_video = true;
   opts.data_channel_type = cricket::DCT_RTP;
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   ContentInfo* ac = offer->GetContentByName("audio");
@@ -1049,7 +1049,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   ac->rejected = true;
   vc->rejected = true;
   dc->rejected = true;
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
   ac = answer->GetContentByName("audio");
   vc = answer->GetContentByName("video");
@@ -1078,7 +1078,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
   opts.AddStream(MEDIA_TYPE_DATA, kDataTrack2, kMediaStream1);
 
   f1_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* ac = offer->GetContentByName("audio");
@@ -1148,7 +1148,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
   opts.AddStream(MEDIA_TYPE_AUDIO, kAudioTrack3, kMediaStream1);
   opts.RemoveStream(MEDIA_TYPE_DATA, kDataTrack2);
   opts.AddStream(MEDIA_TYPE_DATA, kDataTrack3, kMediaStream1);
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       updated_offer(f1_.CreateOffer(opts, offer.get()));
 
   ASSERT_TRUE(updated_offer.get() != NULL);
@@ -1206,7 +1206,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSimulcastVideoOffer) {
   MediaSessionOptions opts;
   const int num_sim_layers = 3;
   opts.AddVideoStream(kVideoTrack1, kMediaStream1, num_sim_layers);
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
 
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* vc = offer->GetContentByName("video");
@@ -1235,7 +1235,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoAnswer) {
   offer_opts.data_channel_type = cricket::DCT_RTP;
   f1_.set_secure(SEC_ENABLED);
   f2_.set_secure(SEC_ENABLED);
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(offer_opts,
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(offer_opts,
                                                                   NULL));
 
   MediaSessionOptions opts;
@@ -1246,7 +1246,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoAnswer) {
   opts.AddStream(MEDIA_TYPE_DATA, kDataTrack1, kMediaStream1);
   opts.AddStream(MEDIA_TYPE_DATA, kDataTrack2, kMediaStream1);
 
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       answer(f2_.CreateAnswer(offer.get(), opts, NULL));
 
   ASSERT_TRUE(answer.get() != NULL);
@@ -1314,7 +1314,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoAnswer) {
   opts.AddStream(MEDIA_TYPE_VIDEO, kVideoTrack2, kMediaStream2);
   opts.RemoveStream(MEDIA_TYPE_AUDIO, kAudioTrack2);
   opts.RemoveStream(MEDIA_TYPE_DATA, kDataTrack2);
-  talk_base::scoped_ptr<SessionDescription>
+  rtc::scoped_ptr<SessionDescription>
       updated_answer(f2_.CreateAnswer(offer.get(), opts, answer.get()));
 
   ASSERT_TRUE(updated_answer.get() != NULL);
@@ -1370,8 +1370,8 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   opts.has_audio = true;
   opts.has_video = true;
 
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const AudioContentDescription* acd =
@@ -1382,7 +1382,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
       GetFirstVideoContentDescription(answer.get());
   EXPECT_EQ(MAKE_VECTOR(kVideoCodecsAnswer), vcd->codecs());
 
-  talk_base::scoped_ptr<SessionDescription> updated_offer(
+  rtc::scoped_ptr<SessionDescription> updated_offer(
       f2_.CreateOffer(opts, answer.get()));
 
   // The expected audio codecs are the common audio codecs from the first
@@ -1428,7 +1428,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
 
   // This creates rtx for H264 with the payload type |f1_| uses.
   rtx_f1.params[cricket::kCodecParamAssociatedPayloadType] =
-      talk_base::ToString<int>(kVideoCodecs1[1].id);
+      rtc::ToString<int>(kVideoCodecs1[1].id);
   f1_codecs.push_back(rtx_f1);
   f1_.set_video_codecs(f1_codecs);
 
@@ -1439,13 +1439,13 @@ TEST_F(MediaSessionDescriptionFactoryTest,
 
   // This creates rtx for H264 with the payload type |f2_| uses.
   rtx_f2.params[cricket::kCodecParamAssociatedPayloadType] =
-      talk_base::ToString<int>(kVideoCodecs2[0].id);
+      rtc::ToString<int>(kVideoCodecs2[0].id);
   f2_codecs.push_back(rtx_f2);
   f2_.set_video_codecs(f2_codecs);
 
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const VideoContentDescription* vcd =
@@ -1461,10 +1461,10 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   // are different from |f1_|.
   expected_codecs[0].preference = f1_codecs[1].preference;
 
-  talk_base::scoped_ptr<SessionDescription> updated_offer(
+  rtc::scoped_ptr<SessionDescription> updated_offer(
       f2_.CreateOffer(opts, answer.get()));
   ASSERT_TRUE(updated_offer);
-  talk_base::scoped_ptr<SessionDescription> updated_answer(
+  rtc::scoped_ptr<SessionDescription> updated_answer(
       f1_.CreateAnswer(updated_offer.get(), opts, answer.get()));
 
   const VideoContentDescription* updated_vcd =
@@ -1486,7 +1486,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
 
   // This creates rtx for H264 with the payload type |f1_| uses.
   rtx_f1.params[cricket::kCodecParamAssociatedPayloadType] =
-      talk_base::ToString<int>(kVideoCodecs1[1].id);
+      rtc::ToString<int>(kVideoCodecs1[1].id);
   f1_codecs.push_back(rtx_f1);
   f1_.set_video_codecs(f1_codecs);
 
@@ -1494,8 +1494,8 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   opts.has_audio = true;
   opts.has_video = false;
 
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const AudioContentDescription* acd =
@@ -1515,14 +1515,14 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   rtx_f2.id = 127;
   rtx_f2.name = cricket::kRtxCodecName;
   rtx_f2.params[cricket::kCodecParamAssociatedPayloadType] =
-      talk_base::ToString<int>(used_pl_type);
+      rtc::ToString<int>(used_pl_type);
   f2_codecs.push_back(rtx_f2);
   f2_.set_video_codecs(f2_codecs);
 
-  talk_base::scoped_ptr<SessionDescription> updated_offer(
+  rtc::scoped_ptr<SessionDescription> updated_offer(
       f2_.CreateOffer(opts, answer.get()));
   ASSERT_TRUE(updated_offer);
-  talk_base::scoped_ptr<SessionDescription> updated_answer(
+  rtc::scoped_ptr<SessionDescription> updated_answer(
       f1_.CreateAnswer(updated_offer.get(), opts, answer.get()));
 
   const AudioContentDescription* updated_acd =
@@ -1537,7 +1537,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   int new_h264_pl_type =  updated_vcd->codecs()[0].id;
   EXPECT_NE(used_pl_type, new_h264_pl_type);
   VideoCodec rtx = updated_vcd->codecs()[1];
-  int pt_referenced_by_rtx = talk_base::FromString<int>(
+  int pt_referenced_by_rtx = rtc::FromString<int>(
       rtx.params[cricket::kCodecParamAssociatedPayloadType]);
   EXPECT_EQ(new_h264_pl_type, pt_referenced_by_rtx);
 }
@@ -1562,11 +1562,11 @@ TEST_F(MediaSessionDescriptionFactoryTest, RtxWithoutApt) {
 
   // This creates rtx for H264 with the payload type |f2_| uses.
   rtx_f2.SetParam(cricket::kCodecParamAssociatedPayloadType,
-                  talk_base::ToString<int>(kVideoCodecs2[0].id));
+                  rtc::ToString<int>(kVideoCodecs2[0].id));
   f2_codecs.push_back(rtx_f2);
   f2_.set_video_codecs(f2_codecs);
 
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   // kCodecParamAssociatedPayloadType will always be added to the offer when RTX
   // is selected. Manually remove kCodecParamAssociatedPayloadType so that it
@@ -1585,7 +1585,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, RtxWithoutApt) {
   }
   desc->set_codecs(codecs);
 
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   const VideoContentDescription* vcd =
@@ -1611,8 +1611,8 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   f2_.set_audio_rtp_header_extensions(MAKE_VECTOR(kAudioRtpExtension2));
   f2_.set_video_rtp_header_extensions(MAKE_VECTOR(kVideoRtpExtension2));
 
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(opts, NULL));
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), opts, NULL));
 
   EXPECT_EQ(MAKE_VECTOR(kAudioRtpExtensionAnswer),
@@ -1622,7 +1622,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
             GetFirstVideoContentDescription(
                 answer.get())->rtp_header_extensions());
 
-  talk_base::scoped_ptr<SessionDescription> updated_offer(
+  rtc::scoped_ptr<SessionDescription> updated_offer(
       f2_.CreateOffer(opts, answer.get()));
 
   // The expected RTP header extensions in the new offer are the resulting
@@ -1668,7 +1668,7 @@ TEST(MediaSessionDescription, CopySessionDescription) {
   vcd->AddLegacyStream(2);
   source.AddContent(cricket::CN_VIDEO, cricket::NS_JINGLE_RTP, vcd);
 
-  talk_base::scoped_ptr<SessionDescription> copy(source.Copy());
+  rtc::scoped_ptr<SessionDescription> copy(source.Copy());
   ASSERT_TRUE(copy.get() != NULL);
   EXPECT_TRUE(copy->HasGroup(cricket::CN_AUDIO));
   const ContentInfo* ac = copy->GetContentByName("audio");
@@ -1808,7 +1808,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
   tdf1_.set_secure(SEC_DISABLED);
   tdf2_.set_secure(SEC_DISABLED);
 
-  talk_base::scoped_ptr<SessionDescription> offer(
+  rtc::scoped_ptr<SessionDescription> offer(
       f1_.CreateOffer(MediaSessionOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   ContentInfo* offer_content = offer->GetContentByName("audio");
@@ -1817,7 +1817,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
       static_cast<AudioContentDescription*>(offer_content->description);
   offer_audio_desc->set_protocol(cricket::kMediaProtocolDtlsSavpf);
 
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
   ASSERT_TRUE(answer != NULL);
   ContentInfo* answer_content = answer->GetContentByName("audio");
@@ -1834,7 +1834,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestOfferDtlsSavpfCreateAnswer) {
   tdf1_.set_secure(SEC_ENABLED);
   tdf2_.set_secure(SEC_ENABLED);
 
-  talk_base::scoped_ptr<SessionDescription> offer(
+  rtc::scoped_ptr<SessionDescription> offer(
       f1_.CreateOffer(MediaSessionOptions(), NULL));
   ASSERT_TRUE(offer.get() != NULL);
   ContentInfo* offer_content = offer->GetContentByName("audio");
@@ -1843,7 +1843,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestOfferDtlsSavpfCreateAnswer) {
       static_cast<AudioContentDescription*>(offer_content->description);
   offer_audio_desc->set_protocol(cricket::kMediaProtocolDtlsSavpf);
 
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), MediaSessionOptions(), NULL));
   ASSERT_TRUE(answer != NULL);
 
@@ -1867,7 +1867,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoDtls) {
   MediaSessionOptions options;
   options.has_audio = true;
   options.has_video = true;
-  talk_base::scoped_ptr<SessionDescription> offer, answer;
+  rtc::scoped_ptr<SessionDescription> offer, answer;
   const cricket::MediaContentDescription* audio_media_desc;
   const cricket::MediaContentDescription* video_media_desc;
   const cricket::TransportDescription* audio_trans_desc;
@@ -1968,10 +1968,10 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestSecureAnswerToUnsecureOffer) {
   f2_.set_secure(SEC_REQUIRED);
   tdf1_.set_secure(SEC_ENABLED);
 
-  talk_base::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(options,
+  rtc::scoped_ptr<SessionDescription> offer(f1_.CreateOffer(options,
                                                                   NULL));
   ASSERT_TRUE(offer.get() != NULL);
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f2_.CreateAnswer(offer.get(), options, NULL));
   EXPECT_TRUE(answer.get() == NULL);
 }
@@ -1988,7 +1988,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoOfferDtlsButNotSdes) {
   options.has_video = true;
   options.data_channel_type = cricket::DCT_RTP;
 
-  talk_base::scoped_ptr<SessionDescription> offer, answer;
+  rtc::scoped_ptr<SessionDescription> offer, answer;
 
   // Generate an offer with DTLS but without SDES.
   offer.reset(f1_.CreateOffer(options, NULL));
@@ -2035,7 +2035,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestVADEnableOption) {
   MediaSessionOptions options;
   options.has_audio = true;
   options.has_video = true;
-  talk_base::scoped_ptr<SessionDescription> offer(
+  rtc::scoped_ptr<SessionDescription> offer(
       f1_.CreateOffer(options, NULL));
   ASSERT_TRUE(offer.get() != NULL);
   const ContentInfo* audio_content = offer->GetContentByName("audio");
@@ -2046,7 +2046,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestVADEnableOption) {
   ASSERT_TRUE(offer.get() != NULL);
   audio_content = offer->GetContentByName("audio");
   EXPECT_TRUE(VerifyNoCNCodecs(audio_content));
-  talk_base::scoped_ptr<SessionDescription> answer(
+  rtc::scoped_ptr<SessionDescription> answer(
       f1_.CreateAnswer(offer.get(), options, NULL));
   ASSERT_TRUE(answer.get() != NULL);
   audio_content = answer->GetContentByName("audio");
diff --git a/talk/session/media/mediasessionclient.cc b/talk/session/media/mediasessionclient.cc
index 2ada987c46..8847c378c6 100644
--- a/talk/session/media/mediasessionclient.cc
+++ b/talk/session/media/mediasessionclient.cc
@@ -29,10 +29,10 @@
 
 #include "talk/session/media/mediasessionclient.h"
 
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/media/base/cryptoparams.h"
 #include "talk/media/base/capturemanager.h"
 #include "talk/media/sctp/sctpdataengine.h"
@@ -283,7 +283,7 @@ bool ParseSsrcAsLegacyStream(const std::string& ssrc_str,
                              ParseError* error) {
   if (!ssrc_str.empty()) {
     uint32 ssrc;
-    if (!talk_base::FromString(ssrc_str, &ssrc)) {
+    if (!rtc::FromString(ssrc_str, &ssrc)) {
       return BadParse("Missing or invalid ssrc.", error);
     }
 
@@ -361,7 +361,7 @@ void ParseBandwidth(const buzz::XmlElement* parent_elem,
                     MediaContentDescription* media) {
   const buzz::XmlElement* bw_elem = GetXmlChild(parent_elem, LN_BANDWIDTH);
   int bandwidth_kbps = -1;
-  if (bw_elem && talk_base::FromString(bw_elem->BodyText(), &bandwidth_kbps)) {
+  if (bw_elem && rtc::FromString(bw_elem->BodyText(), &bandwidth_kbps)) {
     if (bandwidth_kbps >= 0) {
       media->set_bandwidth(bandwidth_kbps * 1000);
     }
@@ -569,7 +569,7 @@ bool ParseJingleStreamsOrLegacySsrc(const buzz::XmlElement* desc_elem,
 bool ParseJingleAudioContent(const buzz::XmlElement* content_elem,
                              ContentDescription** content,
                              ParseError* error) {
-  talk_base::scoped_ptr<AudioContentDescription> audio(
+  rtc::scoped_ptr<AudioContentDescription> audio(
       new AudioContentDescription());
 
   FeedbackParams content_feedback_params;
@@ -611,7 +611,7 @@ bool ParseJingleAudioContent(const buzz::XmlElement* content_elem,
 bool ParseJingleVideoContent(const buzz::XmlElement* content_elem,
                              ContentDescription** content,
                              ParseError* error) {
-  talk_base::scoped_ptr<VideoContentDescription> video(
+  rtc::scoped_ptr<VideoContentDescription> video(
       new VideoContentDescription());
 
   FeedbackParams content_feedback_params;
@@ -654,7 +654,7 @@ bool ParseJingleVideoContent(const buzz::XmlElement* content_elem,
 bool ParseJingleSctpDataContent(const buzz::XmlElement* content_elem,
                                 ContentDescription** content,
                                 ParseError* error) {
-  talk_base::scoped_ptr<DataContentDescription> data(
+  rtc::scoped_ptr<DataContentDescription> data(
       new DataContentDescription());
   data->set_protocol(kMediaProtocolSctp);
 
@@ -666,7 +666,7 @@ bool ParseJingleSctpDataContent(const buzz::XmlElement* content_elem,
     stream.groupid = stream_elem->Attr(QN_NICK);
     stream.id = stream_elem->Attr(QN_NAME);
     uint32 sid;
-    if (!talk_base::FromString(stream_elem->Attr(QN_SID), &sid)) {
+    if (!rtc::FromString(stream_elem->Attr(QN_SID), &sid)) {
       return BadParse("Missing or invalid sid.", error);
     }
     if (sid > kMaxSctpSid) {
@@ -1152,7 +1152,7 @@ bool MediaSessionClient::WriteContent(SignalingProtocol protocol,
     }
   } else {
     return BadWrite("Unknown content type: " +
-                    talk_base::ToString<int>(media->type()), error);
+                    rtc::ToString<int>(media->type()), error);
   }
 
   return true;
diff --git a/talk/session/media/mediasessionclient.h b/talk/session/media/mediasessionclient.h
index d0034cafeb..33750fc310 100644
--- a/talk/session/media/mediasessionclient.h
+++ b/talk/session/media/mediasessionclient.h
@@ -32,10 +32,10 @@
 #include <vector>
 #include <map>
 #include <algorithm>
-#include "talk/base/messagequeue.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/sigslotrepeater.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/sigslotrepeater.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/cryptoparams.h"
 #include "talk/p2p/base/session.h"
 #include "talk/p2p/base/sessionclient.h"
diff --git a/talk/session/media/mediasessionclient_unittest.cc b/talk/session/media/mediasessionclient_unittest.cc
index 3f3c4fa49c..98299d02d6 100644
--- a/talk/session/media/mediasessionclient_unittest.cc
+++ b/talk/session/media/mediasessionclient_unittest.cc
@@ -28,9 +28,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/gunit.h"
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/testutils.h"
 #include "talk/media/devices/fakedevicemanager.h"
@@ -1333,7 +1333,7 @@ class JingleSessionTestParser : public MediaSessionTestParser {
   }
 
  private:
-  talk_base::scoped_ptr<buzz::XmlElement> action_;
+  rtc::scoped_ptr<buzz::XmlElement> action_;
 };
 
 class GingleSessionTestParser : public MediaSessionTestParser {
@@ -1459,7 +1459,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
  public:
   explicit MediaSessionClientTest(MediaSessionTestParser* parser,
                                   cricket::SignalingProtocol initial_protocol) {
-    nm_ = new talk_base::BasicNetworkManager();
+    nm_ = new rtc::BasicNetworkManager();
     pa_ = new cricket::BasicPortAllocator(nm_);
     sm_ = new cricket::SessionManager(pa_, NULL);
     fme_ = new cricket::FakeMediaEngine();
@@ -1714,7 +1714,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
                                 buzz::XmlElement** element) {
     *element = NULL;
 
-    talk_base::scoped_ptr<buzz::XmlElement> el(
+    rtc::scoped_ptr<buzz::XmlElement> el(
         buzz::XmlElement::ForStr(initiate_string));
     client_->session_manager()->OnIncomingMessage(el.get());
     ASSERT_TRUE(call_ != NULL);
@@ -1778,7 +1778,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
                        buzz::XmlElement** element) {
     *element = NULL;
 
-    talk_base::scoped_ptr<buzz::XmlElement> el(
+    rtc::scoped_ptr<buzz::XmlElement> el(
         buzz::XmlElement::ForStr(initiate_string));
     client_->session_manager()->OnIncomingMessage(el.get());
     ASSERT_TRUE(call_ != NULL);
@@ -1842,7 +1842,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
   }
 
   void TestBadIncomingInitiate(const std::string& initiate_string) {
-    talk_base::scoped_ptr<buzz::XmlElement> el(
+    rtc::scoped_ptr<buzz::XmlElement> el(
         buzz::XmlElement::ForStr(initiate_string));
     client_->session_manager()->OnIncomingMessage(el.get());
     ASSERT_TRUE(call_ != NULL);
@@ -2034,7 +2034,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
       } else {
         ASSERT_TRUE(bandwidth != NULL);
         ASSERT_EQ("AS", bandwidth->Attr(buzz::QName("", "type")));
-        ASSERT_EQ(talk_base::ToString(options.video_bandwidth / 1000),
+        ASSERT_EQ(rtc::ToString(options.video_bandwidth / 1000),
                   bandwidth->BodyText());
       }
 
@@ -2346,7 +2346,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
       buzz::XmlElement** element) {
     *element = NULL;
 
-    talk_base::scoped_ptr<buzz::XmlElement> el(
+    rtc::scoped_ptr<buzz::XmlElement> el(
         buzz::XmlElement::ForStr(initiate_string));
     client_->session_manager()->OnIncomingMessage(el.get());
 
@@ -2393,7 +2393,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
     ClearStanzas();
 
     // We need to insert the session ID into the session accept message.
-    talk_base::scoped_ptr<buzz::XmlElement> el(
+    rtc::scoped_ptr<buzz::XmlElement> el(
         buzz::XmlElement::ForStr(accept_string));
     const std::string sid = call_->sessions()[0]->id();
     if (initial_protocol_ == cricket::PROTOCOL_JINGLE) {
@@ -2451,12 +2451,12 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
     cricket::StreamParams stream;
     stream.id = "test-stream";
     stream.ssrcs.push_back(1001);
-    talk_base::scoped_ptr<buzz::XmlElement> expected_stream_add(
+    rtc::scoped_ptr<buzz::XmlElement> expected_stream_add(
         buzz::XmlElement::ForStr(
             JingleOutboundStreamAdd(
                 call_->sessions()[0]->id(),
                 "video", stream.id, "1001")));
-    talk_base::scoped_ptr<buzz::XmlElement> expected_stream_remove(
+    rtc::scoped_ptr<buzz::XmlElement> expected_stream_remove(
         buzz::XmlElement::ForStr(
             JingleOutboundStreamRemove(
                 call_->sessions()[0]->id(),
@@ -2489,7 +2489,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
     ASSERT_EQ(0U, last_streams_removed_.audio().size());
     ASSERT_EQ(0U, last_streams_removed_.video().size());
 
-    talk_base::scoped_ptr<buzz::XmlElement> accept_stanza(
+    rtc::scoped_ptr<buzz::XmlElement> accept_stanza(
         buzz::XmlElement::ForStr(kJingleAcceptWithSsrcs));
     SetJingleSid(accept_stanza.get());
     client_->session_manager()->OnIncomingMessage(accept_stanza.get());
@@ -2505,7 +2505,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
 
     call_->sessions()[0]->SetState(cricket::Session::STATE_INPROGRESS);
 
-    talk_base::scoped_ptr<buzz::XmlElement> streams_stanza(
+    rtc::scoped_ptr<buzz::XmlElement> streams_stanza(
         buzz::XmlElement::ForStr(
             JingleStreamAdd("video", "Bob", "video1", "ABC")));
     SetJingleSid(streams_stanza.get());
@@ -2593,7 +2593,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
     cricket::StaticVideoView staticVideoView(
         cricket::StreamSelector(5678U), 640, 480, 30);
     viewRequest.static_video_views.push_back(staticVideoView);
-    talk_base::scoped_ptr<buzz::XmlElement> expected_view_elem(
+    rtc::scoped_ptr<buzz::XmlElement> expected_view_elem(
         buzz::XmlElement::ForStr(JingleView("5678", "640", "480", "30")));
     SetJingleSid(expected_view_elem.get());
 
@@ -2731,7 +2731,7 @@ class MediaSessionClientTest : public sigslot::has_slots<> {
     last_streams_removed_.CopyFrom(removed);
   }
 
-  talk_base::NetworkManager* nm_;
+  rtc::NetworkManager* nm_;
   cricket::PortAllocator* pa_;
   cricket::SessionManager* sm_;
   cricket::FakeMediaEngine* fme_;
@@ -2764,8 +2764,8 @@ MediaSessionClientTest* JingleTest() {
 }
 
 TEST(MediaSessionTest, JingleGoodInitiateWithRtcpFb) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
 
   cricket::CallOptions options = VideoCallOptions();
   options.data_channel_type = cricket::DCT_SCTP;
@@ -2775,32 +2775,32 @@ TEST(MediaSessionTest, JingleGoodInitiateWithRtcpFb) {
 }
 
 TEST(MediaSessionTest, JingleGoodVideoInitiate) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestGoodIncomingInitiate(
       kJingleVideoInitiate, VideoCallOptions(), elem.use());
   test->TestCodecsOfVideoInitiate(elem.get());
 }
 
 TEST(MediaSessionTest, JingleGoodVideoInitiateWithBandwidth) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->ExpectVideoBandwidth(42000);
   test->TestGoodIncomingInitiate(
       kJingleVideoInitiateWithBandwidth, VideoCallOptions(), elem.use());
 }
 
 TEST(MediaSessionTest, JingleGoodVideoInitiateWithRtcpMux) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->ExpectVideoRtcpMux(true);
   test->TestGoodIncomingInitiate(
       kJingleVideoInitiateWithRtcpMux, VideoCallOptions(), elem.use());
 }
 
 TEST(MediaSessionTest, JingleGoodVideoInitiateWithRtpData) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   cricket::CallOptions options = VideoCallOptions();
   options.data_channel_type = cricket::DCT_RTP;
   test->TestGoodIncomingInitiate(
@@ -2810,8 +2810,8 @@ TEST(MediaSessionTest, JingleGoodVideoInitiateWithRtpData) {
 }
 
 TEST(MediaSessionTest, JingleGoodVideoInitiateWithSctpData) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   cricket::CallOptions options = VideoCallOptions();
   options.data_channel_type = cricket::DCT_SCTP;
   test->TestGoodIncomingInitiate(kJingleVideoInitiateWithSctpData,
@@ -2820,8 +2820,8 @@ TEST(MediaSessionTest, JingleGoodVideoInitiateWithSctpData) {
 }
 
 TEST(MediaSessionTest, JingleRejectAudio) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   cricket::CallOptions options = VideoCallOptions();
   options.has_audio = false;
   options.data_channel_type = cricket::DCT_RTP;
@@ -2829,30 +2829,30 @@ TEST(MediaSessionTest, JingleRejectAudio) {
 }
 
 TEST(MediaSessionTest, JingleRejectVideo) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   cricket::CallOptions options = AudioCallOptions();
   options.data_channel_type = cricket::DCT_RTP;
   test->TestRejectOffer(kJingleVideoInitiateWithRtpData, options, elem.use());
 }
 
 TEST(MediaSessionTest, JingleRejectData) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestRejectOffer(
       kJingleVideoInitiateWithRtpData, VideoCallOptions(), elem.use());
 }
 
 TEST(MediaSessionTest, JingleRejectVideoAndData) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestRejectOffer(
       kJingleVideoInitiateWithRtpData, AudioCallOptions(), elem.use());
 }
 
 TEST(MediaSessionTest, JingleGoodInitiateAllSupportedAudioCodecs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestGoodIncomingInitiate(
       kJingleInitiate, AudioCallOptions(), elem.use());
   test->TestHasAllSupportedAudioCodecs(elem.get());
@@ -2862,89 +2862,89 @@ TEST(MediaSessionTest, JingleGoodInitiateAllSupportedAudioCodecs) {
 // preference order than the incoming offer.
 // Verifies the answer accepts the preference order of the remote peer.
 TEST(MediaSessionTest, JingleGoodInitiateDifferentPreferenceAudioCodecs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->fme()->SetAudioCodecs(MAKE_VECTOR(kAudioCodecsDifferentPreference));
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestGoodIncomingInitiate(
       kJingleInitiate, AudioCallOptions(), elem.use());
   test->TestHasAllSupportedAudioCodecs(elem.get());
 }
 
 TEST(MediaSessionTest, JingleGoodInitiateSomeUnsupportedAudioCodecs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestGoodIncomingInitiate(
       kJingleInitiateSomeUnsupported, AudioCallOptions(), elem.use());
   test->TestHasAudioCodecsFromInitiateSomeUnsupported(elem.get());
 }
 
 TEST(MediaSessionTest, JingleGoodInitiateDynamicAudioCodecs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestGoodIncomingInitiate(
       kJingleInitiateDynamicAudioCodecs, AudioCallOptions(), elem.use());
   test->TestHasAudioCodecsFromInitiateDynamicAudioCodecs(elem.get());
 }
 
 TEST(MediaSessionTest, JingleGoodInitiateStaticAudioCodecs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestGoodIncomingInitiate(
       kJingleInitiateStaticAudioCodecs, AudioCallOptions(), elem.use());
   test->TestHasAudioCodecsFromInitiateStaticAudioCodecs(elem.get());
 }
 
 TEST(MediaSessionTest, JingleBadInitiateNoAudioCodecs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestBadIncomingInitiate(kJingleInitiateNoAudioCodecs);
 }
 
 TEST(MediaSessionTest, JingleBadInitiateNoSupportedAudioCodecs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestBadIncomingInitiate(kJingleInitiateNoSupportedAudioCodecs);
 }
 
 TEST(MediaSessionTest, JingleBadInitiateWrongClockrates) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestBadIncomingInitiate(kJingleInitiateWrongClockrates);
 }
 
 TEST(MediaSessionTest, JingleBadInitiateWrongChannels) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestBadIncomingInitiate(kJingleInitiateWrongChannels);
 }
 
 TEST(MediaSessionTest, JingleBadInitiateNoPayloadTypes) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestBadIncomingInitiate(kJingleInitiateNoPayloadTypes);
 }
 
 TEST(MediaSessionTest, JingleBadInitiateDynamicWithoutNames) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestBadIncomingInitiate(kJingleInitiateDynamicWithoutNames);
 }
 
 TEST(MediaSessionTest, JingleGoodOutgoingInitiate) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestGoodOutgoingInitiate(AudioCallOptions());
 }
 
 TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithBandwidth) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   cricket::CallOptions options = VideoCallOptions();
   options.video_bandwidth = 42000;
   test->TestGoodOutgoingInitiate(options);
 }
 
 TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithRtcpMux) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   cricket::CallOptions options = VideoCallOptions();
   options.rtcp_mux_enabled = true;
   test->TestGoodOutgoingInitiate(options);
 }
 
 TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithRtpData) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   cricket::CallOptions options;
   options.data_channel_type = cricket::DCT_RTP;
   test->ExpectCrypto(cricket::SEC_ENABLED);
@@ -2952,7 +2952,7 @@ TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithRtpData) {
 }
 
 TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithSctpData) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   cricket::CallOptions options;
   options.data_channel_type = cricket::DCT_SCTP;
   test->TestGoodOutgoingInitiate(options);
@@ -2962,8 +2962,8 @@ TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithSctpData) {
 
 // Offer has crypto but the session is not secured, just ignore it.
 TEST(MediaSessionTest, JingleInitiateWithCryptoIsIgnoredWhenNotSecured) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestGoodIncomingInitiate(
       AddEncryption(kJingleVideoInitiate, kJingleCryptoOffer),
       VideoCallOptions(),
@@ -2972,22 +2972,22 @@ TEST(MediaSessionTest, JingleInitiateWithCryptoIsIgnoredWhenNotSecured) {
 
 // Offer has crypto required but the session is not secure, fail.
 TEST(MediaSessionTest, JingleInitiateWithCryptoRequiredWhenNotSecured) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestBadIncomingInitiate(AddEncryption(kJingleVideoInitiate,
                                              kJingleRequiredCryptoOffer));
 }
 
 // Offer has no crypto but the session is secure required, fail.
 TEST(MediaSessionTest, JingleInitiateWithNoCryptoFailsWhenSecureRequired) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->ExpectCrypto(cricket::SEC_REQUIRED);
   test->TestBadIncomingInitiate(kJingleInitiate);
 }
 
 // Offer has crypto and session is secure, expect crypto in the answer.
 TEST(MediaSessionTest, JingleInitiateWithCryptoWhenSecureEnabled) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->ExpectCrypto(cricket::SEC_ENABLED);
   test->TestGoodIncomingInitiate(
       AddEncryption(kJingleVideoInitiate, kJingleCryptoOffer),
@@ -2998,8 +2998,8 @@ TEST(MediaSessionTest, JingleInitiateWithCryptoWhenSecureEnabled) {
 // Offer has crypto and session is secure required, expect crypto in
 // the answer.
 TEST(MediaSessionTest, JingleInitiateWithCryptoWhenSecureRequired) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->ExpectCrypto(cricket::SEC_REQUIRED);
   test->TestGoodIncomingInitiate(
       AddEncryption(kJingleVideoInitiate, kJingleCryptoOffer),
@@ -3010,8 +3010,8 @@ TEST(MediaSessionTest, JingleInitiateWithCryptoWhenSecureRequired) {
 // Offer has unsupported crypto and session is secure, no crypto in
 // the answer.
 TEST(MediaSessionTest, JingleInitiateWithUnsupportedCrypto) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->MakeSignalingSecure(cricket::SEC_ENABLED);
   test->TestGoodIncomingInitiate(
       AddEncryption(kJingleInitiate, kJingleUnsupportedCryptoOffer),
@@ -3021,14 +3021,14 @@ TEST(MediaSessionTest, JingleInitiateWithUnsupportedCrypto) {
 
 // Offer has unsupported REQUIRED crypto and session is not secure, fail.
 TEST(MediaSessionTest, JingleInitiateWithRequiredUnsupportedCrypto) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestBadIncomingInitiate(
       AddEncryption(kJingleInitiate, kJingleRequiredUnsupportedCryptoOffer));
 }
 
 // Offer has unsupported REQUIRED crypto and session is secure, fail.
 TEST(MediaSessionTest, JingleInitiateWithRequiredUnsupportedCryptoWhenSecure) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->MakeSignalingSecure(cricket::SEC_ENABLED);
   test->TestBadIncomingInitiate(
       AddEncryption(kJingleInitiate, kJingleRequiredUnsupportedCryptoOffer));
@@ -3037,7 +3037,7 @@ TEST(MediaSessionTest, JingleInitiateWithRequiredUnsupportedCryptoWhenSecure) {
 // Offer has unsupported REQUIRED crypto and session is required secure, fail.
 TEST(MediaSessionTest,
      JingleInitiateWithRequiredUnsupportedCryptoWhenSecureRequired) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->MakeSignalingSecure(cricket::SEC_REQUIRED);
   test->TestBadIncomingInitiate(
       AddEncryption(kJingleInitiate, kJingleRequiredUnsupportedCryptoOffer));
@@ -3045,26 +3045,26 @@ TEST(MediaSessionTest,
 
 
 TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithCrypto) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->ExpectCrypto(cricket::SEC_ENABLED);
   test->TestGoodOutgoingInitiate(AudioCallOptions());
 }
 
 TEST(MediaSessionTest, JingleGoodOutgoingInitiateWithCryptoRequired) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->ExpectCrypto(cricket::SEC_REQUIRED);
   test->TestGoodOutgoingInitiate(AudioCallOptions());
 }
 
 TEST(MediaSessionTest, JingleIncomingAcceptWithSsrcs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   cricket::CallOptions options = VideoCallOptions();
   options.is_muc = true;
   test->TestIncomingAcceptWithSsrcs(kJingleAcceptWithSsrcs, options);
 }
 
 TEST(MediaSessionTest, JingleIncomingAcceptWithRtpDataSsrcs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   cricket::CallOptions options = VideoCallOptions();
   options.is_muc = true;
   options.data_channel_type = cricket::DCT_RTP;
@@ -3072,7 +3072,7 @@ TEST(MediaSessionTest, JingleIncomingAcceptWithRtpDataSsrcs) {
 }
 
 TEST(MediaSessionTest, JingleIncomingAcceptWithSctpData) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   cricket::CallOptions options = VideoCallOptions();
   options.is_muc = true;
   options.data_channel_type = cricket::DCT_SCTP;
@@ -3080,44 +3080,44 @@ TEST(MediaSessionTest, JingleIncomingAcceptWithSctpData) {
 }
 
 TEST(MediaSessionTest, JingleStreamsUpdateAndView) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestStreamsUpdateAndViewRequests();
 }
 
 TEST(MediaSessionTest, JingleSendVideoStreamUpdate) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(JingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(JingleTest());
   test->TestSendVideoStreamUpdate();
 }
 
 // Gingle tests
 
 TEST(MediaSessionTest, GingleGoodVideoInitiate) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestGoodIncomingInitiate(
       kGingleVideoInitiate, VideoCallOptions(), elem.use());
   test->TestCodecsOfVideoInitiate(elem.get());
 }
 
 TEST(MediaSessionTest, GingleGoodVideoInitiateWithBandwidth) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->ExpectVideoBandwidth(42000);
   test->TestGoodIncomingInitiate(
       kGingleVideoInitiateWithBandwidth, VideoCallOptions(), elem.use());
 }
 
 TEST(MediaSessionTest, GingleGoodInitiateAllSupportedAudioCodecs) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestGoodIncomingInitiate(
       kGingleInitiate, AudioCallOptions(), elem.use());
   test->TestHasAllSupportedAudioCodecs(elem.get());
 }
 
 TEST(MediaSessionTest, GingleGoodInitiateAllSupportedAudioCodecsWithCrypto) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->ExpectCrypto(cricket::SEC_ENABLED);
   test->TestGoodIncomingInitiate(
       AddEncryption(kGingleInitiate, kGingleCryptoOffer),
@@ -3130,79 +3130,79 @@ TEST(MediaSessionTest, GingleGoodInitiateAllSupportedAudioCodecsWithCrypto) {
 // preference order than the incoming offer.
 // Verifies the answer accepts the preference order of the remote peer.
 TEST(MediaSessionTest, GingleGoodInitiateDifferentPreferenceAudioCodecs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->fme()->SetAudioCodecs(MAKE_VECTOR(kAudioCodecsDifferentPreference));
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<buzz::XmlElement> elem;
   test->TestGoodIncomingInitiate(
       kGingleInitiate, AudioCallOptions(), elem.use());
   test->TestHasAllSupportedAudioCodecs(elem.get());
 }
 
 TEST(MediaSessionTest, GingleGoodInitiateSomeUnsupportedAudioCodecs) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestGoodIncomingInitiate(
       kGingleInitiateSomeUnsupported, AudioCallOptions(), elem.use());
   test->TestHasAudioCodecsFromInitiateSomeUnsupported(elem.get());
 }
 
 TEST(MediaSessionTest, GingleGoodInitiateDynamicAudioCodecs) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestGoodIncomingInitiate(
       kGingleInitiateDynamicAudioCodecs, AudioCallOptions(), elem.use());
   test->TestHasAudioCodecsFromInitiateDynamicAudioCodecs(elem.get());
 }
 
 TEST(MediaSessionTest, GingleGoodInitiateStaticAudioCodecs) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestGoodIncomingInitiate(
       kGingleInitiateStaticAudioCodecs, AudioCallOptions(), elem.use());
   test->TestHasAudioCodecsFromInitiateStaticAudioCodecs(elem.get());
 }
 
 TEST(MediaSessionTest, GingleGoodInitiateNoAudioCodecs) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestGoodIncomingInitiate(
       kGingleInitiateNoAudioCodecs, AudioCallOptions(), elem.use());
   test->TestHasDefaultAudioCodecs(elem.get());
 }
 
 TEST(MediaSessionTest, GingleBadInitiateNoSupportedAudioCodecs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestBadIncomingInitiate(kGingleInitiateNoSupportedAudioCodecs);
 }
 
 TEST(MediaSessionTest, GingleBadInitiateWrongClockrates) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestBadIncomingInitiate(kGingleInitiateWrongClockrates);
 }
 
 TEST(MediaSessionTest, GingleBadInitiateWrongChannels) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestBadIncomingInitiate(kGingleInitiateWrongChannels);
 }
 
 
 TEST(MediaSessionTest, GingleBadInitiateNoPayloadTypes) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestBadIncomingInitiate(kGingleInitiateNoPayloadTypes);
 }
 
 TEST(MediaSessionTest, GingleBadInitiateDynamicWithoutNames) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestBadIncomingInitiate(kGingleInitiateDynamicWithoutNames);
 }
 
 TEST(MediaSessionTest, GingleGoodOutgoingInitiate) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestGoodOutgoingInitiate(AudioCallOptions());
 }
 
 TEST(MediaSessionTest, GingleGoodOutgoingInitiateWithBandwidth) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   cricket::CallOptions options = VideoCallOptions();
   options.video_bandwidth = 42000;
   test->TestGoodOutgoingInitiate(options);
@@ -3212,8 +3212,8 @@ TEST(MediaSessionTest, GingleGoodOutgoingInitiateWithBandwidth) {
 
 // Offer has crypto but the session is not secured, just ignore it.
 TEST(MediaSessionTest, GingleInitiateWithCryptoIsIgnoredWhenNotSecured) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestGoodIncomingInitiate(
       AddEncryption(kGingleInitiate, kGingleCryptoOffer),
       VideoCallOptions(),
@@ -3222,22 +3222,22 @@ TEST(MediaSessionTest, GingleInitiateWithCryptoIsIgnoredWhenNotSecured) {
 
 // Offer has crypto required but the session is not secure, fail.
 TEST(MediaSessionTest, GingleInitiateWithCryptoRequiredWhenNotSecured) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestBadIncomingInitiate(AddEncryption(kGingleInitiate,
                                              kGingleRequiredCryptoOffer));
 }
 
 // Offer has no crypto but the session is secure required, fail.
 TEST(MediaSessionTest, GingleInitiateWithNoCryptoFailsWhenSecureRequired) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->ExpectCrypto(cricket::SEC_REQUIRED);
   test->TestBadIncomingInitiate(kGingleInitiate);
 }
 
 // Offer has crypto and session is secure, expect crypto in the answer.
 TEST(MediaSessionTest, GingleInitiateWithCryptoWhenSecureEnabled) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->ExpectCrypto(cricket::SEC_ENABLED);
   test->TestGoodIncomingInitiate(
       AddEncryption(kGingleInitiate, kGingleCryptoOffer),
@@ -3248,8 +3248,8 @@ TEST(MediaSessionTest, GingleInitiateWithCryptoWhenSecureEnabled) {
 // Offer has crypto and session is secure required, expect crypto in
 // the answer.
 TEST(MediaSessionTest, GingleInitiateWithCryptoWhenSecureRequired) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->ExpectCrypto(cricket::SEC_REQUIRED);
   test->TestGoodIncomingInitiate(
       AddEncryption(kGingleInitiate, kGingleCryptoOffer),
@@ -3260,8 +3260,8 @@ TEST(MediaSessionTest, GingleInitiateWithCryptoWhenSecureRequired) {
 // Offer has unsupported crypto and session is secure, no crypto in
 // the answer.
 TEST(MediaSessionTest, GingleInitiateWithUnsupportedCrypto) {
-  talk_base::scoped_ptr<buzz::XmlElement> elem;
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<buzz::XmlElement> elem;
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->MakeSignalingSecure(cricket::SEC_ENABLED);
   test->TestGoodIncomingInitiate(
       AddEncryption(kGingleInitiate, kGingleUnsupportedCryptoOffer),
@@ -3271,14 +3271,14 @@ TEST(MediaSessionTest, GingleInitiateWithUnsupportedCrypto) {
 
 // Offer has unsupported REQUIRED crypto and session is not secure, fail.
 TEST(MediaSessionTest, GingleInitiateWithRequiredUnsupportedCrypto) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->TestBadIncomingInitiate(
       AddEncryption(kGingleInitiate, kGingleRequiredUnsupportedCryptoOffer));
 }
 
 // Offer has unsupported REQUIRED crypto and session is secure, fail.
 TEST(MediaSessionTest, GingleInitiateWithRequiredUnsupportedCryptoWhenSecure) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->MakeSignalingSecure(cricket::SEC_ENABLED);
   test->TestBadIncomingInitiate(
       AddEncryption(kGingleInitiate, kGingleRequiredUnsupportedCryptoOffer));
@@ -3287,33 +3287,33 @@ TEST(MediaSessionTest, GingleInitiateWithRequiredUnsupportedCryptoWhenSecure) {
 // Offer has unsupported REQUIRED crypto and session is required secure, fail.
 TEST(MediaSessionTest,
      GingleInitiateWithRequiredUnsupportedCryptoWhenSecureRequired) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->MakeSignalingSecure(cricket::SEC_REQUIRED);
   test->TestBadIncomingInitiate(
       AddEncryption(kGingleInitiate, kGingleRequiredUnsupportedCryptoOffer));
 }
 
 TEST(MediaSessionTest, GingleGoodOutgoingInitiateWithCrypto) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->ExpectCrypto(cricket::SEC_ENABLED);
   test->TestGoodOutgoingInitiate(AudioCallOptions());
 }
 
 TEST(MediaSessionTest, GingleGoodOutgoingInitiateWithCryptoRequired) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   test->ExpectCrypto(cricket::SEC_REQUIRED);
   test->TestGoodOutgoingInitiate(AudioCallOptions());
 }
 
 TEST(MediaSessionTest, GingleIncomingAcceptWithSsrcs) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   cricket::CallOptions options = VideoCallOptions();
   options.is_muc = true;
   test->TestIncomingAcceptWithSsrcs(kGingleAcceptWithSsrcs, options);
 }
 
 TEST(MediaSessionTest, GingleGoodOutgoingInitiateWithRtpData) {
-  talk_base::scoped_ptr<MediaSessionClientTest> test(GingleTest());
+  rtc::scoped_ptr<MediaSessionClientTest> test(GingleTest());
   cricket::CallOptions options;
   options.data_channel_type = cricket::DCT_RTP;
   test->ExpectCrypto(cricket::SEC_ENABLED);
diff --git a/talk/session/media/planarfunctions_unittest.cc b/talk/session/media/planarfunctions_unittest.cc
index 32cacf9957..3eeb64f91d 100644
--- a/talk/session/media/planarfunctions_unittest.cc
+++ b/talk/session/media/planarfunctions_unittest.cc
@@ -31,9 +31,9 @@
 #include "libyuv/format_conversion.h"
 #include "libyuv/mjpeg_decoder.h"
 #include "libyuv/planar_functions.h"
-#include "talk/base/flags.h"
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/flags.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/testutils.h"
 #include "talk/media/base/videocommon.h"
 
@@ -512,12 +512,12 @@ class PlanarFunctionsTest : public testing::TestWithParam<int> {
   int repeat_;
 
   // Y, U, V and R, G, B channels of testing colors.
-  talk_base::scoped_ptr<uint8[]> testing_color_y_;
-  talk_base::scoped_ptr<uint8[]> testing_color_u_;
-  talk_base::scoped_ptr<uint8[]> testing_color_v_;
-  talk_base::scoped_ptr<uint8[]> testing_color_r_;
-  talk_base::scoped_ptr<uint8[]> testing_color_g_;
-  talk_base::scoped_ptr<uint8[]> testing_color_b_;
+  rtc::scoped_ptr<uint8[]> testing_color_y_;
+  rtc::scoped_ptr<uint8[]> testing_color_u_;
+  rtc::scoped_ptr<uint8[]> testing_color_v_;
+  rtc::scoped_ptr<uint8[]> testing_color_r_;
+  rtc::scoped_ptr<uint8[]> testing_color_g_;
+  rtc::scoped_ptr<uint8[]> testing_color_b_;
 };
 
 TEST_F(PlanarFunctionsTest, I420Copy) {
@@ -529,12 +529,12 @@ TEST_F(PlanarFunctionsTest, I420Copy) {
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
   int block_size = 3;
   // Generate a fake input image.
-  talk_base::scoped_ptr<uint8[]> yuv_input(
+  rtc::scoped_ptr<uint8[]> yuv_input(
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
                                 libyuv::kJpegYuv420,
                                 y_pointer, u_pointer, v_pointer));
   // Allocate space for the output image.
-  talk_base::scoped_ptr<uint8[]> yuv_output(
+  rtc::scoped_ptr<uint8[]> yuv_output(
       new uint8[I420_SIZE(kHeight, kWidth) + kAlignment]);
   uint8 *y_output_pointer = ALIGNP(yuv_output.get(), kAlignment);
   uint8 *u_output_pointer = y_output_pointer + y_size;
@@ -566,12 +566,12 @@ TEST_F(PlanarFunctionsTest, I422ToI420) {
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
   int block_size = 2;
   // Generate a fake input image.
-  talk_base::scoped_ptr<uint8[]> yuv_input(
+  rtc::scoped_ptr<uint8[]> yuv_input(
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
                                 libyuv::kJpegYuv422,
                                 y_pointer, u_pointer, v_pointer));
   // Allocate space for the output image.
-  talk_base::scoped_ptr<uint8[]> yuv_output(
+  rtc::scoped_ptr<uint8[]> yuv_output(
       new uint8[I420_SIZE(kHeight, kWidth) + kAlignment]);
   uint8 *y_output_pointer = ALIGNP(yuv_output.get(), kAlignment);
   uint8 *u_output_pointer = y_output_pointer + y_size;
@@ -579,7 +579,7 @@ TEST_F(PlanarFunctionsTest, I422ToI420) {
   // Generate the expected output.
   uint8 *y_expected_pointer = NULL, *u_expected_pointer = NULL,
         *v_expected_pointer = NULL;
-  talk_base::scoped_ptr<uint8[]> yuv_output_expected(
+  rtc::scoped_ptr<uint8[]> yuv_output_expected(
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
           libyuv::kJpegYuv420,
           y_expected_pointer, u_expected_pointer, v_expected_pointer));
@@ -615,11 +615,11 @@ TEST_P(PlanarFunctionsTest, Q420ToI420) {
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
   int block_size = 2;
   // Generate a fake input image.
-  talk_base::scoped_ptr<uint8[]> yuv_input(
+  rtc::scoped_ptr<uint8[]> yuv_input(
       CreateFakeQ420TestingImage(kHeight, kWidth, block_size,
                                  y_pointer, yuy2_pointer));
   // Allocate space for the output image.
-  talk_base::scoped_ptr<uint8[]> yuv_output(
+  rtc::scoped_ptr<uint8[]> yuv_output(
       new uint8[I420_SIZE(kHeight, kWidth) + kAlignment + unalignment]);
   uint8 *y_output_pointer = ALIGNP(yuv_output.get(), kAlignment) +
       unalignment;
@@ -628,7 +628,7 @@ TEST_P(PlanarFunctionsTest, Q420ToI420) {
   // Generate the expected output.
   uint8 *y_expected_pointer = NULL, *u_expected_pointer = NULL,
         *v_expected_pointer = NULL;
-  talk_base::scoped_ptr<uint8[]> yuv_output_expected(
+  rtc::scoped_ptr<uint8[]> yuv_output_expected(
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
           libyuv::kJpegYuv420,
           y_expected_pointer, u_expected_pointer, v_expected_pointer));
@@ -662,10 +662,10 @@ TEST_P(PlanarFunctionsTest, M420ToI420) {
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
   int block_size = 2;
   // Generate a fake input image.
-  talk_base::scoped_ptr<uint8[]> yuv_input(
+  rtc::scoped_ptr<uint8[]> yuv_input(
       CreateFakeM420TestingImage(kHeight, kWidth, block_size, m420_pointer));
   // Allocate space for the output image.
-  talk_base::scoped_ptr<uint8[]> yuv_output(
+  rtc::scoped_ptr<uint8[]> yuv_output(
       new uint8[I420_SIZE(kHeight, kWidth) + kAlignment + unalignment]);
   uint8 *y_output_pointer = ALIGNP(yuv_output.get(), kAlignment) + unalignment;
   uint8 *u_output_pointer = y_output_pointer + y_size;
@@ -673,7 +673,7 @@ TEST_P(PlanarFunctionsTest, M420ToI420) {
   // Generate the expected output.
   uint8 *y_expected_pointer = NULL, *u_expected_pointer = NULL,
         *v_expected_pointer = NULL;
-  talk_base::scoped_ptr<uint8[]> yuv_output_expected(
+  rtc::scoped_ptr<uint8[]> yuv_output_expected(
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
           libyuv::kJpegYuv420,
           y_expected_pointer, u_expected_pointer, v_expected_pointer));
@@ -706,11 +706,11 @@ TEST_P(PlanarFunctionsTest, NV12ToI420) {
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
   int block_size = 2;
   // Generate a fake input image.
-  talk_base::scoped_ptr<uint8[]> yuv_input(
+  rtc::scoped_ptr<uint8[]> yuv_input(
       CreateFakeNV12TestingImage(kHeight, kWidth, block_size,
                                  y_pointer, uv_pointer));
   // Allocate space for the output image.
-  talk_base::scoped_ptr<uint8[]> yuv_output(
+  rtc::scoped_ptr<uint8[]> yuv_output(
       new uint8[I420_SIZE(kHeight, kWidth) + kAlignment + unalignment]);
   uint8 *y_output_pointer = ALIGNP(yuv_output.get(), kAlignment) + unalignment;
   uint8 *u_output_pointer = y_output_pointer + y_size;
@@ -718,7 +718,7 @@ TEST_P(PlanarFunctionsTest, NV12ToI420) {
   // Generate the expected output.
   uint8 *y_expected_pointer = NULL, *u_expected_pointer = NULL,
         *v_expected_pointer = NULL;
-  talk_base::scoped_ptr<uint8[]> yuv_output_expected(
+  rtc::scoped_ptr<uint8[]> yuv_output_expected(
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
           libyuv::kJpegYuv420,
           y_expected_pointer, u_expected_pointer, v_expected_pointer));
@@ -754,11 +754,11 @@ TEST_P(PlanarFunctionsTest, SRC_NAME##ToI420) { \
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1); \
   int block_size = 2; \
   /* Generate a fake input image.*/ \
-  talk_base::scoped_ptr<uint8[]> yuv_input( \
+  rtc::scoped_ptr<uint8[]> yuv_input( \
       CreateFakeInterleaveYuvTestingImage(kHeight, kWidth, BLOCK_SIZE, \
           yuv_pointer, FOURCC_##SRC_NAME)); \
   /* Allocate space for the output image.*/ \
-  talk_base::scoped_ptr<uint8[]> yuv_output( \
+  rtc::scoped_ptr<uint8[]> yuv_output( \
       new uint8[I420_SIZE(kHeight, kWidth) + kAlignment + unalignment]); \
   uint8 *y_output_pointer = ALIGNP(yuv_output.get(), kAlignment) + \
       unalignment; \
@@ -767,7 +767,7 @@ TEST_P(PlanarFunctionsTest, SRC_NAME##ToI420) { \
   /* Generate the expected output.*/ \
   uint8 *y_expected_pointer = NULL, *u_expected_pointer = NULL, \
         *v_expected_pointer = NULL; \
-  talk_base::scoped_ptr<uint8[]> yuv_output_expected( \
+  rtc::scoped_ptr<uint8[]> yuv_output_expected( \
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size, \
           libyuv::kJpegYuv420, \
           y_expected_pointer, u_expected_pointer, v_expected_pointer)); \
@@ -800,15 +800,15 @@ TEST_F(PlanarFunctionsTest, SRC_NAME##To##DST_NAME) { \
   int u_pitch = (kWidth + 1) >> 1; \
   int v_pitch = (kWidth + 1) >> 1; \
   /* Generate a fake input image.*/ \
-  talk_base::scoped_ptr<uint8[]> yuv_input( \
+  rtc::scoped_ptr<uint8[]> yuv_input( \
       CreateFakeYuvTestingImage(kHeight, kWidth, BLOCK_SIZE, JPG_TYPE, \
                                 y_pointer, u_pointer, v_pointer)); \
   /* Generate the expected output.*/ \
-  talk_base::scoped_ptr<uint8[]> argb_expected( \
+  rtc::scoped_ptr<uint8[]> argb_expected( \
       CreateFakeArgbTestingImage(kHeight, kWidth, BLOCK_SIZE, \
                                  argb_expected_pointer, FOURCC_##DST_NAME)); \
   /* Allocate space for the output.*/ \
-  talk_base::scoped_ptr<uint8[]> argb_output( \
+  rtc::scoped_ptr<uint8[]> argb_output( \
     new uint8[kHeight * kWidth * 4 + kAlignment]); \
   uint8 *argb_pointer = ALIGNP(argb_expected.get(), kAlignment); \
   for (int i = 0; i < repeat_; ++i) { \
@@ -844,7 +844,7 @@ TEST_F(PlanarFunctionsTest, I400ToARGB_Reference) {
   int v_pitch = (kWidth + 1) >> 1;
   int block_size = 3;
   // Generate a fake input image.
-  talk_base::scoped_ptr<uint8[]> yuv_input(
+  rtc::scoped_ptr<uint8[]> yuv_input(
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
                                 libyuv::kJpegYuv420,
                                 y_pointer, u_pointer, v_pointer));
@@ -852,14 +852,14 @@ TEST_F(PlanarFunctionsTest, I400ToARGB_Reference) {
   // U and V channels to be 128) using an I420 converter.
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
 
-  talk_base::scoped_ptr<uint8[]> uv(new uint8[uv_size + kAlignment]);
+  rtc::scoped_ptr<uint8[]> uv(new uint8[uv_size + kAlignment]);
   u_pointer = v_pointer = ALIGNP(uv.get(), kAlignment);
   memset(u_pointer, 128, uv_size);
 
   // Allocate space for the output image and generate the expected output.
-  talk_base::scoped_ptr<uint8[]> argb_expected(
+  rtc::scoped_ptr<uint8[]> argb_expected(
       new uint8[kHeight * kWidth * 4 + kAlignment]);
-  talk_base::scoped_ptr<uint8[]> argb_output(
+  rtc::scoped_ptr<uint8[]> argb_output(
       new uint8[kHeight * kWidth * 4 + kAlignment]);
   uint8 *argb_expected_pointer = ALIGNP(argb_expected.get(), kAlignment);
   uint8 *argb_pointer = ALIGNP(argb_output.get(), kAlignment);
@@ -890,7 +890,7 @@ TEST_P(PlanarFunctionsTest, I400ToARGB) {
   int v_pitch = (kWidth + 1) >> 1;
   int block_size = 3;
   // Generate a fake input image.
-  talk_base::scoped_ptr<uint8[]> yuv_input(
+  rtc::scoped_ptr<uint8[]> yuv_input(
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
                                 libyuv::kJpegYuv420,
                                 y_pointer, u_pointer, v_pointer));
@@ -899,17 +899,17 @@ TEST_P(PlanarFunctionsTest, I400ToARGB) {
   int uv_size = ((kHeight + 1) >> 1) * ((kWidth + 1) >> 1);
 
   // 1 byte extra if in the unaligned mode.
-  talk_base::scoped_ptr<uint8[]> uv(new uint8[uv_size * 2 + kAlignment]);
+  rtc::scoped_ptr<uint8[]> uv(new uint8[uv_size * 2 + kAlignment]);
   u_pointer = ALIGNP(uv.get(), kAlignment);
   v_pointer = u_pointer + uv_size;
   memset(u_pointer, 128, uv_size);
   memset(v_pointer, 128, uv_size);
 
   // Allocate space for the output image and generate the expected output.
-  talk_base::scoped_ptr<uint8[]> argb_expected(
+  rtc::scoped_ptr<uint8[]> argb_expected(
       new uint8[kHeight * kWidth * 4 + kAlignment]);
   // 1 byte extra if in the misalinged mode.
-  talk_base::scoped_ptr<uint8[]> argb_output(
+  rtc::scoped_ptr<uint8[]> argb_output(
       new uint8[kHeight * kWidth * 4 + kAlignment + unalignment]);
   uint8 *argb_expected_pointer = ALIGNP(argb_expected.get(), kAlignment);
   uint8 *argb_pointer = ALIGNP(argb_output.get(), kAlignment) + unalignment;
@@ -940,16 +940,16 @@ TEST_P(PlanarFunctionsTest, ARGBToI400) {
   uint8 *argb_pointer = NULL;
   int block_size = 3;
   // Generate a fake input image.
-  talk_base::scoped_ptr<uint8[]> argb_input(
+  rtc::scoped_ptr<uint8[]> argb_input(
       CreateFakeArgbTestingImage(kHeight, kWidth, block_size,
                                  argb_pointer, FOURCC_ARGB));
   // Generate the expected output. Only Y channel is used
-  talk_base::scoped_ptr<uint8[]> yuv_expected(
+  rtc::scoped_ptr<uint8[]> yuv_expected(
       CreateFakeYuvTestingImage(kHeight, kWidth, block_size,
                                 libyuv::kJpegYuv420,
                                 y_pointer, u_pointer, v_pointer));
   // Allocate space for the Y output.
-  talk_base::scoped_ptr<uint8[]> y_output(
+  rtc::scoped_ptr<uint8[]> y_output(
     new uint8[kHeight * kWidth + kAlignment + unalignment]);
   uint8 *y_output_pointer = ALIGNP(y_output.get(), kAlignment) + unalignment;
 
@@ -972,15 +972,15 @@ TEST_P(PlanarFunctionsTest, SRC_NAME##ToARGB) { \
   int unalignment = GetParam();  /* Get the unalignment offset.*/ \
   uint8 *argb_expected_pointer = NULL, *src_pointer = NULL; \
   /* Generate a fake input image.*/ \
-  talk_base::scoped_ptr<uint8[]> src_input(  \
+  rtc::scoped_ptr<uint8[]> src_input(  \
       CreateFakeArgbTestingImage(kHeight, kWidth, BLOCK_SIZE, \
                                  src_pointer, FOURCC_##FC_ID)); \
   /* Generate the expected output.*/ \
-  talk_base::scoped_ptr<uint8[]> argb_expected( \
+  rtc::scoped_ptr<uint8[]> argb_expected( \
       CreateFakeArgbTestingImage(kHeight, kWidth, BLOCK_SIZE, \
                                  argb_expected_pointer, FOURCC_ARGB)); \
   /* Allocate space for the output; 1 byte extra if in the unaligned mode.*/ \
-  talk_base::scoped_ptr<uint8[]> argb_output( \
+  rtc::scoped_ptr<uint8[]> argb_output( \
       new uint8[kHeight * kWidth * 4 + kAlignment + unalignment]); \
   uint8 *argb_pointer = ALIGNP(argb_output.get(), kAlignment) + unalignment; \
   for (int i = 0; i < repeat_; ++i) { \
diff --git a/talk/session/media/rtcpmuxfilter.cc b/talk/session/media/rtcpmuxfilter.cc
index 7091952fd7..f95199241e 100644
--- a/talk/session/media/rtcpmuxfilter.cc
+++ b/talk/session/media/rtcpmuxfilter.cc
@@ -27,7 +27,7 @@
 
 #include "talk/session/media/rtcpmuxfilter.h"
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 
 namespace cricket {
 
diff --git a/talk/session/media/rtcpmuxfilter.h b/talk/session/media/rtcpmuxfilter.h
index a5bb85e3c0..131c25bc5b 100644
--- a/talk/session/media/rtcpmuxfilter.h
+++ b/talk/session/media/rtcpmuxfilter.h
@@ -28,7 +28,7 @@
 #ifndef TALK_SESSION_MEDIA_RTCPMUXFILTER_H_
 #define TALK_SESSION_MEDIA_RTCPMUXFILTER_H_
 
-#include "talk/base/basictypes.h"
+#include "webrtc/base/basictypes.h"
 #include "talk/p2p/base/sessiondescription.h"
 
 namespace cricket {
diff --git a/talk/session/media/rtcpmuxfilter_unittest.cc b/talk/session/media/rtcpmuxfilter_unittest.cc
index ad3349838f..9475b52a2f 100644
--- a/talk/session/media/rtcpmuxfilter_unittest.cc
+++ b/talk/session/media/rtcpmuxfilter_unittest.cc
@@ -25,7 +25,7 @@
 
 #include "talk/session/media/rtcpmuxfilter.h"
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/testutils.h"
 
 TEST(RtcpMuxFilterTest, DemuxRtcpSender) {
diff --git a/talk/session/media/soundclip.cc b/talk/session/media/soundclip.cc
index 44f457cda5..70a3b18e26 100644
--- a/talk/session/media/soundclip.cc
+++ b/talk/session/media/soundclip.cc
@@ -33,7 +33,7 @@ enum {
   MSG_PLAYSOUND = 1,
 };
 
-struct PlaySoundMessageData : talk_base::MessageData {
+struct PlaySoundMessageData : rtc::MessageData {
   PlaySoundMessageData(const void *c,
                        int l,
                        SoundclipMedia::SoundclipFlags f)
@@ -49,7 +49,7 @@ struct PlaySoundMessageData : talk_base::MessageData {
   bool result;
 };
 
-Soundclip::Soundclip(talk_base::Thread *thread, SoundclipMedia *soundclip_media)
+Soundclip::Soundclip(rtc::Thread *thread, SoundclipMedia *soundclip_media)
     : worker_thread_(thread),
       soundclip_media_(soundclip_media) {
 }
@@ -70,7 +70,7 @@ bool Soundclip::PlaySound_w(const void *clip,
                                      flags);
 }
 
-void Soundclip::OnMessage(talk_base::Message *message) {
+void Soundclip::OnMessage(rtc::Message *message) {
   ASSERT(message->message_id == MSG_PLAYSOUND);
   PlaySoundMessageData *data =
       static_cast<PlaySoundMessageData *>(message->pdata);
diff --git a/talk/session/media/soundclip.h b/talk/session/media/soundclip.h
index f057d8de3e..9d5e52113a 100644
--- a/talk/session/media/soundclip.h
+++ b/talk/session/media/soundclip.h
@@ -28,10 +28,10 @@
 #ifndef TALK_SESSION_MEDIA_SOUNDCLIP_H_
 #define TALK_SESSION_MEDIA_SOUNDCLIP_H_
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/mediaengine.h"
 
-namespace talk_base {
+namespace rtc {
 
 class Thread;
 
@@ -41,9 +41,9 @@ namespace cricket {
 
 // Soundclip wraps SoundclipMedia to support marshalling calls to the proper
 // thread.
-class Soundclip : private talk_base::MessageHandler {
+class Soundclip : private rtc::MessageHandler {
  public:
-  Soundclip(talk_base::Thread* thread, SoundclipMedia* soundclip_media);
+  Soundclip(rtc::Thread* thread, SoundclipMedia* soundclip_media);
 
   // Plays a sound out to the speakers with the given audio stream. The stream
   // must be 16-bit little-endian 16 kHz PCM. If a stream is already playing
@@ -59,10 +59,10 @@ class Soundclip : private talk_base::MessageHandler {
                    SoundclipMedia::SoundclipFlags flags);
 
   // From MessageHandler
-  virtual void OnMessage(talk_base::Message* message);
+  virtual void OnMessage(rtc::Message* message);
 
-  talk_base::Thread* worker_thread_;
-  talk_base::scoped_ptr<SoundclipMedia> soundclip_media_;
+  rtc::Thread* worker_thread_;
+  rtc::scoped_ptr<SoundclipMedia> soundclip_media_;
 };
 
 }  // namespace cricket
diff --git a/talk/session/media/srtpfilter.cc b/talk/session/media/srtpfilter.cc
index 10e9514e1c..d189343259 100644
--- a/talk/session/media/srtpfilter.cc
+++ b/talk/session/media/srtpfilter.cc
@@ -33,10 +33,10 @@
 
 #include <algorithm>
 
-#include "talk/base/base64.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringencode.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/base64.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringencode.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/media/base/rtputils.h"
 
 // Enable this line to turn on SRTP debugging
@@ -449,7 +449,7 @@ bool SrtpFilter::ParseKeyParams(const std::string& key_params,
 
   // Fail if base64 decode fails, or the key is the wrong size.
   std::string key_b64(key_params.substr(7)), key_str;
-  if (!talk_base::Base64::Decode(key_b64, talk_base::Base64::DO_STRICT,
+  if (!rtc::Base64::Decode(key_b64, rtc::Base64::DO_STRICT,
                                  &key_str, NULL) ||
       static_cast<int>(key_str.size()) != len) {
     return false;
@@ -869,9 +869,9 @@ void SrtpStat::HandleSrtpResult(const SrtpStat::FailureKey& key) {
   if (key.error != SrtpFilter::ERROR_NONE) {
     // For errors, signal first time and wait for 1 sec.
     FailureStat* stat = &(failures_[key]);
-    uint32 current_time = talk_base::Time();
+    uint32 current_time = rtc::Time();
     if (stat->last_signal_time == 0 ||
-        talk_base::TimeDiff(current_time, stat->last_signal_time) >
+        rtc::TimeDiff(current_time, stat->last_signal_time) >
         static_cast<int>(signal_silent_time_)) {
       SignalSrtpError(key.ssrc, key.mode, key.error);
       stat->last_signal_time = current_time;
diff --git a/talk/session/media/srtpfilter.h b/talk/session/media/srtpfilter.h
index bc1735a40a..51600236ad 100644
--- a/talk/session/media/srtpfilter.h
+++ b/talk/session/media/srtpfilter.h
@@ -33,9 +33,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/basictypes.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sigslotrepeater.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslotrepeater.h"
 #include "talk/media/base/cryptoparams.h"
 #include "talk/p2p/base/sessiondescription.h"
 
@@ -182,10 +182,10 @@ class SrtpFilter {
   State state_;
   uint32 signal_silent_time_in_ms_;
   std::vector<CryptoParams> offer_params_;
-  talk_base::scoped_ptr<SrtpSession> send_session_;
-  talk_base::scoped_ptr<SrtpSession> recv_session_;
-  talk_base::scoped_ptr<SrtpSession> send_rtcp_session_;
-  talk_base::scoped_ptr<SrtpSession> recv_rtcp_session_;
+  rtc::scoped_ptr<SrtpSession> send_session_;
+  rtc::scoped_ptr<SrtpSession> recv_session_;
+  rtc::scoped_ptr<SrtpSession> send_rtcp_session_;
+  rtc::scoped_ptr<SrtpSession> recv_rtcp_session_;
   CryptoParams applied_send_params_;
   CryptoParams applied_recv_params_;
 };
@@ -241,7 +241,7 @@ class SrtpSession {
   srtp_t session_;
   int rtp_auth_tag_len_;
   int rtcp_auth_tag_len_;
-  talk_base::scoped_ptr<SrtpStat> srtp_stat_;
+  rtc::scoped_ptr<SrtpStat> srtp_stat_;
   static bool inited_;
   int last_send_seq_num_;
   DISALLOW_COPY_AND_ASSIGN(SrtpSession);
diff --git a/talk/session/media/srtpfilter_unittest.cc b/talk/session/media/srtpfilter_unittest.cc
index 4f0ebd4964..2cbe8eff09 100644
--- a/talk/session/media/srtpfilter_unittest.cc
+++ b/talk/session/media/srtpfilter_unittest.cc
@@ -25,9 +25,9 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/byteorder.h"
-#include "talk/base/gunit.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/byteorder.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/thread.h"
 #include "talk/media/base/cryptoparams.h"
 #include "talk/media/base/fakertp.h"
 #include "talk/p2p/base/sessiondescription.h"
@@ -94,7 +94,7 @@ class SrtpFilterTest : public testing::Test {
     memcpy(rtp_packet, kPcmuFrame, rtp_len);
     // In order to be able to run this test function multiple times we can not
     // use the same sequence number twice. Increase the sequence number by one.
-    talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet) + 2,
+    rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet) + 2,
                        ++sequence_number_);
     memcpy(original_rtp_packet, rtp_packet, rtp_len);
     memcpy(rtcp_packet, kRtcpReport, rtcp_len);
@@ -679,36 +679,36 @@ TEST_F(SrtpSessionTest, TestReplay) {
   EXPECT_TRUE(s2_.SetRecv(CS_AES_CM_128_HMAC_SHA1_80, kTestKey1, kTestKeyLen));
 
   // Initial sequence number.
-  talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum_big);
+  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum_big);
   EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                              &out_len));
 
   // Replay within the 1024 window should succeed.
-  talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
+  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
                      seqnum_big - replay_window + 1);
   EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                              &out_len));
 
   // Replay out side of the 1024 window should fail.
-  talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
+  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
                      seqnum_big - replay_window - 1);
   EXPECT_FALSE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                               &out_len));
 
   // Increment sequence number to a small number.
-  talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum_small);
+  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum_small);
   EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                              &out_len));
 
   // Replay around 0 but out side of the 1024 window should fail.
-  talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
+  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
                      kMaxSeqnum + seqnum_small - replay_window - 1);
   EXPECT_FALSE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                               &out_len));
 
   // Replay around 0 but within the 1024 window should succeed.
   for (uint16 seqnum = 65000; seqnum < 65003; ++seqnum) {
-    talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum);
+    rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2, seqnum);
     EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                                &out_len));
   }
@@ -718,7 +718,7 @@ TEST_F(SrtpSessionTest, TestReplay) {
   // without the fix, the loop above would keep incrementing local sequence
   // number in libsrtp, eventually the new sequence number would go out side
   // of the window.
-  talk_base::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
+  rtc::SetBE16(reinterpret_cast<uint8*>(rtp_packet_) + 2,
                      seqnum_small + 1);
   EXPECT_TRUE(s1_.ProtectRtp(rtp_packet_, rtp_len_, sizeof(rtp_packet_),
                              &out_len));
@@ -782,7 +782,7 @@ TEST_F(SrtpStatTest, TestProtectRtpError) {
   EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
   // Now the error will be triggered again.
   Reset();
-  talk_base::Thread::Current()->SleepMs(210);
+  rtc::Thread::Current()->SleepMs(210);
   srtp_stat_.AddProtectRtpResult(1, err_status_fail);
   EXPECT_EQ(1U, ssrc_);
   EXPECT_EQ(cricket::SrtpFilter::PROTECT, mode_);
@@ -806,7 +806,7 @@ TEST_F(SrtpStatTest, TestUnprotectRtpError) {
   EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
   EXPECT_EQ(cricket::SrtpFilter::ERROR_REPLAY, error_);
   Reset();
-  talk_base::Thread::Current()->SleepMs(210);
+  rtc::Thread::Current()->SleepMs(210);
   srtp_stat_.AddUnprotectRtpResult(1, err_status_replay_old);
   EXPECT_EQ(1U, ssrc_);
   EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
@@ -824,7 +824,7 @@ TEST_F(SrtpStatTest, TestUnprotectRtpError) {
   EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
   // Now the error will be triggered again.
   Reset();
-  talk_base::Thread::Current()->SleepMs(210);
+  rtc::Thread::Current()->SleepMs(210);
   srtp_stat_.AddUnprotectRtpResult(1, err_status_fail);
   EXPECT_EQ(1U, ssrc_);
   EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
@@ -851,7 +851,7 @@ TEST_F(SrtpStatTest, TestProtectRtcpError) {
   EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
   // Now the error will be triggered again.
   Reset();
-  talk_base::Thread::Current()->SleepMs(210);
+  rtc::Thread::Current()->SleepMs(210);
   srtp_stat_.AddProtectRtcpResult(err_status_fail);
   EXPECT_EQ(cricket::SrtpFilter::PROTECT, mode_);
   EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
@@ -871,7 +871,7 @@ TEST_F(SrtpStatTest, TestUnprotectRtcpError) {
   EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
   EXPECT_EQ(cricket::SrtpFilter::ERROR_REPLAY, error_);
   Reset();
-  talk_base::Thread::Current()->SleepMs(210);
+  rtc::Thread::Current()->SleepMs(210);
   srtp_stat_.AddUnprotectRtcpResult(err_status_replay_fail);
   EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
   EXPECT_EQ(cricket::SrtpFilter::ERROR_REPLAY, error_);
@@ -886,7 +886,7 @@ TEST_F(SrtpStatTest, TestUnprotectRtcpError) {
   EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_);
   // Now the error will be triggered again.
   Reset();
-  talk_base::Thread::Current()->SleepMs(210);
+  rtc::Thread::Current()->SleepMs(210);
   srtp_stat_.AddUnprotectRtcpResult(err_status_fail);
   EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, mode_);
   EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_);
diff --git a/talk/session/media/typewrapping.h.pump b/talk/session/media/typewrapping.h.pump
index 3b529277fc..2cbb20f1d0 100644
--- a/talk/session/media/typewrapping.h.pump
+++ b/talk/session/media/typewrapping.h.pump
@@ -83,7 +83,7 @@
 #ifndef TALK_SESSION_PHONE_TYPEWRAPPING_H_
 #define TALK_SESSION_PHONE_TYPEWRAPPING_H_
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 
 #ifdef OSX
 // XCode's GCC doesn't respect typedef-equivalence when casting function pointer
diff --git a/talk/session/media/typingmonitor.cc b/talk/session/media/typingmonitor.cc
index 3c5d387b83..d37aabfd88 100644
--- a/talk/session/media/typingmonitor.cc
+++ b/talk/session/media/typingmonitor.cc
@@ -27,14 +27,14 @@
 
 #include "talk/session/media/typingmonitor.h"
 
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 #include "talk/session/media/channel.h"
 
 namespace cricket {
 
 TypingMonitor::TypingMonitor(VoiceChannel* channel,
-                             talk_base::Thread* worker_thread,
+                             rtc::Thread* worker_thread,
                              const TypingMonitorOptions& settings)
     : channel_(channel),
       worker_thread_(worker_thread),
@@ -52,7 +52,7 @@ TypingMonitor::TypingMonitor(VoiceChannel* channel,
 TypingMonitor::~TypingMonitor() {
   // Shortcut any pending unmutes.
   if (has_pending_unmute_) {
-    talk_base::MessageList messages;
+    rtc::MessageList messages;
     worker_thread_->Clear(this, 0, &messages);
     ASSERT(messages.size() == 1);
     channel_->MuteStream(0, false);
@@ -75,7 +75,7 @@ void TypingMonitor::OnVoiceChannelError(uint32 ssrc,
     channel_->MuteStream(0, true);
     SignalMuted(channel_, true);
     has_pending_unmute_ = true;
-    muted_at_ = talk_base::Time();
+    muted_at_ = rtc::Time();
 
     worker_thread_->PostDelayed(mute_period_, this, 0);
     LOG(LS_INFO) << "Muting for at least " << mute_period_ << "ms.";
@@ -89,7 +89,7 @@ void TypingMonitor::OnVoiceChannelError(uint32 ssrc,
  */
 void TypingMonitor::OnChannelMuted() {
   if (has_pending_unmute_) {
-    talk_base::MessageList removed;
+    rtc::MessageList removed;
     worker_thread_->Clear(this, 0, &removed);
     ASSERT(removed.size() == 1);
     has_pending_unmute_ = false;
@@ -102,13 +102,13 @@ void TypingMonitor::OnChannelMuted() {
  * elapse since they finished and try to unmute again.  Should be called on the
  * worker thread.
  */
-void TypingMonitor::OnMessage(talk_base::Message* msg) {
+void TypingMonitor::OnMessage(rtc::Message* msg) {
   if (!channel_->IsStreamMuted(0) || !has_pending_unmute_) return;
   int silence_period = channel_->media_channel()->GetTimeSinceLastTyping();
   int expiry_time = mute_period_ - silence_period;
   if (silence_period < 0 || expiry_time < 50) {
     LOG(LS_INFO) << "Mute timeout hit, last typing " << silence_period
-                 << "ms ago, unmuting after " << talk_base::TimeSince(muted_at_)
+                 << "ms ago, unmuting after " << rtc::TimeSince(muted_at_)
                  << "ms total.";
     has_pending_unmute_ = false;
     channel_->MuteStream(0, false);
@@ -116,7 +116,7 @@ void TypingMonitor::OnMessage(talk_base::Message* msg) {
   } else {
     LOG(LS_INFO) << "Mute timeout hit, last typing " << silence_period
                  << "ms ago, check again in " << expiry_time << "ms.";
-    talk_base::Thread::Current()->PostDelayed(expiry_time, this, 0);
+    rtc::Thread::Current()->PostDelayed(expiry_time, this, 0);
   }
 }
 
diff --git a/talk/session/media/typingmonitor.h b/talk/session/media/typingmonitor.h
index c9b64e79c3..7d93e1b64e 100644
--- a/talk/session/media/typingmonitor.h
+++ b/talk/session/media/typingmonitor.h
@@ -28,10 +28,10 @@
 #ifndef TALK_SESSION_MEDIA_TYPINGMONITOR_H_
 #define TALK_SESSION_MEDIA_TYPINGMONITOR_H_
 
-#include "talk/base/messagehandler.h"
+#include "webrtc/base/messagehandler.h"
 #include "talk/media/base/mediachannel.h"
 
-namespace talk_base {
+namespace rtc {
 class Thread;
 }
 
@@ -57,9 +57,9 @@ struct TypingMonitorOptions {
  * a conference with loud keystroke audio signals.
  */
 class TypingMonitor
-    : public talk_base::MessageHandler, public sigslot::has_slots<> {
+    : public rtc::MessageHandler, public sigslot::has_slots<> {
  public:
-  TypingMonitor(VoiceChannel* channel, talk_base::Thread* worker_thread,
+  TypingMonitor(VoiceChannel* channel, rtc::Thread* worker_thread,
                 const TypingMonitorOptions& params);
   ~TypingMonitor();
 
@@ -69,10 +69,10 @@ class TypingMonitor
 
  private:
   void OnVoiceChannelError(uint32 ssrc, VoiceMediaChannel::Error error);
-  void OnMessage(talk_base::Message* msg);
+  void OnMessage(rtc::Message* msg);
 
   VoiceChannel* channel_;
-  talk_base::Thread* worker_thread_;
+  rtc::Thread* worker_thread_;
   int mute_period_;
   int muted_at_;
   bool has_pending_unmute_;
diff --git a/talk/session/media/typingmonitor_unittest.cc b/talk/session/media/typingmonitor_unittest.cc
index eb8c5bc542..e2ee3f4762 100644
--- a/talk/session/media/typingmonitor_unittest.cc
+++ b/talk/session/media/typingmonitor_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/p2p/base/fakesession.h"
 #include "talk/session/media/channel.h"
@@ -37,13 +37,13 @@ namespace cricket {
 class TypingMonitorTest : public testing::Test {
  protected:
   TypingMonitorTest() : session_(true) {
-    vc_.reset(new VoiceChannel(talk_base::Thread::Current(), &engine_,
+    vc_.reset(new VoiceChannel(rtc::Thread::Current(), &engine_,
                                engine_.CreateChannel(), &session_, "", false));
     engine_.GetVoiceChannel(0)->set_time_since_last_typing(1000);
 
     TypingMonitorOptions settings = {10, 20, 30, 40, 50};
     monitor_.reset(new TypingMonitor(vc_.get(),
-                                     talk_base::Thread::Current(),
+                                     rtc::Thread::Current(),
                                      settings));
   }
 
@@ -51,8 +51,8 @@ class TypingMonitorTest : public testing::Test {
     vc_.reset();
   }
 
-  talk_base::scoped_ptr<TypingMonitor> monitor_;
-  talk_base::scoped_ptr<VoiceChannel> vc_;
+  rtc::scoped_ptr<TypingMonitor> monitor_;
+  rtc::scoped_ptr<VoiceChannel> vc_;
   FakeMediaEngine engine_;
   FakeSession session_;
 };
diff --git a/talk/session/media/yuvscaler_unittest.cc b/talk/session/media/yuvscaler_unittest.cc
index 93ac5343aa..d732bb318e 100644
--- a/talk/session/media/yuvscaler_unittest.cc
+++ b/talk/session/media/yuvscaler_unittest.cc
@@ -29,10 +29,10 @@
 
 #include "libyuv/cpu_id.h"
 #include "libyuv/scale.h"
-#include "talk/base/basictypes.h"
-#include "talk/base/flags.h"
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/flags.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/media/base/testutils.h"
 
 #if defined(_MSC_VER)
@@ -43,7 +43,7 @@
 
 using cricket::LoadPlanarYuvTestImage;
 using cricket::DumpPlanarYuvTestImage;
-using talk_base::scoped_ptr;
+using rtc::scoped_ptr;
 
 DEFINE_bool(yuvscaler_dump, false,
     "whether to write out scaled images for inspection");
@@ -88,8 +88,8 @@ static void FlushCache(uint8* dst, int count) {
 class YuvScalerTest : public testing::Test {
  protected:
   virtual void SetUp() {
-    dump_ = *FlagList::Lookup("yuvscaler_dump")->bool_variable();
-    repeat_ = *FlagList::Lookup("yuvscaler_repeat")->int_variable();
+    dump_ = *rtc::FlagList::Lookup("yuvscaler_dump")->bool_variable();
+    repeat_ = *rtc::FlagList::Lookup("yuvscaler_repeat")->int_variable();
   }
 
   // Scale an image and compare against a Lanczos-filtered test image.
diff --git a/talk/session/tunnel/pseudotcpchannel.cc b/talk/session/tunnel/pseudotcpchannel.cc
index d95dc857d5..e407274fb5 100644
--- a/talk/session/tunnel/pseudotcpchannel.cc
+++ b/talk/session/tunnel/pseudotcpchannel.cc
@@ -26,20 +26,20 @@
  */
 
 #include <string>
-#include "talk/base/basictypes.h"
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/p2p/base/candidate.h"
 #include "talk/p2p/base/transportchannel.h"
 #include "pseudotcpchannel.h"
 
-using namespace talk_base;
+using namespace rtc;
 
 namespace cricket {
 
-extern const talk_base::ConstantLabel SESSION_STATES[];
+extern const rtc::ConstantLabel SESSION_STATES[];
 
 // MSG_WK_* - worker thread messages
 // MSG_ST_* - stream thread messages
@@ -341,7 +341,7 @@ void PseudoTcpChannel::OnChannelWritableState(TransportChannel* channel) {
 
 void PseudoTcpChannel::OnChannelRead(TransportChannel* channel,
                                      const char* data, size_t size,
-                                     const talk_base::PacketTime& packet_time,
+                                     const rtc::PacketTime& packet_time,
                                      int flags) {
   //LOG_F(LS_VERBOSE) << "(" << size << ")";
   ASSERT(worker_thread_->IsCurrent());
@@ -378,7 +378,7 @@ void PseudoTcpChannel::OnChannelConnectionChanged(TransportChannel* channel,
   int family = candidate.address().family();
   Socket* socket =
       worker_thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM);
-  talk_base::scoped_ptr<Socket> mtu_socket(socket);
+  rtc::scoped_ptr<Socket> mtu_socket(socket);
   if (socket == NULL) {
     LOG_F(LS_WARNING) << "Couldn't create socket while estimating MTU.";
   } else {
@@ -504,7 +504,7 @@ IPseudoTcpNotify::WriteResult PseudoTcpChannel::TcpWritePacket(
   ASSERT(cs_.CurrentThreadIsOwner());
   ASSERT(tcp == tcp_);
   ASSERT(NULL != channel_);
-  talk_base::PacketOptions packet_options;
+  rtc::PacketOptions packet_options;
   int sent = channel_->SendPacket(buffer, len, packet_options);
   if (sent > 0) {
     //LOG_F(LS_VERBOSE) << "(" << sent << ") Sent";
diff --git a/talk/session/tunnel/pseudotcpchannel.h b/talk/session/tunnel/pseudotcpchannel.h
index 31cd9a18b6..f8fe72ee1f 100644
--- a/talk/session/tunnel/pseudotcpchannel.h
+++ b/talk/session/tunnel/pseudotcpchannel.h
@@ -28,13 +28,13 @@
 #ifndef TALK_SESSION_TUNNEL_PSEUDOTCPCHANNEL_H_
 #define TALK_SESSION_TUNNEL_PSEUDOTCPCHANNEL_H_
 
-#include "talk/base/criticalsection.h"
-#include "talk/base/messagequeue.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/stream.h"
 #include "talk/p2p/base/pseudotcp.h"
 #include "talk/p2p/base/session.h"
 
-namespace talk_base {
+namespace rtc {
 class Thread;
 }
 
@@ -64,17 +64,17 @@ class TransportChannel;
 
 class PseudoTcpChannel
     : public IPseudoTcpNotify,
-      public talk_base::MessageHandler,
+      public rtc::MessageHandler,
       public sigslot::has_slots<> {
  public:
   // Signal thread methods
-  PseudoTcpChannel(talk_base::Thread* stream_thread,
+  PseudoTcpChannel(rtc::Thread* stream_thread,
                    Session* session);
 
   bool Connect(const std::string& content_name,
                const std::string& channel_name,
                int component);
-  talk_base::StreamInterface* GetStream();
+  rtc::StreamInterface* GetStream();
 
   sigslot::signal1<PseudoTcpChannel*> SignalChannelClosed;
 
@@ -93,15 +93,15 @@ class PseudoTcpChannel
   virtual ~PseudoTcpChannel();
 
   // Stream thread methods
-  talk_base::StreamState GetState() const;
-  talk_base::StreamResult Read(void* buffer, size_t buffer_len,
+  rtc::StreamState GetState() const;
+  rtc::StreamResult Read(void* buffer, size_t buffer_len,
                                size_t* read, int* error);
-  talk_base::StreamResult Write(const void* data, size_t data_len,
+  rtc::StreamResult Write(const void* data, size_t data_len,
                                 size_t* written, int* error);
   void Close();
 
   // Multi-thread methods
-  void OnMessage(talk_base::Message* pmsg);
+  void OnMessage(rtc::Message* pmsg);
   void AdjustClock(bool clear = true);
   void CheckDestroy();
 
@@ -111,7 +111,7 @@ class PseudoTcpChannel
   // Worker thread methods
   void OnChannelWritableState(TransportChannel* channel);
   void OnChannelRead(TransportChannel* channel, const char* data, size_t size,
-                     const talk_base::PacketTime& packet_time, int flags);
+                     const rtc::PacketTime& packet_time, int flags);
   void OnChannelConnectionChanged(TransportChannel* channel,
                                   const Candidate& candidate);
 
@@ -123,7 +123,7 @@ class PseudoTcpChannel
                                                        const char* buffer,
                                                        size_t len);
 
-  talk_base::Thread* signal_thread_, * worker_thread_, * stream_thread_;
+  rtc::Thread* signal_thread_, * worker_thread_, * stream_thread_;
   Session* session_;
   TransportChannel* channel_;
   std::string content_name_;
@@ -132,7 +132,7 @@ class PseudoTcpChannel
   InternalStream* stream_;
   bool stream_readable_, pending_read_event_;
   bool ready_to_connect_;
-  mutable talk_base::CriticalSection cs_;
+  mutable rtc::CriticalSection cs_;
 };
 
 }  // namespace cricket
diff --git a/talk/session/tunnel/securetunnelsessionclient.cc b/talk/session/tunnel/securetunnelsessionclient.cc
index 55f408387b..743a762822 100644
--- a/talk/session/tunnel/securetunnelsessionclient.cc
+++ b/talk/session/tunnel/securetunnelsessionclient.cc
@@ -28,14 +28,14 @@
 // SecureTunnelSessionClient and SecureTunnelSession implementation.
 
 #include "talk/session/tunnel/securetunnelsessionclient.h"
-#include "talk/base/basicdefs.h"
-#include "talk/base/basictypes.h"
-#include "talk/base/common.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/sslidentity.h"
-#include "talk/base/sslstreamadapter.h"
+#include "webrtc/base/basicdefs.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/sslidentity.h"
+#include "webrtc/base/sslstreamadapter.h"
 #include "talk/p2p/base/transportchannel.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/session/tunnel/pseudotcpchannel.h"
@@ -84,14 +84,14 @@ SecureTunnelSessionClient::SecureTunnelSessionClient(
     : TunnelSessionClient(jid, manager, NS_SECURE_TUNNEL) {
 }
 
-void SecureTunnelSessionClient::SetIdentity(talk_base::SSLIdentity* identity) {
+void SecureTunnelSessionClient::SetIdentity(rtc::SSLIdentity* identity) {
   ASSERT(identity_.get() == NULL);
   identity_.reset(identity);
 }
 
 bool SecureTunnelSessionClient::GenerateIdentity() {
   ASSERT(identity_.get() == NULL);
-  identity_.reset(talk_base::SSLIdentity::Generate(
+  identity_.reset(rtc::SSLIdentity::Generate(
       // The name on the certificate does not matter: the peer will
       // make sure the cert it gets during SSL negotiation matches the
       // one it got from XMPP. It would be neat to put something
@@ -112,7 +112,7 @@ bool SecureTunnelSessionClient::GenerateIdentity() {
   return true;
 }
 
-talk_base::SSLIdentity& SecureTunnelSessionClient::GetIdentity() const {
+rtc::SSLIdentity& SecureTunnelSessionClient::GetIdentity() const {
   ASSERT(identity_.get() != NULL);
   return *identity_;
 }
@@ -120,15 +120,15 @@ talk_base::SSLIdentity& SecureTunnelSessionClient::GetIdentity() const {
 // Parses a certificate from a PEM encoded string.
 // Returns NULL on failure.
 // The caller is responsible for freeing the returned object.
-static talk_base::SSLCertificate* ParseCertificate(
+static rtc::SSLCertificate* ParseCertificate(
     const std::string& pem_cert) {
   if (pem_cert.empty())
     return NULL;
-  return talk_base::SSLCertificate::FromPEMString(pem_cert);
+  return rtc::SSLCertificate::FromPEMString(pem_cert);
 }
 
 TunnelSession* SecureTunnelSessionClient::MakeTunnelSession(
-    Session* session, talk_base::Thread* stream_thread,
+    Session* session, rtc::Thread* stream_thread,
     TunnelSessionRole role) {
   return new SecureTunnelSession(this, session, stream_thread, role);
 }
@@ -156,7 +156,7 @@ void SecureTunnelSessionClient::OnIncomingTunnel(const buzz::Jid &jid,
   }
 
   // Validate the certificate
-  talk_base::scoped_ptr<talk_base::SSLCertificate> peer_cert(
+  rtc::scoped_ptr<rtc::SSLCertificate> peer_cert(
       ParseCertificate(content->client_pem_certificate));
   if (peer_cert.get() == NULL) {
     LOG(LS_ERROR)
@@ -309,16 +309,16 @@ SessionDescription* SecureTunnelSessionClient::CreateAnswer(
 
 SecureTunnelSession::SecureTunnelSession(
     SecureTunnelSessionClient* client, Session* session,
-    talk_base::Thread* stream_thread, TunnelSessionRole role)
+    rtc::Thread* stream_thread, TunnelSessionRole role)
     : TunnelSession(client, session, stream_thread),
       role_(role) {
 }
 
-talk_base::StreamInterface* SecureTunnelSession::MakeSecureStream(
-    talk_base::StreamInterface* stream) {
-  talk_base::SSLStreamAdapter* ssl_stream =
-      talk_base::SSLStreamAdapter::Create(stream);
-  talk_base::SSLIdentity* identity =
+rtc::StreamInterface* SecureTunnelSession::MakeSecureStream(
+    rtc::StreamInterface* stream) {
+  rtc::SSLStreamAdapter* ssl_stream =
+      rtc::SSLStreamAdapter::Create(stream);
+  rtc::SSLIdentity* identity =
       static_cast<SecureTunnelSessionClient*>(client_)->
       GetIdentity().GetReference();
   ssl_stream->SetIdentity(identity);
@@ -334,11 +334,11 @@ talk_base::StreamInterface* SecureTunnelSession::MakeSecureStream(
   // OnAccept()). We won't Connect() the PseudoTcpChannel until we get
   // that, so the stream will stay closed until then.  Keep a handle
   // on the streem so we can configure the peer certificate later.
-  ssl_stream_reference_.reset(new talk_base::StreamReference(ssl_stream));
+  ssl_stream_reference_.reset(new rtc::StreamReference(ssl_stream));
   return ssl_stream_reference_->NewReference();
 }
 
-talk_base::StreamInterface* SecureTunnelSession::GetStream() {
+rtc::StreamInterface* SecureTunnelSession::GetStream() {
   ASSERT(channel_ != NULL);
   ASSERT(ssl_stream_reference_.get() == NULL);
   return MakeSecureStream(channel_->GetStream());
@@ -360,7 +360,7 @@ void SecureTunnelSession::OnAccept() {
   const std::string& cert_pem =
       role_ == INITIATOR ? remote_tunnel->server_pem_certificate :
                            remote_tunnel->client_pem_certificate;
-  talk_base::scoped_ptr<talk_base::SSLCertificate> peer_cert(
+  rtc::scoped_ptr<rtc::SSLCertificate> peer_cert(
       ParseCertificate(cert_pem));
   if (peer_cert == NULL) {
     ASSERT(role_ == INITIATOR);  // when RESPONDER we validated it earlier
@@ -370,8 +370,8 @@ void SecureTunnelSession::OnAccept() {
     return;
   }
   ASSERT(ssl_stream_reference_.get() != NULL);
-  talk_base::SSLStreamAdapter* ssl_stream =
-      static_cast<talk_base::SSLStreamAdapter*>(
+  rtc::SSLStreamAdapter* ssl_stream =
+      static_cast<rtc::SSLStreamAdapter*>(
           ssl_stream_reference_->GetStream());
 
   std::string algorithm;
@@ -379,7 +379,7 @@ void SecureTunnelSession::OnAccept() {
     LOG(LS_ERROR) << "Failed to get the algorithm for the peer cert signature";
     return;
   }
-  unsigned char digest[talk_base::MessageDigest::kMaxSize];
+  unsigned char digest[rtc::MessageDigest::kMaxSize];
   size_t digest_len;
   peer_cert->ComputeDigest(algorithm, digest, ARRAY_SIZE(digest), &digest_len);
   ssl_stream->SetPeerCertificateDigest(algorithm, digest, digest_len);
diff --git a/talk/session/tunnel/securetunnelsessionclient.h b/talk/session/tunnel/securetunnelsessionclient.h
index 5c65b984d9..ef12c0792e 100644
--- a/talk/session/tunnel/securetunnelsessionclient.h
+++ b/talk/session/tunnel/securetunnelsessionclient.h
@@ -36,8 +36,8 @@
 
 #include <string>
 
-#include "talk/base/sslidentity.h"
-#include "talk/base/sslstreamadapter.h"
+#include "webrtc/base/sslidentity.h"
+#include "webrtc/base/sslstreamadapter.h"
 #include "talk/session/tunnel/tunnelsessionclient.h"
 
 namespace cricket {
@@ -66,7 +66,7 @@ class SecureTunnelSessionClient : public TunnelSessionClient {
   // Configures this client to use a preexisting SSLIdentity.
   // The client takes ownership of the identity object.
   // Use either SetIdentity or GenerateIdentity, and only once.
-  void SetIdentity(talk_base::SSLIdentity* identity);
+  void SetIdentity(rtc::SSLIdentity* identity);
 
   // Generates an identity from nothing.
   // Returns true if generation was successful.
@@ -77,7 +77,7 @@ class SecureTunnelSessionClient : public TunnelSessionClient {
   // SetIdentity() or generated by GenerateIdentity(). Call this
   // method only after our identity has been successfully established
   // by one of those methods.
-  talk_base::SSLIdentity& GetIdentity() const;
+  rtc::SSLIdentity& GetIdentity() const;
 
   // Inherited methods
   virtual void OnIncomingTunnel(const buzz::Jid& jid, Session *session);
@@ -96,7 +96,7 @@ class SecureTunnelSessionClient : public TunnelSessionClient {
 
  protected:
   virtual TunnelSession* MakeTunnelSession(
-      Session* session, talk_base::Thread* stream_thread,
+      Session* session, rtc::Thread* stream_thread,
       TunnelSessionRole role);
 
  private:
@@ -104,7 +104,7 @@ class SecureTunnelSessionClient : public TunnelSessionClient {
   // certificate part will be communicated within the session
   // description. The identity will be passed to the SSLStreamAdapter
   // and used for SSL authentication.
-  talk_base::scoped_ptr<talk_base::SSLIdentity> identity_;
+  rtc::scoped_ptr<rtc::SSLIdentity> identity_;
 
   DISALLOW_EVIL_CONSTRUCTORS(SecureTunnelSessionClient);
 };
@@ -123,13 +123,13 @@ class SecureTunnelSession : public TunnelSession {
   // role is either INITIATOR or RESPONDER, depending on who is
   // initiating the session.
   SecureTunnelSession(SecureTunnelSessionClient* client, Session* session,
-                      talk_base::Thread* stream_thread,
+                      rtc::Thread* stream_thread,
                       TunnelSessionRole role);
 
   // Returns the stream that implements the actual P2P tunnel.
   // This may be called only once. Caller is responsible for freeing
   // the returned object.
-  virtual talk_base::StreamInterface* GetStream();
+  virtual rtc::StreamInterface* GetStream();
 
  protected:
   // Inherited method: callback on accepting a session.
@@ -138,8 +138,8 @@ class SecureTunnelSession : public TunnelSession {
   // Helper method for GetStream() that Instantiates the
   // SSLStreamAdapter to wrap the PseudoTcpChannel's stream, and
   // configures it with our identity and role.
-  talk_base::StreamInterface* MakeSecureStream(
-      talk_base::StreamInterface* stream);
+  rtc::StreamInterface* MakeSecureStream(
+      rtc::StreamInterface* stream);
 
   // Our role in requesting the tunnel: INITIATOR or
   // RESPONDER. Translates to our role in SSL negotiation:
@@ -155,7 +155,7 @@ class SecureTunnelSession : public TunnelSession {
   // stream endpoint is returned early, but we need to keep a handle
   // on it so we can setup the peer certificate when we receive it
   // later.
-  talk_base::scoped_ptr<talk_base::StreamReference> ssl_stream_reference_;
+  rtc::scoped_ptr<rtc::StreamReference> ssl_stream_reference_;
 
   DISALLOW_EVIL_CONSTRUCTORS(SecureTunnelSession);
 };
diff --git a/talk/session/tunnel/tunnelsessionclient.cc b/talk/session/tunnel/tunnelsessionclient.cc
index 71d0ce1198..d8d6e3e853 100644
--- a/talk/session/tunnel/tunnelsessionclient.cc
+++ b/talk/session/tunnel/tunnelsessionclient.cc
@@ -25,12 +25,12 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/basicdefs.h"
-#include "talk/base/basictypes.h"
-#include "talk/base/common.h"
-#include "talk/base/helpers.h"
-#include "talk/base/logging.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/basicdefs.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/transportchannel.h"
 #include "talk/xmllite/xmlelement.h"
@@ -52,21 +52,21 @@ enum {
   MSG_CREATE_TUNNEL,
 };
 
-struct EventData : public talk_base::MessageData {
+struct EventData : public rtc::MessageData {
   int event, error;
   EventData(int ev, int err = 0) : event(ev), error(err) { }
 };
 
-struct CreateTunnelData : public talk_base::MessageData {
+struct CreateTunnelData : public rtc::MessageData {
   buzz::Jid jid;
   std::string description;
-  talk_base::Thread* thread;
-  talk_base::StreamInterface* stream;
+  rtc::Thread* thread;
+  rtc::StreamInterface* stream;
 };
 
-extern const talk_base::ConstantLabel SESSION_STATES[];
+extern const rtc::ConstantLabel SESSION_STATES[];
 
-const talk_base::ConstantLabel SESSION_STATES[] = {
+const rtc::ConstantLabel SESSION_STATES[] = {
   KLABEL(Session::STATE_INIT),
   KLABEL(Session::STATE_SENTINITIATE),
   KLABEL(Session::STATE_RECEIVEDINITIATE),
@@ -124,7 +124,7 @@ void TunnelSessionClientBase::OnSessionCreate(Session* session, bool received) {
   ASSERT(session_manager_->signaling_thread()->IsCurrent());
   if (received)
     sessions_.push_back(
-        MakeTunnelSession(session, talk_base::Thread::Current(), RESPONDER));
+        MakeTunnelSession(session, rtc::Thread::Current(), RESPONDER));
 }
 
 void TunnelSessionClientBase::OnSessionDestroy(Session* session) {
@@ -143,19 +143,19 @@ void TunnelSessionClientBase::OnSessionDestroy(Session* session) {
   }
 }
 
-talk_base::StreamInterface* TunnelSessionClientBase::CreateTunnel(
+rtc::StreamInterface* TunnelSessionClientBase::CreateTunnel(
     const buzz::Jid& to, const std::string& description) {
   // Valid from any thread
   CreateTunnelData data;
   data.jid = to;
   data.description = description;
-  data.thread = talk_base::Thread::Current();
+  data.thread = rtc::Thread::Current();
   data.stream = NULL;
   session_manager_->signaling_thread()->Send(this, MSG_CREATE_TUNNEL, &data);
   return data.stream;
 }
 
-talk_base::StreamInterface* TunnelSessionClientBase::AcceptTunnel(
+rtc::StreamInterface* TunnelSessionClientBase::AcceptTunnel(
     Session* session) {
   ASSERT(session_manager_->signaling_thread()->IsCurrent());
   TunnelSession* tunnel = NULL;
@@ -182,7 +182,7 @@ void TunnelSessionClientBase::DeclineTunnel(Session* session) {
   session->Reject(STR_TERMINATE_DECLINE);
 }
 
-void TunnelSessionClientBase::OnMessage(talk_base::Message* pmsg) {
+void TunnelSessionClientBase::OnMessage(rtc::Message* pmsg) {
   if (pmsg->message_id == MSG_CREATE_TUNNEL) {
     ASSERT(session_manager_->signaling_thread()->IsCurrent());
     CreateTunnelData* data = static_cast<CreateTunnelData*>(pmsg->pdata);
@@ -201,7 +201,7 @@ void TunnelSessionClientBase::OnMessage(talk_base::Message* pmsg) {
 }
 
 TunnelSession* TunnelSessionClientBase::MakeTunnelSession(
-    Session* session, talk_base::Thread* stream_thread,
+    Session* session, rtc::Thread* stream_thread,
     TunnelSessionRole /*role*/) {
   return new TunnelSession(this, session, stream_thread);
 }
@@ -288,7 +288,7 @@ SessionDescription* TunnelSessionClient::CreateOffer(
     const buzz::Jid &jid, const std::string &description) {
   SessionDescription* offer = NewTunnelSessionDescription(
       CN_TUNNEL, new TunnelContentDescription(description));
-  talk_base::scoped_ptr<TransportDescription> tdesc(
+  rtc::scoped_ptr<TransportDescription> tdesc(
       session_manager_->transport_desc_factory()->CreateOffer(
           TransportOptions(), NULL));
   if (tdesc.get()) {
@@ -313,7 +313,7 @@ SessionDescription* TunnelSessionClient::CreateAnswer(
   if (tinfo) {
     const TransportDescription* offer_tdesc = &tinfo->description;
     ASSERT(offer_tdesc != NULL);
-    talk_base::scoped_ptr<TransportDescription> tdesc(
+    rtc::scoped_ptr<TransportDescription> tdesc(
       session_manager_->transport_desc_factory()->CreateAnswer(
           offer_tdesc, TransportOptions(),  NULL));
     if (tdesc.get()) {
@@ -334,7 +334,7 @@ SessionDescription* TunnelSessionClient::CreateAnswer(
 //
 
 TunnelSession::TunnelSession(TunnelSessionClientBase* client, Session* session,
-                             talk_base::Thread* stream_thread)
+                             rtc::Thread* stream_thread)
     : client_(client), session_(session), channel_(NULL) {
   ASSERT(client_ != NULL);
   ASSERT(session_ != NULL);
@@ -349,7 +349,7 @@ TunnelSession::~TunnelSession() {
   ASSERT(channel_ == NULL);
 }
 
-talk_base::StreamInterface* TunnelSession::GetStream() {
+rtc::StreamInterface* TunnelSession::GetStream() {
   ASSERT(channel_ != NULL);
   return channel_->GetStream();
 }
@@ -375,8 +375,8 @@ Session* TunnelSession::ReleaseSession(bool channel_exists) {
 void TunnelSession::OnSessionState(BaseSession* session,
                                    BaseSession::State state) {
   LOG(LS_INFO) << "TunnelSession::OnSessionState("
-               << talk_base::nonnull(
-                    talk_base::FindLabel(state, SESSION_STATES), "Unknown")
+               << rtc::nonnull(
+                    rtc::FindLabel(state, SESSION_STATES), "Unknown")
                << ")";
   ASSERT(session == session_);
 
diff --git a/talk/session/tunnel/tunnelsessionclient.h b/talk/session/tunnel/tunnelsessionclient.h
index 55ce14a6d4..1d9b061f8e 100644
--- a/talk/session/tunnel/tunnelsessionclient.h
+++ b/talk/session/tunnel/tunnelsessionclient.h
@@ -30,8 +30,8 @@
 
 #include <vector>
 
-#include "talk/base/criticalsection.h"
-#include "talk/base/stream.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/stream.h"
 #include "talk/p2p/base/constants.h"
 #include "talk/p2p/base/pseudotcp.h"
 #include "talk/p2p/base/session.h"
@@ -54,7 +54,7 @@ enum TunnelSessionRole { INITIATOR, RESPONDER };
 
 // Base class is still abstract
 class TunnelSessionClientBase
-  : public SessionClient, public talk_base::MessageHandler {
+  : public SessionClient, public rtc::MessageHandler {
 public:
   TunnelSessionClientBase(const buzz::Jid& jid, SessionManager* manager,
                           const std::string &ns);
@@ -69,10 +69,10 @@ public:
   // This can be called on any thread.  The stream interface is
   // thread-safe, but notifications must be registered on the creating
   // thread.
-  talk_base::StreamInterface* CreateTunnel(const buzz::Jid& to,
+  rtc::StreamInterface* CreateTunnel(const buzz::Jid& to,
                                            const std::string& description);
 
-  talk_base::StreamInterface* AcceptTunnel(Session* session);
+  rtc::StreamInterface* AcceptTunnel(Session* session);
   void DeclineTunnel(Session* session);
 
   // Invoked on an incoming tunnel
@@ -88,13 +88,13 @@ public:
 
 protected:
 
-  void OnMessage(talk_base::Message* pmsg);
+  void OnMessage(rtc::Message* pmsg);
 
   // helper method to instantiate TunnelSession. By overriding this,
   // subclasses of TunnelSessionClient are able to instantiate
   // subclasses of TunnelSession instead.
   virtual TunnelSession* MakeTunnelSession(Session* session,
-                                           talk_base::Thread* stream_thread,
+                                           rtc::Thread* stream_thread,
                                            TunnelSessionRole role);
 
   buzz::Jid jid_;
@@ -155,9 +155,9 @@ class TunnelSession : public sigslot::has_slots<> {
  public:
   // Signalling thread methods
   TunnelSession(TunnelSessionClientBase* client, Session* session,
-                talk_base::Thread* stream_thread);
+                rtc::Thread* stream_thread);
 
-  virtual talk_base::StreamInterface* GetStream();
+  virtual rtc::StreamInterface* GetStream();
   bool HasSession(Session* session);
   Session* ReleaseSession(bool channel_exists);
 
diff --git a/talk/session/tunnel/tunnelsessionclient_unittest.cc b/talk/session/tunnel/tunnelsessionclient_unittest.cc
index 7370351e60..bec0c6d2df 100644
--- a/talk/session/tunnel/tunnelsessionclient_unittest.cc
+++ b/talk/session/tunnel/tunnelsessionclient_unittest.cc
@@ -26,12 +26,12 @@
  */
 
 #include <string>
-#include "talk/base/gunit.h"
-#include "talk/base/messagehandler.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stream.h"
-#include "talk/base/thread.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stream.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/p2p/base/sessionmanager.h"
 #include "talk/p2p/base/transport.h"
 #include "talk/p2p/client/fakeportallocator.h"
@@ -45,14 +45,14 @@ static const buzz::Jid kRemoteJid("remote@localhost");
 // This test fixture creates the necessary plumbing to create and run
 // two TunnelSessionClients that talk to each other.
 class TunnelSessionClientTest : public testing::Test,
-                                public talk_base::MessageHandler,
+                                public rtc::MessageHandler,
                                 public sigslot::has_slots<> {
  public:
   TunnelSessionClientTest()
-      : local_pa_(talk_base::Thread::Current(), NULL),
-        remote_pa_(talk_base::Thread::Current(), NULL),
-        local_sm_(&local_pa_, talk_base::Thread::Current()),
-        remote_sm_(&remote_pa_, talk_base::Thread::Current()),
+      : local_pa_(rtc::Thread::Current(), NULL),
+        remote_pa_(rtc::Thread::Current(), NULL),
+        local_sm_(&local_pa_, rtc::Thread::Current()),
+        remote_sm_(&remote_pa_, rtc::Thread::Current()),
         local_client_(kLocalJid, &local_sm_),
         remote_client_(kRemoteJid, &remote_sm_),
         done_(false) {
@@ -104,19 +104,19 @@ class TunnelSessionClientTest : public testing::Test,
   void OnOutgoingMessage(cricket::SessionManager* manager,
                          const buzz::XmlElement* stanza) {
     if (manager == &local_sm_) {
-      talk_base::Thread::Current()->Post(this, MSG_LSIGNAL,
-          talk_base::WrapMessageData(*stanza));
+      rtc::Thread::Current()->Post(this, MSG_LSIGNAL,
+          rtc::WrapMessageData(*stanza));
     } else if (manager == &remote_sm_) {
-      talk_base::Thread::Current()->Post(this, MSG_RSIGNAL,
-          talk_base::WrapMessageData(*stanza));
+      rtc::Thread::Current()->Post(this, MSG_RSIGNAL,
+          rtc::WrapMessageData(*stanza));
     }
   }
 
   // Need to add a "from=" attribute (normally added by the server)
   // Then route the incoming signaling message to the "other" session manager.
-  virtual void OnMessage(talk_base::Message* message) {
-    talk_base::TypedMessageData<buzz::XmlElement>* data =
-        static_cast<talk_base::TypedMessageData<buzz::XmlElement>*>(
+  virtual void OnMessage(rtc::Message* message) {
+    rtc::TypedMessageData<buzz::XmlElement>* data =
+        static_cast<rtc::TypedMessageData<buzz::XmlElement>*>(
             message->pdata);
     bool response = data->data().Attr(buzz::QN_TYPE) == buzz::STR_RESULT;
     if (message->message_id == MSG_RSIGNAL) {
@@ -150,14 +150,14 @@ class TunnelSessionClientTest : public testing::Test,
   // Read bytes out into recv_stream_ as they arrive.
   // End the test when we are notified that the local side has closed the
   // tunnel. All data has been read out at this point.
-  void OnStreamEvent(talk_base::StreamInterface* stream, int events,
+  void OnStreamEvent(rtc::StreamInterface* stream, int events,
                      int error) {
-    if (events & talk_base::SE_READ) {
+    if (events & rtc::SE_READ) {
       if (stream == remote_tunnel_.get()) {
         ReadData();
       }
     }
-    if (events & talk_base::SE_WRITE) {
+    if (events & rtc::SE_WRITE) {
       if (stream == local_tunnel_.get()) {
         bool done = false;
         WriteData(&done);
@@ -166,7 +166,7 @@ class TunnelSessionClientTest : public testing::Test,
         }
       }
     }
-    if (events & talk_base::SE_CLOSE) {
+    if (events & rtc::SE_CLOSE) {
       if (stream == remote_tunnel_.get()) {
         remote_tunnel_->Close();
         done_ = true;
@@ -179,12 +179,12 @@ class TunnelSessionClientTest : public testing::Test,
   void ReadData() {
     char block[kBlockSize];
     size_t read, position;
-    talk_base::StreamResult res;
+    rtc::StreamResult res;
     while ((res = remote_tunnel_->Read(block, sizeof(block), &read, NULL)) ==
-        talk_base::SR_SUCCESS) {
+        rtc::SR_SUCCESS) {
       recv_stream_.Write(block, read, NULL, NULL);
     }
-    ASSERT(res != talk_base::SR_EOS);
+    ASSERT(res != rtc::SR_EOS);
     recv_stream_.GetPosition(&position);
     LOG(LS_VERBOSE) << "Recv position: " << position;
   }
@@ -192,14 +192,14 @@ class TunnelSessionClientTest : public testing::Test,
   void WriteData(bool* done) {
     char block[kBlockSize];
     size_t leftover = 0, position;
-    talk_base::StreamResult res = talk_base::Flow(&send_stream_,
+    rtc::StreamResult res = rtc::Flow(&send_stream_,
         block, sizeof(block), local_tunnel_.get(), &leftover);
-    if (res == talk_base::SR_BLOCK) {
+    if (res == rtc::SR_BLOCK) {
       send_stream_.GetPosition(&position);
       send_stream_.SetPosition(position - leftover);
       LOG(LS_VERBOSE) << "Send position: " << position - leftover;
       *done = false;
-    } else if (res == talk_base::SR_SUCCESS) {
+    } else if (res == rtc::SR_SUCCESS) {
       *done = true;
     } else {
       ASSERT(false);  // shouldn't happen
@@ -213,10 +213,10 @@ class TunnelSessionClientTest : public testing::Test,
   cricket::SessionManager remote_sm_;
   cricket::TunnelSessionClient local_client_;
   cricket::TunnelSessionClient remote_client_;
-  talk_base::scoped_ptr<talk_base::StreamInterface> local_tunnel_;
-  talk_base::scoped_ptr<talk_base::StreamInterface> remote_tunnel_;
-  talk_base::MemoryStream send_stream_;
-  talk_base::MemoryStream recv_stream_;
+  rtc::scoped_ptr<rtc::StreamInterface> local_tunnel_;
+  rtc::scoped_ptr<rtc::StreamInterface> remote_tunnel_;
+  rtc::MemoryStream send_stream_;
+  rtc::MemoryStream recv_stream_;
   bool done_;
 };
 
diff --git a/talk/sound/alsasoundsystem.cc b/talk/sound/alsasoundsystem.cc
index 7a8857cdf1..fa0a0d9d57 100644
--- a/talk/sound/alsasoundsystem.cc
+++ b/talk/sound/alsasoundsystem.cc
@@ -27,12 +27,12 @@
 
 #include "talk/sound/alsasoundsystem.h"
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringutils.h"
-#include "talk/base/timeutils.h"
-#include "talk/base/worker.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringutils.h"
+#include "webrtc/base/timeutils.h"
+#include "webrtc/base/worker.h"
 #include "talk/sound/sounddevicelocator.h"
 #include "talk/sound/soundinputstreaminterface.h"
 #include "talk/sound/soundoutputstreaminterface.h"
@@ -71,7 +71,7 @@ class AlsaDeviceLocator : public SoundDeviceLocator {
       : SoundDeviceLocator(name, device_name) {
     // The ALSA descriptions have newlines in them, which won't show up in
     // a drop-down box. Replace them with hyphens.
-    talk_base::replace_substrs(kAlsaDescriptionSearch,
+    rtc::replace_substrs(kAlsaDescriptionSearch,
                                sizeof(kAlsaDescriptionSearch) - 1,
                                kAlsaDescriptionReplace,
                                sizeof(kAlsaDescriptionReplace) - 1,
@@ -163,7 +163,7 @@ class AlsaStream {
       return 0;
     }
     // The delay is in frames. Convert to microseconds.
-    return delay * talk_base::kNumMicrosecsPerSec / freq_;
+    return delay * rtc::kNumMicrosecsPerSec / freq_;
   }
 
   // Used to recover from certain recoverable errors, principally buffer overrun
@@ -246,7 +246,7 @@ class AlsaStream {
 // thread-safety.
 class AlsaInputStream :
     public SoundInputStreamInterface,
-    private talk_base::Worker {
+    private rtc::Worker {
  public:
   AlsaInputStream(AlsaSoundSystem *alsa,
                   snd_pcm_t *handle,
@@ -342,7 +342,7 @@ class AlsaInputStream :
   }
 
   AlsaStream stream_;
-  talk_base::scoped_ptr<char[]> buffer_;
+  rtc::scoped_ptr<char[]> buffer_;
   size_t buffer_size_;
 
   DISALLOW_COPY_AND_ASSIGN(AlsaInputStream);
@@ -352,7 +352,7 @@ class AlsaInputStream :
 // regarding thread-safety.
 class AlsaOutputStream :
     public SoundOutputStreamInterface,
-    private talk_base::Worker {
+    private rtc::Worker {
  public:
   AlsaOutputStream(AlsaSoundSystem *alsa,
                    snd_pcm_t *handle,
@@ -584,7 +584,7 @@ bool AlsaSoundSystem::EnumerateDevices(
     if (strcmp(name, ignore_default) != 0 &&
         strcmp(name, ignore_null) != 0 &&
         strcmp(name, ignore_pulse) != 0 &&
-        !talk_base::starts_with(name, ignore_prefix)) {
+        !rtc::starts_with(name, ignore_prefix)) {
 
       // Yes, we do.
       char *desc = symbol_table_.snd_device_name_get_hint()(*list, "DESC");
@@ -672,12 +672,12 @@ StreamInterface *AlsaSoundSystem::OpenDevice(
   } else {
     // kLowLatency is 0, so we treat it the same as a request for zero latency.
     // Compute what the user asked for.
-    latency = talk_base::kNumMicrosecsPerSec *
+    latency = rtc::kNumMicrosecsPerSec *
         params.latency /
         params.freq /
         FrameSize(params);
     // And this is what we'll actually use.
-    latency = talk_base::_max(latency, kMinimumLatencyUsecs);
+    latency = rtc::_max(latency, kMinimumLatencyUsecs);
   }
 
   ASSERT(static_cast<int>(params.format) <
@@ -708,7 +708,7 @@ StreamInterface *AlsaSoundSystem::OpenDevice(
       FrameSize(params),
       // We set the wait time to twice the requested latency, so that wait
       // timeouts should be rare.
-      2 * latency / talk_base::kNumMicrosecsPerMillisec,
+      2 * latency / rtc::kNumMicrosecsPerMillisec,
       params.flags,
       params.freq);
   if (stream) {
diff --git a/talk/sound/alsasoundsystem.h b/talk/sound/alsasoundsystem.h
index 870f25ee3a..1e0813588c 100644
--- a/talk/sound/alsasoundsystem.h
+++ b/talk/sound/alsasoundsystem.h
@@ -28,7 +28,7 @@
 #ifndef TALK_SOUND_ALSASOUNDSYSTEM_H_
 #define TALK_SOUND_ALSASOUNDSYSTEM_H_
 
-#include "talk/base/constructormagic.h"
+#include "webrtc/base/constructormagic.h"
 #include "talk/sound/alsasymboltable.h"
 #include "talk/sound/soundsysteminterface.h"
 
diff --git a/talk/sound/alsasymboltable.cc b/talk/sound/alsasymboltable.cc
index 290c7290b2..570b4b4961 100644
--- a/talk/sound/alsasymboltable.cc
+++ b/talk/sound/alsasymboltable.cc
@@ -32,6 +32,6 @@ namespace cricket {
 #define LATE_BINDING_SYMBOL_TABLE_CLASS_NAME ALSA_SYMBOLS_CLASS_NAME
 #define LATE_BINDING_SYMBOL_TABLE_SYMBOLS_LIST ALSA_SYMBOLS_LIST
 #define LATE_BINDING_SYMBOL_TABLE_DLL_NAME "libasound.so.2"
-#include "talk/base/latebindingsymboltable.cc.def"
+#include "webrtc/base/latebindingsymboltable.cc.def"
 
 }  // namespace cricket
diff --git a/talk/sound/alsasymboltable.h b/talk/sound/alsasymboltable.h
index cf7803f37e..98f1645d10 100644
--- a/talk/sound/alsasymboltable.h
+++ b/talk/sound/alsasymboltable.h
@@ -30,7 +30,7 @@
 
 #include <alsa/asoundlib.h>
 
-#include "talk/base/latebindingsymboltable.h"
+#include "webrtc/base/latebindingsymboltable.h"
 
 namespace cricket {
 
@@ -59,7 +59,7 @@ namespace cricket {
 
 #define LATE_BINDING_SYMBOL_TABLE_CLASS_NAME ALSA_SYMBOLS_CLASS_NAME
 #define LATE_BINDING_SYMBOL_TABLE_SYMBOLS_LIST ALSA_SYMBOLS_LIST
-#include "talk/base/latebindingsymboltable.h.def"
+#include "webrtc/base/latebindingsymboltable.h.def"
 
 }  // namespace cricket
 
diff --git a/talk/sound/automaticallychosensoundsystem.h b/talk/sound/automaticallychosensoundsystem.h
index 026c080e6b..afe62c3ce0 100644
--- a/talk/sound/automaticallychosensoundsystem.h
+++ b/talk/sound/automaticallychosensoundsystem.h
@@ -28,9 +28,9 @@
 #ifndef TALK_SOUND_AUTOMATICALLYCHOSENSOUNDSYSTEM_H_
 #define TALK_SOUND_AUTOMATICALLYCHOSENSOUNDSYSTEM_H_
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/sound/soundsysteminterface.h"
 #include "talk/sound/soundsystemproxy.h"
 
@@ -54,7 +54,7 @@ class AutomaticallyChosenSoundSystem : public SoundSystemProxy {
   virtual const char *GetName() const;
 
  private:
-  talk_base::scoped_ptr<SoundSystemInterface> sound_systems_[kNumSoundSystems];
+  rtc::scoped_ptr<SoundSystemInterface> sound_systems_[kNumSoundSystems];
 };
 
 template <const SoundSystemCreator kSoundSystemCreators[], int kNumSoundSystems>
diff --git a/talk/sound/automaticallychosensoundsystem_unittest.cc b/talk/sound/automaticallychosensoundsystem_unittest.cc
index a8afeecb43..a57b283876 100644
--- a/talk/sound/automaticallychosensoundsystem_unittest.cc
+++ b/talk/sound/automaticallychosensoundsystem_unittest.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/sound/automaticallychosensoundsystem.h"
 #include "talk/sound/nullsoundsystem.h"
 
diff --git a/talk/sound/nullsoundsystem.cc b/talk/sound/nullsoundsystem.cc
index 29200086e2..fc16ccbabd 100644
--- a/talk/sound/nullsoundsystem.cc
+++ b/talk/sound/nullsoundsystem.cc
@@ -27,12 +27,12 @@
 
 #include "talk/sound/nullsoundsystem.h"
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/sound/sounddevicelocator.h"
 #include "talk/sound/soundinputstreaminterface.h"
 #include "talk/sound/soundoutputstreaminterface.h"
 
-namespace talk_base {
+namespace rtc {
 
 class Thread;
 
diff --git a/talk/sound/platformsoundsystem.cc b/talk/sound/platformsoundsystem.cc
index 9dff9ae6e5..c39fc83257 100644
--- a/talk/sound/platformsoundsystem.cc
+++ b/talk/sound/platformsoundsystem.cc
@@ -27,7 +27,7 @@
 
 #include "talk/sound/platformsoundsystem.h"
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #ifdef LINUX
 #include "talk/sound/linuxsoundsystem.h"
 #else
diff --git a/talk/sound/pulseaudiosoundsystem.cc b/talk/sound/pulseaudiosoundsystem.cc
index 7eb690aed4..1ffb24b0f8 100644
--- a/talk/sound/pulseaudiosoundsystem.cc
+++ b/talk/sound/pulseaudiosoundsystem.cc
@@ -29,11 +29,11 @@
 
 #ifdef HAVE_LIBPULSE
 
-#include "talk/base/common.h"
-#include "talk/base/fileutils.h"  // for GetApplicationName()
-#include "talk/base/logging.h"
-#include "talk/base/worker.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/fileutils.h"  // for GetApplicationName()
+#include "webrtc/base/logging.h"
+#include "webrtc/base/worker.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/sound/sounddevicelocator.h"
 #include "talk/sound/soundinputstreaminterface.h"
 #include "talk/sound/soundoutputstreaminterface.h"
@@ -229,7 +229,7 @@ class PulseAudioStream {
 // thread-safety.
 class PulseAudioInputStream :
     public SoundInputStreamInterface,
-    private talk_base::Worker {
+    private rtc::Worker {
 
   struct GetVolumeCallbackData {
     PulseAudioInputStream *instance;
@@ -593,7 +593,7 @@ class PulseAudioInputStream :
 // regarding thread-safety.
 class PulseAudioOutputStream :
     public SoundOutputStreamInterface,
-    private talk_base::Worker {
+    private rtc::Worker {
 
   struct GetVolumeCallbackData {
     PulseAudioOutputStream *instance;
@@ -904,7 +904,7 @@ class PulseAudioOutputStream :
 
     int new_latency = configured_latency_ +
         bytes_per_sec * kPlaybackLatencyIncrementMsecs /
-        talk_base::kNumMicrosecsPerSec;
+        rtc::kNumMicrosecsPerSec;
 
     pa_buffer_attr new_attr = {0};
     FillPlaybackBufferAttr(new_latency, &new_attr);
@@ -1181,7 +1181,7 @@ pa_context *PulseAudioSoundSystem::CreateNewConnection() {
   std::string app_name;
   // TODO: Pulse etiquette says this name should be localized. Do
   // we care?
-  talk_base::Filesystem::GetApplicationName(&app_name);
+  rtc::Filesystem::GetApplicationName(&app_name);
   pa_context *context = symbol_table_.pa_context_new()(
       symbol_table_.pa_threaded_mainloop_get_api()(mainloop_),
       app_name.c_str());
@@ -1458,11 +1458,11 @@ SoundOutputStreamInterface *PulseAudioSoundSystem::ConnectOutputStream(
   if (latency != kNoLatencyRequirements) {
     // kLowLatency is 0, so we treat it the same as a request for zero latency.
     ssize_t bytes_per_sec = symbol_table_.pa_bytes_per_second()(&spec);
-    latency = talk_base::_max(
+    latency = rtc::_max(
         latency,
         static_cast<int>(
             bytes_per_sec * kPlaybackLatencyMinimumMsecs /
-            talk_base::kNumMicrosecsPerSec));
+            rtc::kNumMicrosecsPerSec));
     FillPlaybackBufferAttr(latency, &attr);
     pattr = &attr;
   }
@@ -1494,13 +1494,13 @@ SoundInputStreamInterface *PulseAudioSoundSystem::ConnectInputStream(
     size_t bytes_per_sec = symbol_table_.pa_bytes_per_second()(&spec);
     if (latency == kLowLatency) {
       latency = bytes_per_sec * kLowCaptureLatencyMsecs /
-          talk_base::kNumMicrosecsPerSec;
+          rtc::kNumMicrosecsPerSec;
     }
     // Note: fragsize specifies a maximum transfer size, not a minimum, so it is
     // not possible to force a high latency setting, only a low one.
     attr.fragsize = latency;
     attr.maxlength = latency + bytes_per_sec * kCaptureBufferExtraMsecs /
-        talk_base::kNumMicrosecsPerSec;
+        rtc::kNumMicrosecsPerSec;
     LOG(LS_VERBOSE) << "Configuring latency = " << attr.fragsize
                     << ", maxlength = " << attr.maxlength;
     pattr = &attr;
diff --git a/talk/sound/pulseaudiosoundsystem.h b/talk/sound/pulseaudiosoundsystem.h
index 8a9fe49286..53b950709b 100644
--- a/talk/sound/pulseaudiosoundsystem.h
+++ b/talk/sound/pulseaudiosoundsystem.h
@@ -30,7 +30,7 @@
 
 #ifdef HAVE_LIBPULSE
 
-#include "talk/base/constructormagic.h"
+#include "webrtc/base/constructormagic.h"
 #include "talk/sound/pulseaudiosymboltable.h"
 #include "talk/sound/soundsysteminterface.h"
 
diff --git a/talk/sound/pulseaudiosymboltable.cc b/talk/sound/pulseaudiosymboltable.cc
index 05213ec846..344f354642 100644
--- a/talk/sound/pulseaudiosymboltable.cc
+++ b/talk/sound/pulseaudiosymboltable.cc
@@ -34,7 +34,7 @@ namespace cricket {
 #define LATE_BINDING_SYMBOL_TABLE_CLASS_NAME PULSE_AUDIO_SYMBOLS_CLASS_NAME
 #define LATE_BINDING_SYMBOL_TABLE_SYMBOLS_LIST PULSE_AUDIO_SYMBOLS_LIST
 #define LATE_BINDING_SYMBOL_TABLE_DLL_NAME "libpulse.so.0"
-#include "talk/base/latebindingsymboltable.cc.def"
+#include "webrtc/base/latebindingsymboltable.cc.def"
 
 }  // namespace cricket
 
diff --git a/talk/sound/pulseaudiosymboltable.h b/talk/sound/pulseaudiosymboltable.h
index ef651578e7..46bddeaf30 100644
--- a/talk/sound/pulseaudiosymboltable.h
+++ b/talk/sound/pulseaudiosymboltable.h
@@ -35,7 +35,7 @@
 #include <pulse/stream.h>
 #include <pulse/thread-mainloop.h>
 
-#include "talk/base/latebindingsymboltable.h"
+#include "webrtc/base/latebindingsymboltable.h"
 
 namespace cricket {
 
@@ -97,7 +97,7 @@ namespace cricket {
 
 #define LATE_BINDING_SYMBOL_TABLE_CLASS_NAME PULSE_AUDIO_SYMBOLS_CLASS_NAME
 #define LATE_BINDING_SYMBOL_TABLE_SYMBOLS_LIST PULSE_AUDIO_SYMBOLS_LIST
-#include "talk/base/latebindingsymboltable.h.def"
+#include "webrtc/base/latebindingsymboltable.h.def"
 
 }  // namespace cricket
 
diff --git a/talk/sound/sounddevicelocator.h b/talk/sound/sounddevicelocator.h
index e0a8970d67..420226f3b8 100644
--- a/talk/sound/sounddevicelocator.h
+++ b/talk/sound/sounddevicelocator.h
@@ -30,7 +30,7 @@
 
 #include <string>
 
-#include "talk/base/constructormagic.h"
+#include "webrtc/base/constructormagic.h"
 
 namespace cricket {
 
diff --git a/talk/sound/soundinputstreaminterface.h b/talk/sound/soundinputstreaminterface.h
index de831a6a81..e5573924af 100644
--- a/talk/sound/soundinputstreaminterface.h
+++ b/talk/sound/soundinputstreaminterface.h
@@ -28,14 +28,14 @@
 #ifndef TALK_SOUND_SOUNDINPUTSTREAMINTERFACE_H_
 #define TALK_SOUND_SOUNDINPUTSTREAMINTERFACE_H_
 
-#include "talk/base/constructormagic.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/base/sigslot.h"
 
 namespace cricket {
 
 // Interface for consuming an input stream from a recording device.
 // Semantics and thread-safety of StartReading()/StopReading() are the same as
-// for talk_base::Worker.
+// for rtc::Worker.
 class SoundInputStreamInterface {
  public:
   virtual ~SoundInputStreamInterface() {}
diff --git a/talk/sound/soundoutputstreaminterface.h b/talk/sound/soundoutputstreaminterface.h
index d096ba3f5f..294906da3d 100644
--- a/talk/sound/soundoutputstreaminterface.h
+++ b/talk/sound/soundoutputstreaminterface.h
@@ -28,14 +28,14 @@
 #ifndef TALK_SOUND_SOUNDOUTPUTSTREAMINTERFACE_H_
 #define TALK_SOUND_SOUNDOUTPUTSTREAMINTERFACE_H_
 
-#include "talk/base/constructormagic.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/base/sigslot.h"
 
 namespace cricket {
 
 // Interface for outputting a stream to a playback device.
 // Semantics and thread-safety of EnableBufferMonitoring()/
-// DisableBufferMonitoring() are the same as for talk_base::Worker.
+// DisableBufferMonitoring() are the same as for rtc::Worker.
 class SoundOutputStreamInterface {
  public:
   virtual ~SoundOutputStreamInterface() {}
diff --git a/talk/sound/soundsystemfactory.h b/talk/sound/soundsystemfactory.h
index 517220b03e..06a1c3f791 100644
--- a/talk/sound/soundsystemfactory.h
+++ b/talk/sound/soundsystemfactory.h
@@ -28,16 +28,16 @@
 #ifndef TALK_SOUND_SOUNDSYSTEMFACTORY_H_
 #define TALK_SOUND_SOUNDSYSTEMFACTORY_H_
 
-#include "talk/base/referencecountedsingletonfactory.h"
+#include "webrtc/base/referencecountedsingletonfactory.h"
 
 namespace cricket {
 
 class SoundSystemInterface;
 
-typedef talk_base::ReferenceCountedSingletonFactory<SoundSystemInterface>
+typedef rtc::ReferenceCountedSingletonFactory<SoundSystemInterface>
     SoundSystemFactory;
 
-typedef talk_base::rcsf_ptr<SoundSystemInterface> SoundSystemHandle;
+typedef rtc::rcsf_ptr<SoundSystemInterface> SoundSystemHandle;
 
 }  // namespace cricket
 
diff --git a/talk/sound/soundsysteminterface.h b/talk/sound/soundsysteminterface.h
index 7a059b0d60..5d3e84b93c 100644
--- a/talk/sound/soundsysteminterface.h
+++ b/talk/sound/soundsysteminterface.h
@@ -30,7 +30,7 @@
 
 #include <vector>
 
-#include "talk/base/constructormagic.h"
+#include "webrtc/base/constructormagic.h"
 
 namespace cricket {
 
diff --git a/talk/sound/soundsystemproxy.h b/talk/sound/soundsystemproxy.h
index 9ccace808d..0570704cdb 100644
--- a/talk/sound/soundsystemproxy.h
+++ b/talk/sound/soundsystemproxy.h
@@ -28,7 +28,7 @@
 #ifndef TALK_SOUND_SOUNDSYSTEMPROXY_H_
 #define TALK_SOUND_SOUNDSYSTEMPROXY_H_
 
-#include "talk/base/basictypes.h"  // for NULL
+#include "webrtc/base/basictypes.h"  // for NULL
 #include "talk/sound/soundsysteminterface.h"
 
 namespace cricket {
diff --git a/talk/xmllite/qname_unittest.cc b/talk/xmllite/qname_unittest.cc
index 976d822f17..7ae27fb3b2 100644
--- a/talk/xmllite/qname_unittest.cc
+++ b/talk/xmllite/qname_unittest.cc
@@ -26,7 +26,7 @@
  */
 
 #include <string>
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmllite/qname.h"
 
 using buzz::StaticQName;
diff --git a/talk/xmllite/xmlbuilder.cc b/talk/xmllite/xmlbuilder.cc
index f71e542d67..e923a3d3cc 100644
--- a/talk/xmllite/xmlbuilder.cc
+++ b/talk/xmllite/xmlbuilder.cc
@@ -29,7 +29,7 @@
 
 #include <vector>
 #include <set>
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmllite/xmlconstants.h"
 #include "talk/xmllite/xmlelement.h"
 
@@ -107,8 +107,8 @@ XmlBuilder::StartElement(XmlParseContext * pctx,
 
 void
 XmlBuilder::EndElement(XmlParseContext * pctx, const char * name) {
-  UNUSED(pctx);
-  UNUSED(name);
+  RTC_UNUSED(pctx);
+  RTC_UNUSED(name);
   pelCurrent_ = pvParents_->back();
   pvParents_->pop_back();
 }
@@ -116,7 +116,7 @@ XmlBuilder::EndElement(XmlParseContext * pctx, const char * name) {
 void
 XmlBuilder::CharacterData(XmlParseContext * pctx,
                                const char * text, int len) {
-  UNUSED(pctx);
+  RTC_UNUSED(pctx);
   if (pelCurrent_) {
     pelCurrent_->AddParsedText(text, len);
   }
@@ -124,8 +124,8 @@ XmlBuilder::CharacterData(XmlParseContext * pctx,
 
 void
 XmlBuilder::Error(XmlParseContext * pctx, XML_Error err) {
-  UNUSED(pctx);
-  UNUSED(err);
+  RTC_UNUSED(pctx);
+  RTC_UNUSED(err);
   pelRoot_.reset(NULL);
   pelCurrent_ = NULL;
   pvParents_->clear();
diff --git a/talk/xmllite/xmlbuilder.h b/talk/xmllite/xmlbuilder.h
index 984eee204f..a80773ed38 100644
--- a/talk/xmllite/xmlbuilder.h
+++ b/talk/xmllite/xmlbuilder.h
@@ -30,7 +30,7 @@
 
 #include <string>
 #include <vector>
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/xmllite/xmlparser.h"
 
 #ifdef EXPAT_RELATIVE_PATH
@@ -69,8 +69,8 @@ public:
 
 private:
   XmlElement * pelCurrent_;
-  talk_base::scoped_ptr<XmlElement> pelRoot_;
-  talk_base::scoped_ptr<std::vector<XmlElement*> > pvParents_;
+  rtc::scoped_ptr<XmlElement> pelRoot_;
+  rtc::scoped_ptr<std::vector<XmlElement*> > pvParents_;
 };
 
 }
diff --git a/talk/xmllite/xmlbuilder_unittest.cc b/talk/xmllite/xmlbuilder_unittest.cc
index 9302276d6a..0f0c1e5900 100644
--- a/talk/xmllite/xmlbuilder_unittest.cc
+++ b/talk/xmllite/xmlbuilder_unittest.cc
@@ -28,8 +28,8 @@
 #include <string>
 #include <sstream>
 #include <iostream>
-#include "talk/base/common.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmllite/xmlbuilder.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmllite/xmlparser.h"
diff --git a/talk/xmllite/xmlelement.cc b/talk/xmllite/xmlelement.cc
index 176ce5ce38..d8fb1e86f5 100644
--- a/talk/xmllite/xmlelement.cc
+++ b/talk/xmllite/xmlelement.cc
@@ -32,7 +32,7 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmllite/qname.h"
 #include "talk/xmllite/xmlparser.h"
 #include "talk/xmllite/xmlbuilder.h"
diff --git a/talk/xmllite/xmlelement.h b/talk/xmllite/xmlelement.h
index ffdc333bb4..cdb6873bc7 100644
--- a/talk/xmllite/xmlelement.h
+++ b/talk/xmllite/xmlelement.h
@@ -31,7 +31,7 @@
 #include <iosfwd>
 #include <string>
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/xmllite/qname.h"
 
 namespace buzz {
diff --git a/talk/xmllite/xmlelement_unittest.cc b/talk/xmllite/xmlelement_unittest.cc
index 3c31ce491c..88b0a405dd 100644
--- a/talk/xmllite/xmlelement_unittest.cc
+++ b/talk/xmllite/xmlelement_unittest.cc
@@ -28,9 +28,9 @@
 #include <string>
 #include <sstream>
 #include <iostream>
-#include "talk/base/common.h"
-#include "talk/base/gunit.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/thread.h"
 #include "talk/xmllite/xmlelement.h"
 
 using buzz::QName;
@@ -230,7 +230,7 @@ TEST(XmlElementTest, TestNameSearch) {
   delete element;
 }
 
-class XmlElementCreatorThread : public talk_base::Thread {
+class XmlElementCreatorThread : public rtc::Thread {
  public:
   XmlElementCreatorThread(int count, buzz::QName qname) :
       count_(count), qname_(qname) {}
@@ -261,7 +261,7 @@ TEST(XmlElementTest, TestMultithread) {
   int elem_count = 100;  // Was 100000, but that's too slow.
   buzz::QName qname("foo", "bar");
 
-  std::vector<talk_base::Thread*> threads;
+  std::vector<rtc::Thread*> threads;
   for (int i = 0; i < thread_count; i++) {
     threads.push_back(
         new XmlElementCreatorThread(elem_count, qname));
diff --git a/talk/xmllite/xmlnsstack.h b/talk/xmllite/xmlnsstack.h
index f6b4b81893..3acc7d4921 100644
--- a/talk/xmllite/xmlnsstack.h
+++ b/talk/xmllite/xmlnsstack.h
@@ -30,7 +30,7 @@
 
 #include <string>
 #include <vector>
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/xmllite/qname.h"
 
 namespace buzz {
@@ -54,8 +54,8 @@ public:
 
 private:
 
-  talk_base::scoped_ptr<std::vector<std::string> > pxmlnsStack_;
-  talk_base::scoped_ptr<std::vector<size_t> > pxmlnsDepthStack_;
+  rtc::scoped_ptr<std::vector<std::string> > pxmlnsStack_;
+  rtc::scoped_ptr<std::vector<size_t> > pxmlnsDepthStack_;
 };
 }
 
diff --git a/talk/xmllite/xmlnsstack_unittest.cc b/talk/xmllite/xmlnsstack_unittest.cc
index 20b59721f6..4dc90427d2 100644
--- a/talk/xmllite/xmlnsstack_unittest.cc
+++ b/talk/xmllite/xmlnsstack_unittest.cc
@@ -31,8 +31,8 @@
 #include <sstream>
 #include <iostream>
 
-#include "talk/base/common.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmllite/xmlconstants.h"
 
 using buzz::NS_XML;
diff --git a/talk/xmllite/xmlparser.cc b/talk/xmllite/xmlparser.cc
index 8802231872..f12040fe4e 100644
--- a/talk/xmllite/xmlparser.cc
+++ b/talk/xmllite/xmlparser.cc
@@ -30,7 +30,7 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmllite/xmlconstants.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmllite/xmlnsstack.h"
diff --git a/talk/xmllite/xmlparser_unittest.cc b/talk/xmllite/xmlparser_unittest.cc
index 24947fb9a4..ae0867e471 100644
--- a/talk/xmllite/xmlparser_unittest.cc
+++ b/talk/xmllite/xmlparser_unittest.cc
@@ -28,8 +28,8 @@
 #include <string>
 #include <sstream>
 #include <iostream>
-#include "talk/base/common.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmllite/qname.h"
 #include "talk/xmllite/xmlparser.h"
 
@@ -51,17 +51,17 @@ class XmlParserTestHandler : public XmlParseHandler {
     ss_ << ") ";
   }
   virtual void EndElement(XmlParseContext * pctx, const char * name) {
-    UNUSED(pctx);
-    UNUSED(name);
+    RTC_UNUSED(pctx);
+    RTC_UNUSED(name);
     ss_ << "END ";
   }
   virtual void CharacterData(XmlParseContext * pctx,
                              const char * text, int len) {
-    UNUSED(pctx);
+    RTC_UNUSED(pctx);
     ss_ << "TEXT (" << std::string(text, len) << ") ";
   }
   virtual void Error(XmlParseContext * pctx, XML_Error code) {
-    UNUSED(pctx);
+    RTC_UNUSED(pctx);
     ss_ << "ERROR (" << static_cast<int>(code) << ") ";
   }
   virtual ~XmlParserTestHandler() {
diff --git a/talk/xmllite/xmlprinter_unittest.cc b/talk/xmllite/xmlprinter_unittest.cc
index 60b0e42bdc..309e507693 100644
--- a/talk/xmllite/xmlprinter_unittest.cc
+++ b/talk/xmllite/xmlprinter_unittest.cc
@@ -30,8 +30,8 @@
 #include <sstream>
 #include <string>
 
-#include "talk/base/common.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmllite/qname.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmllite/xmlnsstack.h"
diff --git a/talk/xmpp/asyncsocket.h b/talk/xmpp/asyncsocket.h
index fb4ef029bf..e31e29e1e4 100644
--- a/talk/xmpp/asyncsocket.h
+++ b/talk/xmpp/asyncsocket.h
@@ -28,9 +28,9 @@
 #ifndef _ASYNCSOCKET_H_
 #define _ASYNCSOCKET_H_
 
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 
-namespace talk_base {
+namespace rtc {
   class SocketAddress;
 }
 
@@ -64,7 +64,7 @@ public:
   virtual Error error() = 0;
   virtual int GetError() = 0;    // winsock error code
 
-  virtual bool Connect(const talk_base::SocketAddress& addr) = 0;
+  virtual bool Connect(const rtc::SocketAddress& addr) = 0;
   virtual bool Read(char * data, size_t len, size_t* len_read) = 0;
   virtual bool Write(const char * data, size_t len) = 0;
   virtual bool Close() = 0;
diff --git a/talk/xmpp/chatroommodule_unittest.cc b/talk/xmpp/chatroommodule_unittest.cc
index a152f60609..8c0c662c35 100644
--- a/talk/xmpp/chatroommodule_unittest.cc
+++ b/talk/xmpp/chatroommodule_unittest.cc
@@ -116,7 +116,7 @@ public:
 
   void ChatroomEnteredStatus(XmppChatroomModule* room,
                              XmppChatroomEnteredStatus status) {
-    UNUSED(room);
+    RTC_UNUSED(room);
     ss_ <<"[ChatroomEnteredStatus status: ";
     WriteEnteredStatus(ss_, status);
     ss_ <<"]";
@@ -125,7 +125,7 @@ public:
 
   void ChatroomExitedStatus(XmppChatroomModule* room,
                             XmppChatroomExitedStatus status) {
-    UNUSED(room);
+    RTC_UNUSED(room);
     ss_ <<"[ChatroomExitedStatus status: ";
     WriteExitedStatus(ss_, status);
     ss_ <<"]";
@@ -133,24 +133,24 @@ public:
 
   void MemberEntered(XmppChatroomModule* room, 
                           const XmppChatroomMember* entered_member) {
-    UNUSED(room);
+    RTC_UNUSED(room);
     ss_ << "[MemberEntered " << entered_member->member_jid().Str() << "]";
   }
 
   void MemberExited(XmppChatroomModule* room,
                          const XmppChatroomMember* exited_member) {
-    UNUSED(room);
+    RTC_UNUSED(room);
     ss_ << "[MemberExited " << exited_member->member_jid().Str() << "]";
   }
 
   void MemberChanged(XmppChatroomModule* room,
       const XmppChatroomMember* changed_member) {
-    UNUSED(room);
+    RTC_UNUSED(room);
     ss_ << "[MemberChanged " << changed_member->member_jid().Str() << "]";
   }
 
   virtual void MessageReceived(XmppChatroomModule* room, const XmlElement& message) {
-    UNUSED2(room, message);
+    RTC_UNUSED2(room, message);
   }
 
  
diff --git a/talk/xmpp/chatroommoduleimpl.cc b/talk/xmpp/chatroommoduleimpl.cc
index a12ff5e029..6e94f28763 100644
--- a/talk/xmpp/chatroommoduleimpl.cc
+++ b/talk/xmpp/chatroommoduleimpl.cc
@@ -31,7 +31,7 @@
 #include <algorithm>
 #include <sstream>
 #include <iostream>
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/moduleimpl.h"
 #include "talk/xmpp/chatroommodule.h"
@@ -74,7 +74,7 @@ public:
   virtual XmppReturnStatus SendMessage(const XmlElement& message);
 
   // XmppModule
-  virtual void IqResponse(XmppIqCookie cookie, const XmlElement * pelStanza) {UNUSED2(cookie, pelStanza);}
+  virtual void IqResponse(XmppIqCookie cookie, const XmlElement * pelStanza) {RTC_UNUSED2(cookie, pelStanza);}
   virtual bool HandleStanza(const XmlElement *);
 
 private:
@@ -121,7 +121,7 @@ public:
   const XmppPresence* presence() const;
 
 private:
-  talk_base::scoped_ptr<XmppPresence>  presence_;
+  rtc::scoped_ptr<XmppPresence>  presence_;
 };
 
 class XmppChatroomMemberEnumeratorImpl :
@@ -276,7 +276,7 @@ XmppChatroomModuleImpl::RequestEnterChatroom(
     const std::string& password,
     const std::string& client_version,
     const std::string& locale) {
-  UNUSED(password);
+  RTC_UNUSED(password);
   if (!engine())
     return XMPP_RETURN_BADSTATE;
 
@@ -446,7 +446,7 @@ void
 XmppChatroomModuleImpl::FireEnteredStatus(const XmlElement* presence,
                                           XmppChatroomEnteredStatus status) {
   if (chatroom_handler_) {
-    talk_base::scoped_ptr<XmppPresence> xmpp_presence(XmppPresence::Create());
+    rtc::scoped_ptr<XmppPresence> xmpp_presence(XmppPresence::Create());
     xmpp_presence->set_raw_xml(presence);
     chatroom_handler_->ChatroomEnteredStatus(this, xmpp_presence.get(), status);
   }
@@ -488,7 +488,7 @@ XmppReturnStatus
 XmppChatroomModuleImpl::ServerChangedOtherPresence(const XmlElement&
                                                    presence_element) {
   XmppReturnStatus xmpp_status = XMPP_RETURN_OK;
-  talk_base::scoped_ptr<XmppPresence> presence(XmppPresence::Create());
+  rtc::scoped_ptr<XmppPresence> presence(XmppPresence::Create());
   IFR(presence->set_raw_xml(&presence_element));
 
   JidMemberMap::iterator pos = chatroom_jid_members_.find(presence->jid());
@@ -542,7 +542,7 @@ XmppReturnStatus
 XmppChatroomModuleImpl::ChangePresence(XmppChatroomState new_state,
                                        const XmlElement* presence,
                                        bool isServer) {
-  UNUSED(presence);
+  RTC_UNUSED(presence);
 
   XmppChatroomState old_state = chatroom_state_;
 
diff --git a/talk/xmpp/constants.cc b/talk/xmpp/constants.cc
index f69f84e469..964d5c11ee 100644
--- a/talk/xmpp/constants.cc
+++ b/talk/xmpp/constants.cc
@@ -29,7 +29,7 @@
 
 #include <string>
 
-#include "talk/base/basicdefs.h"
+#include "webrtc/base/basicdefs.h"
 #include "talk/xmllite/xmlconstants.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmllite/qname.h"
diff --git a/talk/xmpp/discoitemsquerytask.cc b/talk/xmpp/discoitemsquerytask.cc
index 7cdee2cd15..3671cb4245 100644
--- a/talk/xmpp/discoitemsquerytask.cc
+++ b/talk/xmpp/discoitemsquerytask.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/discoitemsquerytask.h"
 #include "talk/xmpp/xmpptask.h"
diff --git a/talk/xmpp/fakexmppclient.h b/talk/xmpp/fakexmppclient.h
index 83b8e825a1..3522ba930f 100644
--- a/talk/xmpp/fakexmppclient.h
+++ b/talk/xmpp/fakexmppclient.h
@@ -42,7 +42,7 @@ class XmlElement;
 class FakeXmppClient : public XmppTaskParentInterface,
                        public XmppClientInterface {
  public:
-  explicit FakeXmppClient(talk_base::TaskParent* parent)
+  explicit FakeXmppClient(rtc::TaskParent* parent)
       : XmppTaskParentInterface(parent) {
   }
 
diff --git a/talk/xmpp/hangoutpubsubclient.cc b/talk/xmpp/hangoutpubsubclient.cc
index aede56318c..63baeccf0d 100644
--- a/talk/xmpp/hangoutpubsubclient.cc
+++ b/talk/xmpp/hangoutpubsubclient.cc
@@ -27,7 +27,7 @@
 
 #include "talk/xmpp/hangoutpubsubclient.h"
 
-#include "talk/base/logging.h"
+#include "webrtc/base/logging.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/jid.h"
 #include "talk/xmllite/qname.h"
diff --git a/talk/xmpp/hangoutpubsubclient.h b/talk/xmpp/hangoutpubsubclient.h
index 2fcd691329..3842c475ee 100644
--- a/talk/xmpp/hangoutpubsubclient.h
+++ b/talk/xmpp/hangoutpubsubclient.h
@@ -32,9 +32,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/sigslotrepeater.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/sigslotrepeater.h"
 #include "talk/xmpp/jid.h"
 #include "talk/xmpp/pubsubclient.h"
 #include "talk/xmpp/pubsubstateclient.h"
@@ -180,14 +180,14 @@ class HangoutPubSubClient : public sigslot::has_slots<> {
                                 const XmlElement* stanza);
   Jid mucjid_;
   std::string nick_;
-  talk_base::scoped_ptr<PubSubClient> media_client_;
-  talk_base::scoped_ptr<PubSubClient> presenter_client_;
-  talk_base::scoped_ptr<PubSubStateClient<bool> > presenter_state_client_;
-  talk_base::scoped_ptr<PubSubStateClient<bool> > audio_mute_state_client_;
-  talk_base::scoped_ptr<PubSubStateClient<bool> > video_mute_state_client_;
-  talk_base::scoped_ptr<PubSubStateClient<bool> > video_pause_state_client_;
-  talk_base::scoped_ptr<PubSubStateClient<bool> > recording_state_client_;
-  talk_base::scoped_ptr<PubSubStateClient<bool> > media_block_state_client_;
+  rtc::scoped_ptr<PubSubClient> media_client_;
+  rtc::scoped_ptr<PubSubClient> presenter_client_;
+  rtc::scoped_ptr<PubSubStateClient<bool> > presenter_state_client_;
+  rtc::scoped_ptr<PubSubStateClient<bool> > audio_mute_state_client_;
+  rtc::scoped_ptr<PubSubStateClient<bool> > video_mute_state_client_;
+  rtc::scoped_ptr<PubSubStateClient<bool> > video_pause_state_client_;
+  rtc::scoped_ptr<PubSubStateClient<bool> > recording_state_client_;
+  rtc::scoped_ptr<PubSubStateClient<bool> > media_block_state_client_;
 };
 
 }  // namespace buzz
diff --git a/talk/xmpp/hangoutpubsubclient_unittest.cc b/talk/xmpp/hangoutpubsubclient_unittest.cc
index 1d1c14b13e..5e8b852e86 100644
--- a/talk/xmpp/hangoutpubsubclient_unittest.cc
+++ b/talk/xmpp/hangoutpubsubclient_unittest.cc
@@ -3,9 +3,9 @@
 
 #include <string>
 
-#include "talk/base/faketaskrunner.h"
-#include "talk/base/gunit.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/faketaskrunner.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmllite/qname.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
@@ -181,7 +181,7 @@ class HangoutPubSubClientTest : public testing::Test {
       pubsubjid("room@domain.com"),
       nick("me") {
 
-    runner.reset(new talk_base::FakeTaskRunner());
+    runner.reset(new rtc::FakeTaskRunner());
     xmpp_client = new buzz::FakeXmppClient(runner.get());
     client.reset(new buzz::HangoutPubSubClient(xmpp_client, pubsubjid, nick));
     listener.reset(new TestHangoutPubSubListener());
@@ -221,11 +221,11 @@ class HangoutPubSubClientTest : public testing::Test {
         listener.get(), &TestHangoutPubSubListener::OnMediaBlockError);
   }
 
-  talk_base::scoped_ptr<talk_base::FakeTaskRunner> runner;
+  rtc::scoped_ptr<rtc::FakeTaskRunner> runner;
   // xmpp_client deleted by deleting runner.
   buzz::FakeXmppClient* xmpp_client;
-  talk_base::scoped_ptr<buzz::HangoutPubSubClient> client;
-  talk_base::scoped_ptr<TestHangoutPubSubListener> listener;
+  rtc::scoped_ptr<buzz::HangoutPubSubClient> client;
+  rtc::scoped_ptr<TestHangoutPubSubListener> listener;
   buzz::Jid pubsubjid;
   std::string nick;
 };
diff --git a/talk/xmpp/iqtask.h b/talk/xmpp/iqtask.h
index 2228e6f2c1..34a62b1c9a 100644
--- a/talk/xmpp/iqtask.h
+++ b/talk/xmpp/iqtask.h
@@ -57,7 +57,7 @@ class IqTask : public XmppTask {
   virtual int OnTimeout();
 
   Jid to_;
-  talk_base::scoped_ptr<XmlElement> stanza_;
+  rtc::scoped_ptr<XmlElement> stanza_;
 };
 
 }  // namespace buzz
diff --git a/talk/xmpp/jid.cc b/talk/xmpp/jid.cc
index 45838710cb..3a19e05708 100644
--- a/talk/xmpp/jid.cc
+++ b/talk/xmpp/jid.cc
@@ -32,8 +32,8 @@
 #include <algorithm>
 #include <string>
 
-#include "talk/base/common.h"
-#include "talk/base/logging.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/logging.h"
 #include "talk/xmpp/constants.h"
 
 namespace buzz {
diff --git a/talk/xmpp/jid.h b/talk/xmpp/jid.h
index dcfc123f9a..309048b5fd 100644
--- a/talk/xmpp/jid.h
+++ b/talk/xmpp/jid.h
@@ -29,7 +29,7 @@
 #define TALK_XMPP_JID_H_
 
 #include <string>
-#include "talk/base/basictypes.h"
+#include "webrtc/base/basictypes.h"
 #include "talk/xmllite/xmlconstants.h"
 
 namespace buzz {
diff --git a/talk/xmpp/jid_unittest.cc b/talk/xmpp/jid_unittest.cc
index b9597da729..c728bee900 100644
--- a/talk/xmpp/jid_unittest.cc
+++ b/talk/xmpp/jid_unittest.cc
@@ -1,7 +1,7 @@
 // Copyright 2004 Google Inc. All Rights Reserved
 
 
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmpp/jid.h"
 
 using buzz::Jid;
diff --git a/talk/xmpp/jingleinfotask.cc b/talk/xmpp/jingleinfotask.cc
index cf3eac2899..9727d96072 100644
--- a/talk/xmpp/jingleinfotask.cc
+++ b/talk/xmpp/jingleinfotask.cc
@@ -27,7 +27,7 @@
 
 #include "talk/xmpp/jingleinfotask.h"
 
-#include "talk/base/socketaddress.h"
+#include "webrtc/base/socketaddress.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/xmppclient.h"
 #include "talk/xmpp/xmpptask.h"
@@ -41,7 +41,7 @@ class JingleInfoTask::JingleInfoGetTask : public XmppTask {
         done_(false) {}
 
   virtual int ProcessStart() {
-    talk_base::scoped_ptr<XmlElement> get(
+    rtc::scoped_ptr<XmlElement> get(
         MakeIq(STR_GET, Jid(), task_id()));
     get->AddElement(new XmlElement(QN_JINGLE_INFO_QUERY, true));
     if (SendStanza(get.get()) != XMPP_RETURN_OK) {
@@ -101,7 +101,7 @@ JingleInfoTask::HandleStanza(const XmlElement * stanza) {
 int
 JingleInfoTask::ProcessStart() {
   std::vector<std::string> relay_hosts;
-  std::vector<talk_base::SocketAddress> stun_hosts;
+  std::vector<rtc::SocketAddress> stun_hosts;
   std::string relay_token;
   const XmlElement * stanza = NextStanza();
   if (stanza == NULL)
@@ -116,7 +116,7 @@ JingleInfoTask::ProcessStart() {
       std::string host = server->Attr(QN_JINGLE_INFO_HOST);
       std::string port = server->Attr(QN_JINGLE_INFO_UDP);
       if (host != STR_EMPTY && host != STR_EMPTY) {
-        stun_hosts.push_back(talk_base::SocketAddress(host, atoi(port.c_str())));
+        stun_hosts.push_back(rtc::SocketAddress(host, atoi(port.c_str())));
       }
     }
   }
diff --git a/talk/xmpp/jingleinfotask.h b/talk/xmpp/jingleinfotask.h
index dbc3fb0046..5865a77c81 100644
--- a/talk/xmpp/jingleinfotask.h
+++ b/talk/xmpp/jingleinfotask.h
@@ -33,7 +33,7 @@
 #include "talk/p2p/client/httpportallocator.h"
 #include "talk/xmpp/xmppengine.h"
 #include "talk/xmpp/xmpptask.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 
 namespace buzz {
 
@@ -47,7 +47,7 @@ class JingleInfoTask : public XmppTask {
 
   sigslot::signal3<const std::string &,
                    const std::vector<std::string> &,
-                   const std::vector<talk_base::SocketAddress> &>
+                   const std::vector<rtc::SocketAddress> &>
                        SignalJingleInfo;
 
  protected:
diff --git a/talk/xmpp/moduleimpl.cc b/talk/xmpp/moduleimpl.cc
index b23ca29829..66a1eb1608 100644
--- a/talk/xmpp/moduleimpl.cc
+++ b/talk/xmpp/moduleimpl.cc
@@ -25,7 +25,7 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmpp/moduleimpl.h"
 
 namespace buzz {
diff --git a/talk/xmpp/mucroomconfigtask.cc b/talk/xmpp/mucroomconfigtask.cc
index 272bd44f72..dded3a68a4 100644
--- a/talk/xmpp/mucroomconfigtask.cc
+++ b/talk/xmpp/mucroomconfigtask.cc
@@ -30,7 +30,7 @@
 
 #include "talk/xmpp/mucroomconfigtask.h"
 
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/xmpp/constants.h"
 
 namespace buzz {
diff --git a/talk/xmpp/mucroomconfigtask_unittest.cc b/talk/xmpp/mucroomconfigtask_unittest.cc
index e0a8acaeb7..575c1638e7 100644
--- a/talk/xmpp/mucroomconfigtask_unittest.cc
+++ b/talk/xmpp/mucroomconfigtask_unittest.cc
@@ -28,9 +28,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/faketaskrunner.h"
-#include "talk/base/gunit.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/faketaskrunner.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/fakexmppclient.h"
@@ -61,7 +61,7 @@ class MucRoomConfigTaskTest : public testing::Test {
   }
 
   virtual void SetUp() {
-    runner = new talk_base::FakeTaskRunner();
+    runner = new rtc::FakeTaskRunner();
     xmpp_client = new buzz::FakeXmppClient(runner);
     listener = new MucRoomConfigListener();
   }
@@ -72,7 +72,7 @@ class MucRoomConfigTaskTest : public testing::Test {
     delete runner;
   }
 
-  talk_base::FakeTaskRunner* runner;
+  rtc::FakeTaskRunner* runner;
   buzz::FakeXmppClient* xmpp_client;
   MucRoomConfigListener* listener;
   buzz::Jid room_jid;
diff --git a/talk/xmpp/mucroomdiscoverytask_unittest.cc b/talk/xmpp/mucroomdiscoverytask_unittest.cc
index 354503f688..32c7cd2532 100644
--- a/talk/xmpp/mucroomdiscoverytask_unittest.cc
+++ b/talk/xmpp/mucroomdiscoverytask_unittest.cc
@@ -28,9 +28,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/faketaskrunner.h"
-#include "talk/base/gunit.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/faketaskrunner.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/fakexmppclient.h"
@@ -75,7 +75,7 @@ class MucRoomDiscoveryTaskTest : public testing::Test {
   }
 
   virtual void SetUp() {
-    runner = new talk_base::FakeTaskRunner();
+    runner = new rtc::FakeTaskRunner();
     xmpp_client = new buzz::FakeXmppClient(runner);
     listener = new MucRoomDiscoveryListener();
   }
@@ -86,7 +86,7 @@ class MucRoomDiscoveryTaskTest : public testing::Test {
     delete runner;
   }
 
-  talk_base::FakeTaskRunner* runner;
+  rtc::FakeTaskRunner* runner;
   buzz::FakeXmppClient* xmpp_client;
   MucRoomDiscoveryListener* listener;
   buzz::Jid room_jid;
diff --git a/talk/xmpp/mucroomlookuptask.cc b/talk/xmpp/mucroomlookuptask.cc
index b78e5dde7c..5caa598511 100644
--- a/talk/xmpp/mucroomlookuptask.cc
+++ b/talk/xmpp/mucroomlookuptask.cc
@@ -27,8 +27,8 @@
 
 #include "talk/xmpp/mucroomlookuptask.h"
 
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/xmpp/constants.h"
 
 
diff --git a/talk/xmpp/mucroomlookuptask_unittest.cc b/talk/xmpp/mucroomlookuptask_unittest.cc
index a662d537d4..9af0e4b612 100644
--- a/talk/xmpp/mucroomlookuptask_unittest.cc
+++ b/talk/xmpp/mucroomlookuptask_unittest.cc
@@ -28,9 +28,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/faketaskrunner.h"
-#include "talk/base/gunit.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/faketaskrunner.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/fakexmppclient.h"
@@ -66,7 +66,7 @@ class MucRoomLookupTaskTest : public testing::Test {
   }
 
   virtual void SetUp() {
-    runner = new talk_base::FakeTaskRunner();
+    runner = new rtc::FakeTaskRunner();
     xmpp_client = new buzz::FakeXmppClient(runner);
     listener = new MucRoomLookupListener();
   }
@@ -77,7 +77,7 @@ class MucRoomLookupTaskTest : public testing::Test {
     delete runner;
   }
 
-  talk_base::FakeTaskRunner* runner;
+  rtc::FakeTaskRunner* runner;
   buzz::FakeXmppClient* xmpp_client;
   MucRoomLookupListener* listener;
   buzz::Jid lookup_server_jid;
diff --git a/talk/xmpp/mucroomuniquehangoutidtask_unittest.cc b/talk/xmpp/mucroomuniquehangoutidtask_unittest.cc
index 128bab3731..35931ae085 100644
--- a/talk/xmpp/mucroomuniquehangoutidtask_unittest.cc
+++ b/talk/xmpp/mucroomuniquehangoutidtask_unittest.cc
@@ -28,9 +28,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/faketaskrunner.h"
-#include "talk/base/gunit.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/faketaskrunner.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/fakexmppclient.h"
@@ -62,7 +62,7 @@ class MucRoomUniqueHangoutIdTaskTest : public testing::Test {
   }
 
   virtual void SetUp() {
-    runner = new talk_base::FakeTaskRunner();
+    runner = new rtc::FakeTaskRunner();
     xmpp_client = new buzz::FakeXmppClient(runner);
     listener = new MucRoomUniqueHangoutIdListener();
   }
@@ -73,7 +73,7 @@ class MucRoomUniqueHangoutIdTaskTest : public testing::Test {
     delete runner;
   }
 
-  talk_base::FakeTaskRunner* runner;
+  rtc::FakeTaskRunner* runner;
   buzz::FakeXmppClient* xmpp_client;
   MucRoomUniqueHangoutIdListener* listener;
   buzz::Jid lookup_server_jid;
diff --git a/talk/xmpp/pingtask.cc b/talk/xmpp/pingtask.cc
index 233062f7be..bf6eea28f1 100644
--- a/talk/xmpp/pingtask.cc
+++ b/talk/xmpp/pingtask.cc
@@ -3,14 +3,14 @@
 
 #include "talk/xmpp/pingtask.h"
 
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/xmpp/constants.h"
 
 namespace buzz {
 
 PingTask::PingTask(buzz::XmppTaskParentInterface* parent,
-                   talk_base::MessageQueue* message_queue,
+                   rtc::MessageQueue* message_queue,
                    uint32 ping_period_millis,
                    uint32 ping_timeout_millis)
     : buzz::XmppTask(parent, buzz::XmppEngine::HL_SINGLE),
@@ -49,7 +49,7 @@ int PingTask::ProcessStart() {
     ping_response_deadline_ = 0;
   }
 
-  uint32 now = talk_base::Time();
+  uint32 now = rtc::Time();
 
   // If the ping timed out, signal.
   if (ping_response_deadline_ != 0 && now >= ping_response_deadline_) {
@@ -59,7 +59,7 @@ int PingTask::ProcessStart() {
 
   // Send a ping if it's time.
   if (now >= next_ping_time_) {
-    talk_base::scoped_ptr<buzz::XmlElement> stanza(
+    rtc::scoped_ptr<buzz::XmlElement> stanza(
         MakeIq(buzz::STR_GET, Jid(STR_EMPTY), task_id()));
     stanza->AddElement(new buzz::XmlElement(QN_PING));
     SendStanza(stanza.get());
@@ -76,7 +76,7 @@ int PingTask::ProcessStart() {
   return STATE_BLOCKED;
 }
 
-void PingTask::OnMessage(talk_base::Message* msg) {
+void PingTask::OnMessage(rtc::Message* msg) {
   // Get the task manager to run this task so we can send a ping or signal or
   // process a ping response.
   Wake();
diff --git a/talk/xmpp/pingtask.h b/talk/xmpp/pingtask.h
index 83752412d8..1bd1514236 100644
--- a/talk/xmpp/pingtask.h
+++ b/talk/xmpp/pingtask.h
@@ -28,8 +28,8 @@
 #ifndef TALK_XMPP_PINGTASK_H_
 #define TALK_XMPP_PINGTASK_H_
 
-#include "talk/base/messagehandler.h"
-#include "talk/base/messagequeue.h"
+#include "webrtc/base/messagehandler.h"
+#include "webrtc/base/messagequeue.h"
 #include "talk/xmpp/xmpptask.h"
 
 namespace buzz {
@@ -42,10 +42,10 @@ namespace buzz {
 //    proxies.
 // 2. It detects when the server has crashed or any other case in which the
 //    connection has broken without a fin or reset packet being sent to us.
-class PingTask : public buzz::XmppTask, private talk_base::MessageHandler {
+class PingTask : public buzz::XmppTask, private rtc::MessageHandler {
  public:
   PingTask(buzz::XmppTaskParentInterface* parent,
-      talk_base::MessageQueue* message_queue, uint32 ping_period_millis,
+      rtc::MessageQueue* message_queue, uint32 ping_period_millis,
       uint32 ping_timeout_millis);
 
   virtual bool HandleStanza(const buzz::XmlElement* stanza);
@@ -57,9 +57,9 @@ class PingTask : public buzz::XmppTask, private talk_base::MessageHandler {
 
  private:
   // Implementation of MessageHandler.
-  virtual void OnMessage(talk_base::Message* msg);
+  virtual void OnMessage(rtc::Message* msg);
 
-  talk_base::MessageQueue* message_queue_;
+  rtc::MessageQueue* message_queue_;
   uint32 ping_period_millis_;
   uint32 ping_timeout_millis_;
   uint32 next_ping_time_;
diff --git a/talk/xmpp/pingtask_unittest.cc b/talk/xmpp/pingtask_unittest.cc
index 477847dde1..ef41670715 100644
--- a/talk/xmpp/pingtask_unittest.cc
+++ b/talk/xmpp/pingtask_unittest.cc
@@ -28,9 +28,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/faketaskrunner.h"
-#include "talk/base/gunit.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/faketaskrunner.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/fakexmppclient.h"
@@ -40,7 +40,7 @@ class PingTaskTest;
 
 class PingXmppClient : public buzz::FakeXmppClient {
  public:
-  PingXmppClient(talk_base::TaskParent* parent, PingTaskTest* tst) :
+  PingXmppClient(rtc::TaskParent* parent, PingTaskTest* tst) :
       FakeXmppClient(parent), test(tst) {
   }
 
@@ -56,7 +56,7 @@ class PingTaskTest : public testing::Test, public sigslot::has_slots<> {
   }
 
   virtual void SetUp() {
-    runner = new talk_base::FakeTaskRunner();
+    runner = new rtc::FakeTaskRunner();
     xmpp_client = new PingXmppClient(runner, this);
   }
 
@@ -73,7 +73,7 @@ class PingTaskTest : public testing::Test, public sigslot::has_slots<> {
     timed_out = true;
   }
 
-  talk_base::FakeTaskRunner* runner;
+  rtc::FakeTaskRunner* runner;
   PingXmppClient* xmpp_client;
   bool respond_to_pings;
   bool timed_out;
@@ -93,7 +93,7 @@ buzz::XmppReturnStatus PingXmppClient::SendStanza(
 TEST_F(PingTaskTest, TestSuccess) {
   uint32 ping_period_millis = 100;
   buzz::PingTask* task = new buzz::PingTask(xmpp_client,
-      talk_base::Thread::Current(),
+      rtc::Thread::Current(),
       ping_period_millis, ping_period_millis / 10);
   ConnectTimeoutSignal(task);
   task->Start();
@@ -108,7 +108,7 @@ TEST_F(PingTaskTest, TestTimeout) {
   respond_to_pings = false;
   uint32 ping_timeout_millis = 200;
   buzz::PingTask* task = new buzz::PingTask(xmpp_client,
-      talk_base::Thread::Current(),
+      rtc::Thread::Current(),
       ping_timeout_millis * 10, ping_timeout_millis);
   ConnectTimeoutSignal(task);
   task->Start();
diff --git a/talk/xmpp/plainsaslhandler.h b/talk/xmpp/plainsaslhandler.h
index e7d44b9d55..8d34f5e07e 100644
--- a/talk/xmpp/plainsaslhandler.h
+++ b/talk/xmpp/plainsaslhandler.h
@@ -35,7 +35,7 @@ namespace buzz {
 
 class PlainSaslHandler : public SaslHandler {
 public:
-  PlainSaslHandler(const Jid & jid, const talk_base::CryptString & password, 
+  PlainSaslHandler(const Jid & jid, const rtc::CryptString & password, 
       bool allow_plain) : jid_(jid), password_(password), 
                           allow_plain_(allow_plain) {}
     
@@ -69,7 +69,7 @@ public:
   
 private:
   Jid jid_;
-  talk_base::CryptString password_;
+  rtc::CryptString password_;
   bool allow_plain_;
 };
 
diff --git a/talk/xmpp/presenceouttask.cc b/talk/xmpp/presenceouttask.cc
index cebd740de5..2974edcd8a 100644
--- a/talk/xmpp/presenceouttask.cc
+++ b/talk/xmpp/presenceouttask.cc
@@ -27,7 +27,7 @@
 
 #include <time.h>
 #include <sstream>
-#include "talk/base/stringencode.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/presenceouttask.h"
 #include "talk/xmpp/xmppclient.h"
@@ -117,7 +117,7 @@ PresenceOutTask::TranslateStatus(const PresenceStatus & s) {
     }
 
     std::string pri;
-    talk_base::ToString(s.priority(), &pri);
+    rtc::ToString(s.priority(), &pri);
 
     result->AddElement(new XmlElement(QN_PRIORITY));
     result->AddText(pri, 1);
diff --git a/talk/xmpp/presencereceivetask.cc b/talk/xmpp/presencereceivetask.cc
index 80121dde3b..3a21ea7393 100644
--- a/talk/xmpp/presencereceivetask.cc
+++ b/talk/xmpp/presencereceivetask.cc
@@ -27,7 +27,7 @@
 
 #include "talk/xmpp/presencereceivetask.h"
 
-#include "talk/base/stringencode.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/xmpp/constants.h"
 
 namespace buzz {
@@ -108,7 +108,7 @@ void PresenceReceiveTask::DecodeStatus(const Jid& from,
     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)) {
         presence_status->set_priority(pri);
       }
     }
diff --git a/talk/xmpp/presencereceivetask.h b/talk/xmpp/presencereceivetask.h
index 2bd6494a04..6a090f3a4c 100644
--- a/talk/xmpp/presencereceivetask.h
+++ b/talk/xmpp/presencereceivetask.h
@@ -28,7 +28,7 @@
 #ifndef THIRD_PARTY_LIBJINGLE_FILES_TALK_XMPP_PRESENCERECEIVETASK_H_
 #define THIRD_PARTY_LIBJINGLE_FILES_TALK_XMPP_PRESENCERECEIVETASK_H_
 
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 
 #include "talk/xmpp/presencestatus.h"
 #include "talk/xmpp/xmpptask.h"
diff --git a/talk/xmpp/prexmppauth.h b/talk/xmpp/prexmppauth.h
index 3bc5ca681c..83de5a47f8 100644
--- a/talk/xmpp/prexmppauth.h
+++ b/talk/xmpp/prexmppauth.h
@@ -28,11 +28,11 @@
 #ifndef TALK_XMPP_PREXMPPAUTH_H_
 #define TALK_XMPP_PREXMPPAUTH_H_
 
-#include "talk/base/cryptstring.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/cryptstring.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmpp/saslhandler.h"
 
-namespace talk_base {
+namespace rtc {
   class SocketAddress;
 }
 
@@ -67,8 +67,8 @@ public:
 
   virtual void StartPreXmppAuth(
     const Jid& jid,
-    const talk_base::SocketAddress& server,
-    const talk_base::CryptString& pass,
+    const rtc::SocketAddress& server,
+    const rtc::CryptString& pass,
     const std::string& auth_mechanism,
     const std::string& auth_token) = 0;
 
diff --git a/talk/xmpp/pubsub_task.cc b/talk/xmpp/pubsub_task.cc
index 91e2c729bf..36184c6930 100644
--- a/talk/xmpp/pubsub_task.cc
+++ b/talk/xmpp/pubsub_task.cc
@@ -30,7 +30,7 @@
 #include <map>
 #include <string>
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/xmppengine.h"
 
@@ -99,7 +99,7 @@ int PubsubTask::ProcessResponse() {
 bool PubsubTask::SubscribeToNode(const std::string& pubsub_node,
                                  NodeHandler handler) {
   subscribed_nodes_[pubsub_node] = handler;
-  talk_base::scoped_ptr<buzz::XmlElement> get_iq_request(
+  rtc::scoped_ptr<buzz::XmlElement> get_iq_request(
       MakeIq(buzz::STR_GET, pubsub_node_jid_, task_id()));
   if (!get_iq_request) {
     return false;
diff --git a/talk/xmpp/pubsubclient.h b/talk/xmpp/pubsubclient.h
index f0cd7a98f4..3212119523 100644
--- a/talk/xmpp/pubsubclient.h
+++ b/talk/xmpp/pubsubclient.h
@@ -31,9 +31,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/sigslot.h"
-#include "talk/base/sigslotrepeater.h"
-#include "talk/base/task.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/sigslotrepeater.h"
+#include "webrtc/base/task.h"
 #include "talk/xmpp/jid.h"
 #include "talk/xmpp/pubsubtasks.h"
 
diff --git a/talk/xmpp/pubsubclient_unittest.cc b/talk/xmpp/pubsubclient_unittest.cc
index 2e4c511427..01dec5fe1d 100644
--- a/talk/xmpp/pubsubclient_unittest.cc
+++ b/talk/xmpp/pubsubclient_unittest.cc
@@ -3,9 +3,9 @@
 
 #include <string>
 
-#include "talk/base/faketaskrunner.h"
-#include "talk/base/gunit.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/faketaskrunner.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmllite/qname.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
@@ -78,7 +78,7 @@ class PubSubClientTest : public testing::Test {
       pubsubjid("room@domain.com"),
       node("topic"),
       itemid("key") {
-    runner.reset(new talk_base::FakeTaskRunner());
+    runner.reset(new rtc::FakeTaskRunner());
     xmpp_client = new buzz::FakeXmppClient(runner.get());
     client.reset(new buzz::PubSubClient(xmpp_client, pubsubjid, node));
     listener.reset(new TestPubSubItemsListener());
@@ -96,11 +96,11 @@ class PubSubClientTest : public testing::Test {
         listener.get(), &TestPubSubItemsListener::OnRetractError);
   }
 
-  talk_base::scoped_ptr<talk_base::FakeTaskRunner> runner;
+  rtc::scoped_ptr<rtc::FakeTaskRunner> runner;
   // xmpp_client deleted by deleting runner.
   buzz::FakeXmppClient* xmpp_client;
-  talk_base::scoped_ptr<buzz::PubSubClient> client;
-  talk_base::scoped_ptr<TestPubSubItemsListener> listener;
+  rtc::scoped_ptr<buzz::PubSubClient> client;
+  rtc::scoped_ptr<TestPubSubItemsListener> listener;
   buzz::Jid pubsubjid;
   std::string node;
   std::string itemid;
diff --git a/talk/xmpp/pubsubstateclient.h b/talk/xmpp/pubsubstateclient.h
index f38658defd..17f4097b47 100644
--- a/talk/xmpp/pubsubstateclient.h
+++ b/talk/xmpp/pubsubstateclient.h
@@ -32,9 +32,9 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/sigslotrepeater.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/sigslotrepeater.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/jid.h"
 #include "talk/xmpp/pubsubclient.h"
@@ -273,8 +273,8 @@ class PubSubStateClient : public sigslot::has_slots<> {
   PubSubClient* client_;
   const QName state_name_;
   C default_state_;
-  talk_base::scoped_ptr<PubSubStateKeySerializer> key_serializer_;
-  talk_base::scoped_ptr<PubSubStateSerializer<C> > state_serializer_;
+  rtc::scoped_ptr<PubSubStateKeySerializer> key_serializer_;
+  rtc::scoped_ptr<PubSubStateSerializer<C> > state_serializer_;
   // key => state
   std::map<std::string, C> state_by_key_;
   // itemid => StateItemInfo
diff --git a/talk/xmpp/pubsubtasks.h b/talk/xmpp/pubsubtasks.h
index 2ba618b341..381667b84b 100644
--- a/talk/xmpp/pubsubtasks.h
+++ b/talk/xmpp/pubsubtasks.h
@@ -30,7 +30,7 @@
 
 #include <vector>
 
-#include "talk/base/sigslot.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmpp/iqtask.h"
 #include "talk/xmpp/receivetask.h"
 
diff --git a/talk/xmpp/pubsubtasks_unittest.cc b/talk/xmpp/pubsubtasks_unittest.cc
index 67fc30641a..bcfc6967d3 100644
--- a/talk/xmpp/pubsubtasks_unittest.cc
+++ b/talk/xmpp/pubsubtasks_unittest.cc
@@ -3,9 +3,9 @@
 
 #include <string>
 
-#include "talk/base/faketaskrunner.h"
-#include "talk/base/gunit.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/faketaskrunner.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmllite/qname.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
@@ -68,15 +68,15 @@ class PubSubTasksTest : public testing::Test {
       pubsubjid("room@domain.com"),
       node("topic"),
       itemid("key") {
-    runner.reset(new talk_base::FakeTaskRunner());
+    runner.reset(new rtc::FakeTaskRunner());
     client = new buzz::FakeXmppClient(runner.get());
     listener.reset(new TestPubSubTasksListener());
   }
 
-  talk_base::scoped_ptr<talk_base::FakeTaskRunner> runner;
+  rtc::scoped_ptr<rtc::FakeTaskRunner> runner;
   // Client deleted by deleting runner.
   buzz::FakeXmppClient* client;
-  talk_base::scoped_ptr<TestPubSubTasksListener> listener;
+  rtc::scoped_ptr<TestPubSubTasksListener> listener;
   buzz::Jid pubsubjid;
   std::string node;
   std::string itemid;
diff --git a/talk/xmpp/rostermodule_unittest.cc b/talk/xmpp/rostermodule_unittest.cc
index 9273eb5d25..4dbcabbd66 100644
--- a/talk/xmpp/rostermodule_unittest.cc
+++ b/talk/xmpp/rostermodule_unittest.cc
@@ -29,8 +29,8 @@
 #include <sstream>
 #include <iostream>
 
-#include "talk/base/gunit.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/xmppengine.h"
 #include "talk/xmpp/rostermodule.h"
@@ -267,7 +267,7 @@ TEST_F(RosterModuleTest, TestPresence) {
   status->AddAttr(QN_STATUS, STR_PSTN_CONFERENCE_STATUS_CONNECTING);
   XmlElement presence_xml(QN_PRESENCE);
   presence_xml.AddElement(status);
-  talk_base::scoped_ptr<XmppPresence> presence(XmppPresence::Create());
+  rtc::scoped_ptr<XmppPresence> presence(XmppPresence::Create());
   presence->set_raw_xml(&presence_xml);
   EXPECT_EQ(presence->connection_status(), XMPP_CONNECTION_STATUS_CONNECTING);
 }
@@ -275,11 +275,11 @@ TEST_F(RosterModuleTest, TestPresence) {
 TEST_F(RosterModuleTest, TestOutgoingPresence) {
   std::stringstream dump;
 
-  talk_base::scoped_ptr<XmppEngine> engine(XmppEngine::Create());
+  rtc::scoped_ptr<XmppEngine> engine(XmppEngine::Create());
   XmppTestHandler handler(engine.get());
   XmppTestRosterHandler roster_handler;
 
-  talk_base::scoped_ptr<XmppRosterModule> roster(XmppRosterModule::Create());
+  rtc::scoped_ptr<XmppRosterModule> roster(XmppRosterModule::Create());
   roster->set_roster_handler(&roster_handler);
 
   // Configure the roster module
@@ -381,7 +381,7 @@ TEST_F(RosterModuleTest, TestOutgoingPresence) {
   EXPECT_EQ(handler.SessionActivity(), "");
 
   // Construct a directed presence
-  talk_base::scoped_ptr<XmppPresence> directed_presence(XmppPresence::Create());
+  rtc::scoped_ptr<XmppPresence> directed_presence(XmppPresence::Create());
   TEST_OK(directed_presence->set_available(XMPP_PRESENCE_AVAILABLE));
   TEST_OK(directed_presence->set_priority(120));
   TEST_OK(directed_presence->set_status("*very* available"));
@@ -398,11 +398,11 @@ TEST_F(RosterModuleTest, TestOutgoingPresence) {
 }
 
 TEST_F(RosterModuleTest, TestIncomingPresence) {
-  talk_base::scoped_ptr<XmppEngine> engine(XmppEngine::Create());
+  rtc::scoped_ptr<XmppEngine> engine(XmppEngine::Create());
   XmppTestHandler handler(engine.get());
   XmppTestRosterHandler roster_handler;
 
-  talk_base::scoped_ptr<XmppRosterModule> roster(XmppRosterModule::Create());
+  rtc::scoped_ptr<XmppRosterModule> roster(XmppRosterModule::Create());
   roster->set_roster_handler(&roster_handler);
 
   // Configure the roster module
@@ -530,11 +530,11 @@ TEST_F(RosterModuleTest, TestIncomingPresence) {
 }
 
 TEST_F(RosterModuleTest, TestPresenceSubscription) {
-  talk_base::scoped_ptr<XmppEngine> engine(XmppEngine::Create());
+  rtc::scoped_ptr<XmppEngine> engine(XmppEngine::Create());
   XmppTestHandler handler(engine.get());
   XmppTestRosterHandler roster_handler;
 
-  talk_base::scoped_ptr<XmppRosterModule> roster(XmppRosterModule::Create());
+  rtc::scoped_ptr<XmppRosterModule> roster(XmppRosterModule::Create());
   roster->set_roster_handler(&roster_handler);
 
   // Configure the roster module
@@ -593,11 +593,11 @@ TEST_F(RosterModuleTest, TestPresenceSubscription) {
 }
 
 TEST_F(RosterModuleTest, TestRosterReceive) {
-  talk_base::scoped_ptr<XmppEngine> engine(XmppEngine::Create());
+  rtc::scoped_ptr<XmppEngine> engine(XmppEngine::Create());
   XmppTestHandler handler(engine.get());
   XmppTestRosterHandler roster_handler;
 
-  talk_base::scoped_ptr<XmppRosterModule> roster(XmppRosterModule::Create());
+  rtc::scoped_ptr<XmppRosterModule> roster(XmppRosterModule::Create());
   roster->set_roster_handler(&roster_handler);
 
   // Configure the roster module
@@ -713,7 +713,7 @@ TEST_F(RosterModuleTest, TestRosterReceive) {
   EXPECT_EQ(handler.SessionActivity(), "");
 
   // Request that someone be added
-  talk_base::scoped_ptr<XmppRosterContact> contact(XmppRosterContact::Create());
+  rtc::scoped_ptr<XmppRosterContact> contact(XmppRosterContact::Create());
   TEST_OK(contact->set_jid(Jid("brandt@example.net")));
   TEST_OK(contact->set_name("Brandt"));
   TEST_OK(contact->AddGroup("Business Partners"));
diff --git a/talk/xmpp/rostermoduleimpl.cc b/talk/xmpp/rostermoduleimpl.cc
index 993cfa905f..0ebf7e9ecc 100644
--- a/talk/xmpp/rostermoduleimpl.cc
+++ b/talk/xmpp/rostermoduleimpl.cc
@@ -31,8 +31,8 @@
 #include <algorithm>
 #include <sstream>
 #include <iostream>
-#include "talk/base/common.h"
-#include "talk/base/stringencode.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/stringencode.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/rostermoduleimpl.h"
 
@@ -217,7 +217,7 @@ XmppPresenceImpl::priority() const {
     return 0;
 
   int raw_priority = 0;
-  if (!talk_base::FromString(raw_xml_->TextNamed(QN_PRIORITY), &raw_priority))
+  if (!rtc::FromString(raw_xml_->TextNamed(QN_PRIORITY), &raw_priority))
     raw_priority = 0;
   if (raw_priority < -128)
     raw_priority = -128;
@@ -238,7 +238,7 @@ XmppPresenceImpl::set_priority(int priority) {
   raw_xml_->ClearNamedChildren(QN_PRIORITY);
   if (0 != priority) {
     std::string priority_string;
-    if (talk_base::ToString(priority, &priority_string)) {
+    if (rtc::ToString(priority, &priority_string)) {
       raw_xml_->AddElement(new XmlElement(QN_PRIORITY));
       raw_xml_->AddText(priority_string, 1);
     }
diff --git a/talk/xmpp/rostermoduleimpl.h b/talk/xmpp/rostermoduleimpl.h
index df6b70f13d..a6b15cfa92 100644
--- a/talk/xmpp/rostermoduleimpl.h
+++ b/talk/xmpp/rostermoduleimpl.h
@@ -103,7 +103,7 @@ private:
 
   // Store everything in the XML element. If this becomes a perf issue we can
   // cache the data.
-  talk_base::scoped_ptr<XmlElement> raw_xml_;
+  rtc::scoped_ptr<XmlElement> raw_xml_;
 };
 
 //! A contact as given by the server
@@ -168,7 +168,7 @@ private:
   int group_count_;
   int group_index_returned_;
   XmlElement * group_returned_;
-  talk_base::scoped_ptr<XmlElement> raw_xml_;
+  rtc::scoped_ptr<XmlElement> raw_xml_;
 };
 
 //! An XmppModule for handle roster and presence functionality
@@ -290,11 +290,11 @@ private:
 
   typedef std::vector<XmppPresenceImpl*> PresenceVector;
   typedef std::map<Jid, PresenceVector*> JidPresenceVectorMap;
-  talk_base::scoped_ptr<JidPresenceVectorMap> incoming_presence_map_;
-  talk_base::scoped_ptr<PresenceVector> incoming_presence_vector_;
+  rtc::scoped_ptr<JidPresenceVectorMap> incoming_presence_map_;
+  rtc::scoped_ptr<PresenceVector> incoming_presence_vector_;
 
   typedef std::vector<XmppRosterContactImpl*> ContactVector;
-  talk_base::scoped_ptr<ContactVector> contacts_;
+  rtc::scoped_ptr<ContactVector> contacts_;
 };
 
 }
diff --git a/talk/xmpp/saslmechanism.cc b/talk/xmpp/saslmechanism.cc
index 2645ac04e3..77ffe9c768 100644
--- a/talk/xmpp/saslmechanism.cc
+++ b/talk/xmpp/saslmechanism.cc
@@ -25,12 +25,12 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "talk/base/base64.h"
+#include "webrtc/base/base64.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/saslmechanism.h"
 
-using talk_base::Base64;
+using rtc::Base64;
 
 namespace buzz {
 
diff --git a/talk/xmpp/saslplainmechanism.h b/talk/xmpp/saslplainmechanism.h
index f0793b402a..3491a930f9 100644
--- a/talk/xmpp/saslplainmechanism.h
+++ b/talk/xmpp/saslplainmechanism.h
@@ -28,7 +28,7 @@
 #ifndef TALK_XMPP_SASLPLAINMECHANISM_H_
 #define TALK_XMPP_SASLPLAINMECHANISM_H_
 
-#include "talk/base/cryptstring.h"
+#include "webrtc/base/cryptstring.h"
 #include "talk/xmpp/saslmechanism.h"
 
 namespace buzz {
@@ -36,7 +36,7 @@ namespace buzz {
 class SaslPlainMechanism : public SaslMechanism {
 
 public:
-  SaslPlainMechanism(const buzz::Jid user_jid, const talk_base::CryptString & password) :
+  SaslPlainMechanism(const buzz::Jid user_jid, const rtc::CryptString & password) :
     user_jid_(user_jid), password_(password) {}
 
   virtual std::string GetMechanismName() { return "PLAIN"; }
@@ -46,7 +46,7 @@ public:
     XmlElement * el = new XmlElement(QN_SASL_AUTH, true);
     el->AddAttr(QN_MECHANISM, "PLAIN");
 
-    talk_base::FormatCryptString credential;
+    rtc::FormatCryptString credential;
     credential.Append("\0", 1);
     credential.Append(user_jid_.node());
     credential.Append("\0", 1);
@@ -57,7 +57,7 @@ public:
 
 private:
   Jid user_jid_;
-  talk_base::CryptString password_;
+  rtc::CryptString password_;
 };
 
 }
diff --git a/talk/xmpp/util_unittest.cc b/talk/xmpp/util_unittest.cc
index 3d13007e18..390e7bccbc 100644
--- a/talk/xmpp/util_unittest.cc
+++ b/talk/xmpp/util_unittest.cc
@@ -4,7 +4,7 @@
 #include <string>
 #include <sstream>
 #include <iostream>
-#include "talk/base/gunit.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/xmppengine.h"
 #include "talk/xmpp/util_unittest.h"
diff --git a/talk/xmpp/xmppauth.cc b/talk/xmpp/xmppauth.cc
index efda96741e..d828475fae 100644
--- a/talk/xmpp/xmppauth.cc
+++ b/talk/xmpp/xmppauth.cc
@@ -40,8 +40,8 @@ XmppAuth::~XmppAuth() {
 }
 
 void XmppAuth::StartPreXmppAuth(const buzz::Jid& jid,
-                                const talk_base::SocketAddress& server,
-                                const talk_base::CryptString& pass,
+                                const rtc::SocketAddress& server,
+                                const rtc::CryptString& pass,
                                 const std::string& auth_mechanism,
                                 const std::string& auth_token) {
   jid_ = jid;
diff --git a/talk/xmpp/xmppauth.h b/talk/xmpp/xmppauth.h
index 5dd6963822..504b11e863 100644
--- a/talk/xmpp/xmppauth.h
+++ b/talk/xmpp/xmppauth.h
@@ -30,8 +30,8 @@
 
 #include <vector>
 
-#include "talk/base/cryptstring.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/cryptstring.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmpp/jid.h"
 #include "talk/xmpp/saslhandler.h"
 #include "talk/xmpp/prexmppauth.h"
@@ -44,8 +44,8 @@ public:
   // TODO: Just have one "secret" that is either pass or
   // token?
   virtual void StartPreXmppAuth(const buzz::Jid& jid,
-                                const talk_base::SocketAddress& server,
-                                const talk_base::CryptString& pass,
+                                const rtc::SocketAddress& server,
+                                const rtc::CryptString& pass,
                                 const std::string& auth_mechanism,
                                 const std::string& auth_token);
 
@@ -68,7 +68,7 @@ public:
 
 private:
   buzz::Jid jid_;
-  talk_base::CryptString passwd_;
+  rtc::CryptString passwd_;
   std::string auth_mechanism_;
   std::string auth_token_;
   bool done_;
diff --git a/talk/xmpp/xmppclient.cc b/talk/xmpp/xmppclient.cc
index 8927dad4e4..e378a01a49 100644
--- a/talk/xmpp/xmppclient.cc
+++ b/talk/xmpp/xmppclient.cc
@@ -27,10 +27,10 @@
 
 #include "xmppclient.h"
 #include "xmpptask.h"
-#include "talk/base/logging.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/scoped_ptr.h"
-#include "talk/base/stringutils.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/base/stringutils.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/saslplainmechanism.h"
 #include "talk/xmpp/prexmppauth.h"
@@ -64,13 +64,13 @@ public:
   XmppClient* const client_;
 
   // the two main objects
-  talk_base::scoped_ptr<AsyncSocket> socket_;
-  talk_base::scoped_ptr<XmppEngine> engine_;
-  talk_base::scoped_ptr<PreXmppAuth> pre_auth_;
-  talk_base::CryptString pass_;
+  rtc::scoped_ptr<AsyncSocket> socket_;
+  rtc::scoped_ptr<XmppEngine> engine_;
+  rtc::scoped_ptr<PreXmppAuth> pre_auth_;
+  rtc::CryptString pass_;
   std::string auth_mechanism_;
   std::string auth_token_;
-  talk_base::SocketAddress server_;
+  rtc::SocketAddress server_;
   std::string proxy_host_;
   int proxy_port_;
   XmppEngine::Error pre_engine_error_;
@@ -103,7 +103,7 @@ public:
 bool IsTestServer(const std::string& server_name,
                   const std::string& test_server_domain) {
   return (!test_server_domain.empty() &&
-          talk_base::ends_with(server_name.c_str(),
+          rtc::ends_with(server_name.c_str(),
                                test_server_domain.c_str()));
 }
 
diff --git a/talk/xmpp/xmppclient.h b/talk/xmpp/xmppclient.h
index c8dd91edf7..e5b202e3d0 100644
--- a/talk/xmpp/xmppclient.h
+++ b/talk/xmpp/xmppclient.h
@@ -29,9 +29,9 @@
 #define TALK_XMPP_XMPPCLIENT_H_
 
 #include <string>
-#include "talk/base/basicdefs.h"
-#include "talk/base/sigslot.h"
-#include "talk/base/task.h"
+#include "webrtc/base/basicdefs.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/task.h"
 #include "talk/xmpp/asyncsocket.h"
 #include "talk/xmpp/xmppclientsettings.h"
 #include "talk/xmpp/xmppengine.h"
@@ -73,7 +73,7 @@ class XmppClient : public XmppTaskParentInterface,
                    public sigslot::has_slots<>
 {
 public:
-  explicit XmppClient(talk_base::TaskParent * parent);
+  explicit XmppClient(rtc::TaskParent * parent);
   virtual ~XmppClient();
 
   XmppReturnStatus Connect(const XmppClientSettings & settings,
@@ -154,7 +154,7 @@ public:
 
   class Private;
   friend class Private;
-  talk_base::scoped_ptr<Private> d_;
+  rtc::scoped_ptr<Private> d_;
 
   bool delivering_signal_;
   bool valid_;
diff --git a/talk/xmpp/xmppclientsettings.h b/talk/xmpp/xmppclientsettings.h
index 8851f180c2..8b5a4e2a28 100644
--- a/talk/xmpp/xmppclientsettings.h
+++ b/talk/xmpp/xmppclientsettings.h
@@ -29,7 +29,7 @@
 #define TALK_XMPP_XMPPCLIENTSETTINGS_H_
 
 #include "talk/p2p/base/port.h"
-#include "talk/base/cryptstring.h"
+#include "webrtc/base/cryptstring.h"
 #include "talk/xmpp/xmppengine.h"
 
 namespace buzz {
@@ -43,7 +43,7 @@ class XmppUserSettings {
 
   void set_user(const std::string& user) { user_ = user; }
   void set_host(const std::string& host) { host_ = host; }
-  void set_pass(const talk_base::CryptString& pass) { pass_ = pass; }
+  void set_pass(const rtc::CryptString& pass) { pass_ = pass; }
   void set_auth_token(const std::string& mechanism,
                       const std::string& token) {
     auth_mechanism_ = mechanism;
@@ -61,7 +61,7 @@ class XmppUserSettings {
 
   const std::string& user() const { return user_; }
   const std::string& host() const { return host_; }
-  const talk_base::CryptString& pass() const { return pass_; }
+  const rtc::CryptString& pass() const { return pass_; }
   const std::string& auth_mechanism() const { return auth_mechanism_; }
   const std::string& auth_token() const { return auth_token_; }
   const std::string& resource() const { return resource_; }
@@ -73,7 +73,7 @@ class XmppUserSettings {
  private:
   std::string user_;
   std::string host_;
-  talk_base::CryptString pass_;
+  rtc::CryptString pass_;
   std::string auth_mechanism_;
   std::string auth_token_;
   std::string resource_;
@@ -87,40 +87,40 @@ class XmppClientSettings : public XmppUserSettings {
  public:
   XmppClientSettings()
     : protocol_(cricket::PROTO_TCP),
-      proxy_(talk_base::PROXY_NONE),
+      proxy_(rtc::PROXY_NONE),
       proxy_port_(80),
       use_proxy_auth_(false) {
   }
 
-  void set_server(const talk_base::SocketAddress& server) {
+  void set_server(const rtc::SocketAddress& server) {
       server_ = server;
   }
   void set_protocol(cricket::ProtocolType protocol) { protocol_ = protocol; }
-  void set_proxy(talk_base::ProxyType f) { proxy_ = f; }
+  void set_proxy(rtc::ProxyType f) { proxy_ = f; }
   void set_proxy_host(const std::string& host) { proxy_host_ = host; }
   void set_proxy_port(int port) { proxy_port_ = port; };
   void set_use_proxy_auth(bool f) { use_proxy_auth_ = f; }
   void set_proxy_user(const std::string& user) { proxy_user_ = user; }
-  void set_proxy_pass(const talk_base::CryptString& pass) { proxy_pass_ = pass; }
+  void set_proxy_pass(const rtc::CryptString& pass) { proxy_pass_ = pass; }
 
-  const talk_base::SocketAddress& server() const { return server_; }
+  const rtc::SocketAddress& server() const { return server_; }
   cricket::ProtocolType protocol() const { return protocol_; }
-  talk_base::ProxyType proxy() const { return proxy_; }
+  rtc::ProxyType proxy() const { return proxy_; }
   const std::string& proxy_host() const { return proxy_host_; }
   int proxy_port() const { return proxy_port_; }
   bool use_proxy_auth() const { return use_proxy_auth_; }
   const std::string& proxy_user() const { return proxy_user_; }
-  const talk_base::CryptString& proxy_pass() const { return proxy_pass_; }
+  const rtc::CryptString& proxy_pass() const { return proxy_pass_; }
 
  private:
-  talk_base::SocketAddress server_;
+  rtc::SocketAddress server_;
   cricket::ProtocolType protocol_;
-  talk_base::ProxyType proxy_;
+  rtc::ProxyType proxy_;
   std::string proxy_host_;
   int proxy_port_;
   bool use_proxy_auth_;
   std::string proxy_user_;
-  talk_base::CryptString proxy_pass_;
+  rtc::CryptString proxy_pass_;
 };
 
 }
diff --git a/talk/xmpp/xmppengine_unittest.cc b/talk/xmpp/xmppengine_unittest.cc
index 46b79c6d31..779a7d8a27 100644
--- a/talk/xmpp/xmppengine_unittest.cc
+++ b/talk/xmpp/xmppengine_unittest.cc
@@ -4,8 +4,8 @@
 #include <string>
 #include <sstream>
 #include <iostream>
-#include "talk/base/common.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/util_unittest.h"
@@ -54,14 +54,14 @@ class XmppEngineTest : public testing::Test {
     handler_.reset(new XmppTestHandler(engine_.get()));
 
     Jid jid("david@my-server");
-    talk_base::InsecureCryptStringImpl pass;
+    rtc::InsecureCryptStringImpl pass;
     pass.password() = "david";
     engine_->SetSessionHandler(handler_.get());
     engine_->SetOutputHandler(handler_.get());
     engine_->AddStanzaHandler(handler_.get());
     engine_->SetUser(jid);
     engine_->SetSaslHandler(
-        new buzz::PlainSaslHandler(jid, talk_base::CryptString(pass), true));
+        new buzz::PlainSaslHandler(jid, rtc::CryptString(pass), true));
   }
   virtual void TearDown() {
     handler_.reset();
@@ -70,8 +70,8 @@ class XmppEngineTest : public testing::Test {
   void RunLogin();
 
  private:
-  talk_base::scoped_ptr<XmppEngine> engine_;
-  talk_base::scoped_ptr<XmppTestHandler> handler_;
+  rtc::scoped_ptr<XmppEngine> engine_;
+  rtc::scoped_ptr<XmppTestHandler> handler_;
 };
 
 void XmppEngineTest::RunLogin() {
diff --git a/talk/xmpp/xmppengineimpl.cc b/talk/xmpp/xmppengineimpl.cc
index cf07ab70ab..fb288a0918 100644
--- a/talk/xmpp/xmppengineimpl.cc
+++ b/talk/xmpp/xmppengineimpl.cc
@@ -31,7 +31,7 @@
 #include <sstream>
 #include <vector>
 
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmllite/xmlprinter.h"
 #include "talk/xmpp/constants.h"
diff --git a/talk/xmpp/xmppengineimpl.h b/talk/xmpp/xmppengineimpl.h
index 8278681365..4eacf2fb1b 100644
--- a/talk/xmpp/xmppengineimpl.h
+++ b/talk/xmpp/xmppengineimpl.h
@@ -250,7 +250,7 @@ class XmppEngineImpl : public XmppEngine {
   TlsOptions tls_option_;
   std::string tls_server_hostname_;
   std::string tls_server_domain_;
-  talk_base::scoped_ptr<XmppLoginTask> login_task_;
+  rtc::scoped_ptr<XmppLoginTask> login_task_;
   std::string lang_;
 
   int next_id_;
@@ -259,7 +259,7 @@ class XmppEngineImpl : public XmppEngine {
   bool encrypted_;
   Error error_code_;
   int subcode_;
-  talk_base::scoped_ptr<XmlElement> stream_error_;
+  rtc::scoped_ptr<XmlElement> stream_error_;
   bool raised_reset_;
   XmppOutputHandler* output_handler_;
   XmppSessionHandler* session_handler_;
@@ -267,14 +267,14 @@ class XmppEngineImpl : public XmppEngine {
   XmlnsStack xmlns_stack_;
 
   typedef std::vector<XmppStanzaHandler*> StanzaHandlerVector;
-  talk_base::scoped_ptr<StanzaHandlerVector> stanza_handlers_[HL_COUNT];
+  rtc::scoped_ptr<StanzaHandlerVector> stanza_handlers_[HL_COUNT];
 
   typedef std::vector<XmppIqEntry*> IqEntryVector;
-  talk_base::scoped_ptr<IqEntryVector> iq_entries_;
+  rtc::scoped_ptr<IqEntryVector> iq_entries_;
 
-  talk_base::scoped_ptr<SaslHandler> sasl_handler_;
+  rtc::scoped_ptr<SaslHandler> sasl_handler_;
 
-  talk_base::scoped_ptr<std::stringstream> output_;
+  rtc::scoped_ptr<std::stringstream> output_;
 };
 
 }  // namespace buzz
diff --git a/talk/xmpp/xmppengineimpl_iq.cc b/talk/xmpp/xmppengineimpl_iq.cc
index 5834b90d4b..3f449d0583 100644
--- a/talk/xmpp/xmppengineimpl_iq.cc
+++ b/talk/xmpp/xmppengineimpl_iq.cc
@@ -27,7 +27,7 @@
 
 #include <vector>
 #include <algorithm>
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmpp/xmppengineimpl.h"
 #include "talk/xmpp/constants.h"
 
diff --git a/talk/xmpp/xmpplogintask.cc b/talk/xmpp/xmpplogintask.cc
index b3a2047cfe..1ff6e223e3 100644
--- a/talk/xmpp/xmpplogintask.cc
+++ b/talk/xmpp/xmpplogintask.cc
@@ -30,15 +30,15 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/base64.h"
-#include "talk/base/common.h"
+#include "webrtc/base/base64.h"
+#include "webrtc/base/common.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/constants.h"
 #include "talk/xmpp/jid.h"
 #include "talk/xmpp/saslmechanism.h"
 #include "talk/xmpp/xmppengineimpl.h"
 
-using talk_base::ConstantLabel;
+using rtc::ConstantLabel;
 
 namespace buzz {
 
@@ -103,7 +103,7 @@ XmppLoginTask::Advance() {
 
 #if _DEBUG
     LOG(LS_VERBOSE) << "XmppLoginTask::Advance - "
-      << talk_base::ErrorName(state_, LOGINTASK_STATES);
+      << rtc::ErrorName(state_, LOGINTASK_STATES);
 #endif  // _DEBUG
 
     switch (state_) {
diff --git a/talk/xmpp/xmpplogintask.h b/talk/xmpp/xmpplogintask.h
index 9b3f5aec73..61be0d2bde 100644
--- a/talk/xmpp/xmpplogintask.h
+++ b/talk/xmpp/xmpplogintask.h
@@ -31,8 +31,8 @@
 #include <string>
 #include <vector>
 
-#include "talk/base/logging.h"
-#include "talk/base/scoped_ptr.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "talk/xmpp/jid.h"
 #include "talk/xmpp/xmppengine.h"
 
@@ -87,15 +87,15 @@ private:
   const XmlElement * pelStanza_;
   bool isStart_;
   std::string iqId_;
-  talk_base::scoped_ptr<XmlElement> pelFeatures_;
+  rtc::scoped_ptr<XmlElement> pelFeatures_;
   Jid fullJid_;
   std::string streamId_;
-  talk_base::scoped_ptr<std::vector<XmlElement *> > pvecQueuedStanzas_;
+  rtc::scoped_ptr<std::vector<XmlElement *> > pvecQueuedStanzas_;
 
-  talk_base::scoped_ptr<SaslMechanism> sasl_mech_;
+  rtc::scoped_ptr<SaslMechanism> sasl_mech_;
 
 #ifdef _DEBUG
-  static const talk_base::ConstantLabel LOGINTASK_STATES[];
+  static const rtc::ConstantLabel LOGINTASK_STATES[];
 #endif  // _DEBUG
 };
 
diff --git a/talk/xmpp/xmpplogintask_unittest.cc b/talk/xmpp/xmpplogintask_unittest.cc
index 51af81a039..1a3b2d663a 100644
--- a/talk/xmpp/xmpplogintask_unittest.cc
+++ b/talk/xmpp/xmpplogintask_unittest.cc
@@ -4,9 +4,9 @@
 #include <string>
 #include <sstream>
 #include <iostream>
-#include "talk/base/common.h"
-#include "talk/base/cryptstring.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/cryptstring.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/util_unittest.h"
 #include "talk/xmpp/constants.h"
@@ -43,14 +43,14 @@ class XmppLoginTaskTest : public testing::Test {
     handler_.reset(new XmppTestHandler(engine_.get()));
 
     Jid jid("david@my-server");
-    talk_base::InsecureCryptStringImpl pass;
+    rtc::InsecureCryptStringImpl pass;
     pass.password() = "david";
     engine_->SetSessionHandler(handler_.get());
     engine_->SetOutputHandler(handler_.get());
     engine_->AddStanzaHandler(handler_.get());
     engine_->SetUser(jid);
     engine_->SetSaslHandler(
-        new buzz::PlainSaslHandler(jid, talk_base::CryptString(pass), true));
+        new buzz::PlainSaslHandler(jid, rtc::CryptString(pass), true));
   }
   virtual void TearDown() {
     handler_.reset();
@@ -60,8 +60,8 @@ class XmppLoginTaskTest : public testing::Test {
   void SetTlsOptions(buzz::TlsOptions option);
 
  private:
-  talk_base::scoped_ptr<XmppEngine> engine_;
-  talk_base::scoped_ptr<XmppTestHandler> handler_;
+  rtc::scoped_ptr<XmppEngine> engine_;
+  rtc::scoped_ptr<XmppTestHandler> handler_;
 };
 
 void XmppLoginTaskTest::SetTlsOptions(buzz::TlsOptions option) {
diff --git a/talk/xmpp/xmpppump.cc b/talk/xmpp/xmpppump.cc
index 57329861a3..cf7aa7b1a0 100644
--- a/talk/xmpp/xmpppump.cc
+++ b/talk/xmpp/xmpppump.cc
@@ -63,14 +63,14 @@ void XmppPump::OnStateChange(buzz::XmppEngine::State state) {
 }
 
 void XmppPump::WakeTasks() {
-  talk_base::Thread::Current()->Post(this);
+  rtc::Thread::Current()->Post(this);
 }
 
 int64 XmppPump::CurrentTime() {
-  return (int64)talk_base::Time();
+  return (int64)rtc::Time();
 }
 
-void XmppPump::OnMessage(talk_base::Message *pmsg) {
+void XmppPump::OnMessage(rtc::Message *pmsg) {
   RunTasks();
 }
 
diff --git a/talk/xmpp/xmpppump.h b/talk/xmpp/xmpppump.h
index 7a374cc793..4dc4ba836f 100644
--- a/talk/xmpp/xmpppump.h
+++ b/talk/xmpp/xmpppump.h
@@ -28,10 +28,10 @@
 #ifndef TALK_XMPP_XMPPPUMP_H_
 #define TALK_XMPP_XMPPPUMP_H_
 
-#include "talk/base/messagequeue.h"
-#include "talk/base/taskrunner.h"
-#include "talk/base/thread.h"
-#include "talk/base/timeutils.h"
+#include "webrtc/base/messagequeue.h"
+#include "webrtc/base/taskrunner.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/timeutils.h"
 #include "talk/xmpp/xmppclient.h"
 #include "talk/xmpp/xmppengine.h"
 #include "talk/xmpp/xmpptask.h"
@@ -46,7 +46,7 @@ public:
   virtual void OnStateChange(buzz::XmppEngine::State state) = 0;
 };
 
-class XmppPump : public talk_base::MessageHandler, public talk_base::TaskRunner {
+class XmppPump : public rtc::MessageHandler, public rtc::TaskRunner {
 public:
   XmppPump(buzz::XmppPumpNotify * notify = NULL);
 
@@ -63,7 +63,7 @@ public:
 
   int64 CurrentTime();
 
-  void OnMessage(talk_base::Message *pmsg);
+  void OnMessage(rtc::Message *pmsg);
 
   buzz::XmppReturnStatus SendStanza(const buzz::XmlElement *stanza);
 
diff --git a/talk/xmpp/xmppsocket.cc b/talk/xmpp/xmppsocket.cc
index 31d1b69ee7..67240ba961 100644
--- a/talk/xmpp/xmppsocket.cc
+++ b/talk/xmpp/xmppsocket.cc
@@ -32,17 +32,17 @@
 #endif
 
 #include <errno.h>
-#include "talk/base/basicdefs.h"
-#include "talk/base/logging.h"
-#include "talk/base/thread.h"
+#include "webrtc/base/basicdefs.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/thread.h"
 #ifdef FEATURE_ENABLE_SSL
-#include "talk/base/ssladapter.h"
+#include "webrtc/base/ssladapter.h"
 #endif
 
 #ifdef USE_SSLSTREAM
-#include "talk/base/socketstream.h"
+#include "webrtc/base/socketstream.h"
 #ifdef FEATURE_ENABLE_SSL
-#include "talk/base/sslstreamadapter.h"
+#include "webrtc/base/sslstreamadapter.h"
 #endif  // FEATURE_ENABLE_SSL
 #endif  // USE_SSLSTREAM
 
@@ -54,16 +54,16 @@ XmppSocket::XmppSocket(buzz::TlsOptions tls) : cricket_socket_(NULL),
 }
 
 void XmppSocket::CreateCricketSocket(int family) {
-  talk_base::Thread* pth = talk_base::Thread::Current();
+  rtc::Thread* pth = rtc::Thread::Current();
   if (family == AF_UNSPEC) {
     family = AF_INET;
   }
-  talk_base::AsyncSocket* socket =
+  rtc::AsyncSocket* socket =
       pth->socketserver()->CreateAsyncSocket(family, SOCK_STREAM);
 #ifndef USE_SSLSTREAM
 #ifdef FEATURE_ENABLE_SSL
   if (tls_ != buzz::TLS_DISABLED) {
-    socket = talk_base::SSLAdapter::Create(socket);
+    socket = rtc::SSLAdapter::Create(socket);
   }
 #endif  // FEATURE_ENABLE_SSL
   cricket_socket_ = socket;
@@ -74,10 +74,10 @@ void XmppSocket::CreateCricketSocket(int family) {
   cricket_socket_->SignalCloseEvent.connect(this, &XmppSocket::OnCloseEvent);
 #else  // USE_SSLSTREAM
   cricket_socket_ = socket;
-  stream_ = new talk_base::SocketStream(cricket_socket_);
+  stream_ = new rtc::SocketStream(cricket_socket_);
 #ifdef FEATURE_ENABLE_SSL
   if (tls_ != buzz::TLS_DISABLED)
-    stream_ = talk_base::SSLStreamAdapter::Create(stream_);
+    stream_ = rtc::SSLStreamAdapter::Create(stream_);
 #endif  // FEATURE_ENABLE_SSL
   stream_->SignalEvent.connect(this, &XmppSocket::OnEvent);
 #endif  // USE_SSLSTREAM
@@ -93,11 +93,11 @@ XmppSocket::~XmppSocket() {
 }
 
 #ifndef USE_SSLSTREAM
-void XmppSocket::OnReadEvent(talk_base::AsyncSocket * socket) {
+void XmppSocket::OnReadEvent(rtc::AsyncSocket * socket) {
   SignalRead();
 }
 
-void XmppSocket::OnWriteEvent(talk_base::AsyncSocket * socket) {
+void XmppSocket::OnWriteEvent(rtc::AsyncSocket * socket) {
   // Write bytes if there are any
   while (buffer_.Length() != 0) {
     int written = cricket_socket_->Send(buffer_.Data(), buffer_.Length());
@@ -111,7 +111,7 @@ void XmppSocket::OnWriteEvent(talk_base::AsyncSocket * socket) {
   }
 }
 
-void XmppSocket::OnConnectEvent(talk_base::AsyncSocket * socket) {
+void XmppSocket::OnConnectEvent(rtc::AsyncSocket * socket) {
 #if defined(FEATURE_ENABLE_SSL)
   if (state_ == buzz::AsyncSocket::STATE_TLS_CONNECTING) {
     state_ = buzz::AsyncSocket::STATE_TLS_OPEN;
@@ -124,20 +124,20 @@ void XmppSocket::OnConnectEvent(talk_base::AsyncSocket * socket) {
   SignalConnected();
 }
 
-void XmppSocket::OnCloseEvent(talk_base::AsyncSocket * socket, int error) {
+void XmppSocket::OnCloseEvent(rtc::AsyncSocket * socket, int error) {
   SignalCloseEvent(error);
 }
 
 #else  // USE_SSLSTREAM
 
-void XmppSocket::OnEvent(talk_base::StreamInterface* stream,
+void XmppSocket::OnEvent(rtc::StreamInterface* stream,
                          int events, int err) {
-  if ((events & talk_base::SE_OPEN)) {
+  if ((events & rtc::SE_OPEN)) {
 #if defined(FEATURE_ENABLE_SSL)
     if (state_ == buzz::AsyncSocket::STATE_TLS_CONNECTING) {
       state_ = buzz::AsyncSocket::STATE_TLS_OPEN;
       SignalSSLConnected();
-      events |= talk_base::SE_WRITE;
+      events |= rtc::SE_WRITE;
     } else
 #endif
     {
@@ -145,28 +145,28 @@ void XmppSocket::OnEvent(talk_base::StreamInterface* stream,
       SignalConnected();
     }
   }
-  if ((events & talk_base::SE_READ))
+  if ((events & rtc::SE_READ))
     SignalRead();
-  if ((events & talk_base::SE_WRITE)) {
+  if ((events & rtc::SE_WRITE)) {
     // Write bytes if there are any
     while (buffer_.Length() != 0) {
-      talk_base::StreamResult result;
+      rtc::StreamResult result;
       size_t written;
       int error;
       result = stream_->Write(buffer_.Data(), buffer_.Length(),
                               &written, &error);
-      if (result == talk_base::SR_ERROR) {
+      if (result == rtc::SR_ERROR) {
         LOG(LS_ERROR) << "Send error: " << error;
         return;
       }
-      if (result == talk_base::SR_BLOCK)
+      if (result == rtc::SR_BLOCK)
         return;
-      ASSERT(result == talk_base::SR_SUCCESS);
+      ASSERT(result == rtc::SR_SUCCESS);
       ASSERT(written > 0);
       buffer_.Shift(written);
     }
   }
-  if ((events & talk_base::SE_CLOSE))
+  if ((events & rtc::SE_CLOSE))
     SignalCloseEvent(err);
 }
 #endif  // USE_SSLSTREAM
@@ -183,7 +183,7 @@ int XmppSocket::GetError() {
   return 0;
 }
 
-bool XmppSocket::Connect(const talk_base::SocketAddress& addr) {
+bool XmppSocket::Connect(const rtc::SocketAddress& addr) {
   if (cricket_socket_ == NULL) {
     CreateCricketSocket(addr.family());
   }
@@ -201,8 +201,8 @@ bool XmppSocket::Read(char * data, size_t len, size_t* len_read) {
     return true;
   }
 #else  // USE_SSLSTREAM
-  talk_base::StreamResult result = stream_->Read(data, len, len_read, NULL);
-  if (result == talk_base::SR_SUCCESS)
+  rtc::StreamResult result = stream_->Read(data, len, len_read, NULL);
+  if (result == rtc::SR_SUCCESS)
     return true;
 #endif  // USE_SSLSTREAM
   return false;
@@ -213,7 +213,7 @@ bool XmppSocket::Write(const char * data, size_t len) {
 #ifndef USE_SSLSTREAM
   OnWriteEvent(cricket_socket_);
 #else  // USE_SSLSTREAM
-  OnEvent(stream_, talk_base::SE_WRITE, 0);
+  OnEvent(stream_, rtc::SE_WRITE, 0);
 #endif  // USE_SSLSTREAM
   return true;
 }
@@ -241,13 +241,13 @@ bool XmppSocket::StartTls(const std::string & domainname) {
   if (tls_ == buzz::TLS_DISABLED)
     return false;
 #ifndef USE_SSLSTREAM
-  talk_base::SSLAdapter* ssl_adapter =
-    static_cast<talk_base::SSLAdapter *>(cricket_socket_);
+  rtc::SSLAdapter* ssl_adapter =
+    static_cast<rtc::SSLAdapter *>(cricket_socket_);
   if (ssl_adapter->StartSSL(domainname.c_str(), false) != 0)
     return false;
 #else  // USE_SSLSTREAM
-  talk_base::SSLStreamAdapter* ssl_stream =
-    static_cast<talk_base::SSLStreamAdapter *>(stream_);
+  rtc::SSLStreamAdapter* ssl_stream =
+    static_cast<rtc::SSLStreamAdapter *>(stream_);
   if (ssl_stream->StartSSLWithServer(domainname.c_str()) != 0)
     return false;
 #endif  // USE_SSLSTREAM
diff --git a/talk/xmpp/xmppsocket.h b/talk/xmpp/xmppsocket.h
index f89333f6bb..e32ce4c767 100644
--- a/talk/xmpp/xmppsocket.h
+++ b/talk/xmpp/xmppsocket.h
@@ -28,9 +28,9 @@
 #ifndef TALK_XMPP_XMPPSOCKET_H_
 #define TALK_XMPP_XMPPSOCKET_H_
 
-#include "talk/base/asyncsocket.h"
-#include "talk/base/bytebuffer.h"
-#include "talk/base/sigslot.h"
+#include "webrtc/base/asyncsocket.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/sigslot.h"
 #include "talk/xmpp/asyncsocket.h"
 #include "talk/xmpp/xmppengine.h"
 
@@ -38,11 +38,11 @@
 // SSL, as opposed to the SSLAdapter socket adapter.
 // #define USE_SSLSTREAM 
 
-namespace talk_base {
+namespace rtc {
   class StreamInterface;
   class SocketAddress;
 };
-extern talk_base::AsyncSocket* cricket_socket_;
+extern rtc::AsyncSocket* cricket_socket_;
 
 namespace buzz {
 
@@ -55,7 +55,7 @@ public:
   virtual buzz::AsyncSocket::Error error();
   virtual int GetError();
 
-  virtual bool Connect(const talk_base::SocketAddress& addr);
+  virtual bool Connect(const rtc::SocketAddress& addr);
   virtual bool Read(char * data, size_t len, size_t* len_read);
   virtual bool Write(const char * data, size_t len);
   virtual bool Close();
@@ -66,20 +66,20 @@ public:
 private:
   void CreateCricketSocket(int family);
 #ifndef USE_SSLSTREAM
-  void OnReadEvent(talk_base::AsyncSocket * socket);
-  void OnWriteEvent(talk_base::AsyncSocket * socket);
-  void OnConnectEvent(talk_base::AsyncSocket * socket);
-  void OnCloseEvent(talk_base::AsyncSocket * socket, int error);
+  void OnReadEvent(rtc::AsyncSocket * socket);
+  void OnWriteEvent(rtc::AsyncSocket * socket);
+  void OnConnectEvent(rtc::AsyncSocket * socket);
+  void OnCloseEvent(rtc::AsyncSocket * socket, int error);
 #else  // USE_SSLSTREAM
-  void OnEvent(talk_base::StreamInterface* stream, int events, int err);
+  void OnEvent(rtc::StreamInterface* stream, int events, int err);
 #endif  // USE_SSLSTREAM
 
-  talk_base::AsyncSocket * cricket_socket_;
+  rtc::AsyncSocket * cricket_socket_;
 #ifdef USE_SSLSTREAM
-  talk_base::StreamInterface *stream_;
+  rtc::StreamInterface *stream_;
 #endif  // USE_SSLSTREAM
   buzz::AsyncSocket::State state_;
-  talk_base::ByteBuffer buffer_;
+  rtc::ByteBuffer buffer_;
   buzz::TlsOptions tls_;
 };
 
diff --git a/talk/xmpp/xmppstanzaparser.cc b/talk/xmpp/xmppstanzaparser.cc
index 6c3ef5fee8..1b75f285ec 100644
--- a/talk/xmpp/xmppstanzaparser.cc
+++ b/talk/xmpp/xmppstanzaparser.cc
@@ -28,7 +28,7 @@
 #include "talk/xmpp/xmppstanzaparser.h"
 
 #include "talk/xmllite/xmlelement.h"
-#include "talk/base/common.h"
+#include "webrtc/base/common.h"
 #include "talk/xmpp/constants.h"
 #ifdef EXPAT_RELATIVE_PATH
 #include "expat.h"
@@ -98,8 +98,8 @@ XmppStanzaParser::IncomingEndElement(
 void
 XmppStanzaParser::IncomingError(
     XmlParseContext * pctx, XML_Error errCode) {
-  UNUSED(pctx);
-  UNUSED(errCode);
+  RTC_UNUSED(pctx);
+  RTC_UNUSED(errCode);
   psph_->XmlError();
 }
 
diff --git a/talk/xmpp/xmppstanzaparser_unittest.cc b/talk/xmpp/xmppstanzaparser_unittest.cc
index 06faf87657..3930a9d4df 100644
--- a/talk/xmpp/xmppstanzaparser_unittest.cc
+++ b/talk/xmpp/xmppstanzaparser_unittest.cc
@@ -4,8 +4,8 @@
 #include <string>
 #include <sstream>
 #include <iostream>
-#include "talk/base/common.h"
-#include "talk/base/gunit.h"
+#include "webrtc/base/common.h"
+#include "webrtc/base/gunit.h"
 #include "talk/xmllite/xmlelement.h"
 #include "talk/xmpp/xmppstanzaparser.h"
 
diff --git a/talk/xmpp/xmpptask.h b/talk/xmpp/xmpptask.h
index 6a88f98f18..ab132898f0 100644
--- a/talk/xmpp/xmpptask.h
+++ b/talk/xmpp/xmpptask.h
@@ -30,9 +30,9 @@
 
 #include <string>
 #include <deque>
-#include "talk/base/sigslot.h"
-#include "talk/base/task.h"
-#include "talk/base/taskparent.h"
+#include "webrtc/base/sigslot.h"
+#include "webrtc/base/task.h"
+#include "webrtc/base/taskparent.h"
 #include "talk/xmpp/xmppengine.h"
 
 namespace buzz {
@@ -94,9 +94,9 @@ class XmppClientInterface {
 // We really ought to inherit from a TaskParentInterface, but we tried
 // that and it's way too complicated to change
 // Task/TaskParent/TaskRunner.  For now, this works.
-class XmppTaskParentInterface : public talk_base::Task {
+class XmppTaskParentInterface : public rtc::Task {
  public:
-  explicit XmppTaskParentInterface(talk_base::TaskParent* parent)
+  explicit XmppTaskParentInterface(rtc::TaskParent* parent)
       : Task(parent) {
   }
   virtual ~XmppTaskParentInterface() {}
@@ -176,7 +176,7 @@ private:
 
   bool stopped_;
   std::deque<XmlElement*> stanza_queue_;
-  talk_base::scoped_ptr<XmlElement> next_stanza_;
+  rtc::scoped_ptr<XmlElement> next_stanza_;
   std::string id_;
 
 #ifdef _DEBUG
diff --git a/talk/xmpp/xmppthread.cc b/talk/xmpp/xmppthread.cc
index 716aaf8363..e67bffe800 100644
--- a/talk/xmpp/xmppthread.cc
+++ b/talk/xmpp/xmppthread.cc
@@ -36,7 +36,7 @@ namespace {
 const uint32 MSG_LOGIN = 1;
 const uint32 MSG_DISCONNECT = 2;
 
-struct LoginData: public talk_base::MessageData {
+struct LoginData: public rtc::MessageData {
   LoginData(const buzz::XmppClientSettings& s) : xcs(s) {}
   virtual ~LoginData() {}
 
@@ -55,7 +55,7 @@ XmppThread::~XmppThread() {
 }
 
 void XmppThread::ProcessMessages(int cms) {
-  talk_base::Thread::ProcessMessages(cms);
+  rtc::Thread::ProcessMessages(cms);
 }
 
 void XmppThread::Login(const buzz::XmppClientSettings& xcs) {
@@ -69,7 +69,7 @@ void XmppThread::Disconnect() {
 void XmppThread::OnStateChange(buzz::XmppEngine::State state) {
 }
 
-void XmppThread::OnMessage(talk_base::Message* pmsg) {
+void XmppThread::OnMessage(rtc::Message* pmsg) {
   if (pmsg->message_id == MSG_LOGIN) {
     ASSERT(pmsg->pdata != NULL);
     LoginData* data = reinterpret_cast<LoginData*>(pmsg->pdata);
diff --git a/talk/xmpp/xmppthread.h b/talk/xmpp/xmppthread.h
index 62a5ce695c..a42fa4d31a 100644
--- a/talk/xmpp/xmppthread.h
+++ b/talk/xmpp/xmppthread.h
@@ -28,7 +28,7 @@
 #ifndef TALK_XMPP_XMPPTHREAD_H_
 #define TALK_XMPP_XMPPTHREAD_H_
 
-#include "talk/base/thread.h"
+#include "webrtc/base/thread.h"
 #include "talk/xmpp/xmppclientsettings.h"
 #include "talk/xmpp/xmppengine.h"
 #include "talk/xmpp/xmpppump.h"
@@ -37,7 +37,7 @@
 namespace buzz {
 
 class XmppThread:
-    public talk_base::Thread, buzz::XmppPumpNotify, talk_base::MessageHandler {
+    public rtc::Thread, buzz::XmppPumpNotify, rtc::MessageHandler {
 public:
   XmppThread();
   ~XmppThread();
@@ -53,7 +53,7 @@ private:
   buzz::XmppPump* pump_;
 
   void OnStateChange(buzz::XmppEngine::State state);
-  void OnMessage(talk_base::Message* pmsg);
+  void OnMessage(rtc::Message* pmsg);
 };
 
 }  // namespace buzz