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 "app/l10n_util.h"
 #include "base/command_line.h"
@@ skipping 33 matching lines @@
 static const int64 kMinUpdateIntervalMinutes = 1;
 static const int64 kMaxUpdateIntervalMinutes = 60;
 
 
 TopSites::TopSites(Profile* profile) : profile_(profile),
                                        mock_history_service_(NULL),
                                        last_num_urls_changed_(0),
                                        migration_in_progress_(false),
                                        waiting_for_results_(true),
                                        blacklist_(NULL),
-                                       pinned_urls_(NULL) {
+                                       pinned_urls_(NULL),
+                                       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 18 matching lines @@
   if (!db_->Init(db_name)) {
     NOTREACHED() << "Failed to initialize database.";
     return;
   }
 
   ChromeThread::PostTask(ChromeThread::DB, FROM_HERE, NewRunnableMethod(
       this, &TopSites::ReadDatabase));
 
   // Start the one-shot timer.
   timer_.Start(base::TimeDelta::FromSeconds(kUpdateIntervalSecs), this,
-               &TopSites::StartQueryForMostVisited);
+               &TopSites::TimerFired);
 }
 
 void TopSites::ReadDatabase() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::DB));
   std::map<GURL, Images> thumbnails;
 
   DCHECK(db_.get());
   MostVisitedURLList top_urls;
   db_->GetPageThumbnails(&top_urls, &thumbnails);
   MostVisitedURLList copy(top_urls);  // StoreMostVisited destroys the list.
@@ skipping 338 matching lines @@
       }
     }
   }
 
   // If we are not expecting any thumbnails, migration is done.
   if (migration_in_progress_ && migration_pending_urls_.empty())
     OnMigrationDone();
 
   timer_.Stop();
   timer_.Start(GetUpdateDelay(), this,
-               &TopSites::StartQueryForMostVisited);
+               &TopSites::TimerFired);
 }
 
 void TopSites::OnMigrationDone() {
   migration_in_progress_ = false;
   if (!profile_)
     return;
 
   HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   // |hs| may be null during unit tests.
   if (!hs)
@@ skipping 168 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)
       deleted_urls->push_back(i->second);
   }
 }
 
-void TopSites::StartQueryForMostVisited() {
+CancelableRequestProvider::Handle TopSites::StartQueryForMostVisited() {
+  CancelableRequestProvider::Handle request_handle = NULL;
   if (mock_history_service_) {
     // Testing with a mockup.
     // QueryMostVisitedURLs is not virtual, so we have to duplicate the code.
-    mock_history_service_->QueryMostVisitedURLs(
+    request_handle = mock_history_service_->QueryMostVisitedURLs(
         kTopSitesNumber + blacklist_->size(),
         kDaysOfHistory,
         &cancelable_consumer_,
         NewCallback(this, &TopSites::OnTopSitesAvailable));
-  } else {
-    if (!profile_)
-      return;
-
+  } else if (profile_) {
     HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
     // |hs| may be null during unit tests.
     if (hs) {
-      hs->QueryMostVisitedURLs(
+      request_handle = hs->QueryMostVisitedURLs(
           kTopSitesNumber + blacklist_->size(),
           kDaysOfHistory,
           &cancelable_consumer_,
           NewCallback(this, &TopSites::OnTopSitesAvailable));
     } else {
       LOG(INFO) << "History Service not available.";
     }
   }
+  return request_handle;
+}
+
+void TopSites::TimerFired() {
+  StartQueryForMostVisited();
 }
 
 void TopSites::StartMigration() {
   LOG(INFO) << "Starting migration to TopSites.";
   migration_in_progress_ = true;
   StartQueryForMostVisited();
   MigratePinnedURLs();
 }
 
 bool TopSites::HasBlacklistedItems() const {
@@ skipping 77 matching lines @@
   if (ChromeThread::IsWellKnownThread(ChromeThread::UI)) {
     ptr = NULL;
   } else {
     // Need to roll our own UI thread.
     ChromeThread ui_loop(ChromeThread::UI, MessageLoop::current());
     ptr = NULL;
     MessageLoop::current()->RunAllPending();
   }
 }
 
+void TopSites::RefreshAndCallback(CancelableRequestConsumer* consumer,
+                                  Callback0::Type* callback) {
+  if (refresh_callback_) {
+    DLOG(ERROR) << "Waiting for refresh before previous refresh finished";
+    return;
+  }
+  scoped_refptr<CancelableRequest<Callback0::Type> > request(
+      new CancelableRequest<Callback0::Type>(callback));
+  AddRequest(request, consumer);
+  refresh_callback_ = request;
+  handle_to_wait_for_ = StartQueryForMostVisited();
+}
+
 void TopSites::ClearProfile() {
   profile_ = NULL;
 }
 
 base::TimeDelta TopSites::GetUpdateDelay() {
   AutoLock lock(lock_);
   if (top_sites_.size() == 0)
     return base::TimeDelta::FromSeconds(30);
 
   int64 range = kMaxUpdateIntervalMinutes - kMinUpdateIntervalMinutes;
   int64 minutes = kMaxUpdateIntervalMinutes -
       last_num_urls_changed_ * range / top_sites_.size();
   return base::TimeDelta::FromMinutes(minutes);
 }
 
 void TopSites::OnTopSitesAvailable(
     CancelableRequestProvider::Handle handle,
     MostVisitedURLList pages) {
   AddPrepopulatedPages(&pages);
   ChromeThread::PostTask(ChromeThread::DB, FROM_HERE, NewRunnableMethod(
       this, &TopSites::UpdateMostVisited, pages));
+
+  if (handle == handle_to_wait_for_) {
+    if (ChromeThread::IsWellKnownThread(ChromeThread::UI)) {
+      DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+      // Posting this task after the one above should guarantee that
+      // |top_sites_| is completely refreshed.
+      ChromeThread::PostTask(ChromeThread::DB, FROM_HERE, NewRunnableMethod(
+          this, &TopSites::InvokeRefreshCallback));
+    } else {
+      // This will happen in unit tests when we don't have a real UI thread.
+      InvokeRefreshCallbackOnUIThread();
+    }
+  }
 }
 
 // static
 void TopSites::ProcessPendingCallbacks(PendingCallbackSet pending_callbacks,
                                        const MostVisitedURLList& urls) {
   PendingCallbackSet::iterator i;
   for (i = pending_callbacks.begin();
        i != pending_callbacks.end(); ++i) {
     scoped_refptr<CancelableRequest<GetTopSitesCallback> > request = *i;
     if (!request->canceled())
@@ skipping 92 matching lines @@
 void TopSites::ResetDatabase() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::DB));
   db_.reset(new TopSitesDatabaseImpl());
   file_util::Delete(db_path_, false);
   if (!db_->Init(db_path_)) {
     NOTREACHED() << "Failed to initialize database.";
     return;
   }
 }
 
+void TopSites::InvokeRefreshCallback() {
+  ChromeThread::PostTask(ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(this, &TopSites::InvokeRefreshCallbackOnUIThread));
+}
+
+void TopSites::InvokeRefreshCallbackOnUIThread() {
+  if (refresh_callback_) {
+    if (!refresh_callback_->canceled())
+      refresh_callback_->ForwardResult(Callback0::Type::TupleType());
+    refresh_callback_.release();
+  } else {
+    LOG(DFATAL) << "No refresh callback was set.";
+  }
+}
+
 }  // namespace history