Stop history search going on beyond the start of history....

chrome/browser/history/history_backend.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/history/history_backend.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 332 matching lines @@
   // added in order. However, we don't want to disallow pages from recording
   // times earlier than our last_recorded_time_, because someone might set
   // their machine's clock back.
   if (last_requested_time_ == request->time) {
     last_recorded_time_ = last_recorded_time_ + TimeDelta::FromMicroseconds(1);
   } else {
     last_requested_time_ = request->time;
     last_recorded_time_ = last_requested_time_;
   }
 
+  // If the user is adding older history, we need to make sure our times
+  // are correct.
+  if (request->time < first_recorded_time_)
+    first_recorded_time_ = request->time;
+
   if (request->redirects.size() <= 1) {
     // The single entry is both a chain start and end.
     PageTransition::Type t = request->transition |
         PageTransition::CHAIN_START | PageTransition::CHAIN_END;
 
     // No redirect case (one element means just the page itself).
     last_ids = AddPageVisit(request->url, last_recorded_time_,
                             last_ids.second, t);
 
     // Update the segment for this visit.
@@ skipping 195 matching lines @@
 
   // Open the long-running transaction.
   db_->BeginTransaction();
   if (thumbnail_db_.get())
     thumbnail_db_->BeginTransaction();
   if (archived_db_.get())
     archived_db_->BeginTransaction();
   if (text_database_.get())
     text_database_->BeginTransaction();
 
+  // Get the first item in our database.
+  db_->GetStartDate(&first_recorded_time_);
+
   // Start expiring old stuff.
   expirer_.StartArchivingOldStuff(TimeDelta::FromDays(kArchiveDaysThreshold));
 
   HISTOGRAM_TIMES("History.InitTime",
                   TimeTicks::Now() - beginning_time);
 }
 
 std::pair<URLID, VisitID> HistoryBackend::AddPageVisit(
     const GURL& url,
     Time time,
@@ skipping 457 matching lines @@
       // main DB, and do nothing otherwise.
       db_->GetRowForURL(url_result.url(), &url_result);
     }
 
     url_result.set_visit_time(visit.visit_time);
 
     // We don't set any of the query-specific parts of the URLResult, since
     // snippets and stuff don't apply to basic querying.
     result->AppendURLBySwapping(&url_result);
   }
+
+  if (options.begin_time <= first_recorded_time_)
+    result->set_reached_beginning(true);
 }
 
 void HistoryBackend::QueryHistoryFTS(const std::wstring& text_query,
                                      const QueryOptions& options,
                                      QueryResults* result) {
   if (!text_database_.get())
     return;
 
   // Full text query, first get all the FTS results in the time range.
   std::vector<TextDatabase::Match> fts_matches;
@@ skipping 30 matching lines @@
     url_result.snippet_.Swap(&fts_matches[i].snippet);
 
     // The visit time also comes from the full text search database. Since it
     // has the time, we can avoid an extra query of the visits table.
     url_result.set_visit_time(fts_matches[i].time);
 
     // Add it to the vector, this will clear our |url_row| object as a
     // result of the swap.
     result->AppendURLBySwapping(&url_result);
   }
+
+  if (options.begin_time <= first_recorded_time_)
+    result->set_reached_beginning(true);
 }
 
 // Frontend to GetMostRecentRedirectsFrom from the history thread.
 void HistoryBackend::QueryRedirectsFrom(
     scoped_refptr<QueryRedirectsRequest> request,
     const GURL& url) {
   if (request->canceled())
     return;
   bool success = GetMostRecentRedirectsFrom(url, &request->value);
   request->ForwardResult(QueryRedirectsRequest::TupleType(
@@ skipping 469 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Generic operations
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 void HistoryBackend::DeleteURL(const GURL& url) {
   expirer_.DeleteURL(url);
 
+  db_->GetStartDate(&first_recorded_time_);
   // Force a commit, if the user is deleting something for privacy reasons, we
   // want to get it on disk ASAP.
   Commit();
 }
 
 void HistoryBackend::ExpireHistoryBetween(
     scoped_refptr<ExpireHistoryRequest> request,
     Time begin_time,
     Time end_time) {
   if (request->canceled())
     return;
 
   if (db_.get()) {
     if (begin_time.is_null() && end_time.is_null()) {
       // Special case deleting all history so it can be faster and to reduce the
       // possibility of an information leak.
       DeleteAllHistory();
     } else {
       // Clearing parts of history, have the expirer do the depend
       expirer_.ExpireHistoryBetween(begin_time, end_time);
 
       // Force a commit, if the user is deleting something for privacy reasons,
       // we want to get it on disk ASAP.
       Commit();
     }
   }
 
+  if (begin_time <= first_recorded_time_)
+    db_->GetStartDate(&first_recorded_time_);
+
   request->ForwardResult(ExpireHistoryRequest::TupleType());
 
   if (history_publisher_.get())
     history_publisher_->DeleteUserHistoryBetween(begin_time, end_time);
 }
 
 void HistoryBackend::URLsNoLongerBookmarked(const std::set<GURL>& urls) {
   if (!db_.get())
     return;
 
@@ skipping 101 matching lines @@
     archived_db_.reset(new ArchivedDatabase());
     if (!archived_db_->Init(archived_file_name)) {
       LOG(WARNING) << "Could not initialize the archived database.";
       archived_db_.reset();
     } else {
       // Open our long-running transaction on this database.
       archived_db_->BeginTransaction();
     }
   }
 
+  db_->GetStartDate(&first_recorded_time_);
+
   // Send out the notfication that history is cleared. The in-memory datdabase
   // will pick this up and clear itself.
   URLsDeletedDetails* details = new URLsDeletedDetails;
   details->all_history = true;
   BroadcastNotifications(NotificationType::HISTORY_URLS_DELETED, details);
 }
 
 bool HistoryBackend::ClearAllThumbnailHistory(
     std::vector<URLRow>* kept_urls) {
   if (!thumbnail_db_.get()) {
@@ skipping 73 matching lines @@
 
   // Delete the old tables and recreate them empty.
   db_->RecreateAllTablesButURL();
 
   // Vacuum to reclaim the space from the dropped tables. This must be done
   // when there is no transaction open, and we assume that our long-running
   // transaction is currently open.
   db_->CommitTransaction();
   db_->Vacuum();
   db_->BeginTransaction();
+  db_->GetStartDate(&first_recorded_time_);
+
+  first_recorded_time_ = Time::Now();

[sky, 2009/03/11 01:11:31]

nuke this.

+
   return true;
 }
 
 BookmarkService* HistoryBackend::GetBookmarkService() {
   if (bookmark_service_)
     bookmark_service_->BlockTillLoaded();
   return bookmark_service_;
 }
 
 }  // namespace history