Implement Send() in JingleThreadWrapper.

Send() is used in some of libjingle code. WebRTC needs to create two separate
threads which Send() messages to each other. This wasn't previously supported in
JingleThreadWrapper.

BUG=None
TEST=Unittests

Review URL: http://codereview.chromium.org/7520014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@94956 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 47 insertions, 21 deletions

diff --git a/jingle/glue/thread_wrapper.h b/jingle/glue/thread_wrapper.h
index 5b5cf08..4707e21 100644
--- a/jingle/glue/thread_wrapper.h
+++ b/jingle/glue/thread_wrapper.h
@@ -5,21 +5,21 @@
 #ifndef JINGLE_GLUE_THREAD_WRAPPER_H_
 #define JINGLE_GLUE_THREAD_WRAPPER_H_
 
+#include <list>
 #include <map>
 
 #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"
 
-class MessageLoop;
-
 namespace jingle_glue {
 
 // JingleThreadWrapper wraps Chromium threads using talk_base::Thread
-// interface. The object must be created on a thread it belongs
-// to. Each JingleThreadWrapper deletes itself when MessageLoop is
-// destroyed. Currently only the bare minimum that is used by P2P
-// part of libjingle is implemented.
+// 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 {
@@ -28,21 +28,38 @@ class JingleThreadWrapper
   // been created yet.
   static void EnsureForCurrentThread();
 
+  // 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);
 
+  // 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;
 
   // talk_base::MessageQueue overrides.
-  virtual void Post(talk_base::MessageHandler *phandler, uint32 id = 0,
-                    talk_base::MessageData *pdata = NULL,
-                    bool time_sensitive = false) OVERRIDE;
-  virtual void PostDelayed(
-      int delay_ms, talk_base::MessageHandler* handler, uint32 id = 0,
-      talk_base::MessageData* data = NULL) OVERRIDE;
+  virtual void Post(talk_base::MessageHandler *phandler,
+                    uint32 id,
+                    talk_base::MessageData *pdata,
+                    bool time_sensitive) OVERRIDE;
+  virtual void PostDelayed(int delay_ms,
+                           talk_base::MessageHandler* handler,
+                           uint32 id,
+                           talk_base::MessageData* data) OVERRIDE;
   virtual void Clear(talk_base::MessageHandler* handler,
-                     uint32 id = talk_base::MQID_ANY,
-                     talk_base::MessageList* removed = NULL) OVERRIDE;
+                     uint32 id,
+                     talk_base::MessageList* removed) OVERRIDE;
+  virtual void Send(talk_base::MessageHandler *handler,
+                    uint32 id,
+                    talk_base::MessageData *data) OVERRIDE;
 
   // Following methods are not supported.They are overriden just to
   // ensure that they are not called (each of them contain NOTREACHED
@@ -51,13 +68,16 @@ class JingleThreadWrapper
   virtual void Quit() OVERRIDE;
   virtual bool IsQuitting() OVERRIDE;
   virtual void Restart() OVERRIDE;
-  virtual bool Get(talk_base::Message* msg, int delay_ms = talk_base::kForever,
-                   bool process_io = true) OVERRIDE;
-  virtual bool Peek(talk_base::Message* msg, int delay_ms = 0) OVERRIDE;
-  virtual void PostAt(
-      uint32 timestamp, talk_base::MessageHandler* handler,
-      uint32 id = 0, talk_base::MessageData* data = NULL) OVERRIDE;
-  virtual void Dispatch(talk_base::Message* msg) OVERRIDE;
+  virtual bool Get(talk_base::Message* message,
+                   int delay_ms,
+                   bool process_io) OVERRIDE;
+  virtual bool Peek(talk_base::Message* message,
+                    int delay_ms) OVERRIDE;
+  virtual void PostAt(uint32 timestamp,
+                      talk_base::MessageHandler* handler,
+                      uint32 id,
+                      talk_base::MessageData* data) OVERRIDE;
+  virtual void Dispatch(talk_base::Message* message) OVERRIDE;
   virtual void ReceiveSends() OVERRIDE;
   virtual int GetDelay() OVERRIDE;
 
@@ -67,6 +87,7 @@ class JingleThreadWrapper
 
  private:
   typedef std::map<int, talk_base::Message> MessagesQueue;
+  struct PendingSend;
 
   virtual ~JingleThreadWrapper();
 
@@ -74,14 +95,19 @@ class JingleThreadWrapper
       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_;
 
+  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_;
 };
 
 }