Remove PrerenderLocalPredictor, part 1.

chrome/browser/prerender/prerender_manager.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/prerender/prerender_manager.h"
 
 #include <algorithm>
 #include <functional>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
-#include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
-#include "base/prefs/pref_service.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/net/chrome_cookie_notification_details.h"
 #include "chrome/browser/net/prediction_options.h"
-#include "chrome/browser/predictors/predictor_database.h"
-#include "chrome/browser/predictors/predictor_database_factory.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_histograms.h"
 #include "chrome/browser/prerender/prerender_history.h"
-#include "chrome/browser/prerender/prerender_local_predictor.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/prerender/prerender_tab_helper.h"
 #include "chrome/browser/prerender/prerender_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/prerender_messages.h"
 #include "chrome/common/prerender_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/common/constants.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 using content::RenderViewHost;
 using content::SessionStorageNamespace;
 using content::WebContents;
-using predictors::LoggedInPredictorTable;
 
 namespace prerender {
 
 namespace {
 
 // Time interval at which periodic cleanups are performed.
 const int kPeriodicCleanupIntervalMs = 1000;
 
 // Valid HTTP methods for prerendering.
 const char* const kValidHttpMethods[] = {
@@ skipping 33 matching lines @@
       final_status != FINAL_STATUS_WINDOW_OPENER &&
       final_status != FINAL_STATUS_CACHE_OR_HISTORY_CLEARED &&
       final_status != FINAL_STATUS_CANCELLED &&
       final_status != FINAL_STATUS_DEVTOOLS_ATTACHED &&
       final_status != FINAL_STATUS_CROSS_SITE_NAVIGATION_PENDING &&
       final_status != FINAL_STATUS_PAGE_BEING_CAPTURED &&
       final_status != FINAL_STATUS_NAVIGATION_UNCOMMITTED &&
       final_status != FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE;
 }
 
-void CheckIfCookiesExistForDomainResultOnUIThread(
-    const net::CookieMonster::HasCookiesForETLDP1Callback& callback,
-    bool cookies_exist) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  callback.Run(cookies_exist);
-}
-
-void CheckIfCookiesExistForDomainResultOnIOThread(
-    const net::CookieMonster::HasCookiesForETLDP1Callback& callback,
-    bool cookies_exist) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&CheckIfCookiesExistForDomainResultOnUIThread,
-                 callback,
-                 cookies_exist));
-}
-
-void CheckIfCookiesExistForDomainOnIOThread(
-    net::URLRequestContextGetter* rq_context,
-    const std::string& domain_key,
-    const net::CookieMonster::HasCookiesForETLDP1Callback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::CookieStore* cookie_store =
-      rq_context->GetURLRequestContext()->cookie_store();
-  cookie_store->GetCookieMonster()->HasCookiesForETLDP1Async(
-      domain_key,
-      base::Bind(&CheckIfCookiesExistForDomainResultOnIOThread, callback));
-}
-
 }  // namespace
 
 class PrerenderManager::OnCloseWebContentsDeleter
     : public content::WebContentsDelegate,
       public base::SupportsWeakPtr<
           PrerenderManager::OnCloseWebContentsDeleter> {
  public:
   OnCloseWebContentsDeleter(PrerenderManager* manager,
                             WebContents* tab)
       : manager_(manager),
@@ skipping 67 matching lines @@
           base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs)),
       prerender_history_(new PrerenderHistory(kHistoryLength)),
       histograms_(new PrerenderHistograms()),
       profile_network_bytes_(0),
       last_recorded_profile_network_bytes_(0) {
   // 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));
 
-  if (IsLocalPredictorEnabled())
-    local_predictor_.reset(new PrerenderLocalPredictor(this));
-
-  if (IsLoggedInPredictorEnabled() && !profile_->IsOffTheRecord()) {
-    predictors::PredictorDatabase* predictor_db =
-        predictors::PredictorDatabaseFactory::GetForProfile(profile);
-    if (predictor_db) {
-      logged_in_predictor_table_ = predictor_db->logged_in_table();
-      scoped_ptr<LoggedInStateMap> new_state_map(new LoggedInStateMap);
-      LoggedInStateMap* new_state_map_ptr = new_state_map.get();
-      BrowserThread::PostTaskAndReply(
-          BrowserThread::DB, FROM_HERE,
-          base::Bind(&LoggedInPredictorTable::GetAllData,
-                     logged_in_predictor_table_,
-                     new_state_map_ptr),
-          base::Bind(&PrerenderManager::LoggedInPredictorDataReceived,
-                     AsWeakPtr(),
-                     base::Passed(&new_state_map)));
-    }
-  }
-
   // Certain experiments override our default config_ values.
   switch (PrerenderManager::GetMode()) {
     case PrerenderManager::PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP:
       config_.max_link_concurrency = 4;
       config_.max_link_concurrency_per_launcher = 2;
       break;
     case PrerenderManager::PRERENDER_MODE_EXPERIMENT_15MIN_TTL_GROUP:
       config_.time_to_live = base::TimeDelta::FromMinutes(15);
       break;
     default:
       break;
   }
 
   notification_registrar_.Add(
-      this, chrome::NOTIFICATION_COOKIE_CHANGED,
-      content::NotificationService::AllBrowserContextsAndSources());
-
-  notification_registrar_.Add(
       this, chrome::NOTIFICATION_PROFILE_DESTROYED,
       content::Source<Profile>(profile_));
 
   MediaCaptureDevicesDispatcher::GetInstance()->AddObserver(this);
 }
 
 PrerenderManager::~PrerenderManager() {
   MediaCaptureDevicesDispatcher::GetInstance()->RemoveObserver(this);
 
   // The earlier call to KeyedService::Shutdown() should have
   // emptied these vectors already.
   DCHECK(active_prerenders_.empty());
   DCHECK(to_delete_prerenders_.empty());
 
   for (PrerenderProcessSet::const_iterator it =
            prerender_process_hosts_.begin();
        it != prerender_process_hosts_.end();
        ++it) {
     (*it)->RemoveObserver(this);
   }
 }
 
 void PrerenderManager::Shutdown() {
   DestroyAllContents(FINAL_STATUS_MANAGER_SHUTDOWN);
   on_close_web_contents_deleters_.clear();
-  // Must happen before |profile_| is set to NULL as
-  // |local_predictor_| accesses it.
-  if (local_predictor_)
-    local_predictor_->Shutdown();
   profile_ = NULL;
 
   DCHECK(active_prerenders_.empty());
 }
 
 PrerenderHandle* PrerenderManager::AddPrerenderFromLinkRelPrerender(
     int process_id,
     int route_id,
     const GURL& url,
     const uint32 rel_types,
@@ skipping 29 matching lines @@
 PrerenderHandle* PrerenderManager::AddPrerenderFromOmnibox(
     const GURL& url,
     SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
   if (!IsOmniboxEnabled(profile_))
     return NULL;
   return AddPrerender(ORIGIN_OMNIBOX, url, content::Referrer(), size,
                       session_storage_namespace);
 }
 
-PrerenderHandle* PrerenderManager::AddPrerenderFromLocalPredictor(
-    const GURL& url,
-    SessionStorageNamespace* session_storage_namespace,
-    const gfx::Size& size) {
-  return AddPrerender(ORIGIN_LOCAL_PREDICTOR, url, content::Referrer(),
-                      size, session_storage_namespace);
-}
-
 PrerenderHandle* PrerenderManager::AddPrerenderFromExternalRequest(
     const GURL& url,
     const content::Referrer& referrer,
     SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
   return AddPrerender(ORIGIN_EXTERNAL_REQUEST, url, referrer, size,
                       session_storage_namespace);
 }
 
 PrerenderHandle* PrerenderManager::AddPrerenderForInstant(
@@ skipping 275 matching lines @@
   if (!IsEnabled())
     return;
 
   histograms_->RecordPerceivedPageLoadTime(
       origin, perceived_page_load_time, navigation_type, url);
 
   if (navigation_type == NAVIGATION_TYPE_PRERENDERED) {
     histograms_->RecordPercentLoadDoneAtSwapin(
         origin, fraction_plt_elapsed_at_swap_in);
   }
-  if (local_predictor_) {
-    local_predictor_->OnPLTEventForURL(url, perceived_page_load_time);
-  }
 }
 
 // static
 PrerenderManager::PrerenderManagerMode PrerenderManager::GetMode() {
   return mode_;
 }
 
 // static
 void PrerenderManager::SetMode(PrerenderManagerMode mode) {
   mode_ = mode;
@@ skipping 391 matching lines @@
 
   last_prerender_start_time_ = GetCurrentTimeTicks();
 
   gfx::Size contents_size =
       size.IsEmpty() ? config_.default_tab_bounds.size() : size;
 
   prerender_contents->StartPrerendering(contents_size,
                                         session_storage_namespace);
 
   DCHECK(IsControlGroup(experiment) ||
-         prerender_contents->prerendering_has_started() ||
-         (origin == ORIGIN_LOCAL_PREDICTOR &&
-          IsLocalPredictorPrerenderAlwaysControlEnabled()));
+         prerender_contents->prerendering_has_started());
 
   if (GetMode() == PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP)
     histograms_->RecordConcurrency(active_prerenders_.size());
 
   StartSchedulingPeriodicCleanups();
   return prerender_handle;
 }
 
 void PrerenderManager::StartSchedulingPeriodicCleanups() {
   DCHECK(CalledOnValidThread());
@@ skipping 49 matching lines @@
 
 void PrerenderManager::PostCleanupTask() {
   DCHECK(CalledOnValidThread());
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PrerenderManager::PeriodicCleanup, AsWeakPtr()));
 }
 
 base::TimeTicks PrerenderManager::GetExpiryTimeForNewPrerender(
     Origin origin) const {
-  base::TimeDelta ttl = config_.time_to_live;
-  if (origin == ORIGIN_LOCAL_PREDICTOR)
-    ttl = base::TimeDelta::FromSeconds(GetLocalPredictorTTLSeconds());
-  return GetCurrentTimeTicks() + ttl;
+  return GetCurrentTimeTicks() + config_.time_to_live;
 }
 
 base::TimeTicks PrerenderManager::GetExpiryTimeForNavigatedAwayPrerender()
     const {
   return GetCurrentTimeTicks() + config_.abandon_time_to_live;
 }
 
 void PrerenderManager::DeleteOldEntries() {
   DCHECK(CalledOnValidThread());
   while (!active_prerenders_.empty()) {
@@ skipping 52 matching lines @@
   return active_prerenders_.end();
 }
 
 bool PrerenderManager::DoesRateLimitAllowPrerender(Origin origin) const {
   DCHECK(CalledOnValidThread());
   base::TimeDelta elapsed_time =
       GetCurrentTimeTicks() - last_prerender_start_time_;
   histograms_->RecordTimeBetweenPrerenderRequests(origin, elapsed_time);
   if (!config_.rate_limit_enabled)
     return true;
-  // The LocalPredictor may issue multiple prerenders simultaneously (if so
-  // configured), so no throttling.
-  if (origin == ORIGIN_LOCAL_PREDICTOR)
-    return true;
   return elapsed_time >=
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
 }
 
 void PrerenderManager::DeleteOldWebContents() {
   while (!old_web_contents_list_.empty()) {
     WebContents* web_contents = old_web_contents_list_.front();
     old_web_contents_list_.pop_front();
     // TODO(dominich): should we use Instant Unload Handler here?
     delete web_contents;
@@ skipping 77 matching lines @@
   RecordFinalStatusWithMatchCompleteStatus(
       origin, experiment_id,
       PrerenderContents::MATCH_COMPLETE_DEFAULT,
       final_status);
 }
 
 void PrerenderManager::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_COOKIE_CHANGED: {
-      Profile* profile = content::Source<Profile>(source).ptr();
-      if (!profile || !profile_->IsSameProfile(profile) ||
-          profile->IsOffTheRecord()) {
-        return;
-      }
-      CookieChanged(content::Details<ChromeCookieDetails>(details).ptr());
-      break;
-    }
     case chrome::NOTIFICATION_PROFILE_DESTROYED:
       DestroyAllContents(FINAL_STATUS_PROFILE_DESTROYED);
       on_close_web_contents_deleters_.clear();
       break;
     default:
       NOTREACHED() << "Unexpected notification sent.";
       break;
   }
 }
 
 void PrerenderManager::OnCreatingAudioStream(int render_process_id,
                                              int render_frame_id) {
   content::RenderFrameHost* render_frame_host =
       content::RenderFrameHost::FromID(render_process_id, render_frame_id);
   WebContents* tab = WebContents::FromRenderFrameHost(render_frame_host);
   if (!tab)
     return;
 
   PrerenderContents* prerender_contents = GetPrerenderContents(tab);
   if (!prerender_contents)
     return;
 
   prerender_contents->Destroy(prerender::FINAL_STATUS_CREATING_AUDIO_STREAM);
 }
 
-void PrerenderManager::RecordLikelyLoginOnURL(const GURL& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!url.SchemeIsHTTPOrHTTPS())
-    return;
-  if (logged_in_predictor_table_.get()) {
-    BrowserThread::PostTask(
-        BrowserThread::DB,
-        FROM_HERE,
-        base::Bind(&LoggedInPredictorTable::AddDomainFromURL,
-                   logged_in_predictor_table_,
-                   url));
-  }
-  std::string key = LoggedInPredictorTable::GetKey(url);
-  if (!logged_in_state_.get())
-    return;
-  if (logged_in_state_->count(key))
-    return;
-  (*logged_in_state_)[key] = base::Time::Now().ToInternalValue();
-}
-
-void PrerenderManager::CheckIfLikelyLoggedInOnURL(
-    const GURL& url,
-    bool* lookup_result,
-    bool* database_was_present,
-    const base::Closure& result_cb) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!logged_in_predictor_table_.get()) {
-    *database_was_present = false;
-    *lookup_result = false;
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, result_cb);
-    return;
-  }
-  BrowserThread::PostTaskAndReply(
-      BrowserThread::DB, FROM_HERE,
-      base::Bind(&LoggedInPredictorTable::HasUserLoggedIn,
-                 logged_in_predictor_table_,
-                 url,
-                 lookup_result,
-                 database_was_present),
-      result_cb);
-}
-
-
-void PrerenderManager::CookieChanged(ChromeCookieDetails* details) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (!logged_in_predictor_table_.get())
-    return;
-
-  // We only care when a cookie has been removed.
-  if (!details->removed)
-    return;
-
-  std::string domain_key =
-      LoggedInPredictorTable::GetKeyFromDomain(details->cookie->Domain());
-
-  // If we have no record of this domain as a potentially logged in domain,
-  // nothing to do here.
-  if (logged_in_state_.get() && logged_in_state_->count(domain_key) < 1)
-    return;
-
-  net::URLRequestContextGetter* rq_context = profile_->GetRequestContext();
-  if (!rq_context)
-    return;
-
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&CheckIfCookiesExistForDomainOnIOThread,
-                 base::Unretained(rq_context),
-                 domain_key,
-                 base::Bind(
-                     &PrerenderManager::CookieChangedAnyCookiesLeftLookupResult,
-                     AsWeakPtr(),
-                     domain_key)
-                 ));
-}
-
-void PrerenderManager::CookieChangedAnyCookiesLeftLookupResult(
-    const std::string& domain_key,
-    bool cookies_exist) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (cookies_exist)
-    return;
-
-  if (logged_in_predictor_table_.get()) {
-    BrowserThread::PostTask(BrowserThread::DB,
-                            FROM_HERE,
-                            base::Bind(&LoggedInPredictorTable::DeleteDomain,
-                                       logged_in_predictor_table_,
-                                       domain_key));
-  }
-
-  if (logged_in_state_.get())
-    logged_in_state_->erase(domain_key);
-}
-
-void PrerenderManager::LoggedInPredictorDataReceived(
-    scoped_ptr<LoggedInStateMap> new_map) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  logged_in_state_.swap(new_map);
-}
-
 void PrerenderManager::RecordNetworkBytes(Origin origin,
                                           bool used,
                                           int64 prerender_bytes) {
   if (!ActuallyPrerendering())
     return;
   int64 recent_profile_bytes =
       profile_network_bytes_ - last_recorded_profile_network_bytes_;
   last_recorded_profile_network_bytes_ = profile_network_bytes_;
   DCHECK_GE(recent_profile_bytes, 0);
   histograms_->RecordNetworkBytes(
@@ skipping 31 matching lines @@
 }
 
 void PrerenderManager::RenderProcessHostDestroyed(
     content::RenderProcessHost* host) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   size_t erased = prerender_process_hosts_.erase(host);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace prerender