1. Create and use the TopSites database file....

chrome/browser/history/top_sites.cc

 // Copyright (c) 2009 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/top_sites.h"
 
+#include <algorithm>
+
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/history/top_sites_database.h"
+#include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/page_usage_data.h"
 #include "gfx/codec/jpeg_codec.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace history {
 
 // How many top sites to store in the cache.
 static const int kTopSitesNumber = 20;
 static const int kDaysOfHistory = 90;
-static const int64 kUpdateIntervalSecs = 15;  // TODO(Nik): come up
-                                              // with an algorithm for timing.
+static const int64 kUpdateIntervalSecs = 15;  // Time from startup to DB query.
+// Intervals between requests to HistoryService.
+static const int64 kMinUpdateIntervalMinutes = 1;
+static const int64 kMaxUpdateIntervalMinutes = 60;
+
 
 TopSites::TopSites(Profile* profile) : profile_(profile),
-                                       mock_history_service_(NULL) {
+                                       mock_history_service_(NULL),
+                                       last_num_urls_changed_(0) {
+  registrar_.Add(this, NotificationType::HISTORY_URLS_DELETED,
+                 Source<Profile>(profile_));
 }
 
 TopSites::~TopSites() {
+  timer_.Stop();
 }
 
-void TopSites::Init() {
-  if (db_.get())
-    ReadDatabase();
+void TopSites::Init(const FilePath& db_name) {
+  db_path_ = db_name;
+  db_.reset(new TopSitesDatabaseImpl());
+  if (!db_->Init(db_name))
+    return;
+
+  ReadDatabase();
 
   // Start the one-shot timer.
   timer_.Start(base::TimeDelta::FromSeconds(kUpdateIntervalSecs), this,
                &TopSites::StartQueryForMostVisited);
 }
 
 void TopSites::ReadDatabase() {
   DCHECK(db_.get());
   {
     AutoLock lock(lock_);
@@ skipping 91 matching lines @@
 void TopSites::UpdateMostVisited(MostVisitedURLList* most_visited) {
   lock_.AssertAcquired();
   // TODO(brettw) filter for blacklist!
 
   if (!top_sites_.empty()) {
     std::vector<size_t> added;    // Indices into most_visited.
     std::vector<size_t> deleted;  // Indices into top_sites_.
     std::vector<size_t> moved;    // Indices into most_visited.
     DiffMostVisited(top_sites_, *most_visited, &added, &deleted, &moved);
 
+    // #added == #deleted; #added + #moved = total.
+    last_num_urls_changed_ = added.size() + moved.size();
+
     // Process the diff: delete from images and disk, add to disk.
     // Delete all the thumbnails associated with URLs that were deleted.
     for (size_t i = 0; i < deleted.size(); i++) {
       MostVisitedURL deleted_url = top_sites_[deleted[i]];
       std::map<GURL, Images>::iterator found =
           top_images_.find(deleted_url.url);
       if (found != top_images_.end())
         top_images_.erase(found);
 
       // Delete from disk.
@@ skipping 102 matching lines @@
   for (std::map<GURL, size_t>::const_iterator i = all_old_urls.begin();
        i != all_old_urls.end(); ++i) {
     if (i->second != kAlreadyFoundMarker)
       deleted_urls->push_back(i->second);
   }
 }
 
 void TopSites::StartQueryForMostVisited() {
   if (mock_history_service_) {
     // Testing with a mockup.
-    // QuerySegmentUsageSince is not virtual, so we have to duplicate the code.
+    // QueryMostVisitedURLs is not virtual, so we have to duplicate the code.
     mock_history_service_->QueryMostVisitedURLs(
         kTopSitesNumber,
         kDaysOfHistory,
         &cancelable_consumer_,
         NewCallback(this, &TopSites::OnTopSitesAvailable));
   } else {
     HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
     // |hs| may be null during unit tests.
     if (hs) {
       hs->QueryMostVisitedURLs(
           kTopSitesNumber,
           kDaysOfHistory,
           &cancelable_consumer_,
           NewCallback(this, &TopSites::OnTopSitesAvailable));
     } else {
       LOG(INFO) << "History Service not available.";
     }
   }
+
+  timer_.Stop();
+  timer_.Start(GetUpdateDelay(), this,
+               &TopSites::StartQueryForMostVisited);
+}
+
+base::TimeDelta TopSites::GetUpdateDelay() {
+  int64 range = kMaxUpdateIntervalMinutes - kMinUpdateIntervalMinutes;
+  int64 minutes = kMaxUpdateIntervalMinutes -
+      last_num_urls_changed_ * range / kTopSitesNumber;
+  return base::TimeDelta::FromMinutes(minutes);
 }
 
 void TopSites::OnTopSitesAvailable(
     CancelableRequestProvider::Handle handle,
     MostVisitedURLList pages) {
   AutoLock lock(lock_);
   UpdateMostVisited(&pages);
 }
 
 void TopSites::SetMockHistoryService(MockHistoryService* mhs) {
   mock_history_service_ = mhs;
 }
 
+void TopSites::Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) {
+  if (type != NotificationType::HISTORY_URLS_DELETED) {
+    NOTREACHED();
+    return;
+  }
+
+  Details<history::URLsDeletedDetails> deleted_details(details);
+  if (deleted_details->all_history) {
+    db_.reset(new TopSitesDatabaseImpl());
+    // TODO(nshkrob): delete file in background (FILE) thread.
+    file_util::Delete(db_path_, false);
+    if (!db_->Init(db_path_)) {
+      NOTREACHED() << "Failed to initialize database.";
+      return;
+    }
+  }
+  StartQueryForMostVisited();
+}
+
 }  // namespace history