First version of the time slicing on the urls. Not ready for review yet.

chrome/browser/history/visit_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 "chrome/browser/history/visit_database.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/timer.h"
 #include "base/stl_util.h"
+#include "chrome/browser/history/time_filter.h"
 #include "chrome/browser/history/url_database.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/common/page_transition_types.h"
 #include "sql/statement.h"
 
 // Rows, in order, of the visit table.
 #define HISTORY_VISIT_ROW_FIELDS \
   " id,url,visit_time,from_visit,transition,segment_id,is_indexed "
 
 namespace history {
@@ skipping 496 matching lines @@
   // See GetVisibleVisitsInRange for more info on how these times are bound.
   int64 end = end_time.ToInternalValue();
   statement.BindInt64(0, begin_time.ToInternalValue());
   statement.BindInt64(1, end ? end : std::numeric_limits<int64>::max());
   statement.BindInt64(2,
       max_results ? max_results : std::numeric_limits<int64>::max());
 
   return FillVisitVector(statement, visits);
 }
 
+bool VisitDatabase::GetAllVisitsDuringTimes(const TimeFilter& time_filter,
+                                            int max_results,
+                                            VisitVector* visits) {
+  visits->clear();
+  if (max_results)
+    visits->reserve(max_results);
+
+  for (TimeFilter::TimeVector::const_iterator it =
+           time_filter.get_times().begin();
+       it != time_filter.get_times().end(); ++it) {
+    sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
+        "SELECT" HISTORY_VISIT_ROW_FIELDS "FROM visits "
+        "WHERE visit_time >= ? AND visit_time < ?"
+        "ORDER BY visit_time LIMIT ?"));
+
+    // See GetVisibleVisitsInRange for more info on how these times are bound.
+    statement.BindInt64(0, it->first.ToInternalValue());
+    statement.BindInt64(1, it->second.is_null() ?
+        it->second.ToInternalValue() : std::numeric_limits<int64>::max());
+    statement.BindInt64(2,
+        max_results ? max_results : std::numeric_limits<int64>::max());
+
+    VisitVector v;
+    if (!FillVisitVector(statement, &v))
+      return false;
+    size_t take_only = 0;
+    if (max_results &&
+        static_cast<int>(visits->size() + v.size()) > max_results) {
+      take_only = max_results - visits->size();
+    }
+
+    visits->insert(visits->end(),
+                   v.begin(), take_only ? v.begin() + take_only : v.end());
+    if (max_results && static_cast<int>(visits->size()) == max_results)
+      return true;
+  }
+  return true;
+}
+
+
 bool VisitDatabase::GetVisitsInRangeForTransition(
     base::Time begin_time,
     base::Time end_time,
     int max_results,
     content::PageTransition transition,
     VisitVector* visits) {
   DCHECK(visits);
   visits->clear();
 
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
@@ skipping 49 matching lines @@
     if (found_urls.find(visit.url_id) != found_urls.end())
       continue;
     found_urls.insert(visit.url_id);
     visits->push_back(visit);
 
     if (max_count > 0 && static_cast<int>(visits->size()) >= max_count)
       break;
   }
 }
 
+void VisitDatabase::GetVisibleVisitsDuringTimes(const TimeFilter& time_filter,
+                                                int max_results,
+                                                VisitVector* visits) {
+  visits->clear();
+  if (max_results)
+    visits->reserve(max_results);
+  for (TimeFilter::TimeVector::const_iterator it =
+           time_filter.get_times().begin();
+       it != time_filter.get_times().end(); ++it) {
+    VisitVector v;
+    GetVisibleVisitsInRange(it->first, it->second, max_results, &v);
+    size_t take_only = 0;
+    if (max_results &&
+        static_cast<int>(visits->size() + v.size()) > max_results) {
+      take_only = max_results - visits->size();
+    }
+
+    visits->insert(visits->end(),
+                   v.begin(), take_only ? v.begin() + take_only : v.end());
+    if (max_results && static_cast<int>(visits->size()) == max_results)
+      return;
+  }
+}
+
+
 VisitID VisitDatabase::GetMostRecentVisitForURL(URLID url_id,
                                                 VisitRow* visit_row) {
   // The visit_time values can be duplicated in a redirect chain, so we sort
   // by id too, to ensure a consistent ordering just in case.
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT" HISTORY_VISIT_ROW_FIELDS "FROM visits "
       "WHERE url=? "
       "ORDER BY visit_time DESC, id DESC "
       "LIMIT 1"));
   statement.BindInt64(0, url_id);
@@ skipping 160 matching lines @@
     // Get the source entries out of the query result.
     while (statement.Step()) {
       std::pair<VisitID, VisitSource> source_entry(statement.ColumnInt64(0),
           static_cast<VisitSource>(statement.ColumnInt(1)));
       sources->insert(source_entry);
     }
   }
 }
 
 }  // namespace history