Added page score to the ntp suggestions tab.

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 93 matching lines @@
   HistoryBackendTest() : bookmark_model_(NULL), loaded_(false) {}
   virtual ~HistoryBackendTest() {
   }
 
   // Callback for QueryMostVisited.
   void OnQueryMostVisited(CancelableRequestProvider::Handle handle,
                           history::MostVisitedURLList data) {
     most_visited_list_.swap(data);
   }
 
+  // Callback for QueryFiltered.
+  void OnQueryFiltered(CancelableRequestProvider::Handle handle,
+                       history::FilteredURLList data) {
+    filtered_list_.swap(data);
+  }
+
   const history::MostVisitedURLList& get_most_visited_list() const {
     return most_visited_list_;
   }
 
+  const history::FilteredURLList& get_filtered_list() const {
+    return filtered_list_;
+  }
+
  protected:
   scoped_refptr<HistoryBackend> backend_;  // Will be NULL on init failure.
   scoped_ptr<InMemoryHistoryBackend> mem_backend_;
 
   void AddRedirectChain(const char* sequence[], int page_id) {
     AddRedirectChainWithTransitionAndTime(sequence, page_id,
                                           content::PAGE_TRANSITION_LINK,
                                           Time::Now());
   }
 
@@ skipping 103 matching lines @@
     content::Details<HistoryDetails> det(details);
     mem_backend_->Observe(type, content::Source<HistoryBackendTest>(NULL), det);
 
     // The backend passes ownership of the details pointer to us.
     delete details;
   }
 
   MessageLoop message_loop_;
   FilePath test_dir_;
   history::MostVisitedURLList most_visited_list_;
+  history::FilteredURLList filtered_list_;
 };
 
 void HistoryBackendTestDelegate::SetInMemoryBackend(int backend_id,
     InMemoryHistoryBackend* backend) {
   test_->SetInMemoryBackend(backend_id, backend);
 }
 
 void HistoryBackendTestDelegate::BroadcastNotifications(
     int type,
     HistoryDetails* details) {
@@ skipping 1035 matching lines @@
                     false,
                     tested_time - one_day + half_an_hour * 2,
                     &transition1, &transition2);
 
   redirect_sequence[0] = yahoo_sports_soccer;
   AddRedirectChainWithTransitionAndTime(redirect_sequence, 0,
                                         kTypedTransition,
                                         tested_time - half_an_hour);
   backend_->Commit();
 
-  scoped_refptr<QueryMostVisitedURLsRequest> request1 =
-      new history::QueryMostVisitedURLsRequest(
-          base::Bind(&HistoryBackendTest::OnQueryMostVisited,
+  scoped_refptr<QueryFilteredURLsRequest> request1 =
+      new history::QueryFilteredURLsRequest(
+          base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   HistoryBackendCancelableRequest cancellable_request;
-  cancellable_request.MockScheduleOfRequest<QueryMostVisitedURLsRequest>(
+  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);
   backend_->QueryFilteredURLs(request1, 100, filter);
 
-  ASSERT_EQ(4U, get_most_visited_list().size());
-  EXPECT_EQ(std::string(google), get_most_visited_list()[0].url.spec());
+  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_most_visited_list()[1].url.spec());
-  EXPECT_EQ(std::string(yahoo), get_most_visited_list()[2].url.spec());
+            get_filtered_list()[1].url.spec());
+  EXPECT_EQ(std::string(yahoo), get_filtered_list()[2].url.spec());
   EXPECT_EQ(std::string(yahoo_sports),
-            get_most_visited_list()[3].url.spec());
+            get_filtered_list()[3].url.spec());
 
   // Time limit is between |tested_time| and |tested_time| + 2 hours.
-  scoped_refptr<QueryMostVisitedURLsRequest> request2 =
-      new history::QueryMostVisitedURLsRequest(
-          base::Bind(&HistoryBackendTest::OnQueryMostVisited,
+  scoped_refptr<QueryFilteredURLsRequest> request2 =
+      new history::QueryFilteredURLsRequest(
+          base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
-  cancellable_request.MockScheduleOfRequest<QueryMostVisitedURLsRequest>(
+  cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
       request2);
   filter.SetTimeInRangeFilter(tested_time,
                               tested_time + base::TimeDelta::FromHours(2));
   backend_->QueryFilteredURLs(request2, 100, filter);
 
-  ASSERT_EQ(3U, get_most_visited_list().size());
-  EXPECT_EQ(std::string(google), get_most_visited_list()[0].url.spec());
-  EXPECT_EQ(std::string(yahoo), get_most_visited_list()[1].url.spec());
-  EXPECT_EQ(std::string(yahoo_sports), get_most_visited_list()[2].url.spec());
+  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<QueryMostVisitedURLsRequest> request3 =
-      new history::QueryMostVisitedURLsRequest(
-          base::Bind(&HistoryBackendTest::OnQueryMostVisited,
+  scoped_refptr<QueryFilteredURLsRequest> request3 =
+      new history::QueryFilteredURLsRequest(
+          base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
-  cancellable_request.MockScheduleOfRequest<QueryMostVisitedURLsRequest>(
+  cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
       request3);
   filter.SetTimeInRangeFilter(tested_time - base::TimeDelta::FromHours(2),
                               tested_time);
   backend_->QueryFilteredURLs(request3, 100, filter);
 
-  ASSERT_EQ(3U, get_most_visited_list().size());
-  EXPECT_EQ(std::string(google), get_most_visited_list()[0].url.spec());
+  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_most_visited_list()[1].url.spec());
-  EXPECT_EQ(std::string(yahoo_sports), get_most_visited_list()[2].url.spec());
+            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<QueryMostVisitedURLsRequest> request4 =
-      new history::QueryMostVisitedURLsRequest(
-          base::Bind(&HistoryBackendTest::OnQueryMostVisited,
+  scoped_refptr<QueryFilteredURLsRequest> request4 =
+      new history::QueryFilteredURLsRequest(
+          base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
-  cancellable_request.MockScheduleOfRequest<QueryMostVisitedURLsRequest>(
+  cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
       request4);
   filter.SetDayOfTheWeekFilter(static_cast<int>(exploded_time.day_of_week),
                                tested_time);
   backend_->QueryFilteredURLs(request4, 100, filter);
 
-  ASSERT_EQ(2U, get_most_visited_list().size());
-  EXPECT_EQ(std::string(google), get_most_visited_list()[0].url.spec());
+  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_most_visited_list()[1].url.spec());
+            get_filtered_list()[1].url.spec());
 
   // Today + time limit - only yahoo_sports_soccer should fit.
-  scoped_refptr<QueryMostVisitedURLsRequest> request5 =
-      new history::QueryMostVisitedURLsRequest(
-          base::Bind(&HistoryBackendTest::OnQueryMostVisited,
+  scoped_refptr<QueryFilteredURLsRequest> request5 =
+      new history::QueryFilteredURLsRequest(
+          base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
-  cancellable_request.MockScheduleOfRequest<QueryMostVisitedURLsRequest>(
+  cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
       request5);
   filter.SetTimeInRangeFilter(tested_time - base::TimeDelta::FromHours(1),
                               tested_time - base::TimeDelta::FromMinutes(20));
   backend_->QueryFilteredURLs(request5, 100, filter);
 
-  ASSERT_EQ(1U, get_most_visited_list().size());
+  ASSERT_EQ(1U, get_filtered_list().size());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
-            get_most_visited_list()[0].url.spec());
+            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());
 
   GURL url1("http://www.cnn.com");
   std::vector<VisitInfo> visit_info1, visit_info2;
   Time start_ts = Time::Now() - base::TimeDelta::FromDays(5);
   Time end_ts = start_ts + base::TimeDelta::FromDays(2);
@@ skipping 98 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