Make sure we can still navigate to URLs when the History DB can't be loaded....

chrome/browser/autocomplete/history_url_provider.cc

 // Copyright (c) 2006-2008 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/autocomplete/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/histogram.h"
@@ skipping 18 matching lines @@
 using base::TimeTicks;
 
 HistoryURLProviderParams::HistoryURLProviderParams(
     const AutocompleteInput& input,
     bool trim_http,
     const std::wstring& languages)
     : message_loop(MessageLoop::current()),
       input(input),
       trim_http(trim_http),
       cancel(false),
+      failed(false),
       languages(languages) {
 }
 
 void HistoryURLProvider::Start(const AutocompleteInput& input,
                                bool minimal_changes) {
   // NOTE: We could try hard to do less work in the |minimal_changes| case
   // here; some clever caching would let us reuse the raw matches from the
   // history DB without re-querying.  However, we'd still have to go back to
   // the history thread to mark these up properly, and if pass 2 is currently
   // running, we'd need to wait for it to return to the main thread before
@@ skipping 47 matching lines @@
   }
   DCHECK(found) << "Asked to delete a URL that isn't in our set of matches";
   listener_->OnProviderUpdate(true);
 }
 
 // Called on the history thread.
 void HistoryURLProvider::ExecuteWithDB(history::HistoryBackend* backend,
                                        history::URLDatabase* db,
                                        HistoryURLProviderParams* params) {
   // We may get called with a NULL database if it couldn't be properly
-  // initialized.  In this case we just say the query is complete.
-  if (db && !params->cancel) {
+  // initialized.
+  if (!db) {
+    params->failed = true;
+  } else if (!params->cancel) {
     TimeTicks beginning_time = TimeTicks::Now();
 
     DoAutocomplete(backend, db, params);
 
     UMA_HISTOGRAM_TIMES("Autocomplete.HistoryAsyncQueryTime",
                         TimeTicks::Now() - beginning_time);
   }
 
   // Return the results (if any) to the main thread.
   params->message_loop->PostTask(FROM_HERE, NewRunnableMethod(
@@ skipping 97 matching lines @@
 
   // If the user hasn't already started another query, clear our member pointer
   // so we can't write into deleted memory.
   if (params_ == params_gets_deleted)
     params_ = NULL;
 
   // Don't send responses for queries that have been canceled.
   if (params->cancel)
     return;  // Already set done_ when we canceled, no need to set it again.
 
+  // Don't modify |matches_| if the query failed, since it might have a default
+  // match in it, whereas |params->matches| will be empty.
+  if (!params->failed) {
+    matches_.swap(params->matches);
+    UpdateStarredStateOfMatches();
+  }
+
   done_ = true;
-  matches_.swap(params->matches);
-  UpdateStarredStateOfMatches();
   listener_->OnProviderUpdate(true);
 }
 
 AutocompleteMatch HistoryURLProvider::SuggestExactInput(
     const AutocompleteInput& input,
     bool trim_http) {
   AutocompleteMatch match(this,
       CalculateRelevance(input.type(), WHAT_YOU_TYPED, 0), false,
       AutocompleteMatch::URL_WHAT_YOU_TYPED);
 
@@ skipping 591 matching lines @@
       history_match.input_location - offset, params->input.text().length(),
       match.contents.length(), ACMatchClassification::URL,
       &match.contents_class);
   match.description = info.title();
   AutocompleteMatch::ClassifyMatchInString(params->input.text(), info.title(),
                                            ACMatchClassification::NONE,
                                            &match.description_class);
 
   return match;
 }