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

jingle/glue/thread_wrapper.h

 // 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.
 
 #ifndef JINGLE_GLUE_THREAD_WRAPPER_H_
 #define JINGLE_GLUE_THREAD_WRAPPER_H_
 
 #include <list>
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "third_party/libjingle/source/talk/base/thread.h"
 
 namespace jingle_glue {
 
 // JingleThreadWrapper wraps Chromium threads using talk_base::Thread
 // interface. The object must be created by calling
 // EnsureForCurrentThread(). Each JingleThreadWrapper deletes itself
 // when MessageLoop is destroyed. Currently only the bare minimum that
 // is used by P2P part of libjingle is implemented.
 class JingleThreadWrapper
     : public MessageLoop::DestructionObserver,
       public talk_base::Thread {
  public:
-  // Create JingleThreadWrapper for the current thread if it hasn't
-  // been created yet.
+  // Create JingleThreadWrapper for the current thread if it hasn't been created
+  // yet. The task runner is destroyed automatically when the current
+  // MessageLoop is destroyed.

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

I think you mean that the ThreadWrapper will be destroyed automatically when the
MessageLoop is destroyed?

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

Done.

   static void EnsureForCurrentThread();

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

This should probably become EnsureForCurrentMessageLoop, since it only works on
threads with MessageLoops, and your TaskRunner changes are intended to make this
class usable on non-MessageLoop threads.

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

Good point. Done.

 
   // Returns thread wrapper for the current thread. NULL is returned
   // if EnsureForCurrentThread() has never been called for this
   // thread.
   static JingleThreadWrapper* current();
 
-  JingleThreadWrapper(MessageLoop* message_loop);
+  JingleThreadWrapper(scoped_refptr<base::SingleThreadTaskRunner> task_runner);

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

nit: explicit

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

Done.

 
   // Sets whether the thread can be used to send messages
   // synchronously to another thread using Send() method. Set to false
   // by default to avoid potential jankiness when Send() used on
   // renderer thread. It should be set explicitly for threads that
   // need to call Send() for other threads.
   void set_send_allowed(bool allowed) { send_allowed_ = allowed; }
 
   // MessageLoop::DestructionObserver implementation.
   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
@@ skipping 43 matching lines @@
   struct PendingSend;
 
   virtual ~JingleThreadWrapper();
 
   void PostTaskInternal(
       int delay_ms, talk_base::MessageHandler* handler,
       uint32 message_id, talk_base::MessageData* data);
   void RunTask(int task_id);
   void ProcessPendingSends();
 
-  // Chromium thread used to execute messages posted on this thread.
-  MessageLoop* message_loop_;
+  // Task runner used to execute messages posted on this thread.
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   bool send_allowed_;
 
   // |lock_| must be locked when accessing |messages_|.
   base::Lock lock_;
   int last_task_id_;
   MessagesQueue messages_;
   std::list<PendingSend*> pending_send_messages_;
   base::WaitableEvent pending_send_event_;
 };
 
 }
 
 #endif  // JINGLE_GLUE_THREAD_WRAPPER_H_