Fix JingleThreadWrapper initialization in PNaCl plugin.

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"
@@ skipping 12 matching lines @@
   JingleThreadWrapper* sending_thread;
   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) {
+  if (JingleThreadWrapper::current() == nullptr) {
     base::MessageLoop* message_loop = base::MessageLoop::current();
-    g_jingle_thread_wrapper.Get()
-        .Set(new JingleThreadWrapper(message_loop->message_loop_proxy()));
-    message_loop->AddDestructionObserver(current());
+    scoped_ptr<JingleThreadWrapper> wrapper =
+        JingleThreadWrapper::WrapTaskRunner(message_loop->task_runner());
+    message_loop->AddDestructionObserver(wrapper.release());
   }
 
   DCHECK_EQ(rtc::Thread::Current(), current());
 }
 
+scoped_ptr<JingleThreadWrapper> JingleThreadWrapper::WrapTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(!JingleThreadWrapper::current());
+  DCHECK(task_runner->BelongsToCurrentThread());
+
+  scoped_ptr<JingleThreadWrapper> result(new JingleThreadWrapper(task_runner));
+  g_jingle_thread_wrapper.Get().Set(result.get());
+  return result.Pass();
+}
+
 // static
 JingleThreadWrapper* JingleThreadWrapper::current() {
   return g_jingle_thread_wrapper.Get().Get();
 }
 
 JingleThreadWrapper::JingleThreadWrapper(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : rtc::Thread(new rtc::NullSocketServer()),
-      task_runner_(task_runner),
+    : 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(!rtc::Thread::Current());
   weak_ptr_ = weak_ptr_factory_.GetWeakPtr();
   rtc::MessageQueueManager::Add(this);
   SafeWrapCurrent();
 }
 
 JingleThreadWrapper::~JingleThreadWrapper() {
-  Clear(NULL, rtc::MQID_ANY, NULL);
+  DCHECK_EQ(this, JingleThreadWrapper::current());
+  DCHECK_EQ(this, rtc::Thread::Current());
+
+  UnwrapCurrent();
+  rtc::ThreadManager::Instance()->SetCurrentThread(nullptr);
+  rtc::MessageQueueManager::Remove(this);
+  g_jingle_thread_wrapper.Get().Set(nullptr);
+
+  Clear(nullptr, rtc::MQID_ANY, nullptr);
 }
 
 void JingleThreadWrapper::WillDestroyCurrentMessageLoop() {
-  DCHECK_EQ(rtc::Thread::Current(), current());
-  UnwrapCurrent();
-  g_jingle_thread_wrapper.Get().Set(NULL);
-  rtc::ThreadManager::Instance()->SetCurrentThread(NULL);
-  rtc::MessageQueueManager::Remove(this);
-  rtc::SocketServer* ss = socketserver();
   delete this;
-  delete ss;
 }
 
 void JingleThreadWrapper::Post(
     rtc::MessageHandler* handler, uint32 message_id,
     rtc::MessageData* data, bool time_sensitive) {
   PostTaskInternal(0, handler, message_id, data);
 }
 
 void JingleThreadWrapper::PostDelayed(
     int delay_ms, rtc::MessageHandler* handler,
@@ skipping 40 matching lines @@
     it = next;
   }
 }
 
 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 "
+  DCHECK(current_thread != nullptr) << "Send() can be called only from a "
       "thread that has JingleThreadWrapper.";
 
   rtc::Message message;
   message.phandler = handler;
   message.message_id = id;
   message.pdata = data;
 
   if (current_thread == this) {
     handler->OnMessage(&message);
     return;
@@ skipping 26 matching lines @@
     size_t event = base::WaitableEvent::WaitMany(events, arraysize(events));
     DCHECK(event == 0 || event == 1);
 
     if (event == 1)
       current_thread->ProcessPendingSends();
   }
 }
 
 void JingleThreadWrapper::ProcessPendingSends() {
   while (true) {
-    PendingSend* pending_send = NULL;
+    PendingSend* pending_send = nullptr;
     {
       base::AutoLock auto_lock(lock_);
       if (!pending_send_messages_.empty()) {
         pending_send = pending_send_messages_.front();
         pending_send_messages_.pop_front();
       } else {
         // Reset the event while |lock_| is still locked.
         pending_send_event_.Reset();
         break;
       }
@@ skipping 39 matching lines @@
     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 == rtc::MQID_DISPOSE) {
-      DCHECK(message.phandler == NULL);
+      DCHECK(message.phandler == nullptr);
       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() {
@@ skipping 39 matching lines @@
 
 void JingleThreadWrapper::Stop() {
   NOTREACHED();
 }
 
 void JingleThreadWrapper::Run() {
   NOTREACHED();
 }
 
 }  // namespace jingle_glue