Omnibox: Rebuild HQP Cache if it's old

chrome/browser/history/url_index_private_data.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/url_index_private_data.h"
 
 #include <algorithm>
 #include <functional>
 #include <iterator>
 #include <limits>
@@ skipping 426 matching lines @@
   if (!history_db)
     return NULL;
 
   base::TimeTicks beginning_time = base::TimeTicks::Now();
 
   scoped_refptr<URLIndexPrivateData>
       rebuilt_data(new URLIndexPrivateData);
   URLDatabase::URLEnumerator history_enum;
   if (!history_db->InitURLEnumeratorForSignificant(&history_enum))
     return NULL;
+  rebuilt_data->last_time_rebuilt_from_history_ = base::Time::Now();
   for (URLRow row; history_enum.GetNextURL(&row); ) {
     rebuilt_data->IndexRow(history_db, NULL, row, languages,
                            scheme_whitelist);
   }
 
   UMA_HISTOGRAM_TIMES("History.InMemoryURLIndexingTime",
                       base::TimeTicks::Now() - beginning_time);
   UMA_HISTOGRAM_COUNTS("History.InMemoryURLHistoryItems",
                        rebuilt_data->history_id_word_map_.size());
   UMA_HISTOGRAM_COUNTS_10000("History.InMemoryURLWords",
@@ skipping 11 matching lines @@
   DCHECK(!file_path.empty());
   return private_data->SaveToFile(file_path);
 }
 
 void URLIndexPrivateData::CancelPendingUpdates() {
   recent_visits_consumer_.CancelAllRequests();
 }
 
 scoped_refptr<URLIndexPrivateData> URLIndexPrivateData::Duplicate() const {
   scoped_refptr<URLIndexPrivateData> data_copy = new URLIndexPrivateData;
+  data_copy->last_time_rebuilt_from_history_ = last_time_rebuilt_from_history_;
   data_copy->word_list_ = word_list_;
   data_copy->available_words_ = available_words_;
   data_copy->word_map_ = word_map_;
   data_copy->char_word_map_ = char_word_map_;
   data_copy->word_id_history_map_ = word_id_history_map_;
   data_copy->history_id_word_map_ = history_id_word_map_;
   data_copy->history_info_map_ = history_info_map_;
   data_copy->word_starts_map_ = word_starts_map_;
   return data_copy;
   // Not copied:
   //    search_term_cache_
   //    pre_filter_item_count_
   //    post_filter_item_count_
   //    post_scoring_item_count_
 };
 
 bool URLIndexPrivateData::Empty() const {
   return history_info_map_.empty();
 }
 
 void URLIndexPrivateData::Clear() {
+  last_time_rebuilt_from_history_ = base::Time();
   word_list_.clear();
   available_words_.clear();
   word_map_.clear();
   char_word_map_.clear();
   word_id_history_map_.clear();
   history_id_word_map_.clear();
   history_info_map_.clear();
   word_starts_map_.clear();
 }
 
@@ skipping 392 matching lines @@
     return false;
   }
   UMA_HISTOGRAM_TIMES("History.InMemoryURLIndexSaveCacheTime",
                       base::TimeTicks::Now() - beginning_time);
   return true;
 }
 
 void URLIndexPrivateData::SavePrivateData(
     InMemoryURLIndexCacheItem* cache) const {
   DCHECK(cache);
-  cache->set_timestamp(base::Time::Now().ToInternalValue());
+  cache->set_last_rebuild_timestamp(
+      last_time_rebuilt_from_history_.ToInternalValue());
   cache->set_version(saved_cache_version_);
   // history_item_count_ is no longer used but rather than change the protobuf
   // definition use a placeholder. This will go away with the switch to SQLite.
   cache->set_history_item_count(0);
   SaveWordList(cache);
   SaveWordMap(cache);
   SaveCharWordMap(cache);
   SaveWordIDHistoryMap(cache);
   SaveHistoryInfoMap(cache);
   SaveWordStartsMap(cache);
@@ skipping 111 matching lines @@
       map_entry->add_url_word_starts(*i);
     for (WordStarts::const_iterator i = word_starts.title_word_starts_.begin();
          i != word_starts.title_word_starts_.end(); ++i)
       map_entry->add_title_word_starts(*i);
   }
 }
 
 bool URLIndexPrivateData::RestorePrivateData(
     const InMemoryURLIndexCacheItem& cache,
     const std::string& languages) {
+  last_time_rebuilt_from_history_ =
+      base::Time::FromInternalValue(cache.last_rebuild_timestamp());
+  const base::TimeDelta rebuilt_ago =
+      base::Time::Now() - last_time_rebuilt_from_history_;
+  if ((rebuilt_ago > base::TimeDelta::FromDays(7)) ||
+      (rebuilt_ago < base::TimeDelta::FromDays(-1))) {
+    // Cache is more than a week old or, somehow, from some time in the future.
+    // It's probably a good time to rebuild the index from history to
+    // allow synced entries to now appear, expired entries to disappear, etc.
+    // Allow one day in the future to make the cache not rebuild on simple
+    // system clock changes such as time zone changes.
+    return false;
+  }
   if (cache.has_version()) {
     if (cache.version() < kCurrentCacheFileVersion) {
       // Don't try to restore an old format cache file.  (This will cause
       // the InMemoryURLIndex to schedule rebuilding the URLIndexPrivateData
       // from history.)
       return false;
     }
     restored_cache_version_ = cache.version();
   }
   return RestoreWordList(cache) && RestoreWordMap(cache) &&
@@ skipping 262 matching lines @@
   // recently visited (within the last 12/24 hours) as highly important. Get
   // input from mpearson.
   if (r1.typed_count() != r2.typed_count())
     return (r1.typed_count() > r2.typed_count());
   if (r1.visit_count() != r2.visit_count())
     return (r1.visit_count() > r2.visit_count());
   return (r1.last_visit() > r2.last_visit());
 }
 
 }  // namespace history