[SyncFS] Move FROM_HEREs in SyncTaskManager to its client

chrome/browser/sync_file_system/sync_task_manager_unittest.cc

 // Copyright 2013 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/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/sync_file_system/sync_task_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 47 matching lines @@
   }
   virtual void NotifyLastOperationStatus(
       SyncStatusCode last_operation_status,
       bool last_operation_used_network) OVERRIDE {
     last_operation_status_ = last_operation_status;
   }
 
   void ScheduleTask(SyncStatusCode status_to_return,
                     const SyncStatusCallback& callback) {
     task_manager_->ScheduleTask(
+        FROM_HERE,
         base::Bind(&TaskManagerClient::DoTask, AsWeakPtr(),
                    status_to_return, false /* idle */),
         callback);
   }
 
   void ScheduleTaskIfIdle(SyncStatusCode status_to_return) {
     task_manager_->ScheduleTaskIfIdle(
+        FROM_HERE,
         base::Bind(&TaskManagerClient::DoTask, AsWeakPtr(),
                    status_to_return, true /* idle */),
         SyncStatusCallback());
   }
 
   int maybe_schedule_next_task_count() const {
     return maybe_schedule_next_task_count_;
   }
   int task_scheduled_count() const { return task_scheduled_count_; }
   int idle_task_scheduled_count() const { return idle_task_scheduled_count_; }
@@ skipping 153 matching lines @@
   int callback_count = 0;
   SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 
   bool task_started = false;
   bool task_completed = false;
 
   {
     SyncTaskManager task_manager((base::WeakPtr<SyncTaskManager::Client>()));
     task_manager.Initialize(SYNC_STATUS_OK);
     task_manager.ScheduleSyncTask(
+        FROM_HERE,
         scoped_ptr<SyncTask>(new MultihopSyncTask(
             &task_started, &task_completed)),
         base::Bind(&IncrementAndAssign, 0, &callback_count, &status));
   }
 
   message_loop.RunUntilIdle();
   EXPECT_EQ(0, callback_count);
   EXPECT_EQ(SYNC_STATUS_UNKNOWN, status);
   EXPECT_TRUE(task_started);
   EXPECT_FALSE(task_completed);
 }
 
 TEST(SyncTaskManagerTest, ScheduleAndCancelTask) {
   base::MessageLoop message_loop;
 
   int callback_count = 0;
   SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 
   bool task_started = false;
   bool task_completed = false;
 
   {
     SyncTaskManager task_manager((base::WeakPtr<SyncTaskManager::Client>()));
     task_manager.Initialize(SYNC_STATUS_OK);
     MultihopSyncTask* task = new MultihopSyncTask(
         &task_started, &task_completed);
     task_manager.ScheduleTask(
+        FROM_HERE,
         base::Bind(&MultihopSyncTask::Run, base::Unretained(task)),
         base::Bind(&IncrementAndAssignWithOwnedPointer<MultihopSyncTask>,
                    base::Owned(task), &callback_count, &status));
   }
 
   message_loop.RunUntilIdle();
   EXPECT_EQ(0, callback_count);
   EXPECT_EQ(SYNC_STATUS_UNKNOWN, status);
   EXPECT_TRUE(task_started);
   EXPECT_FALSE(task_completed);
 }
 
 TEST(SyncTaskManagerTest, ScheduleTaskAtPriority) {
   base::MessageLoop message_loop;
   SyncTaskManager task_manager((base::WeakPtr<SyncTaskManager::Client>()));
   task_manager.Initialize(SYNC_STATUS_OK);
 
   int callback_count = 0;
   SyncStatusCode callback_status1 = SYNC_STATUS_OK;
   SyncStatusCode callback_status2 = SYNC_STATUS_OK;
   SyncStatusCode callback_status3 = SYNC_STATUS_OK;
   SyncStatusCode callback_status4 = SYNC_STATUS_OK;
   SyncStatusCode callback_status5 = SYNC_STATUS_OK;
 
   // This will run first even if its priority is low, since there're no
   // pending tasks.
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus1),
       SyncTaskManager::PRIORITY_LOW,
       base::Bind(&IncrementAndAssign, 0, &callback_count, &callback_status1));
 
   // This runs last (expected counter == 4).
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus2),
       SyncTaskManager::PRIORITY_LOW,
       base::Bind(&IncrementAndAssign, 4, &callback_count, &callback_status2));
 
   // This runs second (expected counter == 1).
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus3),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&IncrementAndAssign, 1, &callback_count, &callback_status3));
 
   // This runs fourth (expected counter == 3).
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus4),
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&IncrementAndAssign, 3, &callback_count, &callback_status4));
 
   // This runs third (expected counter == 2).
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus5),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&IncrementAndAssign, 2, &callback_count, &callback_status5));
 
   message_loop.RunUntilIdle();
 
   EXPECT_EQ(kStatus1, callback_status1);
   EXPECT_EQ(kStatus2, callback_status2);
   EXPECT_EQ(kStatus3, callback_status3);
   EXPECT_EQ(kStatus4, callback_status4);
   EXPECT_EQ(kStatus5, callback_status5);
   EXPECT_EQ(5, callback_count);
 }
 
 }  // namespace sync_file_system