Adding more detail to MessageQueue::Dispatch logging.

webrtc/base/messagequeue.h

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_BASE_MESSAGEQUEUE_H_
 #define WEBRTC_BASE_MESSAGEQUEUE_H_
 
 #include <string.h>
 
 #include <algorithm>
 #include <list>
 #include <memory>
 #include <queue>
 #include <vector>
 
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/criticalsection.h"
+#include "webrtc/base/location.h"
 #include "webrtc/base/messagehandler.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/base/sharedexclusivelock.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/socketserver.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/thread_annotations.h"
 
 namespace rtc {
 
@@ skipping 96 matching lines @@
  private:
   T* data_;
 };
 
 const uint32_t MQID_ANY = static_cast<uint32_t>(-1);
 const uint32_t MQID_DISPOSE = static_cast<uint32_t>(-2);
 
 // No destructor
 
 struct Message {
-  Message() {
-    memset(this, 0, sizeof(*this));
-  }
+  Message()
+      : phandler(nullptr), message_id(0), pdata(nullptr), ts_sensitive(0) {}
   inline bool Match(MessageHandler* handler, uint32_t id) const {
     return (handler == NULL || handler == phandler)
            && (id == MQID_ANY || id == message_id);
   }
+  Location posted_from;
   MessageHandler *phandler;
   uint32_t message_id;
   MessageData *pdata;
   int64_t ts_sensitive;
 };
 
 typedef std::list<Message> MessageList;
 
 // DelayedMessage goes into a priority queue, sorted by trigger time.  Messages
 // with the same trigger time are processed in num_ (FIFO) order.
@@ skipping 48 matching lines @@
   virtual bool IsQuitting();
   virtual void Restart();
 
   // Get() will process I/O until:
   //  1) A message is available (returns true)
   //  2) cmsWait seconds have elapsed (returns false)
   //  3) Stop() is called (returns false)
   virtual bool Get(Message *pmsg, int cmsWait = kForever,
                    bool process_io = true);
   virtual bool Peek(Message *pmsg, int cmsWait = 0);
-  virtual void Post(MessageHandler* phandler,
+  virtual void Post(const Location& posted_from,
+                    MessageHandler* phandler,
                     uint32_t id = 0,
                     MessageData* pdata = NULL,
                     bool time_sensitive = false);
-  virtual void PostDelayed(int cmsDelay,
+  virtual void PostDelayed(const Location& posted_from,
+                           int cmsDelay,
                            MessageHandler* phandler,
                            uint32_t id = 0,
                            MessageData* pdata = NULL);
-  virtual void PostAt(int64_t tstamp,
+  virtual void PostAt(const Location& posted_from,
+                      int64_t tstamp,
                       MessageHandler* phandler,
                       uint32_t id = 0,
                       MessageData* pdata = NULL);
   // TODO(honghaiz): Remove this when all the dependencies are removed.
-  virtual void PostAt(uint32_t tstamp,
+  virtual void PostAt(const Location& posted_from,
+                      uint32_t tstamp,
                       MessageHandler* phandler,
                       uint32_t id = 0,
                       MessageData* pdata = NULL);
   virtual void Clear(MessageHandler* phandler,
                      uint32_t id = MQID_ANY,
                      MessageList* removed = NULL);
   virtual void Dispatch(Message *pmsg);
   virtual void ReceiveSends();
 
   // Amount of time until the next message can be retrieved
   virtual int GetDelay();
 
   bool empty() const { return size() == 0u; }
   size_t size() const {
     CritScope cs(&crit_);  // msgq_.size() is not thread safe.
     return msgq_.size() + dmsgq_.size() + (fPeekKeep_ ? 1u : 0u);
   }
 
   // Internally posts a message which causes the doomed object to be deleted
   template<class T> void Dispose(T* doomed) {
     if (doomed) {
-      Post(NULL, MQID_DISPOSE, new DisposeData<T>(doomed));
+      Post(RTC_FROM_HERE, NULL, MQID_DISPOSE, new DisposeData<T>(doomed));
     }
   }
 
   // When this signal is sent out, any references to this queue should
   // no longer be used.
   sigslot::signal0<> SignalQueueDestroyed;
 
  protected:
   class PriorityQueue : public std::priority_queue<DelayedMessage> {
    public:
     container_type& container() { return c; }
     void reheap() { make_heap(c.begin(), c.end(), comp); }
   };
 
-  void DoDelayPost(int64_t cmsDelay,
+  void DoDelayPost(const Location& posted_from,
+                   int64_t cmsDelay,
                    int64_t tstamp,
                    MessageHandler* phandler,
                    uint32_t id,
                    MessageData* pdata);
 
   // Perform initialization, subclasses must call this from their constructor
   // if false was passed as init_queue to the MessageQueue constructor.
   void DoInit();
 
   // Perform cleanup, subclasses that override Clear must call this from the
@@ skipping 18 matching lines @@
   // Used if SocketServer ownership lies with |this|.
   std::unique_ptr<SocketServer> own_ss_;
   SharedExclusiveLock ss_lock_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(MessageQueue);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_MESSAGEQUEUE_H_