Boost HQP Scores for Bookmarks

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/file_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_service_factory.h"
@@ skipping 40 matching lines @@
 
 InMemoryURLIndex::RestoreCacheObserver::~RestoreCacheObserver() {}
 
 InMemoryURLIndex::SaveCacheObserver::~SaveCacheObserver() {}
 
 // RebuildPrivateDataFromHistoryDBTask -----------------------------------------
 
 InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::
     RebuildPrivateDataFromHistoryDBTask(
         InMemoryURLIndex* index,
+        Profile* profile,

[sky, 2012/09/05 20:57:49]

Are you using this on the db thread?

[mrossetti, 2012/09/05 22:35:40]

No, it was not referenced on the db thread, however I simplified things
dramatically to remove even this dubious usage. I think you'll be pleased.

         const std::string& languages,
         const std::set<std::string>& scheme_whitelist)
     : index_(index),
+      profile_(profile),
       languages_(languages),
       scheme_whitelist_(scheme_whitelist),
       succeeded_(false) {
 }
 
 bool InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::RunOnDBThread(
     HistoryBackend* backend,
     HistoryDatabase* db) {
-  data_ = URLIndexPrivateData::RebuildFromHistory(db, languages_,
+  data_ = URLIndexPrivateData::RebuildFromHistory(profile_, db, languages_,
                                                   scheme_whitelist_);
   succeeded_ = data_.get() && !data_->Empty();
   if (!succeeded_ && data_.get())
     data_->Clear();
   return true;
 }
 
 void InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::
     DoneRunOnMainThread() {
   index_->DoneRebuidingPrivateDataFromHistoryDB(succeeded_, data_);
 }
 
 InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::
     ~RebuildPrivateDataFromHistoryDBTask() {
 }
 
 // InMemoryURLIndex ------------------------------------------------------------
 
 InMemoryURLIndex::InMemoryURLIndex(Profile* profile,
                                    const FilePath& history_dir,
                                    const std::string& languages)
     : profile_(profile),
       history_dir_(history_dir),
       languages_(languages),
-      private_data_(new URLIndexPrivateData),
+      private_data_(new URLIndexPrivateData(profile)),
       restore_cache_observer_(NULL),
       save_cache_observer_(NULL),
       shutdown_(false),
       restored_(false),
       needs_to_be_cached_(false) {
   InitializeSchemeWhitelist(&scheme_whitelist_);
   if (profile) {
     // TODO(mrossetti): Register for language change notifications.
     content::Source<Profile> source(profile);
     registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URL_VISITED, source);
     registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_MODIFIED,
                    source);
     registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_DELETED, source);
   }
 }
 
 // Called only by unit tests.
 InMemoryURLIndex::InMemoryURLIndex()
     : profile_(NULL),
-      private_data_(new URLIndexPrivateData),
+      private_data_(new URLIndexPrivateData(NULL)),
       restore_cache_observer_(NULL),
       save_cache_observer_(NULL),
       shutdown_(false),
       restored_(false),
       needs_to_be_cached_(false) {
   InitializeSchemeWhitelist(&scheme_whitelist_);
 }
 
 InMemoryURLIndex::~InMemoryURLIndex() {
   // If there was a history directory (which there won't be for some unit tests)
@@ skipping 95 matching lines @@
 
   FilePath path;
   if (!GetCacheFilePath(&path) || shutdown_) {
     restored_ = true;
     if (restore_cache_observer_)
       restore_cache_observer_->OnCacheRestoreFinished(false);
     return;
   }
 
   scoped_refptr<URLIndexPrivateData> restored_private_data =
-      new URLIndexPrivateData;
+      new URLIndexPrivateData(profile_);
   content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&URLIndexPrivateData::RestoreFromFileTask, path,
+      base::Bind(&URLIndexPrivateData::RestoreFromFileTask, profile_, path,
           restored_private_data, languages_),
       base::Bind(&InMemoryURLIndex::OnCacheLoadDone, AsWeakPtr(),
           restored_private_data));
 }
 
 void InMemoryURLIndex::OnCacheLoadDone(
     scoped_refptr<URLIndexPrivateData> private_data) {
   if (private_data.get() && !private_data->Empty()) {
     private_data_ = private_data;
     restored_ = true;
@@ skipping 20 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_),
+          this, profile_, languages_, scheme_whitelist_),
       &cache_reader_consumer_);
 }
 
 void InMemoryURLIndex::DoneRebuidingPrivateDataFromHistoryDB(
     bool succeeded,
     scoped_refptr<URLIndexPrivateData> private_data) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (succeeded) {
     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_ = URLIndexPrivateData::RebuildFromHistory(history_db,
+  private_data_ = URLIndexPrivateData::RebuildFromHistory(profile_,
+                                                          history_db,
                                                           languages_,
                                                           scheme_whitelist_);
 }
 
 // Saving to Cache -------------------------------------------------------------
 
 void InMemoryURLIndex::PostSaveToCacheFileTask() {
   FilePath path;
   if (!GetCacheFilePath(&path))
     return;
@@ skipping 18 matching lines @@
   }
 }
 
 void InMemoryURLIndex::OnCacheSaveDone(
     scoped_refptr<RefCountedBool> succeeded) {
   if (save_cache_observer_)
     save_cache_observer_->OnCacheSaveFinished(succeeded->value());
 }
 
 }  // namespace history