Add pyauto hook for getting and manipulating the data underneath the NTP.

chrome/browser/history/top_sites.cc

 // Copyright (c) 2010 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 <set>
 
 #include "app/l10n_util.h"
@@ skipping 118 matching lines @@
 TopSites::TopSites(Profile* profile)
     : backend_(new TopSitesBackend()),
       cache_(new TopSitesCache()),
       thread_safe_cache_(new TopSitesCache()),
       profile_(profile),
       last_num_urls_changed_(0),
       blacklist_(NULL),
       pinned_urls_(NULL),
       history_state_(HISTORY_LOADING),
       top_sites_state_(TOP_SITES_LOADING),
-      loaded_(false) {
+      loaded_(false),
+      handle_to_wait_for_(NULL) {
   if (!profile_)
     return;
 
   if (NotificationService::current()) {
     registrar_.Add(this, NotificationType::HISTORY_URLS_DELETED,
                    Source<Profile>(profile_));
     registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                    NotificationService::AllSources());
   }
 
@@ skipping 283 matching lines @@
 
   // Any member without the special marker in the all_old_urls list means that
   // there wasn't a "new" URL that mapped to it, so it was deleted.
   for (std::map<GURL, size_t>::const_iterator i = all_old_urls.begin();
        i != all_old_urls.end(); ++i) {
     if (i->second != kAlreadyFoundMarker)
       delta->deleted.push_back(old_list[i->second]);
   }
 }
 
+void TopSites::RefreshAndCallback(Callback0::Type* callback) {
+  if (refresh_callback_.get()) {
+    DLOG(ERROR) << "Waiting for refresh before previous refresh finished";
+    return;
+  }
+  refresh_callback_.reset(callback);
+  handle_to_wait_for_ = StartQueryForMostVisited();
+}
+
 TopSites::~TopSites() {
 }
 
 bool TopSites::SetPageThumbnailNoDB(const GURL& url,
                                     const RefCountedBytes* thumbnail_data,
                                     const ThumbnailScore& score) {
   // This should only be invoked when we know about the url.
   DCHECK(cache_->IsKnownURL(url));
 
   const MostVisitedURL& most_visited =
@@ skipping 73 matching lines @@
   if (temp_images_.size() == kMaxTempTopImages)
     temp_images_.erase(temp_images_.begin());
 
   TempImage image;
   image.first = url;
   image.second.thumbnail = const_cast<RefCountedBytes*>(thumbnail);
   image.second.thumbnail_score = score;
   temp_images_.push_back(image);
 }
 
-void TopSites::StartQueryForMostVisited() {
+CancelableRequestProvider::Handle TopSites::StartQueryForMostVisited() {
   if (!profile_)
-    return;
+    return NULL;
 
+  CancelableRequestProvider::Handle request_handle = NULL;
   HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   // |hs| may be null during unit tests.
   if (hs) {
-    hs->QueryMostVisitedURLs(
+    request_handle = hs->QueryMostVisitedURLs(
         num_results_to_request_from_history(),
         kDaysOfHistory,
         &cancelable_consumer_,
         NewCallback(this, &TopSites::OnTopSitesAvailableFromHistory));
   }
+  return request_handle;
+}
+
+void TopSites::TimerFired() {
+  StartQueryForMostVisited();
 }
 
 // static
 int TopSites::GetRedirectDistanceForURL(const MostVisitedURL& most_visited,
                                         const GURL& url) {
   for (size_t i = 0; i < most_visited.redirects.size(); i++) {
     if (most_visited.redirects[i] == url)
       return static_cast<int>(most_visited.redirects.size() - i - 1);
   }
   NOTREACHED() << "URL should always be found.";
@@ skipping 278 matching lines @@
 }
 
 void TopSites::RestartQueryForTopSitesTimer(base::TimeDelta delta) {
   if (timer_.IsRunning() && ((timer_start_time_ + timer_.GetCurrentDelay()) <
                              (base::TimeTicks::Now() + delta))) {
     return;
   }
 
   timer_start_time_ = base::TimeTicks::Now();
   timer_.Stop();
-  timer_.Start(delta, this, &TopSites::StartQueryForMostVisited);
+  timer_.Start(delta, this, &TopSites::TimerFired);
 }
 
 void TopSites::OnHistoryMigrationWrittenToDisk(TopSitesBackend::Handle handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!profile_)
     return;
 
   HistoryService* history =
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
@@ skipping 37 matching lines @@
       // finishes loading we'll do migration and/or move to loaded.
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
     }
   }
 }
 
 void TopSites::OnTopSitesAvailableFromHistory(
     CancelableRequestProvider::Handle handle,
     MostVisitedURLList pages) {
   SetTopSites(pages);
+
+  // For testing only. Invoke the testing callback if this is the handle to the
+  // request that is being waited upon.
+  if (handle == handle_to_wait_for_) {
+    handle_to_wait_for_ = NULL;
+    // Invoke the callback after this empty request goes through the backend, to
+    // ensure that the database is updated.
+    backend_->DoEmptyRequest(
+        &cancelable_consumer_,
+        NewCallback(this, &TopSites::InvokeRefreshCallback));
+  }
+}
+
+void TopSites::InvokeRefreshCallback(CancelableRequestProvider::Handle handle) {
+  if (refresh_callback_.get()) {
+    refresh_callback_->Run();
+    refresh_callback_.reset();
+  } else {
+    LOG(DFATAL) << "refresh callback was not set";
+  }
 }
 
 }  // namespace history