Support for different weight-functions for time-slicing.

chrome/browser/history/history_backend.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/history_backend.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <vector>
@@ skipping 1264 matching lines @@
 }
 
 // Basic time-based querying of history.
 void HistoryBackend::QueryHistoryBasic(URLDatabase* url_db,
                                        VisitDatabase* visit_db,
                                        const QueryOptions& options,
                                        QueryResults* result) {
   // First get all visits.
   VisitVector visits;
   visit_db->GetVisibleVisitsInRange(options.begin_time, options.end_time,
-                                    options.max_count, &visits);
+                                    options.max_count, &visits, true);
   DCHECK(options.max_count == 0 ||
          static_cast<int>(visits.size()) <= options.max_count);
 
   // Now add them and the URL rows to the results.
   URLResult url_result;
   for (size_t i = 0; i < visits.size(); i++) {
     const VisitRow visit = visits[i];
 
     // Add a result row for this visit, get the URL info from the DB.
     if (!url_db->GetURLRow(visit.url_id, &url_result)) {
@@ skipping 179 matching lines @@
   VisitVector visits;
   db_->GetVisibleVisitsDuringTimes(filter, 0, &visits);
 
   std::map<VisitID, std::pair<VisitID, URLID> > segment_ids;
   for (size_t i = 0; i < visits.size(); ++i) {
     segment_ids[visits[i].visit_id] =
         std::make_pair(visits[i].referring_visit, visits[i].segment_id);
   }
 
   std::map<URLID, double> score_map;
-  const double kLn2 = 0.6931471805599453;
-  base::Time now = base::Time::Now();
   for (size_t i = 0; i < visits.size(); ++i) {
     URLID segment_id = visits[i].segment_id;
     for (VisitID visit_id = visits[i].visit_id; !segment_id && visit_id;) {
       std::map<VisitID, std::pair<VisitID, URLID> >::iterator vi =
           segment_ids.find(visit_id);
       if (vi == segment_ids.end()) {
         VisitRow visit_row;
         if (!db_->GetRowForVisit(visit_id, &visit_row))
           break;
         segment_ids[visit_id] =
             std::make_pair(visit_row.referring_visit, visit_row.segment_id);
         segment_id = visit_row.segment_id;
         visit_id = visit_row.referring_visit;
       } else {
         visit_id = vi->second.first;
         segment_id = vi->second.second;
       }
     }
     if (!segment_id)
       continue;
-    double score = 0.0;
-    switch (filter.sorting_order()) {
-      case VisitFilter::ORDER_BY_RECENCY: {
-        // Decay score by half each week.
-        base::TimeDelta time_passed = now - visits[i].visit_time;
-        // Clamp to 0 in case time jumps backwards (e.g. due to DST).
-        double decay_exponent = std::max(0.0, kLn2 * static_cast<double>(
-            time_passed.InMicroseconds()) / base::Time::kMicrosecondsPerWeek);
-        score = 1.0 / exp(decay_exponent);
-      } break;
-      case VisitFilter::ORDER_BY_VISIT_COUNT:
-        score = 1.0;  // Every visit counts the same.
-        break;
-      case VisitFilter::ORDER_BY_DURATION_SPENT:
-        NOTREACHED() << "Not implemented!";
-        break;
-    }
+    double score = filter.GetVisitScore(visits[i]);
 
     std::map<URLID, double>::iterator it = score_map.find(visits[i].segment_id);
     if (it == score_map.end())
       score_map[visits[i].segment_id] = score;
     else
       it->second += score;
   }
 
   // TODO(georgey): experiment with visit_segment database granularity (it is
   // currently 24 hours) to use it directly instead of using visits database,
@@ skipping 975 matching lines @@
   info.url_id = visit.url_id;
   info.time = visit.visit_time;
   info.transition = visit.transition;
   // If we don't have a delegate yet during setup or shutdown, we will drop
   // these notifications.
   if (delegate_.get())
     delegate_->NotifyVisitDBObserversOnAddVisit(info);
 }
 
 }  // namespace history