Adding more detail to MessageQueue::Dispatch logging.

webrtc/p2p/client/basicportallocator.cc

 /*
  *  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.
  */
 
@@ skipping 167 matching lines @@
 
 void BasicPortAllocatorSession::StartGettingPorts() {
   network_thread_ = rtc::Thread::Current();
   if (!socket_factory_) {
     owned_socket_factory_.reset(
         new rtc::BasicPacketSocketFactory(network_thread_));
     socket_factory_ = owned_socket_factory_.get();
   }
 
   running_ = true;
-  network_thread_->Post(this, MSG_CONFIG_START);
+  network_thread_->Post(FROM_HERE, this, MSG_CONFIG_START);
 
   if (flags() & PORTALLOCATOR_ENABLE_SHAKER)
-    network_thread_->PostDelayed(ShakeDelay(), this, MSG_SHAKE);
+    network_thread_->PostDelayed(FROM_HERE, ShakeDelay(), this, MSG_SHAKE);
 }
 
 void BasicPortAllocatorSession::StopGettingPorts() {
   ASSERT(rtc::Thread::Current() == network_thread_);
   running_ = false;
-  network_thread_->Post(this, MSG_CONFIG_STOP);
+  network_thread_->Post(FROM_HERE, this, MSG_CONFIG_STOP);
   ClearGettingPorts();
 }
 
 void BasicPortAllocatorSession::ClearGettingPorts() {
   network_thread_->Clear(this, MSG_ALLOCATE);
   for (uint32_t i = 0; i < sequences_.size(); ++i)
     sequences_[i]->Stop();
 }
 
 std::vector<PortInterface*> BasicPortAllocatorSession::ReadyPorts() const {
@@ skipping 97 matching lines @@
                                                     username(),
                                                     password());
 
   for (const RelayServerConfig& turn_server : allocator_->turn_servers()) {
     config->AddRelay(turn_server);
   }
   ConfigReady(config);
 }
 
 void BasicPortAllocatorSession::ConfigReady(PortConfiguration* config) {
-  network_thread_->Post(this, MSG_CONFIG_READY, config);
+  network_thread_->Post(FROM_HERE, this, MSG_CONFIG_READY, config);
 }
 
 // Adds a configuration to the list.
 void BasicPortAllocatorSession::OnConfigReady(PortConfiguration* config) {
   if (config) {
     configs_.push_back(config);
   }
 
   AllocatePorts();
 }
@@ skipping 24 matching lines @@
   }
 
   // If we stopped anything that was running, send a done signal now.
   if (send_signal) {
     MaybeSignalCandidatesAllocationDone();
   }
 }
 
 void BasicPortAllocatorSession::AllocatePorts() {
   ASSERT(rtc::Thread::Current() == network_thread_);
-  network_thread_->Post(this, MSG_ALLOCATE);
+  network_thread_->Post(FROM_HERE, this, MSG_ALLOCATE);
 }
 
 void BasicPortAllocatorSession::OnAllocate() {
   if (network_manager_started_)
     DoAllocate();
 
   allocation_started_ = true;
 }
 
 void BasicPortAllocatorSession::GetNetworks(
@@ skipping 76 matching lines @@
       }
       done_signal_needed = true;
       sequence->SignalPortAllocationComplete.connect(
           this, &BasicPortAllocatorSession::OnPortAllocationComplete);
       if (running_)
         sequence->Start();
       sequences_.push_back(sequence);
     }
   }
   if (done_signal_needed) {
-    network_thread_->Post(this, MSG_SEQUENCEOBJECTS_CREATED);
+    network_thread_->Post(FROM_HERE, this, MSG_SEQUENCEOBJECTS_CREATED);
   }
 }
 
 void BasicPortAllocatorSession::OnNetworksChanged() {
   std::vector<rtc::Network*> networks;
   GetNetworks(&networks);
   for (AllocationSequence* sequence : sequences_) {
     // Remove the network from the allocation sequence if it is not in
     // |networks|.
     if (!sequence->network_removed() &&
@@ skipping 265 matching lines @@
     }
   }
 
   LOG(INFO) << ">>>>> Destroying " << ports.size() << " ports and "
             << connections.size() << " connections";
 
   for (size_t i = 0; i < connections.size(); ++i)
     connections[i]->Destroy();
 
   if (running_ || (ports.size() > 0) || (connections.size() > 0))
-    network_thread_->PostDelayed(ShakeDelay(), this, MSG_SHAKE);
+    network_thread_->PostDelayed(FROM_HERE, ShakeDelay(), this, MSG_SHAKE);
 }
 
 BasicPortAllocatorSession::PortData* BasicPortAllocatorSession::FindPort(
     Port* port) {
   for (std::vector<PortData>::iterator it = ports_.begin();
        it != ports_.end(); ++it) {
     if (it->port() == port) {
       return &*it;
     }
   }
@@ skipping 77 matching lines @@
       // were to be given one, but that never happens in our codebase. Should
       // probably get rid of the list in PortConfiguration and just keep a
       // single relay server in each one.
       *flags |= PORTALLOCATOR_DISABLE_RELAY;
     }
   }
 }
 
 void AllocationSequence::Start() {
   state_ = kRunning;
-  session_->network_thread()->Post(this, MSG_ALLOCATION_PHASE);
+  session_->network_thread()->Post(FROM_HERE, this, MSG_ALLOCATION_PHASE);
 }
 
 void AllocationSequence::Stop() {
   // If the port is completed, don't set it to stopped.
   if (state_ == kRunning) {
     state_ = kStopped;
     session_->network_thread()->Clear(this, MSG_ALLOCATION_PHASE);
   }
 }
 
@@ skipping 29 matching lines @@
       state_ = kCompleted;
       EnableProtocol(PROTO_SSLTCP);
       break;
 
     default:
       ASSERT(false);
   }
 
   if (state() == kRunning) {
     ++phase_;
-    session_->network_thread()->PostDelayed(
-        session_->allocator()->step_delay(),
-        this, MSG_ALLOCATION_PHASE);
+    session_->network_thread()->PostDelayed(FROM_HERE,
+                                            session_->allocator()->step_delay(),
+                                            this, MSG_ALLOCATION_PHASE);
   } else {
     // If all phases in AllocationSequence are completed, no allocation
     // steps needed further. Canceling  pending signal.
     session_->network_thread()->Clear(this, MSG_ALLOCATION_PHASE);
     SignalPortAllocationComplete(this);
   }
 }
 
 void AllocationSequence::EnableProtocol(ProtocolType proto) {
   if (!ProtocolEnabled(proto)) {
@@ skipping 329 matching lines @@
   ServerAddresses servers;
   for (size_t i = 0; i < relays.size(); ++i) {
     if (relays[i].type == turn_type && SupportsProtocol(relays[i], type)) {
       servers.insert(relays[i].ports.front().address);
     }
   }
   return servers;
 }
 
 }  // namespace cricket