Webrtc deps roll.

jingle/glue/thread_wrapper.cc

Index: jingle/glue/thread_wrapper.cc
diff --git a/jingle/glue/thread_wrapper.cc b/jingle/glue/thread_wrapper.cc
index e2109fe6ae9e5885b82e7ced1ba1897619ba6092..af69c24531bb2fda5f95b5ecaaaf7a591c8fc797 100644
--- a/jingle/glue/thread_wrapper.cc
+++ b/jingle/glue/thread_wrapper.cc
@@ -8,12 +8,12 @@
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/threading/thread_local.h"
-#include "third_party/libjingle/source/talk/base/nullsocketserver.h"
+#include "third_party/webrtc/base/nullsocketserver.h"
 
 namespace jingle_glue {
 
 struct JingleThreadWrapper::PendingSend {
-  PendingSend(const talk_base::Message& message_value)
+  PendingSend(const rtc::Message& message_value)
       : sending_thread(JingleThreadWrapper::current()),
         message(message_value),
         done_event(true, false) {
@@ -21,7 +21,7 @@ struct JingleThreadWrapper::PendingSend {
   }
 
   JingleThreadWrapper* sending_thread;
-  talk_base::Message message;
+  rtc::Message message;
   base::WaitableEvent done_event;
 };
 
@@ -37,7 +37,7 @@ void JingleThreadWrapper::EnsureForCurrentMessageLoop() {
     message_loop->AddDestructionObserver(current());
   }
 
-  DCHECK_EQ(talk_base::Thread::Current(), current());
+  DCHECK_EQ(rtc::Thread::Current(), current());
 }
 
 // static
@@ -47,48 +47,48 @@ JingleThreadWrapper* JingleThreadWrapper::current() {
 
 JingleThreadWrapper::JingleThreadWrapper(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : talk_base::Thread(new talk_base::NullSocketServer()),
+    : rtc::Thread(new rtc::NullSocketServer()),
       task_runner_(task_runner),
       send_allowed_(false),
       last_task_id_(0),
       pending_send_event_(true, false),
       weak_ptr_factory_(this) {
   DCHECK(task_runner->BelongsToCurrentThread());
-  DCHECK(!talk_base::Thread::Current());
+  DCHECK(!rtc::Thread::Current());
   weak_ptr_ = weak_ptr_factory_.GetWeakPtr();
-  talk_base::MessageQueueManager::Add(this);
+  rtc::MessageQueueManager::Add(this);
   WrapCurrent();
 }
 
 JingleThreadWrapper::~JingleThreadWrapper() {
-  Clear(NULL, talk_base::MQID_ANY, NULL);
+  Clear(NULL, rtc::MQID_ANY, NULL);
 }
 
 void JingleThreadWrapper::WillDestroyCurrentMessageLoop() {
-  DCHECK_EQ(talk_base::Thread::Current(), current());
+  DCHECK_EQ(rtc::Thread::Current(), current());
   UnwrapCurrent();
   g_jingle_thread_wrapper.Get().Set(NULL);
-  talk_base::ThreadManager::Instance()->SetCurrentThread(NULL);
-  talk_base::MessageQueueManager::Remove(this);
-  talk_base::SocketServer* ss = socketserver();
+  rtc::ThreadManager::Instance()->SetCurrentThread(NULL);
+  rtc::MessageQueueManager::Remove(this);
+  rtc::SocketServer* ss = socketserver();
   delete this;
   delete ss;
 }
 
 void JingleThreadWrapper::Post(
-    talk_base::MessageHandler* handler, uint32 message_id,
-    talk_base::MessageData* data, bool time_sensitive) {
+    rtc::MessageHandler* handler, uint32 message_id,
+    rtc::MessageData* data, bool time_sensitive) {
   PostTaskInternal(0, handler, message_id, data);
 }
 
 void JingleThreadWrapper::PostDelayed(
-    int delay_ms, talk_base::MessageHandler* handler,
-    uint32 message_id, talk_base::MessageData* data) {
+    int delay_ms, rtc::MessageHandler* handler,
+    uint32 message_id, rtc::MessageData* data) {
   PostTaskInternal(delay_ms, handler, message_id, data);
 }
 
-void JingleThreadWrapper::Clear(talk_base::MessageHandler* handler, uint32 id,
-                                talk_base::MessageList* removed) {
+void JingleThreadWrapper::Clear(rtc::MessageHandler* handler, uint32 id,
+                                rtc::MessageList* removed) {
   base::AutoLock auto_lock(lock_);
 
   for (MessagesQueue::iterator it = messages_.begin();
@@ -127,8 +127,8 @@ void JingleThreadWrapper::Clear(talk_base::MessageHandler* handler, uint32 id,
   }
 }
 
-void JingleThreadWrapper::Send(talk_base::MessageHandler *handler, uint32 id,
-                               talk_base::MessageData *data) {
+void JingleThreadWrapper::Send(rtc::MessageHandler *handler, uint32 id,
+                               rtc::MessageData *data) {
   if (fStop_)
     return;
 
@@ -136,7 +136,7 @@ void JingleThreadWrapper::Send(talk_base::MessageHandler *handler, uint32 id,
   DCHECK(current_thread != NULL) << "Send() can be called only from a "
       "thread that has JingleThreadWrapper.";
 
-  talk_base::Message message;
+  rtc::Message message;
   message.phandler = handler;
   message.message_id = id;
   message.pdata = data;
@@ -200,17 +200,17 @@ void JingleThreadWrapper::ProcessPendingSends() {
 }
 
 void JingleThreadWrapper::PostTaskInternal(
-    int delay_ms, talk_base::MessageHandler* handler,
-    uint32 message_id, talk_base::MessageData* data) {
+    int delay_ms, rtc::MessageHandler* handler,
+    uint32 message_id, rtc::MessageData* data) {
   int task_id;
-  talk_base::Message message;
+  rtc::Message message;
   message.phandler = handler;
   message.message_id = message_id;
   message.pdata = data;
   {
     base::AutoLock auto_lock(lock_);
     task_id = ++last_task_id_;
-    messages_.insert(std::pair<int, talk_base::Message>(task_id, message));
+    messages_.insert(std::pair<int, rtc::Message>(task_id, message));
   }
 
   if (delay_ms <= 0) {
@@ -227,7 +227,7 @@ void JingleThreadWrapper::PostTaskInternal(
 
 void JingleThreadWrapper::RunTask(int task_id) {
   bool have_message = false;
-  talk_base::Message message;
+  rtc::Message message;
   {
     base::AutoLock auto_lock(lock_);
     MessagesQueue::iterator it = messages_.find(task_id);
@@ -239,7 +239,7 @@ void JingleThreadWrapper::RunTask(int task_id) {
   }
 
   if (have_message) {
-    if (message.message_id == talk_base::MQID_DISPOSE) {
+    if (message.message_id == rtc::MQID_DISPOSE) {
       DCHECK(message.phandler == NULL);
       delete message.pdata;
     } else {
@@ -263,22 +263,22 @@ void JingleThreadWrapper::Restart() {
   NOTREACHED();
 }
 
-bool JingleThreadWrapper::Get(talk_base::Message*, int, bool) {
+bool JingleThreadWrapper::Get(rtc::Message*, int, bool) {
   NOTREACHED();
   return false;
 }
 
-bool JingleThreadWrapper::Peek(talk_base::Message*, int) {
+bool JingleThreadWrapper::Peek(rtc::Message*, int) {
   NOTREACHED();
   return false;
 }
 
-void JingleThreadWrapper::PostAt(uint32, talk_base::MessageHandler*,
-                                 uint32, talk_base::MessageData*) {
+void JingleThreadWrapper::PostAt(uint32, rtc::MessageHandler*,
+                                 uint32, rtc::MessageData*) {
   NOTREACHED();
 }
 
-void JingleThreadWrapper::Dispatch(talk_base::Message* message) {
+void JingleThreadWrapper::Dispatch(rtc::Message* message) {
   NOTREACHED();
 }