Update JingleThreadWrapper to allow it to be created using task runner.

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 c63f89a7ed79476acd9891d8056df0fb4f5cf65f..c84f9826a766ce788a8ee532ded746ec0da1d9b1 100644
--- a/jingle/glue/thread_wrapper.cc
+++ b/jingle/glue/thread_wrapper.cc
@@ -31,8 +31,10 @@ base::LazyInstance<base::ThreadLocalPointer<JingleThreadWrapper> >
 // static
 void JingleThreadWrapper::EnsureForCurrentThread() {
   if (JingleThreadWrapper::current() == NULL) {
-    g_jingle_thread_wrapper.Get().Set(
-        new JingleThreadWrapper(MessageLoop::current()));
+    MessageLoop* message_loop = MessageLoop::current();

[Wez, 2012/08/09 23:30:25]

This will only work if called from a MessageLoop; if you used
ThreadTaskRunnerHandle::Get() then it'd work for any thread with a TaskRunner,
although you wouldn't be able to hook destruction.

[Sergey Ulanov, 2012/08/13 21:15:34]

Yes. That's intentional. We need it to add destruction observer. So after this
change there are two ways to use this class:

- JingleThreadWrapper::EnsureForCurrentThread() - this autodestroys the wrapper,
  but only works on threads with MessageLoop.
- Explicitly create and destroy JingleThreadWrapper - requires to delete the
wrapper explicitly, but allows to use this object on any thread.

[Wez, 2012/08/14 00:06:04]

Would it be useful to have a LeakyEnsureForCurrentTaskRunner()?

[Sergey Ulanov, 2012/08/14 01:02:14]

Don't think it's necessary. It's always possible to just create
JingleThreadWrapper without destroying it.

+    g_jingle_thread_wrapper.Get().Set(new JingleThreadWrapper(
+        message_loop->message_loop_proxy()));
+    message_loop->AddDestructionObserver(current());
   }
 
   DCHECK_EQ(talk_base::Thread::Current(), current());
@@ -43,19 +45,16 @@ JingleThreadWrapper* JingleThreadWrapper::current() {
   return g_jingle_thread_wrapper.Get().Get();
 }
 
-JingleThreadWrapper::JingleThreadWrapper(MessageLoop* message_loop)
+JingleThreadWrapper::JingleThreadWrapper(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : talk_base::Thread(new talk_base::NullSocketServer()),
-      message_loop_(message_loop),
+      task_runner_(task_runner),
       send_allowed_(false),
       last_task_id_(0),
       pending_send_event_(true, false) {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
-
-  talk_base::ThreadManager::Instance()->UnwrapCurrentThread();
-  talk_base::ThreadManager::Instance()->SetCurrentThread(this);
+  DCHECK(task_runner->BelongsToCurrentThread());
+  DCHECK(!talk_base::Thread::Current());
   talk_base::MessageQueueManager::Instance()->Add(this);
-  message_loop_->AddDestructionObserver(this);
-
   WrapCurrent();
 }
 
@@ -69,7 +68,6 @@ void JingleThreadWrapper::WillDestroyCurrentMessageLoop() {
   g_jingle_thread_wrapper.Get().Set(NULL);
   talk_base::ThreadManager::Instance()->SetCurrentThread(NULL);
   talk_base::MessageQueueManager::Instance()->Remove(this);
-  message_loop_->RemoveDestructionObserver(this);
   talk_base::SocketServer* ss = socketserver();
   delete this;
   delete ss;
@@ -162,9 +160,9 @@ void JingleThreadWrapper::Send(talk_base::MessageHandler *handler, uint32 id,
   // Need to signal |pending_send_event_| here in case the thread is
   // sending message to another thread.
   pending_send_event_.Signal();
-  message_loop_->PostTask(FROM_HERE,
-                          base::Bind(&JingleThreadWrapper::ProcessPendingSends,
-                                     base::Unretained(this)));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&JingleThreadWrapper::ProcessPendingSends,
+                                    base::Unretained(this)));

[Wez, 2012/08/09 23:30:25]

Should this be a WeakPtr?

[Sergey Ulanov, 2012/08/13 21:15:34]

Yes. Thanks for catching this. Fixed.

 
 
   while (!pending_send.done_event.IsSignaled()) {
@@ -214,14 +212,14 @@ void JingleThreadWrapper::PostTaskInternal(
   }
 
   if (delay_ms <= 0) {
-    message_loop_->PostTask(FROM_HERE,
-                            base::Bind(&JingleThreadWrapper::RunTask,
-                                       base::Unretained(this), task_id));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&JingleThreadWrapper::RunTask,
+                                      base::Unretained(this), task_id));

[Wez, 2012/08/09 23:30:25]

WeakPtr?

[Sergey Ulanov, 2012/08/13 21:15:34]

Done.

   } else {
-    message_loop_->PostDelayedTask(FROM_HERE,
-                                   base::Bind(&JingleThreadWrapper::RunTask,
-                                              base::Unretained(this), task_id),
-                                   base::TimeDelta::FromMilliseconds(delay_ms));
+    task_runner_->PostDelayedTask(FROM_HERE,
+                                  base::Bind(&JingleThreadWrapper::RunTask,
+                                             base::Unretained(this), task_id),

[Wez, 2012/08/09 23:30:25]

WeakPtr?

[Sergey Ulanov, 2012/08/13 21:15:34]

Done.

+                                  base::TimeDelta::FromMilliseconds(delay_ms));
   }
 }