Update webrtc&libjingle 6774:6825.

jingle/glue/thread_wrapper.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "jingle/glue/thread_wrapper.h"
 
 #include "base/bind.h"
 #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) {
     DCHECK(sending_thread);
   }
 
   JingleThreadWrapper* sending_thread;
-  talk_base::Message message;
+  rtc::Message message;
   base::WaitableEvent done_event;
 };
 
 base::LazyInstance<base::ThreadLocalPointer<JingleThreadWrapper> >
     g_jingle_thread_wrapper = LAZY_INSTANCE_INITIALIZER;
 
 // static
 void JingleThreadWrapper::EnsureForCurrentMessageLoop() {
   if (JingleThreadWrapper::current() == NULL) {
     base::MessageLoop* message_loop = base::MessageLoop::current();
     g_jingle_thread_wrapper.Get()
         .Set(new JingleThreadWrapper(message_loop->message_loop_proxy()));
     message_loop->AddDestructionObserver(current());
   }
 
-  DCHECK_EQ(talk_base::Thread::Current(), current());
+  DCHECK_EQ(rtc::Thread::Current(), current());
 }
 
 // static
 JingleThreadWrapper* JingleThreadWrapper::current() {
   return g_jingle_thread_wrapper.Get().Get();
 }
 
 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();
        it != messages_.end();) {
     MessagesQueue::iterator next = it;
     ++next;
 
     if (it->second.Match(handler, id)) {
       if (removed) {
         removed->push_back(it->second);
@@ skipping 18 matching lines @@
         delete (*it)->message.pdata;
       }
       (*it)->done_event.Signal();
       pending_send_messages_.erase(it);
     }
 
     it = next;
   }
 }
 
-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;
 
   JingleThreadWrapper* current_thread = JingleThreadWrapper::current();
   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;
 
   if (current_thread == this) {
     handler->OnMessage(&message);
     return;
   }
 
   // Send message from a thread different than |this|.
@@ skipping 43 matching lines @@
       }
     }
     if (pending_send) {
       pending_send->message.phandler->OnMessage(&pending_send->message);
       pending_send->done_event.Signal();
     }
   }
 }
 
 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) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&JingleThreadWrapper::RunTask,
                                       weak_ptr_, task_id));
   } else {
     task_runner_->PostDelayedTask(FROM_HERE,
                                   base::Bind(&JingleThreadWrapper::RunTask,
                                              weak_ptr_, task_id),
                                   base::TimeDelta::FromMilliseconds(delay_ms));
   }
 }
 
 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);
     if (it != messages_.end()) {
       have_message = true;
       message = it->second;
       messages_.erase(it);
     }
   }
 
   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 {
       message.phandler->OnMessage(&message);
     }
   }
 }
 
 // All methods below are marked as not reached. See comments in the
 // header for more details.
 void JingleThreadWrapper::Quit() {
   NOTREACHED();
 }
 
 bool JingleThreadWrapper::IsQuitting() {
   NOTREACHED();
   return false;
 }
 
 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();
 }
 
 void JingleThreadWrapper::ReceiveSends() {
   NOTREACHED();
 }
 
 int JingleThreadWrapper::GetDelay() {
   NOTREACHED();
   return 0;
 }
 
 void JingleThreadWrapper::Stop() {
   NOTREACHED();
 }
 
 void JingleThreadWrapper::Run() {
   NOTREACHED();
 }
 
 }  // namespace jingle_glue