Add the ability to unload the HistoryBackend....

chrome/browser/history/history.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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
 // -----------                       --------------
 // HistoryService <----------------> HistoryBackend
 //                                   -> HistoryDatabase
 //                                      -> SQLite connection to History
 //                                   -> ArchivedDatabase
 //                                      -> SQLite connection to Archived History
 //                                   -> TextDatabaseManager
 //                                      -> SQLite connection to one month's data
 //                                      -> SQLite connection to one month's data
 //                                      ...
 //                                   -> ThumbnailDatabase
 //                                      -> SQLite connection to Thumbnails
 //                                         (and favicons)
 
 #include "chrome/browser/history/history.h"
 
 #include "app/l10n_util.h"
-#include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/ref_counted.h"
 #include "base/task.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/history/download_types.h"
@@ skipping 108 matching lines @@
                  Source<Profile>(profile_));
 }
 
 HistoryService::~HistoryService() {
   // Shutdown the backend. This does nothing if Cleanup was already invoked.
   Cleanup();
 }
 
 bool HistoryService::Init(const FilePath& history_dir,
                           BookmarkService* bookmark_service) {
-  if (!thread_->Start())
+  if (!thread_->Start()) {
+    Cleanup();
     return false;
+  }
+
+  history_dir_ = history_dir;
+  bookmark_service_ = bookmark_service;
 
   // Create the history backend.
-  scoped_refptr<HistoryBackend> backend(
-      new HistoryBackend(history_dir,
-                         new BackendDelegate(this),
-                         bookmark_service));
-  history_backend_.swap(backend);
-
-  ScheduleAndForget(PRIORITY_UI, &HistoryBackend::Init);
+  LoadBackendIfNecessary();
   return true;
 }
 
-void HistoryService::Cleanup() {
-  if (!thread_) {
-    // We've already cleaned up.
-    return;
-  }
+bool HistoryService::BackendLoaded() {
+  LoadBackendIfNecessary();
+  return backend_loaded_;
+}
 
-  // Shutdown is a little subtle. The backend's destructor must run on the
-  // history thread since it is not threadsafe. So this thread must not be the
-  // last thread holding a reference to the backend, or a crash could happen.
+void HistoryService::UnloadBackend() {
+  if (!history_backend_)
+    return;  // Already unloaded.
+
+  // Get rid of the in-memory backend.
+  in_memory_backend_.reset();
+
+  // The backend's destructor must run on the history thread since it is not
+  // threadsafe. So this thread must not be the last thread holding a reference
+  // to the backend, or a crash could happen.
   //
   // We have a reference to the history backend. There is also an extra
   // reference held by our delegate installed in the backend, which
   // HistoryBackend::Closing will release. This means if we scheduled a call
   // to HistoryBackend::Closing and *then* released our backend reference, there
   // will be a race between us and the backend's Closing function to see who is
   // the last holder of a reference. If the backend thread's Closing manages to
   // run before we release our backend refptr, the last reference will be held
   // by this thread and the destructor will be called from here.
   //
   // Therefore, we create a task to run the Closing operation first. This holds
   // a reference to the backend. Then we release our reference, then we schedule
   // the task to run. After the task runs, it will delete its reference from
   // the history thread, ensuring everything works properly.
   Task* closing_task =
       NewRunnableMethod(history_backend_.get(), &HistoryBackend::Closing);
   history_backend_ = NULL;
   ScheduleTask(PRIORITY_NORMAL, closing_task);
+}
+
+void HistoryService::Cleanup() {
+  if (!thread_) {
+    // We've already cleaned up.
+    return;
+  }
+
+  // Unload the backend.
+  UnloadBackend();
 
   // Delete the thread, which joins with the background thread. We defensively
   // NULL the pointer before deleting it in case somebody tries to use it
   // during shutdown, but this shouldn't happen.
   base::Thread* thread = thread_;
   thread_ = NULL;
   delete thread;
 }
 
 void HistoryService::NotifyRenderProcessHostDestruction(const void* host) {
   ScheduleAndForget(PRIORITY_NORMAL,
                     &HistoryBackend::NotifyRenderProcessHostDestruction, host);
 }
 
-history::URLDatabase* HistoryService::in_memory_database() const {
+history::URLDatabase* HistoryService::InMemoryDatabase() {
+  LoadBackendIfNecessary();
   if (in_memory_backend_.get())
     return in_memory_backend_->db();
   return NULL;
 }
 
 void HistoryService::SetSegmentPresentationIndex(int64 segment_id, int index) {
   ScheduleAndForget(PRIORITY_UI,
                     &HistoryBackend::SetSegmentPresentationIndex,
                     segment_id, index);
 }
@@ skipping 67 matching lines @@
 }
 
 void HistoryService::AddPage(const GURL& url,
                              Time time,
                              const void* id_scope,
                              int32 page_id,
                              const GURL& referrer,
                              PageTransition::Type transition,
                              const history::RedirectList& redirects,
                              bool did_replace_entry) {
-  DCHECK(history_backend_) << "History service being called after cleanup";
+  DCHECK(thread_) << "History service being called after cleanup";
 
   // Filter out unwanted URLs. We don't add auto-subframe URLs. They are a
   // large part of history (think iframes for ads) and we never display them in
   // history UI. We will still add manual subframes, which are ones the user
   // has clicked on to get.
   if (!CanAddURL(url))
     return;
 
   // Add link & all redirects to visited link list.
   VisitedLinkMaster* visited_links;
@@ skipping 69 matching lines @@
   }
 
   ScheduleAndForget(PRIORITY_NORMAL,
                     &HistoryBackend::AddPagesWithDetails, info);
 }
 
 void HistoryService::SetPageContents(const GURL& url,
                                      const std::wstring& contents) {
   if (!CanAddURL(url))
     return;
+
   ScheduleAndForget(PRIORITY_LOW, &HistoryBackend::SetPageContents,
                     url, contents);
 }
 
 void HistoryService::SetPageThumbnail(const GURL& page_url,
                                       const SkBitmap& thumbnail,
                                       const ThumbnailScore& score) {
   if (!CanAddURL(page_url))
     return;
 
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetPageThumbnail,
                     page_url, thumbnail, score);
 }
 
 HistoryService::Handle HistoryService::GetPageThumbnail(
     const GURL& page_url,
     CancelableRequestConsumerBase* consumer,
     ThumbnailDataCallback* callback) {
   return Schedule(PRIORITY_NORMAL, &HistoryBackend::GetPageThumbnail, consumer,
                   new history::GetPageThumbnailRequest(callback), page_url);
 }
 
 void HistoryService::GetFavicon(FaviconService::GetFaviconRequest* request,
                                 const GURL& icon_url) {
-  ScheduleTask(PRIORITY_NORMAL,
-      NewRunnableMethod(history_backend_.get(),
-          &HistoryBackend::GetFavIcon,
-          scoped_refptr<FaviconService::GetFaviconRequest>(request),
-          icon_url));
+  Schedule(PRIORITY_NORMAL, &HistoryBackend::GetFavIcon, NULL, request,
+           icon_url);
 }
 
 void HistoryService::UpdateFaviconMappingAndFetch(
     FaviconService::GetFaviconRequest* request,
     const GURL& page_url,
     const GURL& icon_url) {
-  ScheduleTask(PRIORITY_NORMAL,
-      NewRunnableMethod(history_backend_.get(),
-          &HistoryBackend::UpdateFavIconMappingAndFetch,
-          scoped_refptr<FaviconService::GetFaviconRequest>(request),
-          page_url,
-          icon_url));
+  Schedule(PRIORITY_NORMAL, &HistoryBackend::UpdateFavIconMappingAndFetch, NULL,
+           request, page_url, icon_url);
 }
 
 void HistoryService::GetFaviconForURL(
     FaviconService::GetFaviconRequest* request,
     const GURL& page_url) {
-  ScheduleTask(PRIORITY_UI,
-      NewRunnableMethod(history_backend_.get(),
-          &HistoryBackend::GetFavIconForURL,
-          scoped_refptr<FaviconService::GetFaviconRequest>(request),
-          page_url));
+  Schedule(PRIORITY_NORMAL, &HistoryBackend::GetFavIconForURL, NULL, request,
+           page_url);
 }
 
 void HistoryService::SetFavicon(const GURL& page_url,
                                 const GURL& icon_url,
                                 const std::vector<unsigned char>& image_data) {
   if (!CanAddURL(page_url))
     return;
 
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetFavIcon,
       page_url, icon_url,
@@ skipping 238 matching lines @@
   Source<Profile> source(profile_);
 
   // The details object just contains the pointer to the object that the
   // backend has allocated for us. The receiver of the notification will cast
   // this to the proper type.
   Details<history::HistoryDetails> det(details_deleted);
 
   NotificationService::current()->Notify(type, source, det);
 }
 
+void HistoryService::LoadBackendIfNecessary() {
+  if (!thread_ || history_backend_)
+    return;  // Failed to init, or already started loading.
+
+  scoped_refptr<HistoryBackend> backend(
+      new HistoryBackend(history_dir_,
+                         new BackendDelegate(this),
+                         bookmark_service_));
+  history_backend_.swap(backend);
+
+  ScheduleAndForget(PRIORITY_UI, &HistoryBackend::Init);
+}
+
 void HistoryService::OnDBLoaded() {
   LOG(INFO) << "History backend finished loading";
   backend_loaded_ = true;
   NotificationService::current()->Notify(NotificationType::HISTORY_LOADED,
                                          Source<Profile>(profile_),
                                          Details<HistoryService>(this));
 }