Port HistoryService::ScheduleDBTask to CancelableTaskTracker

chrome/browser/history/in_memory_url_index.cc

 // Copyright (c) 2012 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 "chrome/browser/history/in_memory_url_index.h"
 
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
@@ skipping 120 matching lines @@
   // then insure that the cache has already been saved.
   DCHECK(history_dir_.empty() || !needs_to_be_cached_);
 }
 
 void InMemoryURLIndex::Init() {
   PostRestoreFromCacheFileTask();
 }
 
 void InMemoryURLIndex::ShutDown() {
   registrar_.RemoveAll();
-  cache_reader_consumer_.CancelAllRequests();
+  cache_reader_tracker_.TryCancelAll();
   shutdown_ = true;
   base::FilePath path;
   if (!GetCacheFilePath(&path))
     return;
-  private_data_->CancelPendingUpdates();
+  private_data_tracker_.TryCancelAll();
   URLIndexPrivateData::WritePrivateDataToCacheFileTask(private_data_, path);
   needs_to_be_cached_ = false;
 }
 
 void InMemoryURLIndex::ClearPrivateData() {
   private_data_->Clear();
 }
 
 bool InMemoryURLIndex::GetCacheFilePath(base::FilePath* file_path) {
   if (history_dir_.empty())
@@ skipping 46 matching lines @@
       // For simplicity, the unit tests send us all notifications, even when
       // we haven't registered for them, so don't assert here.
       break;
   }
 }
 
 void InMemoryURLIndex::OnURLVisited(const URLVisitedDetails* details) {
   HistoryService* service =
       HistoryServiceFactory::GetForProfile(profile_,
                                            Profile::EXPLICIT_ACCESS);
-  needs_to_be_cached_ |= private_data_->UpdateURL(
-      service, details->row, languages_, scheme_whitelist_);
+  needs_to_be_cached_ |= private_data_->UpdateURL(service,
+                                                  details->row,
+                                                  languages_,
+                                                  scheme_whitelist_,
+                                                  &private_data_tracker_);
 }
 
 void InMemoryURLIndex::OnURLsModified(const URLsModifiedDetails* details) {
   HistoryService* service =
       HistoryServiceFactory::GetForProfile(profile_,
                                            Profile::EXPLICIT_ACCESS);
   for (URLRows::const_iterator row = details->changed_urls.begin();
-       row != details->changed_urls.end(); ++row)
-    needs_to_be_cached_ |=
-        private_data_->UpdateURL(service, *row, languages_, scheme_whitelist_);
+       row != details->changed_urls.end(); ++row) {
+    needs_to_be_cached_ |= private_data_->UpdateURL(
+        service, *row, languages_, scheme_whitelist_, &private_data_tracker_);
+  }
 }
 
 void InMemoryURLIndex::OnURLsDeleted(const URLsDeletedDetails* details) {
   if (details->all_history) {
     ClearPrivateData();
     needs_to_be_cached_ = true;
   } else {
     for (URLRows::const_iterator row = details->rows.begin();
          row != details->rows.end(); ++row)
       needs_to_be_cached_ |= private_data_->DeleteURL(row->url());
@@ skipping 17 matching lines @@
   content::BrowserThread::PostTaskAndReplyWithResult
       <scoped_refptr<URLIndexPrivateData> >(
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&URLIndexPrivateData::RestoreFromFile, path, languages_),
       base::Bind(&InMemoryURLIndex::OnCacheLoadDone, AsWeakPtr()));
 }
 
 void InMemoryURLIndex::OnCacheLoadDone(
     scoped_refptr<URLIndexPrivateData> private_data) {
   if (private_data.get() && !private_data->Empty()) {
+    private_data_tracker_.TryCancelAll();
     private_data_ = private_data;
     restored_ = true;
     if (restore_cache_observer_)
       restore_cache_observer_->OnCacheRestoreFinished(true);
   } else if (profile_) {
     // When unable to restore from the cache file delete the cache file, if
     // it exists, and then rebuild from the history database if it's available,
     // otherwise wait until the history database loaded and then rebuild.
     base::FilePath path;
     if (!GetCacheFilePath(&path) || shutdown_)
@@ skipping 13 matching lines @@
 
 // Restoring from the History DB -----------------------------------------------
 
 void InMemoryURLIndex::ScheduleRebuildFromHistory() {
   HistoryService* service =
       HistoryServiceFactory::GetForProfile(profile_,
                                            Profile::EXPLICIT_ACCESS);
   service->ScheduleDBTask(
       new InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask(
           this, languages_, scheme_whitelist_),
-      &cache_reader_consumer_);
+      &cache_reader_tracker_);
 }
 
 void InMemoryURLIndex::DoneRebuidingPrivateDataFromHistoryDB(
     bool succeeded,
     scoped_refptr<URLIndexPrivateData> private_data) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (succeeded) {
+    private_data_tracker_.TryCancelAll();
     private_data_ = private_data;
     PostSaveToCacheFileTask();  // Cache the newly rebuilt index.
   } else {
     private_data_->Clear();  // Dump the old private data.
     // There is no need to do anything with the cache file as it was deleted
     // when the rebuild from the history operation was kicked off.
   }
   restored_ = true;
   if (restore_cache_observer_)
     restore_cache_observer_->OnCacheRestoreFinished(succeeded);
 }
 
 void InMemoryURLIndex::RebuildFromHistory(HistoryDatabase* history_db) {
+  private_data_tracker_.TryCancelAll();
   private_data_ = URLIndexPrivateData::RebuildFromHistory(history_db,
                                                           languages_,
                                                           scheme_whitelist_);
 }
 
 // Saving to Cache -------------------------------------------------------------
 
 void InMemoryURLIndex::PostSaveToCacheFileTask() {
   base::FilePath path;
   if (!GetCacheFilePath(&path))
@@ skipping 17 matching lines @@
         base::Bind(DeleteCacheFile, path));
   }
 }
 
 void InMemoryURLIndex::OnCacheSaveDone(bool succeeded) {
   if (save_cache_observer_)
     save_cache_observer_->OnCacheSaveFinished(succeeded);
 }
 
 }  // namespace history