Make DownloadHistory observe manager, items

chrome/browser/history/history.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.
 
 // The history system runs on a background thread so that potentially slow
 // database operations don't delay the browser. This backend processing is
 // represented by HistoryBackend. The HistoryService's job is to dispatch to
 // that thread.
 //
 // Main thread                       History thread
@@ skipping 17 matching lines @@
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/history/download_persistent_store_info.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/history/in_memory_database.h"
 #include "chrome/browser/history/in_memory_history_backend.h"
 #include "chrome/browser/history/in_memory_url_index.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/history/visit_database.h"
 #include "chrome/browser/history/visit_filter.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/profile_error_dialog.h"
 #include "chrome/browser/visitedlink/visitedlink_master.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/download_persistent_store_info.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using base::Time;
 using history::HistoryBackend;
 
 namespace {
 
@@ skipping 514 matching lines @@
     CancelableRequestConsumerBase* consumer,
     const QueryURLCallback& callback) {
   return Schedule(PRIORITY_UI, &HistoryBackend::QueryURL, consumer,
                   new history::QueryURLRequest(callback), url, want_visits);
 }
 
 // Downloads -------------------------------------------------------------------
 
 // Handle creation of a download by creating an entry in the history service's
 // 'downloads' table.
-HistoryService::Handle HistoryService::CreateDownload(
-    int32 id,
-    const content::DownloadPersistentStoreInfo& create_info,
-    CancelableRequestConsumerBase* consumer,
+void HistoryService::CreateDownload(
+    const DownloadPersistentStoreInfo& info,
     const HistoryService::DownloadCreateCallback& callback) {
-  return Schedule(PRIORITY_NORMAL, &HistoryBackend::CreateDownload, consumer,
-                  new history::DownloadCreateRequest(callback), id,
-                  create_info);
+  LoadBackendIfNecessary();
+  ScheduleTask(PRIORITY_NORMAL, base::Bind(
+      &HistoryBackend::CreateDownload, history_backend_.get(), info, callback));
+}
+
+void HistoryService::GetVisibleVisitCountToHostSimple(
+      const GURL& url,
+      const GetVisibleVisitCountToHostSimpleCallback& callback) {
+  LoadBackendIfNecessary();
+  ScheduleTask(PRIORITY_NORMAL, base::Bind(
+      &HistoryBackend::GetVisibleVisitCountToHostSimple, history_backend_.get(),
+      url, callback));
 }
 
 HistoryService::Handle HistoryService::GetNextDownloadId(
     CancelableRequestConsumerBase* consumer,
     const DownloadNextIdCallback& callback) {
   return Schedule(PRIORITY_NORMAL, &HistoryBackend::GetNextDownloadId, consumer,
                   new history::DownloadNextIdRequest(callback));
 }
 
 // Handle queries for a list of all downloads in the history database's
 // 'downloads' table.
-HistoryService::Handle HistoryService::QueryDownloads(
-    CancelableRequestConsumerBase* consumer,
-    const DownloadQueryCallback& callback) {
-  return Schedule(PRIORITY_NORMAL, &HistoryBackend::QueryDownloads, consumer,
-                  new history::DownloadQueryRequest(callback));
+void HistoryService::QueryDownloads(const DownloadQueryCallback& callback) {
+  LoadBackendIfNecessary();
+  ScheduleTask(PRIORITY_NORMAL, base::Bind(
+      &HistoryBackend::QueryDownloads, history_backend_.get(), callback));
 }
 
 // Changes all IN_PROGRESS in the database entries to CANCELED.
 // IN_PROGRESS entries are the corrupted entries, not updated by next function
 // because of the crash or some other extremal exit.
 void HistoryService::CleanUpInProgressEntries() {
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::CleanUpInProgressEntries);
 }
 
 // Handle updates for a particular download. This is a 'fire and forget'
 // operation, so we don't need to be called back.
 void HistoryService::UpdateDownload(
-    const content::DownloadPersistentStoreInfo& data) {
+    const DownloadPersistentStoreInfo& data) {
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::UpdateDownload, data);
 }
 
-void HistoryService::UpdateDownloadPath(const FilePath& path,
-                                        int64 db_handle) {
-  ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::UpdateDownloadPath,
-                    path, db_handle);
-}
-
-void HistoryService::RemoveDownload(int64 db_handle) {
+void HistoryService::RemoveDownloads(const std::set<int64>& handles) {
   ScheduleAndForget(PRIORITY_NORMAL,
-                    &HistoryBackend::RemoveDownload, db_handle);
-}
-
-void HistoryService::RemoveDownloadsBetween(Time remove_begin,
-                                            Time remove_end) {
-  ScheduleAndForget(PRIORITY_NORMAL,
-                    &HistoryBackend::RemoveDownloadsBetween,
-                    remove_begin,
-                    remove_end);
+                    &HistoryBackend::RemoveDownloads, handles);
 }
 
 HistoryService::Handle HistoryService::QueryHistory(
     const string16& text_query,
     const history::QueryOptions& options,
     CancelableRequestConsumerBase* consumer,
     const QueryHistoryCallback& callback) {
   return Schedule(PRIORITY_UI, &HistoryBackend::QueryHistory, consumer,
                   new history::QueryHistoryRequest(callback),
                   text_query, options);
@@ skipping 300 matching lines @@
 void HistoryService::RemoveVisitDatabaseObserver(
     history::VisitDatabaseObserver* observer) {
   visit_database_observers_->RemoveObserver(observer);
 }
 
 void HistoryService::NotifyVisitDBObserversOnAddVisit(
     const history::BriefVisitInfo& info) {
   visit_database_observers_->Notify(
       &history::VisitDatabaseObserver::OnAddVisit, info);
 }