Make HistoryDBTask not refcounted, and ensure it's destroyed on its origin thread.

chrome/browser/sync/profile_sync_service_typed_url_unittest.cc

Index: chrome/browser/sync/profile_sync_service_typed_url_unittest.cc
diff --git a/chrome/browser/sync/profile_sync_service_typed_url_unittest.cc b/chrome/browser/sync/profile_sync_service_typed_url_unittest.cc
index 1d520fdbd19e0342d01212fc5bde605bc78e8d15..79eeb4e18abf28a90b5574cb1319dfede7bb6cc6 100644
--- a/chrome/browser/sync/profile_sync_service_typed_url_unittest.cc
+++ b/chrome/browser/sync/profile_sync_service_typed_url_unittest.cc
@@ -111,19 +111,45 @@ class HistoryBackendMock : public HistoryBackend {
 
 class HistoryServiceMock : public HistoryService {
  public:
-  explicit HistoryServiceMock(history::HistoryClient* client, Profile* profile)
-      : HistoryService(client, profile) {}
-  MOCK_METHOD2(ScheduleDBTask,
-               void(scoped_refptr<history::HistoryDBTask>,
-                    base::CancelableTaskTracker*));
+  HistoryServiceMock(history::HistoryClient* client, Profile* profile)
+      : HistoryService(client, profile), backend_(NULL) {}
+
+  virtual void ScheduleDBTask(scoped_ptr<history::HistoryDBTask> task,
+                              base::CancelableTaskTracker* tracker) OVERRIDE {
+    history::HistoryDBTask* task_raw = task.get();
+    task_runner_->PostTaskAndReply(
+        FROM_HERE,
+        base::Bind(&HistoryServiceMock::RunTaskOnDBThread,
+                   base::Unretained(this), task_raw),
+        base::Bind(&base::DeletePointer<history::HistoryDBTask>,
+                   task.release()));
+  }
+
   MOCK_METHOD0(Shutdown, void());
 
   void ShutdownBaseService() {
     HistoryService::Shutdown();
   }
 
+  void set_task_runner(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+    DCHECK(task_runner);
+    task_runner_ = task_runner;
+  }
+
+  void set_backend(scoped_refptr<history::HistoryBackend> backend) {
+    backend_ = backend;
+  }
+
  private:
   virtual ~HistoryServiceMock() {}
+
+  void RunTaskOnDBThread(history::HistoryDBTask* task) {
+    EXPECT_TRUE(task->RunOnDBThread(backend_, NULL));
+  }
+
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<history::HistoryBackend> backend_;
 };
 
 KeyedService* BuildFakeProfileInvalidationProvider(
@@ -151,17 +177,6 @@ class TestTypedUrlModelAssociator : public TypedUrlModelAssociator {
   virtual void ClearErrorStats() OVERRIDE {}
 };
 
-void RunOnDBThreadCallback(HistoryBackend* backend,
-                           scoped_refptr<history::HistoryDBTask> task) {
-  task->RunOnDBThread(backend, NULL);
-}
-
-ACTION_P2(RunTaskOnDBThread, thread, backend) {
-  thread->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&RunOnDBThreadCallback, base::Unretained(backend), arg0));
-}
-
 ACTION_P2(ShutdownHistoryService, thread, service) {
   service->ShutdownBaseService();
   delete thread;
@@ -221,14 +236,13 @@ class ProfileSyncServiceTypedUrlTest : public AbstractProfileSyncServiceTest {
         testing_factories);
     invalidation::ProfileInvalidationProviderFactory::GetInstance()->
         SetTestingFactory(profile_, BuildFakeProfileInvalidationProvider);
+    history_thread_->Start();
     history_backend_ = new HistoryBackendMock();
     history_service_ = static_cast<HistoryServiceMock*>(
         HistoryServiceFactory::GetInstance()->SetTestingFactoryAndUse(
             profile_, BuildHistoryService));
-    EXPECT_CALL((*history_service_), ScheduleDBTask(_, _))
-        .WillRepeatedly(RunTaskOnDBThread(history_thread_.get(),
-                                          history_backend_.get()));
-    history_thread_->Start();
+    history_service_->set_task_runner(history_thread_->task_runner());
+    history_service_->set_backend(history_backend_);
   }
 
   virtual void TearDown() {