Support for different weight-functions for time-slicing.

chrome/browser/history/history_backend_unittest.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 <set>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 592 matching lines @@
   EXPECT_EQ(0, backend_->db()->GetSegmentNamed(segment_name));
 
   // One visit should be added.
   VisitVector visits;
   EXPECT_TRUE(backend_->db()->GetVisitsForURL(url_id, &visits));
   EXPECT_EQ(1U, visits.size());
 
   // But no visible visits.
   visits.clear();
   backend_->db()->GetVisibleVisitsInRange(base::Time(), base::Time(), 1,
-                                          &visits);
+                                          &visits, true);
   EXPECT_TRUE(visits.empty());
 
   // Expire the visits.
   std::set<GURL> restrict_urls;
   backend_->expire_backend()->ExpireHistoryBetween(restrict_urls,
                                                    visit_time, Time::Now());
 
   // The visit should have been nuked.
   visits.clear();
   EXPECT_TRUE(backend_->db()->GetVisitsForURL(url_id, &visits));
@@ skipping 624 matching lines @@
   const char* yahoo_sports_with_article2 =
       "http://sports.yahoo.com/article2.htm";
   const char* yahoo_sports_soccer = "http://sports.yahoo.com/soccer";
 
   // Clear all history.
   backend_->DeleteAllHistory();
 
   Time tested_time = Time::Now().LocalMidnight() +
                      base::TimeDelta::FromHours(4);
   base::TimeDelta half_an_hour = base::TimeDelta::FromMinutes(30);
+  base::TimeDelta one_hour = base::TimeDelta::FromHours(1);
   base::TimeDelta one_day = base::TimeDelta::FromDays(1);
 
   const content::PageTransition kTypedTransition =
       content::PAGE_TRANSITION_TYPED;
 
   const char* redirect_sequence[2];
   redirect_sequence[1] = NULL;
 
   redirect_sequence[0] = google;
   AddRedirectChainWithTransitionAndTime(
@@ skipping 42 matching lines @@
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   HistoryBackendCancelableRequest cancellable_request;
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
       request1);
 
   VisitFilter filter;
   // Time limit is |tested_time| +/- 45 min.
   base::TimeDelta three_quarters_of_an_hour = base::TimeDelta::FromMinutes(45);
-  filter.SetTimeInRangeFilter(tested_time - three_quarters_of_an_hour,
-                              tested_time + three_quarters_of_an_hour);
+  filter.SetFilterTime(tested_time);
+  filter.SetFilterWidth(three_quarters_of_an_hour);
   backend_->QueryFilteredURLs(request1, 100, filter);
 
   ASSERT_EQ(4U, get_filtered_list().size());
   EXPECT_EQ(std::string(google), get_filtered_list()[0].url.spec());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
             get_filtered_list()[1].url.spec());
   EXPECT_EQ(std::string(yahoo), get_filtered_list()[2].url.spec());
   EXPECT_EQ(std::string(yahoo_sports),
             get_filtered_list()[3].url.spec());
 
   // Time limit is between |tested_time| and |tested_time| + 2 hours.
   scoped_refptr<QueryFilteredURLsRequest> request2 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
       request2);
-  filter.SetTimeInRangeFilter(tested_time,
-                              tested_time + base::TimeDelta::FromHours(2));
+  filter.SetFilterTime(tested_time + one_hour);
+  filter.SetFilterWidth(one_hour);
   backend_->QueryFilteredURLs(request2, 100, filter);
 
   ASSERT_EQ(3U, get_filtered_list().size());
   EXPECT_EQ(std::string(google), get_filtered_list()[0].url.spec());
   EXPECT_EQ(std::string(yahoo), get_filtered_list()[1].url.spec());
   EXPECT_EQ(std::string(yahoo_sports), get_filtered_list()[2].url.spec());
 
   // Time limit is between |tested_time| - 2 hours and |tested_time|.
   scoped_refptr<QueryFilteredURLsRequest> request3 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
       request3);
-  filter.SetTimeInRangeFilter(tested_time - base::TimeDelta::FromHours(2),
-                              tested_time);
+  filter.SetFilterTime(tested_time - one_hour);
+  filter.SetFilterWidth(one_hour);
   backend_->QueryFilteredURLs(request3, 100, filter);
 
   ASSERT_EQ(3U, get_filtered_list().size());
   EXPECT_EQ(std::string(google), get_filtered_list()[0].url.spec());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
             get_filtered_list()[1].url.spec());
   EXPECT_EQ(std::string(yahoo_sports), get_filtered_list()[2].url.spec());
 
   filter.ClearFilters();
   base::Time::Exploded exploded_time;
   tested_time.LocalExplode(&exploded_time);
 
   // Today.
   scoped_refptr<QueryFilteredURLsRequest> request4 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
       request4);
-  filter.SetDayOfTheWeekFilter(static_cast<int>(exploded_time.day_of_week),
-                               tested_time);
+  filter.SetFilterTime(tested_time);
+  filter.SetDayOfTheWeekFilter(static_cast<int>(exploded_time.day_of_week));
   backend_->QueryFilteredURLs(request4, 100, filter);
 
   ASSERT_EQ(2U, get_filtered_list().size());
   EXPECT_EQ(std::string(google), get_filtered_list()[0].url.spec());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
             get_filtered_list()[1].url.spec());
 
   // Today + time limit - only yahoo_sports_soccer should fit.
   scoped_refptr<QueryFilteredURLsRequest> request5 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
       request5);
-  filter.SetTimeInRangeFilter(tested_time - base::TimeDelta::FromHours(1),
-                              tested_time - base::TimeDelta::FromMinutes(20));
+  filter.SetFilterTime(tested_time - base::TimeDelta::FromMinutes(40));
+  filter.SetFilterWidth(base::TimeDelta::FromMinutes(20));
   backend_->QueryFilteredURLs(request5, 100, filter);
 
   ASSERT_EQ(1U, get_filtered_list().size());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
             get_filtered_list()[0].url.spec());
 }
 
 TEST_F(HistoryBackendTest, UpdateVisitDuration) {
   // This unit test will test adding and deleting visit details information.
   ASSERT_TRUE(backend_.get());
@@ skipping 103 matching lines @@
   EXPECT_EQ(cur_version, file_version);
 
   // Check visit_duration column in visits table is created and set to 0.
   s1.Assign(archived_db.GetUniqueStatement(
       "SELECT visit_duration FROM visits LIMIT 1"));
   ASSERT_TRUE(s1.Step());
   EXPECT_EQ(0, s1.ColumnInt(0));
 }
 
 }  // namespace history