TopSites: filter out non-WebSafe URLs

components/history/core/browser/visitsegment_database.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 "components/history/core/browser/visitsegment_database.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
+#include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "components/history/core/browser/page_usage_data.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 // The following tables are used to store url segment information.
 //
@@ skipping 169 matching lines @@
         "(segment_id, time_slot, visit_count) VALUES (?, ?, ?)"));
     insert.BindInt64(0, segment_id);
     insert.BindInt64(1, t.ToInternalValue());
     insert.BindInt64(2, static_cast<int64_t>(amount));
 
     return insert.Run();
   }
 }
 
 std::vector<std::unique_ptr<PageUsageData>>
-VisitSegmentDatabase::QuerySegmentUsage(base::Time from_time,
-                                        int max_result_count) {
+VisitSegmentDatabase::QuerySegmentUsage(
+    base::Time from_time,
+    int max_result_count,
+    const base::Callback<bool(const GURL&)>& url_filter) {
   // This function gathers the highest-ranked segments in two queries.
   // The first gathers scores for all segments.
   // The second gathers segment data (url, title, etc.) for the highest-ranked
   // segments.
 
   // Gather all the segment scores.
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT segment_id, time_slot, visit_count "
       "FROM segment_usage WHERE time_slot >= ? "
       "ORDER BY segment_id"));
   if (!statement.is_valid())
     return std::vector<std::unique_ptr<PageUsageData>>();
 
   base::Time ts = from_time.LocalMidnight();
   statement.BindInt64(0, ts.ToInternalValue());
 
-  std::vector<std::unique_ptr<PageUsageData>> results;
+  std::vector<std::unique_ptr<PageUsageData>> segments;
   base::Time now = base::Time::Now();
   SegmentID previous_segment_id = 0;
   while (statement.Step()) {
     SegmentID segment_id = statement.ColumnInt64(0);
     if (segment_id != previous_segment_id) {
-      results.push_back(base::WrapUnique(new PageUsageData(segment_id)));
+      segments.push_back(base::WrapUnique(new PageUsageData(segment_id)));
       previous_segment_id = segment_id;
     }
 
     base::Time timeslot =
         base::Time::FromInternalValue(statement.ColumnInt64(1));
     int visit_count = statement.ColumnInt(2);
     int days_ago = (now - timeslot).InDays();
 
     // Score for this day in isolation.
     float day_visits_score = 1.0f + log(static_cast<float>(visit_count));
     // Recent visits count more than historical ones, so we multiply in a boost
     // related to how long ago this day was.
     // This boost is a curve that smoothly goes through these values:
     // Today gets 3x, a week ago 2x, three weeks ago 1.5x, falling off to 1x
     // at the limit of how far we reach into the past.
     float recency_boost = 1.0f + (2.0f * (1.0f / (1.0f + days_ago/7.0f)));
     float score = recency_boost * day_visits_score;
-    results.back()->SetScore(results.back()->GetScore() + score);
+    segments.back()->SetScore(segments.back()->GetScore() + score);
   }
 
-  // Limit to the top |max_result_count| results.
-  std::sort(results.begin(), results.end(),
+  // Order by descending scores.
+  std::sort(segments.begin(), segments.end(),
             [](const std::unique_ptr<PageUsageData>& lhs,
                const std::unique_ptr<PageUsageData>& rhs) {
               return lhs->GetScore() > rhs->GetScore();
             });
-  DCHECK_GE(max_result_count, 0);
-  if (results.size() > static_cast<size_t>(max_result_count))
-    results.resize(max_result_count);
 
   // Now fetch the details about the entries we care about.
   sql::Statement statement2(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT urls.url, urls.title FROM urls "
       "JOIN segments ON segments.url_id = urls.id "
       "WHERE segments.id = ?"));
 
   if (!statement2.is_valid())
     return std::vector<std::unique_ptr<PageUsageData>>();
 
-  for (std::unique_ptr<PageUsageData>& pud : results) {
+  std::vector<std::unique_ptr<PageUsageData>> results;
+  DCHECK_GE(max_result_count, 0);
+  for (std::unique_ptr<PageUsageData>& pud : segments) {
     statement2.BindInt64(0, pud->GetID());
     if (statement2.Step()) {
-      pud->SetURL(GURL(statement2.ColumnString(0)));
-      pud->SetTitle(statement2.ColumnString16(1));
+      GURL url(statement2.ColumnString(0));
+      if (url_filter.is_null() || url_filter.Run(url)) {
+        pud->SetURL(url);
+        pud->SetTitle(statement2.ColumnString16(1));
+        results.push_back(std::move(pud));
+        if (results.size() >= static_cast<size_t>(max_result_count))
+          break;
+      }
     }
     statement2.Reset(true);
   }
 
   return results;
 }
 
 bool VisitSegmentDatabase::DeleteSegmentData(base::Time older_than) {
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM segment_usage WHERE time_slot < ?"));
@@ skipping 27 matching lines @@
                       "name VARCHAR,"
                       "url_id INTEGER NON NULL)") &&
       GetDB().Execute("INSERT INTO segments_tmp SELECT "
                       "id, name, url_id FROM segments") &&
       GetDB().Execute("DROP TABLE segments") &&
       GetDB().Execute("ALTER TABLE segments_tmp RENAME TO segments") &&
       transaction.Commit();
 }
 
 }  // namespace history