1 files changed, 21 insertions, 47 deletions

diff --git a/jingle/glue/thread_wrapper.h b/jingle/glue/thread_wrapper.h
index 4707e21..5b5cf08 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 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.
+// 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.
 class JingleThreadWrapper
     : public MessageLoop::DestructionObserver,
       public talk_base::Thread {
@@ -28,38 +28,21 @@ 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,
-                    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 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 Clear(talk_base::MessageHandler* handler,
-                     uint32 id,
-                     talk_base::MessageList* removed) OVERRIDE;
-  virtual void Send(talk_base::MessageHandler *handler,
-                    uint32 id,
-                    talk_base::MessageData *data) OVERRIDE;
+                     uint32 id = talk_base::MQID_ANY,
+                     talk_base::MessageList* removed = NULL) OVERRIDE;
 
   // Following methods are not supported.They are overriden just to
   // ensure that they are not called (each of them contain NOTREACHED
@@ -68,16 +51,13 @@ class JingleThreadWrapper
   virtual void Quit() OVERRIDE;
   virtual bool IsQuitting() OVERRIDE;
   virtual void Restart() 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 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 void ReceiveSends() OVERRIDE;
   virtual int GetDelay() OVERRIDE;
 
@@ -87,7 +67,6 @@ class JingleThreadWrapper
 
  private:
   typedef std::map<int, talk_base::Message> MessagesQueue;
-  struct PendingSend;
 
   virtual ~JingleThreadWrapper();
 
@@ -95,19 +74,14 @@ 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_;
 };
 
 }