Roll WebRTC 13098:13104

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 <stdint.h>
 
 #include <list>
@@ skipping 43 matching lines @@
   // 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.
   void WillDestroyCurrentMessageLoop() override;
 
   // rtc::MessageQueue overrides.
-  void Post(rtc::MessageHandler* phandler,
+  void Post(const rtc::Location& posted_from,
+            rtc::MessageHandler* phandler,
             uint32_t id,
             rtc::MessageData* pdata,
             bool time_sensitive) override;
-  void PostDelayed(int delay_ms,
+  void PostDelayed(const rtc::Location& posted_from,
+                   int delay_ms,
                    rtc::MessageHandler* handler,
                    uint32_t id,
                    rtc::MessageData* data) override;
   void Clear(rtc::MessageHandler* handler,
              uint32_t id,
              rtc::MessageList* removed) override;
-  void Send(rtc::MessageHandler* handler,
+  void Dispatch(rtc::Message* message) override;
+  void Send(const rtc::Location& posted_from,
+            rtc::MessageHandler* handler,
             uint32_t id,
             rtc::MessageData* data) override;
 
   // Following methods are not supported.They are overriden just to
   // ensure that they are not called (each of them contain NOTREACHED
   // in the body). Some of this methods can be implemented if it
   // becomes neccessary to use libjingle code that calls them.
   void Quit() override;
   bool IsQuitting() override;
   void Restart() override;
   bool Get(rtc::Message* message, int delay_ms, bool process_io) override;
   bool Peek(rtc::Message* message, int delay_ms) override;
-  void PostAt(uint32_t timestamp,
+  void PostAt(const rtc::Location& posted_from,
+              uint32_t timestamp,
               rtc::MessageHandler* handler,
               uint32_t id,
               rtc::MessageData* data) override;
-  void Dispatch(rtc::Message* message) override;
   void ReceiveSends() override;
   int GetDelay() override;
 
   // rtc::Thread overrides.
   void Stop() override;
   void Run() override;
 
  private:
   typedef std::map<int, rtc::Message> MessagesQueue;
   struct PendingSend;
 
   explicit JingleThreadWrapper(
      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
-  void PostTaskInternal(int delay_ms,
+  void PostTaskInternal(const rtc::Location& posted_from,
+                        int delay_ms,
                         rtc::MessageHandler* handler,
                         uint32_t message_id,
                         rtc::MessageData* data);
   void RunTask(int task_id);
   void ProcessPendingSends();
 
   // 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_;
 
   base::WeakPtr<JingleThreadWrapper> weak_ptr_;
   base::WeakPtrFactory<JingleThreadWrapper> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(JingleThreadWrapper);
 };
 
 }  // namespace jingle_glue
 
 #endif  // JINGLE_GLUE_THREAD_WRAPPER_H_