Unittest for fix to allow navigation when there is no history DB....

chrome/browser/history/history.cc

 // 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
@@ skipping 112 matching lines @@
   scoped_refptr<HistoryService> history_service_;
   MessageLoop* message_loop_;
 };
 
 // static
 const history::StarID HistoryService::kBookmarkBarID = 1;
 
 HistoryService::HistoryService()
     : thread_(new ChromeHistoryThread()),
       profile_(NULL),
-      backend_loaded_(false) {
+      backend_loaded_(false),
+      bookmark_service_(NULL),
+      no_db_(false) {
   // Is NULL when running generate_profile.
   if (NotificationService::current()) {
     registrar_.Add(this, NotificationType::HISTORY_URLS_DELETED,
                    Source<Profile>(profile_));
   }
 }
 
 HistoryService::HistoryService(Profile* profile)
     : thread_(new ChromeHistoryThread()),
       profile_(profile),
-      backend_loaded_(false) {
+      backend_loaded_(false),
+      bookmark_service_(NULL),
+      no_db_(false) {
   registrar_.Add(this, NotificationType::HISTORY_URLS_DELETED,
                  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()) {
-    Cleanup();
-    return false;
-  }
-
-  history_dir_ = history_dir;
-  bookmark_service_ = bookmark_service;
-
-  // Create the history backend.
-  LoadBackendIfNecessary();
-  return true;
-}
-
 bool HistoryService::BackendLoaded() {
   // NOTE: We start the backend loading even though it completes asynchronously
   // and thus won't affect the return value of this function.  This is because
   // callers of this assume that if the backend isn't yet loaded it will be
   // soon, so they will either listen for notifications or just retry this call
   // later.  If we've purged the backend, we haven't necessarily restarted it
   // loading by now, so we need to trigger the load in order to maintain that
   // expectation.
   LoadBackendIfNecessary();
   return backend_loaded_;
@@ skipping 434 matching lines @@
   Details<history::URLsDeletedDetails> deleted_details(details);
   VisitedLinkMaster* visited_links = profile_->GetVisitedLinkMaster();
   if (!visited_links)
     return;  // Nobody to update.
   if (deleted_details->all_history)
     visited_links->DeleteAllURLs();
   else  // Delete individual ones.
     visited_links->DeleteURLs(deleted_details->urls);
 }
 
+bool HistoryService::Init(const FilePath& history_dir,
+                          BookmarkService* bookmark_service,
+                          bool no_db) {
+  if (!thread_->Start()) {
+    Cleanup();
+    return false;
+  }
+
+  history_dir_ = history_dir;
+  bookmark_service_ = bookmark_service;
+  no_db_ = no_db;
+
+  // Create the history backend.
+  LoadBackendIfNecessary();
+  return true;
+}
+
 void HistoryService::ScheduleAutocomplete(HistoryURLProvider* provider,
                                           HistoryURLProviderParams* params) {
   ScheduleAndForget(PRIORITY_UI, &HistoryBackend::ScheduleAutocomplete,
                     scoped_refptr<HistoryURLProvider>(provider), params);
 }
 
 void HistoryService::ScheduleTask(SchedulePriority priority,
                                   Task* task) {
   // FIXME(brettw) do prioritization.
   thread_->message_loop()->PostTask(FROM_HERE, task);
@@ skipping 82 matching lines @@
 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);
+  ScheduleAndForget(PRIORITY_UI, &HistoryBackend::Init, no_db_);
 }
 
 void HistoryService::OnDBLoaded() {
   LOG(INFO) << "History backend finished loading";
   backend_loaded_ = true;
   NotificationService::current()->Notify(NotificationType::HISTORY_LOADED,
                                          Source<Profile>(profile_),
                                          Details<HistoryService>(this));
 }