Update base/timer.h code to pass through Location from call sites.

net/curvecp/messenger.cc

 // Copyright (c) 2011 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.
 
 #include "net/curvecp/messenger.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 76 matching lines @@
 }
 
 int Messenger::Write(IOBuffer* buf, int buf_len, CompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!pending_send_.get());   // Already a write pending!
   DCHECK(!send_complete_callback_);
   DCHECK_LT(0, buf_len);
 
   int len = send_buffer_.write(buf->data(), buf_len);
   if (!send_timer_.IsRunning())
-    send_timer_.Start(base::TimeDelta(), this, &Messenger::OnSendTimer);
+    send_timer_.Start(FROM_HERE, base::TimeDelta(),
+                      this, &Messenger::OnSendTimer);
   if (len)
     return len;
 
   // We couldn't add data to the send buffer, so block the application.
   pending_send_ = buf;
   pending_send_length_ = buf_len;
   send_complete_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
@@ skipping 68 matching lines @@
 
   // If the send timer fired while we were waiting for this send to complete,
   // we need to manually run the timer now.
   if (!send_timer_.IsRunning())
     OnSendTimer();
 
   if (!send_timeout_timer_.IsRunning()) {
     LOG(ERROR) << "RttTimeout is " << rtt_.rtt_timeout();
     base::TimeDelta delay =
         base::TimeDelta::FromMicroseconds(rtt_.rtt_timeout());
-    send_timeout_timer_.Start(delay, this, &Messenger::OnTimeout);
+    send_timeout_timer_.Start(FROM_HERE, delay, this, &Messenger::OnTimeout);
   }
 }
 
 void Messenger::OnTimeout() {
   LOG(ERROR) << "OnTimeout fired";
   int64 position = sent_list_.FindPositionOfOldestSentBlock();
   // XXXMB - need to verify that we really need to retransmit...
   if (position >= 0) {
     rtt_.OnTimeout();  // adjust our send rate.
     LOG(ERROR) << "OnTimeout retransmitting: " << position;
@@ skipping 10 matching lines @@
   DCHECK(!send_timer_.IsRunning());
 
   // If the send buffer is empty, then we don't need to keep firing.
   if (!send_buffer_.length()) {
     LOG(ERROR) << "OnSendTimer: send_buffer empty";
     return;
   }
 
   // Set the next send timer.
   LOG(ERROR) << "SendRate is: " << rtt_.send_rate() << "us";
-  send_timer_.Start(base::TimeDelta::FromMicroseconds(rtt_.send_rate()),
-                    this,
-                    &Messenger::OnSendTimer);
+  send_timer_.Start(FROM_HERE,
+                    base::TimeDelta::FromMicroseconds(rtt_.send_rate()),
+                    this, &Messenger::OnSendTimer);
 
   // Create a block from the send_buffer.
   if (!sent_list_.is_full()) {
     scoped_refptr<IOBufferWithSize> buffer = CreateBufferFromSendQueue();
     int64 position = sent_list_.CreateBlock(buffer.get());
     DCHECK_LE(0, position);
     SendMessage(position);
   }
 
   RecvMessage();  // Try to process an incoming message
@@ skipping 131 matching lines @@
 
   int rv = packetizer_->SendMessage(key_,
                                     buffer->data(),
                                     sizeof(Message),
                                     &send_message_callback_);
   // TODO(mbelshe): Fix me!  Deal with the error cases
   DCHECK(rv == sizeof(Message));
 }
 
 }  // namespace net