Revert "Currently, base/timer.cc calls PostTask with FROM_HERE as the Location,

base/timer_unittest.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 "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 namespace {
 
 class OneShotTimerTester {
  public:
   OneShotTimerTester(bool* did_run, unsigned milliseconds = 10)
       : did_run_(did_run),
         delay_ms_(milliseconds) {
   }
   void Start() {
-    timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(delay_ms_), this,
+    timer_.Start(TimeDelta::FromMilliseconds(delay_ms_), this,
                  &OneShotTimerTester::Run);
   }
  private:
   void Run() {
     *did_run_ = true;
     MessageLoop::current()->Quit();
   }
   bool* did_run_;
   base::OneShotTimer<OneShotTimerTester> timer_;
   const unsigned delay_ms_;
 };
 
 class OneShotSelfDeletingTimerTester {
  public:
   explicit OneShotSelfDeletingTimerTester(bool* did_run) :
       did_run_(did_run),
       timer_(new base::OneShotTimer<OneShotSelfDeletingTimerTester>()) {
   }
   void Start() {
-    timer_->Start(FROM_HERE, TimeDelta::FromMilliseconds(10), this,
+    timer_->Start(TimeDelta::FromMilliseconds(10), this,
                   &OneShotSelfDeletingTimerTester::Run);
   }
  private:
   void Run() {
     *did_run_ = true;
     timer_.reset();
     MessageLoop::current()->Quit();
   }
   bool* did_run_;
   scoped_ptr<base::OneShotTimer<OneShotSelfDeletingTimerTester> > timer_;
 };
 
 class RepeatingTimerTester {
  public:
   explicit RepeatingTimerTester(bool* did_run)
       : did_run_(did_run), counter_(10) {
   }
 
   void Start() {
-    timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(10), this,
+    timer_.Start(TimeDelta::FromMilliseconds(10), this,
                  &RepeatingTimerTester::Run);
   }
  private:
   void Run() {
     if (--counter_ == 0) {
       *did_run_ = true;
       MessageLoop::current()->Quit();
     }
   }
   bool* did_run_;
@@ skipping 96 matching lines @@
 
  private:
   bool signaled_;
 };
 
 void RunTest_DelayTimer_NoCall(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // If Delay is never called, the timer shouldn't go off.
   DelayTimerTarget target;
-  base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
+  base::DelayTimer<DelayTimerTarget> timer(
       TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run);
   tester.Start();
   MessageLoop::current()->Run();
 
   ASSERT_FALSE(target.signaled());
 }
 
 void RunTest_DelayTimer_OneCall(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   DelayTimerTarget target;
-  base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
+  base::DelayTimer<DelayTimerTarget> timer(
       TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
   timer.Reset();
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run, 100 /* milliseconds */);
   tester.Start();
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(target.signaled());
 }
@@ skipping 13 matching lines @@
  private:
   base::DelayTimer<DelayTimerTarget> *const timer_;
   DelayTimerTarget *const target_;
 };
 
 void RunTest_DelayTimer_Reset(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // If Delay is never called, the timer shouldn't go off.
   DelayTimerTarget target;
-  base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
+  base::DelayTimer<DelayTimerTarget> timer(
       TimeDelta::FromMilliseconds(50), &target, &DelayTimerTarget::Signal);
   timer.Reset();
 
   ResetHelper reset_helper(&timer, &target);
 
   base::OneShotTimer<ResetHelper> timers[20];
   for (size_t i = 0; i < arraysize(timers); ++i) {
-    timers[i].Start(FROM_HERE, TimeDelta::FromMilliseconds(i * 10),
-                    &reset_helper, &ResetHelper::Reset);
+    timers[i].Start(TimeDelta::FromMilliseconds(i * 10), &reset_helper,
+                    &ResetHelper::Reset);
   }
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run, 300);
   tester.Start();
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(target.signaled());
 }
 
 class DelayTimerFatalTarget {
  public:
   void Signal() {
     ASSERT_TRUE(false);
   }
 };
 
 
 void RunTest_DelayTimer_Deleted(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   DelayTimerFatalTarget target;
 
   {
     base::DelayTimer<DelayTimerFatalTarget> timer(
-        FROM_HERE, TimeDelta::FromMilliseconds(50), &target,
+        TimeDelta::FromMilliseconds(50), &target,
         &DelayTimerFatalTarget::Signal);
     timer.Reset();
   }
 
   // When the timer is deleted, the DelayTimerFatalTarget should never be
   // called.
   base::PlatformThread::Sleep(100);
 }
 
 }  // namespace
@@ skipping 72 matching lines @@
     OneShotTimerTester d(&did_run);
     {
       MessageLoop loop(MessageLoop::TYPE_DEFAULT);
       a.Start();
       b.Start();
     }  // MessageLoop destructs by falling out of scope.
   }  // OneShotTimers destruct.  SHOULD NOT CRASH, of course.
 
   EXPECT_FALSE(did_run);
 }