Add code to keep track of what fraction of pageviews are top sites.

chrome/browser/prerender/prerender_manager.cc

 // Copyright (c) 2011 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/prerender/prerender_manager.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
+#include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/prerender/prerender_condition.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_histograms.h"
 #include "chrome/browser/prerender/prerender_history.h"
 #include "chrome/browser/prerender/prerender_observer.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/prerender/prerender_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper_delegate.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/browser_thread.h"
+#include "content/browser/cancelable_request.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/render_view_host_manager.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
+#include "content/common/notification_observer.h"
+#include "content/common/notification_registrar.h"
 #include "content/common/notification_service.h"
 
 namespace prerender {
 
 namespace {
 
 // Time window for which we will record windowed PLT's from the last
 // observed link rel=prefetch tag.
 const int kWindowDurationSeconds = 30;
 
@@ skipping 110 matching lines @@
   PendingContentsData(const GURL& url,
                       const GURL& referrer,
                       Origin origin)
       : url_(url), referrer_(referrer), origin_(origin) { }
   ~PendingContentsData() {}
   GURL url_;
   GURL referrer_;
   Origin origin_;
 };
 
+class PrerenderManager::MostVisitedSites : public NotificationObserver {
+ public:
+  explicit MostVisitedSites(Profile* profile) :
+      profile_(profile) {
+    // If TopSites is already loaded, we will want to use it right away.
+    // Otherwise, wait for three seconds to avoid race conditions.
+    // This is a hack to ensure unit tests don't fail.
+    // See http://crbug.com/94654

[jar (doing other things), 2011/09/01 18:14:52]

Any time you have to wait for something like 3 seconds to assure the unit tests
won't crash, you know you are doing something wrong.  This is generally
guaranteed to create a flaky test, as bots regularly stall for more than 3
seconds (which will mean that your delay will have been for naught).

It also shows that you haven't properly sequenced your code to wait for proper
initialization in other areas... which hints at an even larger problem.

+    if (profile && profile->GetTopSitesWithoutCreating()) {
+      Init();
+    } else {
+      timer_.Start(base::TimeDelta::FromSeconds(3), this,
+                   &prerender::PrerenderManager::MostVisitedSites::Init);
+    }
+  }
+
+  void Init() {
+    history::TopSites* top_sites = GetTopSites();
+    if (top_sites) {
+      registrar_.Add(this, chrome::NOTIFICATION_TOP_SITES_CHANGED,
+                     Source<history::TopSites>(top_sites));
+    }
+
+    UpdateMostVisited();
+  }
+
+  void UpdateMostVisited() {
+    history::TopSites* top_sites = GetTopSites();
+    if (top_sites) {
+      top_sites->GetMostVisitedURLs(
+          &topsites_consumer_,
+          NewCallback(this,
+                      &prerender::PrerenderManager::MostVisitedSites::
+                      OnMostVisitedURLsAvailable));
+    }
+  }
+
+  void OnMostVisitedURLsAvailable(const history::MostVisitedURLList& data) {
+    urls_.clear();
+    for (int i = 0; i < static_cast<int>(data.size()); i++)
+      urls_.insert(data[i].url);
+  }
+
+  void Observe(int type,
+               const NotificationSource& source,
+               const NotificationDetails& details) {
+    DCHECK_EQ(type, chrome::NOTIFICATION_TOP_SITES_CHANGED);
+    UpdateMostVisited();
+  }
+
+  bool IsTopSite(const GURL& url) const {
+    return (urls_.count(url) > 0);
+  }
+
+ private:
+  history::TopSites* GetTopSites() const {
+    if (profile_)
+      return profile_->GetTopSites();
+    return NULL;
+  }
+
+  CancelableRequestConsumer topsites_consumer_;
+  Profile* profile_;
+  NotificationRegistrar registrar_;
+  std::set<GURL> urls_;
+  base::OneShotTimer<prerender::PrerenderManager::MostVisitedSites> timer_;
+};
+
+bool PrerenderManager::IsTopSite(const GURL& url) const {
+  DCHECK(most_visited_.get());
+  return most_visited_->IsTopSite(url);
+}
+
 PrerenderManager::PrerenderManager(Profile* profile,
                                    PrerenderTracker* prerender_tracker)
     : enabled_(true),
       profile_(profile),
       prerender_tracker_(prerender_tracker),
       prerender_contents_factory_(PrerenderContents::CreateFactory()),
       last_prerender_start_time_(GetCurrentTimeTicks() -
           base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs)),
       runnable_method_factory_(this),
       prerender_history_(new PrerenderHistory(kHistoryLength)),
-      histograms_(new PrerenderHistograms()) {
+      histograms_(new PrerenderHistograms()),
+      most_visited_(new MostVisitedSites(profile)) {
   // There are some assumptions that the PrerenderManager is on the UI thread.
   // Any other checks simply make sure that the PrerenderManager is accessed on
   // the same thread that it was created on.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 PrerenderManager::~PrerenderManager() {
   DestroyAllContents(FINAL_STATUS_MANAGER_SHUTDOWN);
   STLDeleteElements(&prerender_conditions_);
 }
@@ skipping 763 matching lines @@
   DeletePendingDeleteEntries();
 }
 
 void PrerenderManager::RecordFinalStatus(Origin origin,
                                          uint8 experiment_id,
                                          FinalStatus final_status) const {
   histograms_->RecordFinalStatus(origin, experiment_id, final_status);
 }
 
 }  // namespace prerender