chrome/browser/prerender/prerender_manager.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/prerender/prerender_manager.h"
   6
   7 #include <algorithm>
   8 #include <functional>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/bind_helpers.h"
  14 #include "base/logging.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/metrics/histogram.h"
  17 #include "base/prefs/pref_service.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/time/time.h"
  20 #include "base/timer/elapsed_timer.h"
  21 #include "base/values.h"
  22 #include "chrome/browser/browser_process.h"
  23 #include "chrome/browser/chrome_notification_types.h"
  24 #include "chrome/browser/history/history_service_factory.h"
  25 #include "chrome/browser/net/chrome_cookie_notification_details.h"
  26 #include "chrome/browser/net/prediction_options.h"
  27 #include "chrome/browser/predictors/predictor_database.h"
  28 #include "chrome/browser/predictors/predictor_database_factory.h"
  29 #include "chrome/browser/prerender/prerender_contents.h"
  30 #include "chrome/browser/prerender/prerender_field_trial.h"
  31 #include "chrome/browser/prerender/prerender_final_status.h"
  32 #include "chrome/browser/prerender/prerender_handle.h"
  33 #include "chrome/browser/prerender/prerender_histograms.h"
  34 #include "chrome/browser/prerender/prerender_history.h"
  35 #include "chrome/browser/prerender/prerender_local_predictor.h"
  36 #include "chrome/browser/prerender/prerender_manager_factory.h"
  37 #include "chrome/browser/prerender/prerender_tab_helper.h"
  38 #include "chrome/browser/prerender/prerender_tracker.h"
  39 #include "chrome/browser/prerender/prerender_util.h"
  40 #include "chrome/browser/profiles/profile.h"
  41 #include "chrome/browser/search/search.h"
  42 #include "chrome/browser/tab_contents/tab_util.h"
  43 #include "chrome/browser/ui/browser_navigator.h"
  44 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
  45 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
  46 #include "chrome/common/chrome_switches.h"
  47 #include "chrome/common/pref_names.h"
  48 #include "chrome/common/prerender_messages.h"
  49 #include "chrome/common/prerender_types.h"
  50 #include "content/public/browser/browser_thread.h"
  51 #include "content/public/browser/devtools_agent_host.h"
  52 #include "content/public/browser/navigation_controller.h"
  53 #include "content/public/browser/notification_service.h"
  54 #include "content/public/browser/notification_source.h"
  55 #include "content/public/browser/render_frame_host.h"
  56 #include "content/public/browser/render_process_host.h"
  57 #include "content/public/browser/render_view_host.h"
  58 #include "content/public/browser/resource_request_details.h"
  59 #include "content/public/browser/session_storage_namespace.h"
  60 #include "content/public/browser/site_instance.h"
  61 #include "content/public/browser/storage_partition.h"
  62 #include "content/public/browser/web_contents.h"
  63 #include "content/public/browser/web_contents_delegate.h"
  64 #include "content/public/common/url_constants.h"
  65 #include "extensions/common/constants.h"
  66 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
  67 #include "net/url_request/url_request_context.h"
  68 #include "net/url_request/url_request_context_getter.h"
  69
  70 using content::BrowserThread;
  71 using content::RenderViewHost;
  72 using content::RenderFrameHost;
  73 using content::SessionStorageNamespace;
  74 using content::WebContents;
  75 using predictors::LoggedInPredictorTable;
  76
  77 namespace prerender {
  78
  79 namespace {
  80
  81 // Time interval at which periodic cleanups are performed.
  82 const int kPeriodicCleanupIntervalMs = 1000;
  83
  84 // Valid HTTP methods for prerendering.
  85 const char* const kValidHttpMethods[] = {
  86   "GET",
  87   "HEAD",
  88   "OPTIONS",
  89   "POST",
  90   "TRACE",
  91 };
  92
  93 // Length of prerender history, for display in chrome://net-internals
  94 const int kHistoryLength = 100;
  95
  96 // Timeout, in ms, for a session storage namespace merge.
  97 const int kSessionStorageNamespaceMergeTimeoutMs = 500;
  98
  99 // If true, all session storage merges hang indefinitely.
 100 bool g_hang_session_storage_merges_for_testing = false;
 101
 102 // Indicates whether a Prerender has been cancelled such that we need
 103 // a dummy replacement for the purpose of recording the correct PPLT for
 104 // the Match Complete case.
 105 // Traditionally, "Match" means that a prerendered page was actually visited &
 106 // the prerender was used.  Our goal is to have "Match" cases line up in the
 107 // control group & the experiment group, so that we can make meaningful
 108 // comparisons of improvements.  However, in the control group, since we don't
 109 // actually perform prerenders, many of the cancellation reasons cannot be
 110 // detected.  Therefore, in the Prerender group, when we cancel for one of these
 111 // reasons, we keep track of a dummy Prerender representing what we would
 112 // have in the control group.  If that dummy prerender in the prerender group
 113 // would then be swapped in (but isn't actually b/c it's a dummy), we record
 114 // this as a MatchComplete.  This allows us to compare MatchComplete's
 115 // across Prerender & Control group which ideally should be lining up.
 116 // This ensures that there is no bias in terms of the page load times
 117 // of the pages forming the difference between the two sets.
 118
 119 bool NeedMatchCompleteDummyForFinalStatus(FinalStatus final_status) {
 120   return final_status != FINAL_STATUS_USED &&
 121       final_status != FINAL_STATUS_TIMED_OUT &&
 122       final_status != FINAL_STATUS_MANAGER_SHUTDOWN &&
 123       final_status != FINAL_STATUS_PROFILE_DESTROYED &&
 124       final_status != FINAL_STATUS_APP_TERMINATING &&
 125       final_status != FINAL_STATUS_WINDOW_OPENER &&
 126       final_status != FINAL_STATUS_CACHE_OR_HISTORY_CLEARED &&
 127       final_status != FINAL_STATUS_CANCELLED &&
 128       final_status != FINAL_STATUS_DEVTOOLS_ATTACHED &&
 129       final_status != FINAL_STATUS_CROSS_SITE_NAVIGATION_PENDING &&
 130       final_status != FINAL_STATUS_PAGE_BEING_CAPTURED &&
 131       final_status != FINAL_STATUS_NAVIGATION_UNCOMMITTED &&
 132       final_status != FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE;
 133 }
 134
 135 void CheckIfCookiesExistForDomainResultOnUIThread(
 136     const net::CookieMonster::HasCookiesForETLDP1Callback& callback,
 137     bool cookies_exist) {
 138   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 139   callback.Run(cookies_exist);
 140 }
 141
 142 void CheckIfCookiesExistForDomainResultOnIOThread(
 143     const net::CookieMonster::HasCookiesForETLDP1Callback& callback,
 144     bool cookies_exist) {
 145   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 146   BrowserThread::PostTask(
 147       BrowserThread::UI,
 148       FROM_HERE,
 149       base::Bind(&CheckIfCookiesExistForDomainResultOnUIThread,
 150                  callback,
 151                  cookies_exist));
 152 }
 153
 154 void CheckIfCookiesExistForDomainOnIOThread(
 155     net::URLRequestContextGetter* rq_context,
 156     const std::string& domain_key,
 157     const net::CookieMonster::HasCookiesForETLDP1Callback& callback) {
 158   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 159   net::CookieStore* cookie_store =
 160       rq_context->GetURLRequestContext()->cookie_store();
 161   cookie_store->GetCookieMonster()->HasCookiesForETLDP1Async(
 162       domain_key,
 163       base::Bind(&CheckIfCookiesExistForDomainResultOnIOThread, callback));
 164 }
 165
 166 }  // namespace
 167
 168 class PrerenderManager::OnCloseWebContentsDeleter
 169     : public content::WebContentsDelegate,
 170       public base::SupportsWeakPtr<
 171           PrerenderManager::OnCloseWebContentsDeleter> {
 172  public:
 173   OnCloseWebContentsDeleter(PrerenderManager* manager,
 174                             WebContents* tab)
 175       : manager_(manager),
 176         tab_(tab),
 177         suppressed_dialog_(false) {
 178     tab_->SetDelegate(this);
 179     base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
 180         base::Bind(&OnCloseWebContentsDeleter::ScheduleWebContentsForDeletion,
 181                    AsWeakPtr(), true),
 182         base::TimeDelta::FromSeconds(kDeleteWithExtremePrejudiceSeconds));
 183   }
 184
 185   virtual void CloseContents(WebContents* source) override {
 186     DCHECK_EQ(tab_, source);
 187     ScheduleWebContentsForDeletion(false);
 188   }
 189
 190   virtual void SwappedOut(WebContents* source) override {
 191     DCHECK_EQ(tab_, source);
 192     ScheduleWebContentsForDeletion(false);
 193   }
 194
 195   virtual bool ShouldSuppressDialogs() override {
 196     // Use this as a proxy for getting statistics on how often we fail to honor
 197     // the beforeunload event.
 198     suppressed_dialog_ = true;
 199     return true;
 200   }
 201
 202  private:
 203   static const int kDeleteWithExtremePrejudiceSeconds = 3;
 204
 205   void ScheduleWebContentsForDeletion(bool timeout) {
 206     UMA_HISTOGRAM_BOOLEAN("Prerender.TabContentsDeleterTimeout", timeout);
 207     UMA_HISTOGRAM_BOOLEAN("Prerender.TabContentsDeleterSuppressedDialog",
 208                           suppressed_dialog_);
 209     tab_->SetDelegate(NULL);
 210     manager_->ScheduleDeleteOldWebContents(tab_.release(), this);
 211     // |this| is deleted at this point.
 212   }
 213
 214   PrerenderManager* manager_;
 215   scoped_ptr<WebContents> tab_;
 216   bool suppressed_dialog_;
 217
 218   DISALLOW_COPY_AND_ASSIGN(OnCloseWebContentsDeleter);
 219 };
 220
 221 // static
 222 int PrerenderManager::prerenders_per_session_count_ = 0;
 223
 224 // static
 225 PrerenderManager::PrerenderManagerMode PrerenderManager::mode_ =
 226     PRERENDER_MODE_ENABLED;
 227
 228 struct PrerenderManager::NavigationRecord {
 229   NavigationRecord(const GURL& url, base::TimeTicks time)
 230       : url(url),
 231         time(time) {
 232   }
 233
 234   GURL url;
 235   base::TimeTicks time;
 236 };
 237
 238 PrerenderManager::PrerenderManager(Profile* profile,
 239                                    PrerenderTracker* prerender_tracker)
 240     : profile_(profile),
 241       prerender_tracker_(prerender_tracker),
 242       prerender_contents_factory_(PrerenderContents::CreateFactory()),
 243       last_prerender_start_time_(GetCurrentTimeTicks() -
 244           base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs)),
 245       prerender_history_(new PrerenderHistory(kHistoryLength)),
 246       histograms_(new PrerenderHistograms()),
 247       profile_network_bytes_(0),
 248       last_recorded_profile_network_bytes_(0),
 249       cookie_store_loaded_(false) {
 250   // There are some assumptions that the PrerenderManager is on the UI thread.
 251   // Any other checks simply make sure that the PrerenderManager is accessed on
 252   // the same thread that it was created on.
 253   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 254
 255   if (IsLocalPredictorEnabled())
 256     local_predictor_.reset(new PrerenderLocalPredictor(this));
 257
 258   if (IsLoggedInPredictorEnabled() && !profile_->IsOffTheRecord()) {
 259     predictors::PredictorDatabase* predictor_db =
 260         predictors::PredictorDatabaseFactory::GetForProfile(profile);
 261     if (predictor_db) {
 262       logged_in_predictor_table_ = predictor_db->logged_in_table();
 263       scoped_ptr<LoggedInStateMap> new_state_map(new LoggedInStateMap);
 264       LoggedInStateMap* new_state_map_ptr = new_state_map.get();
 265       BrowserThread::PostTaskAndReply(
 266           BrowserThread::DB, FROM_HERE,
 267           base::Bind(&LoggedInPredictorTable::GetAllData,
 268                      logged_in_predictor_table_,
 269                      new_state_map_ptr),
 270           base::Bind(&PrerenderManager::LoggedInPredictorDataReceived,
 271                      AsWeakPtr(),
 272                      base::Passed(&new_state_map)));
 273     }
 274   }
 275
 276   // Certain experiments override our default config_ values.
 277   switch (PrerenderManager::GetMode()) {
 278     case PrerenderManager::PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP:
 279       config_.max_link_concurrency = 4;
 280       config_.max_link_concurrency_per_launcher = 2;
 281       break;
 282     case PrerenderManager::PRERENDER_MODE_EXPERIMENT_15MIN_TTL_GROUP:
 283       config_.time_to_live = base::TimeDelta::FromMinutes(15);
 284       break;
 285     default:
 286       break;
 287   }
 288
 289   notification_registrar_.Add(
 290       this, chrome::NOTIFICATION_COOKIE_CHANGED,
 291       content::NotificationService::AllBrowserContextsAndSources());
 292
 293   notification_registrar_.Add(
 294       this, chrome::NOTIFICATION_PROFILE_DESTROYED,
 295       content::Source<Profile>(profile_));
 296
 297   MediaCaptureDevicesDispatcher::GetInstance()->AddObserver(this);
 298 }
 299
 300 PrerenderManager::~PrerenderManager() {
 301   MediaCaptureDevicesDispatcher::GetInstance()->RemoveObserver(this);
 302
 303   // The earlier call to KeyedService::Shutdown() should have
 304   // emptied these vectors already.
 305   DCHECK(active_prerenders_.empty());
 306   DCHECK(to_delete_prerenders_.empty());
 307
 308   for (PrerenderProcessSet::const_iterator it =
 309            prerender_process_hosts_.begin();
 310        it != prerender_process_hosts_.end();
 311        ++it) {
 312     (*it)->RemoveObserver(this);
 313   }
 314 }
 315
 316 void PrerenderManager::Shutdown() {
 317   DestroyAllContents(FINAL_STATUS_MANAGER_SHUTDOWN);
 318   on_close_web_contents_deleters_.clear();
 319   // Must happen before |profile_| is set to NULL as
 320   // |local_predictor_| accesses it.
 321   if (local_predictor_)
 322     local_predictor_->Shutdown();
 323   profile_ = NULL;
 324
 325   DCHECK(active_prerenders_.empty());
 326 }
 327
 328 PrerenderHandle* PrerenderManager::AddPrerenderFromLinkRelPrerender(
 329     int process_id,
 330     int route_id,
 331     const GURL& url,
 332     const uint32 rel_types,
 333     const content::Referrer& referrer,
 334     const gfx::Size& size) {
 335   Origin origin = rel_types & PrerenderRelTypePrerender ?
 336                       ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN :
 337                       ORIGIN_LINK_REL_NEXT;
 338   SessionStorageNamespace* session_storage_namespace = NULL;
 339   // Unit tests pass in a process_id == -1.
 340   if (process_id != -1) {
 341     RenderViewHost* source_render_view_host =
 342         RenderViewHost::FromID(process_id, route_id);
 343     if (!source_render_view_host)
 344       return NULL;
 345     WebContents* source_web_contents =
 346         WebContents::FromRenderViewHost(source_render_view_host);
 347     if (!source_web_contents)
 348       return NULL;
 349     if (origin == ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN &&
 350         source_web_contents->GetURL().host() == url.host()) {
 351       origin = ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN;
 352     }
 353     // TODO(ajwong): This does not correctly handle storage for isolated apps.
 354     session_storage_namespace =
 355         source_web_contents->GetController()
 356             .GetDefaultSessionStorageNamespace();
 357   }
 358
 359   return AddPrerender(origin, process_id, url, referrer, size,
 360                       session_storage_namespace);
 361 }
 362
 363 PrerenderHandle* PrerenderManager::AddPrerenderFromOmnibox(
 364     const GURL& url,
 365     SessionStorageNamespace* session_storage_namespace,
 366     const gfx::Size& size) {
 367   if (!IsOmniboxEnabled(profile_))
 368     return NULL;
 369   return AddPrerender(ORIGIN_OMNIBOX, -1, url, content::Referrer(), size,
 370                       session_storage_namespace);
 371 }
 372
 373 PrerenderHandle* PrerenderManager::AddPrerenderFromLocalPredictor(
 374     const GURL& url,
 375     SessionStorageNamespace* session_storage_namespace,
 376     const gfx::Size& size) {
 377   return AddPrerender(ORIGIN_LOCAL_PREDICTOR, -1, url, content::Referrer(),
 378                       size, session_storage_namespace);
 379 }
 380
 381 PrerenderHandle* PrerenderManager::AddPrerenderFromExternalRequest(
 382     const GURL& url,
 383     const content::Referrer& referrer,
 384     SessionStorageNamespace* session_storage_namespace,
 385     const gfx::Size& size) {
 386   return AddPrerender(ORIGIN_EXTERNAL_REQUEST, -1, url, referrer, size,
 387                       session_storage_namespace);
 388 }
 389
 390 PrerenderHandle* PrerenderManager::AddPrerenderForInstant(
 391     const GURL& url,
 392     content::SessionStorageNamespace* session_storage_namespace,
 393     const gfx::Size& size) {
 394   DCHECK(chrome::ShouldPrefetchSearchResults());
 395   return AddPrerender(ORIGIN_INSTANT, -1, url, content::Referrer(), size,
 396                       session_storage_namespace);
 397 }
 398
 399 void PrerenderManager::CancelAllPrerenders() {
 400   DCHECK(CalledOnValidThread());
 401   while (!active_prerenders_.empty()) {
 402     PrerenderContents* prerender_contents =
 403         active_prerenders_.front()->contents();
 404     prerender_contents->Destroy(FINAL_STATUS_CANCELLED);
 405   }
 406 }
 407
 408 bool PrerenderManager::MaybeUsePrerenderedPage(const GURL& url,
 409                                                chrome::NavigateParams* params) {
 410   DCHECK(CalledOnValidThread());
 411
 412   content::WebContents* web_contents = params->target_contents;
 413   DCHECK(!IsWebContentsPrerendering(web_contents, NULL));
 414
 415   // Don't prerender if the navigation involves some special parameters.
 416   if (params->uses_post || !params->extra_headers.empty())
 417     return false;
 418
 419   DeleteOldEntries();
 420   to_delete_prerenders_.clear();
 421
 422   // First, try to find prerender data with the correct session storage
 423   // namespace.
 424   // TODO(ajwong): This doesn't handle isolated apps correctly.
 425   PrerenderData* prerender_data = FindPrerenderData(
 426       url,
 427       web_contents->GetController().GetDefaultSessionStorageNamespace());
 428
 429   // If this failed, we may still find a prerender for the same URL, but a
 430   // different session storage namespace. If we do, we might have to perform
 431   // a merge.
 432   if (!prerender_data) {
 433     prerender_data = FindPrerenderData(url, NULL);
 434   } else {
 435     RecordEvent(prerender_data->contents(),
 436                 PRERENDER_EVENT_SWAPIN_CANDIDATE_NAMESPACE_MATCHES);
 437   }
 438
 439   if (!prerender_data)
 440     return false;
 441   RecordEvent(prerender_data->contents(), PRERENDER_EVENT_SWAPIN_CANDIDATE);
 442   DCHECK(prerender_data->contents());
 443
 444   // If there is currently a merge pending for this prerender data, don't swap.
 445   if (prerender_data->pending_swap())
 446     return false;
 447
 448   // Abort any existing pending swap on the target contents.
 449   PrerenderData* pending_swap =
 450       FindPrerenderDataForTargetContents(web_contents);
 451   if (pending_swap) {
 452     pending_swap->ClearPendingSwap();
 453     DCHECK(FindPrerenderDataForTargetContents(web_contents) == NULL);
 454   }
 455
 456   RecordEvent(prerender_data->contents(),
 457               PRERENDER_EVENT_SWAPIN_NO_MERGE_PENDING);
 458   SessionStorageNamespace* target_namespace =
 459       web_contents->GetController().GetDefaultSessionStorageNamespace();
 460   SessionStorageNamespace* prerender_namespace =
 461       prerender_data->contents()->GetSessionStorageNamespace();
 462   // Only when actually prerendering is session storage namespace merging an
 463   // issue. For the control group, it will be assumed that the merge succeeded.
 464   if (prerender_namespace && prerender_namespace != target_namespace &&
 465       !prerender_namespace->IsAliasOf(target_namespace)) {
 466     if (!ShouldMergeSessionStorageNamespaces()) {
 467       RecordEvent(prerender_data->contents(),
 468                   PRERENDER_EVENT_SWAPIN_MERGING_DISABLED);
 469       return false;
 470     }
 471     RecordEvent(prerender_data->contents(),
 472                 PRERENDER_EVENT_SWAPIN_ISSUING_MERGE);
 473     prerender_data->set_pending_swap(new PendingSwap(
 474         this, web_contents, prerender_data, url,
 475         params->should_replace_current_entry));
 476     prerender_data->pending_swap()->BeginSwap();
 477     // Although this returns false, creating a PendingSwap registers with
 478     // PrerenderTracker to throttle MAIN_FRAME navigations while the swap is
 479     // pending.
 480     return false;
 481   }
 482
 483   // No need to merge; swap synchronously.
 484   WebContents* new_web_contents = SwapInternal(
 485       url, web_contents, prerender_data,
 486       params->should_replace_current_entry);
 487   if (!new_web_contents)
 488     return false;
 489
 490   // Record the new target_contents for the callers.
 491   params->target_contents = new_web_contents;
 492   return true;
 493 }
 494
 495 WebContents* PrerenderManager::SwapInternal(
 496     const GURL& url,
 497     WebContents* web_contents,
 498     PrerenderData* prerender_data,
 499     bool should_replace_current_entry) {
 500   DCHECK(CalledOnValidThread());
 501   DCHECK(!IsWebContentsPrerendering(web_contents, NULL));
 502
 503   // Only swap if the target WebContents has a CoreTabHelper delegate to swap
 504   // out of it. For a normal WebContents, this is if it is in a TabStripModel.
 505   CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(web_contents);
 506   if (!core_tab_helper || !core_tab_helper->delegate()) {
 507     RecordEvent(prerender_data->contents(), PRERENDER_EVENT_SWAPIN_NO_DELEGATE);
 508     return NULL;
 509   }
 510
 511   PrerenderTabHelper* target_tab_helper =
 512       PrerenderTabHelper::FromWebContents(web_contents);
 513   if (!target_tab_helper) {
 514     NOTREACHED();
 515     return NULL;
 516   }
 517
 518   if (IsNoSwapInExperiment(prerender_data->contents()->experiment_id()))
 519     return NULL;
 520
 521   if (WebContents* new_web_contents =
 522       prerender_data->contents()->prerender_contents()) {
 523     if (web_contents == new_web_contents)
 524       return NULL;  // Do not swap in to ourself.
 525
 526     // We cannot swap in if there is no last committed entry, because we would
 527     // show a blank page under an existing entry from the current tab.  Even if
 528     // there is a pending entry, it may not commit.
 529     // TODO(creis): If there is a pending navigation and no last committed
 530     // entry, we might be able to transfer the network request instead.
 531     if (!new_web_contents->GetController().CanPruneAllButLastCommitted()) {
 532       // Abort this prerender so it is not used later. http://crbug.com/292121
 533       prerender_data->contents()->Destroy(FINAL_STATUS_NAVIGATION_UNCOMMITTED);
 534       return NULL;
 535     }
 536   }
 537
 538   // Do not swap if the target WebContents is not the only WebContents in its
 539   // current BrowsingInstance.
 540   if (web_contents->GetSiteInstance()->GetRelatedActiveContentsCount() != 1u) {
 541     DCHECK_GT(
 542         web_contents->GetSiteInstance()->GetRelatedActiveContentsCount(), 1u);
 543     prerender_data->contents()->Destroy(
 544         FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE);
 545     return NULL;
 546   }
 547
 548   // Do not use the prerendered version if there is an opener object.
 549   if (web_contents->HasOpener()) {
 550     prerender_data->contents()->Destroy(FINAL_STATUS_WINDOW_OPENER);
 551     return NULL;
 552   }
 553
 554   // Do not swap in the prerender if the current WebContents is being captured.
 555   if (web_contents->GetCapturerCount() > 0) {
 556     prerender_data->contents()->Destroy(FINAL_STATUS_PAGE_BEING_CAPTURED);
 557     return NULL;
 558   }
 559
 560   // If we are just in the control group (which can be detected by noticing
 561   // that prerendering hasn't even started yet), record that |web_contents| now
 562   // would be showing a prerendered contents, but otherwise, don't do anything.
 563   if (!prerender_data->contents()->prerendering_has_started()) {
 564     target_tab_helper->WouldHavePrerenderedNextLoad(
 565         prerender_data->contents()->origin());
 566     prerender_data->contents()->Destroy(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
 567     return NULL;
 568   }
 569
 570   // Don't use prerendered pages if debugger is attached to the tab.
 571   // See http://crbug.com/98541
 572   if (content::DevToolsAgentHost::IsDebuggerAttached(web_contents)) {
 573     DestroyAndMarkMatchCompleteAsUsed(prerender_data->contents(),
 574                                       FINAL_STATUS_DEVTOOLS_ATTACHED);
 575     return NULL;
 576   }
 577
 578   // If the prerendered page is in the middle of a cross-site navigation,
 579   // don't swap it in because there isn't a good way to merge histories.
 580   if (prerender_data->contents()->IsCrossSiteNavigationPending()) {
 581     DestroyAndMarkMatchCompleteAsUsed(
 582         prerender_data->contents(),
 583         FINAL_STATUS_CROSS_SITE_NAVIGATION_PENDING);
 584     return NULL;
 585   }
 586
 587   // For bookkeeping purposes, we need to mark this WebContents to
 588   // reflect that it would have been prerendered.
 589   if (GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP) {
 590     target_tab_helper->WouldHavePrerenderedNextLoad(
 591         prerender_data->contents()->origin());
 592     prerender_data->contents()->Destroy(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
 593     return NULL;
 594   }
 595
 596   // At this point, we've determined that we will use the prerender.
 597   content::RenderProcessHost* process_host =
 598       prerender_data->contents()->GetRenderViewHost()->GetProcess();
 599   prerender_process_hosts_.erase(process_host);
 600   BrowserThread::PostTask(
 601       BrowserThread::IO, FROM_HERE,
 602       base::Bind(&PrerenderTracker::RemovePrerenderCookieStoreOnIOThread,
 603                  base::Unretained(prerender_tracker()), process_host->GetID(),
 604                  true));
 605   if (!prerender_data->contents()->load_start_time().is_null()) {
 606     histograms_->RecordTimeUntilUsed(
 607         prerender_data->contents()->origin(),
 608         GetCurrentTimeTicks() - prerender_data->contents()->load_start_time());
 609   }
 610   histograms_->RecordAbandonTimeUntilUsed(
 611       prerender_data->contents()->origin(),
 612       prerender_data->abandon_time().is_null() ?
 613           base::TimeDelta() :
 614           GetCurrentTimeTicks() - prerender_data->abandon_time());
 615
 616   histograms_->RecordPerSessionCount(prerender_data->contents()->origin(),
 617                                      ++prerenders_per_session_count_);
 618   histograms_->RecordUsedPrerender(prerender_data->contents()->origin());
 619
 620   if (prerender_data->pending_swap())
 621     prerender_data->pending_swap()->set_swap_successful(true);
 622   ScopedVector<PrerenderData>::iterator to_erase =
 623       FindIteratorForPrerenderContents(prerender_data->contents());
 624   DCHECK(active_prerenders_.end() != to_erase);
 625   DCHECK_EQ(prerender_data, *to_erase);
 626   scoped_ptr<PrerenderContents>
 627       prerender_contents(prerender_data->ReleaseContents());
 628   active_prerenders_.erase(to_erase);
 629
 630   // Mark prerender as used.
 631   prerender_contents->PrepareForUse();
 632
 633   WebContents* new_web_contents =
 634       prerender_contents->ReleasePrerenderContents();
 635   WebContents* old_web_contents = web_contents;
 636   DCHECK(new_web_contents);
 637   DCHECK(old_web_contents);
 638
 639   // Merge the browsing history.
 640   new_web_contents->GetController().CopyStateFromAndPrune(
 641       &old_web_contents->GetController(),
 642       should_replace_current_entry);
 643   CoreTabHelper::FromWebContents(old_web_contents)->delegate()->
 644       SwapTabContents(old_web_contents,
 645                       new_web_contents,
 646                       true,
 647                       prerender_contents->has_finished_loading());
 648   prerender_contents->CommitHistory(new_web_contents);
 649
 650   // Update PPLT metrics:
 651   // If the tab has finished loading, record a PPLT of 0.
 652   // If the tab is still loading, reset its start time to the current time.
 653   PrerenderTabHelper* prerender_tab_helper =
 654       PrerenderTabHelper::FromWebContents(new_web_contents);
 655   DCHECK(prerender_tab_helper != NULL);
 656   prerender_tab_helper->PrerenderSwappedIn();
 657
 658   if (old_web_contents->NeedToFireBeforeUnload()) {
 659     // Schedule the delete to occur after the tab has run its unload handlers.
 660     // TODO(davidben): Honor the beforeunload event. http://crbug.com/304932
 661     on_close_web_contents_deleters_.push_back(
 662         new OnCloseWebContentsDeleter(this, old_web_contents));
 663     old_web_contents->DispatchBeforeUnload(false);
 664   } else {
 665     // No unload handler to run, so delete asap.
 666     ScheduleDeleteOldWebContents(old_web_contents, NULL);
 667   }
 668
 669   // TODO(cbentzel): Should prerender_contents move to the pending delete
 670   //                 list, instead of deleting directly here?
 671   AddToHistory(prerender_contents.get());
 672   RecordNavigation(url);
 673   return new_web_contents;
 674 }
 675
 676 void PrerenderManager::MoveEntryToPendingDelete(PrerenderContents* entry,
 677                                                 FinalStatus final_status) {
 678   DCHECK(CalledOnValidThread());
 679   DCHECK(entry);
 680
 681   ScopedVector<PrerenderData>::iterator it =
 682       FindIteratorForPrerenderContents(entry);
 683   DCHECK(it != active_prerenders_.end());
 684
 685   // If this PrerenderContents is being deleted due to a cancellation any time
 686   // after the prerender has started then we need to create a dummy replacement
 687   // for PPLT accounting purposes for the Match Complete group. This is the case
 688   // if the cancellation is for any reason that would not occur in the control
 689   // group case.
 690   if (entry->prerendering_has_started() &&
 691       entry->match_complete_status() ==
 692           PrerenderContents::MATCH_COMPLETE_DEFAULT &&
 693       NeedMatchCompleteDummyForFinalStatus(final_status) &&
 694       ActuallyPrerendering() &&
 695       GetMode() == PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP) {
 696     // TODO(tburkard): I'd like to DCHECK that we are actually prerendering.
 697     // However, what if new conditions are added and
 698     // NeedMatchCompleteDummyForFinalStatus is not being updated.  Not sure
 699     // what's the best thing to do here.  For now, I will just check whether
 700     // we are actually prerendering.
 701     (*it)->MakeIntoMatchCompleteReplacement();
 702   } else {
 703     to_delete_prerenders_.push_back(*it);
 704     (*it)->ClearPendingSwap();
 705     active_prerenders_.weak_erase(it);
 706   }
 707
 708   // Destroy the old WebContents relatively promptly to reduce resource usage.
 709   PostCleanupTask();
 710 }
 711
 712 void PrerenderManager::RecordPageLoadTimeNotSwappedIn(
 713     Origin origin,
 714     base::TimeDelta page_load_time,
 715     const GURL& url) {
 716   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 717   histograms_->RecordPageLoadTimeNotSwappedIn(origin, page_load_time, url);
 718 }
 719
 720 void PrerenderManager::RecordPerceivedPageLoadTime(
 721     Origin origin,
 722     NavigationType navigation_type,
 723     base::TimeDelta perceived_page_load_time,
 724     double fraction_plt_elapsed_at_swap_in,
 725     const GURL& url) {
 726   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 727   if (!IsEnabled())
 728     return;
 729
 730   histograms_->RecordPerceivedPageLoadTime(
 731       origin, perceived_page_load_time, navigation_type, url);
 732
 733   if (navigation_type == NAVIGATION_TYPE_PRERENDERED) {
 734     histograms_->RecordPercentLoadDoneAtSwapin(
 735         origin, fraction_plt_elapsed_at_swap_in);
 736   }
 737   if (local_predictor_) {
 738     local_predictor_->OnPLTEventForURL(url, perceived_page_load_time);
 739   }
 740 }
 741
 742 // static
 743 PrerenderManager::PrerenderManagerMode PrerenderManager::GetMode() {
 744   return mode_;
 745 }
 746
 747 // static
 748 void PrerenderManager::SetMode(PrerenderManagerMode mode) {
 749   mode_ = mode;
 750 }
 751
 752 // static
 753 const char* PrerenderManager::GetModeString() {
 754   switch (mode_) {
 755     case PRERENDER_MODE_DISABLED:
 756       return "_Disabled";
 757     case PRERENDER_MODE_ENABLED:
 758     case PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP:
 759       return "_Enabled";
 760     case PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP:
 761       return "_Control";
 762     case PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP:
 763       return "_Multi";
 764     case PRERENDER_MODE_EXPERIMENT_15MIN_TTL_GROUP:
 765       return "_15MinTTL";
 766     case PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP:
 767       return "_NoUse";
 768     case PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP:
 769       return "_MatchComplete";
 770     case PRERENDER_MODE_MAX:
 771     default:
 772       NOTREACHED() << "Invalid PrerenderManager mode.";
 773       break;
 774   }
 775   return "";
 776 }
 777
 778 // static
 779 bool PrerenderManager::IsPrerenderingPossible() {
 780   return GetMode() != PRERENDER_MODE_DISABLED;
 781 }
 782
 783 // static
 784 bool PrerenderManager::ActuallyPrerendering() {
 785   return IsPrerenderingPossible() && !IsControlGroup(kNoExperiment);
 786 }
 787
 788 // static
 789 bool PrerenderManager::IsControlGroup(uint8 experiment_id) {
 790   return GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP ||
 791       IsControlGroupExperiment(experiment_id);
 792 }
 793
 794 // static
 795 bool PrerenderManager::IsNoUseGroup() {
 796   return GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP;
 797 }
 798
 799 bool PrerenderManager::IsWebContentsPrerendering(
 800     const WebContents* web_contents,
 801     Origin* origin) const {
 802   DCHECK(CalledOnValidThread());
 803   if (PrerenderContents* prerender_contents =
 804           GetPrerenderContents(web_contents)) {
 805     if (origin)
 806       *origin = prerender_contents->origin();
 807     return true;
 808   }
 809   return false;
 810 }
 811
 812 bool PrerenderManager::HasPrerenderedUrl(
 813     GURL url,
 814     content::WebContents* web_contents) const {
 815   content::SessionStorageNamespace* session_storage_namespace = web_contents->
 816       GetController().GetDefaultSessionStorageNamespace();
 817
 818   for (ScopedVector<PrerenderData>::const_iterator it =
 819            active_prerenders_.begin();
 820        it != active_prerenders_.end(); ++it) {
 821     PrerenderContents* prerender_contents = (*it)->contents();
 822     if (prerender_contents->Matches(url, session_storage_namespace)) {
 823       return true;
 824     }
 825   }
 826   return false;
 827 }
 828
 829 PrerenderContents* PrerenderManager::GetPrerenderContents(
 830     const content::WebContents* web_contents) const {
 831   DCHECK(CalledOnValidThread());
 832   for (ScopedVector<PrerenderData>::const_iterator it =
 833            active_prerenders_.begin();
 834        it != active_prerenders_.end(); ++it) {
 835     WebContents* prerender_web_contents =
 836         (*it)->contents()->prerender_contents();
 837     if (prerender_web_contents == web_contents) {
 838       return (*it)->contents();
 839     }
 840   }
 841
 842   // Also check the pending-deletion list. If the prerender is in pending
 843   // delete, anyone with a handle on the WebContents needs to know.
 844   for (ScopedVector<PrerenderData>::const_iterator it =
 845            to_delete_prerenders_.begin();
 846        it != to_delete_prerenders_.end(); ++it) {
 847     WebContents* prerender_web_contents =
 848         (*it)->contents()->prerender_contents();
 849     if (prerender_web_contents == web_contents) {
 850       return (*it)->contents();
 851     }
 852   }
 853   return NULL;
 854 }
 855
 856 PrerenderContents* PrerenderManager::GetPrerenderContentsForRoute(
 857     int child_id,
 858     int route_id) const {
 859   content::WebContents* web_contents =
 860       tab_util::GetWebContentsByID(child_id, route_id);
 861   if (web_contents == NULL)
 862     return NULL;
 863   return GetPrerenderContents(web_contents);
 864 }
 865
 866 const std::vector<WebContents*>
 867 PrerenderManager::GetAllPrerenderingContents() const {
 868   DCHECK(CalledOnValidThread());
 869   std::vector<WebContents*> result;
 870
 871   for (ScopedVector<PrerenderData>::const_iterator it =
 872            active_prerenders_.begin();
 873        it != active_prerenders_.end(); ++it) {
 874     if (WebContents* contents = (*it)->contents()->prerender_contents())
 875       result.push_back(contents);
 876   }
 877
 878   return result;
 879 }
 880
 881 bool PrerenderManager::HasRecentlyBeenNavigatedTo(Origin origin,
 882                                                   const GURL& url) {
 883   DCHECK(CalledOnValidThread());
 884
 885   CleanUpOldNavigations();
 886   std::list<NavigationRecord>::const_reverse_iterator end = navigations_.rend();
 887   for (std::list<NavigationRecord>::const_reverse_iterator it =
 888            navigations_.rbegin();
 889        it != end;
 890        ++it) {
 891     if (it->url == url) {
 892       base::TimeDelta delta = GetCurrentTimeTicks() - it->time;
 893       histograms_->RecordTimeSinceLastRecentVisit(origin, delta);
 894       return true;
 895     }
 896   }
 897
 898   return false;
 899 }
 900
 901 // static
 902 bool PrerenderManager::IsValidHttpMethod(const std::string& method) {
 903   // method has been canonicalized to upper case at this point so we can just
 904   // compare them.
 905   DCHECK_EQ(method, StringToUpperASCII(method));
 906   for (size_t i = 0; i < arraysize(kValidHttpMethods); ++i) {
 907     if (method.compare(kValidHttpMethods[i]) == 0)
 908       return true;
 909   }
 910
 911   return false;
 912 }
 913
 914 // static
 915 bool PrerenderManager::DoesURLHaveValidScheme(const GURL& url) {
 916   return (url.SchemeIsHTTPOrHTTPS() ||
 917           url.SchemeIs(extensions::kExtensionScheme) ||
 918           url.SchemeIs("data"));
 919 }
 920
 921 // static
 922 bool PrerenderManager::DoesSubresourceURLHaveValidScheme(const GURL& url) {
 923   return DoesURLHaveValidScheme(url) || url == GURL(url::kAboutBlankURL);
 924 }
 925
 926 base::DictionaryValue* PrerenderManager::GetAsValue() const {
 927   DCHECK(CalledOnValidThread());
 928   base::DictionaryValue* dict_value = new base::DictionaryValue();
 929   dict_value->Set("history", prerender_history_->GetEntriesAsValue());
 930   dict_value->Set("active", GetActivePrerendersAsValue());
 931   dict_value->SetBoolean("enabled", IsEnabled());
 932   dict_value->SetBoolean("omnibox_enabled", IsOmniboxEnabled(profile_));
 933   // If prerender is disabled via a flag this method is not even called.
 934   std::string enabled_note;
 935   if (IsControlGroup(kNoExperiment))
 936     enabled_note += "(Control group: Not actually prerendering) ";
 937   if (IsNoUseGroup())
 938     enabled_note += "(No-use group: Not swapping in prerendered pages) ";
 939   if (GetMode() == PRERENDER_MODE_EXPERIMENT_15MIN_TTL_GROUP)
 940     enabled_note +=
 941         "(15 min TTL group: Extended prerender eviction to 15 mins) ";
 942   dict_value->SetString("enabled_note", enabled_note);
 943   return dict_value;
 944 }
 945
 946 void PrerenderManager::ClearData(int clear_flags) {
 947   DCHECK_GE(clear_flags, 0);
 948   DCHECK_LT(clear_flags, CLEAR_MAX);
 949   if (clear_flags & CLEAR_PRERENDER_CONTENTS)
 950     DestroyAllContents(FINAL_STATUS_CACHE_OR_HISTORY_CLEARED);
 951   // This has to be second, since destroying prerenders can add to the history.
 952   if (clear_flags & CLEAR_PRERENDER_HISTORY)
 953     prerender_history_->Clear();
 954 }
 955
 956 void PrerenderManager::RecordFinalStatusWithMatchCompleteStatus(
 957     Origin origin,
 958     uint8 experiment_id,
 959     PrerenderContents::MatchCompleteStatus mc_status,
 960     FinalStatus final_status) const {
 961   histograms_->RecordFinalStatus(origin,
 962                                  experiment_id,
 963                                  mc_status,
 964                                  final_status);
 965 }
 966
 967 void PrerenderManager::RecordNavigation(const GURL& url) {
 968   DCHECK(CalledOnValidThread());
 969
 970   navigations_.push_back(NavigationRecord(url, GetCurrentTimeTicks()));
 971   CleanUpOldNavigations();
 972 }
 973
 974 // protected
 975 struct PrerenderManager::PrerenderData::OrderByExpiryTime {
 976   bool operator()(const PrerenderData* a, const PrerenderData* b) const {
 977     return a->expiry_time() < b->expiry_time();
 978   }
 979 };
 980
 981 PrerenderManager::PrerenderData::PrerenderData(PrerenderManager* manager,
 982                                                PrerenderContents* contents,
 983                                                base::TimeTicks expiry_time)
 984     : manager_(manager),
 985       contents_(contents),
 986       handle_count_(0),
 987       expiry_time_(expiry_time) {
 988   DCHECK_NE(static_cast<PrerenderContents*>(NULL), contents_);
 989 }
 990
 991 PrerenderManager::PrerenderData::~PrerenderData() {
 992 }
 993
 994 void PrerenderManager::PrerenderData::MakeIntoMatchCompleteReplacement() {
 995   DCHECK(contents_);
 996   contents_->set_match_complete_status(
 997       PrerenderContents::MATCH_COMPLETE_REPLACED);
 998   PrerenderData* to_delete = new PrerenderData(manager_, contents_.release(),
 999                                                expiry_time_);
1000   contents_.reset(to_delete->contents_->CreateMatchCompleteReplacement());
1001   manager_->to_delete_prerenders_.push_back(to_delete);
1002 }
1003
1004 void PrerenderManager::PrerenderData::OnHandleCreated(PrerenderHandle* handle) {
1005   DCHECK_NE(static_cast<PrerenderContents*>(NULL), contents_);
1006   ++handle_count_;
1007   contents_->AddObserver(handle);
1008 }
1009
1010 void PrerenderManager::PrerenderData::OnHandleNavigatedAway(
1011     PrerenderHandle* handle) {
1012   DCHECK_LT(0, handle_count_);
1013   DCHECK_NE(static_cast<PrerenderContents*>(NULL), contents_);
1014   if (abandon_time_.is_null())
1015     abandon_time_ = base::TimeTicks::Now();
1016   // We intentionally don't decrement the handle count here, so that the
1017   // prerender won't be canceled until it times out.
1018   manager_->SourceNavigatedAway(this);
1019 }
1020
1021 void PrerenderManager::PrerenderData::OnHandleCanceled(
1022     PrerenderHandle* handle) {
1023   DCHECK_LT(0, handle_count_);
1024   DCHECK_NE(static_cast<PrerenderContents*>(NULL), contents_);
1025
1026   if (--handle_count_ == 0) {
1027     // This will eventually remove this object from active_prerenders_.
1028     contents_->Destroy(FINAL_STATUS_CANCELLED);
1029   }
1030 }
1031
1032 void PrerenderManager::PrerenderData::ClearPendingSwap() {
1033   pending_swap_.reset(NULL);
1034 }
1035
1036 PrerenderContents* PrerenderManager::PrerenderData::ReleaseContents() {
1037   return contents_.release();
1038 }
1039
1040 PrerenderManager::PendingSwap::PendingSwap(
1041     PrerenderManager* manager,
1042     content::WebContents* target_contents,
1043     PrerenderData* prerender_data,
1044     const GURL& url,
1045     bool should_replace_current_entry)
1046     : content::WebContentsObserver(target_contents),
1047       manager_(manager),
1048       prerender_data_(prerender_data),
1049       url_(url),
1050       should_replace_current_entry_(should_replace_current_entry),
1051       start_time_(base::TimeTicks::Now()),
1052       seen_target_route_id_(false),
1053       swap_successful_(false),
1054       weak_factory_(this) {
1055 }
1056
1057 PrerenderManager::PendingSwap::~PendingSwap() {
1058   manager_->prerender_tracker()->RemovePrerenderPendingSwap(
1059       target_route_id_, swap_successful_);
1060 }
1061
1062 void PrerenderManager::PendingSwap::BeginSwap() {
1063   if (g_hang_session_storage_merges_for_testing)
1064     return;
1065
1066   SessionStorageNamespace* target_namespace =
1067       web_contents()->GetController().GetDefaultSessionStorageNamespace();
1068   SessionStorageNamespace* prerender_namespace =
1069       prerender_data_->contents()->GetSessionStorageNamespace();
1070
1071   prerender_namespace->Merge(
1072       true, prerender_data_->contents()->child_id(),
1073       target_namespace,
1074       base::Bind(&PrerenderManager::PendingSwap::OnMergeCompleted,
1075                  weak_factory_.GetWeakPtr()));
1076
1077   merge_timeout_.Start(
1078       FROM_HERE,
1079       base::TimeDelta::FromMilliseconds(
1080           kSessionStorageNamespaceMergeTimeoutMs),
1081       this, &PrerenderManager::PendingSwap::OnMergeTimeout);
1082 }
1083
1084 void PrerenderManager::PendingSwap::AboutToNavigateRenderView(
1085     RenderViewHost* render_view_host) {
1086   if (seen_target_route_id_) {
1087     // A second navigation began browser-side.
1088     prerender_data_->ClearPendingSwap();
1089     return;
1090   }
1091
1092   seen_target_route_id_ = true;
1093   target_route_id_ = PrerenderTracker::ChildRouteIdPair(
1094       render_view_host->GetMainFrame()->GetProcess()->GetID(),
1095       render_view_host->GetMainFrame()->GetRoutingID());
1096   manager_->prerender_tracker()->AddPrerenderPendingSwap(
1097       target_route_id_, url_);
1098 }
1099
1100 void PrerenderManager::PendingSwap::DidStartProvisionalLoadForFrame(
1101     content::RenderFrameHost* render_frame_host,
1102     const GURL& validated_url,
1103     bool is_error_page,
1104     bool is_iframe_srcdoc) {
1105   if (render_frame_host->GetParent())
1106     return;
1107
1108   // We must only cancel the pending swap if the url navigated to is not
1109   // the URL being attempted to be swapped in. That's because in the normal
1110   // flow, a ProvisionalChangeToMainFrameUrl will happen for the URL attempted
1111   // to be swapped in immediately after the pending swap has issued its merge.
1112   if (validated_url != url_)
1113     prerender_data_->ClearPendingSwap();
1114 }
1115
1116 void PrerenderManager::PendingSwap::DidCommitProvisionalLoadForFrame(
1117     content::RenderFrameHost* render_frame_host,
1118     const GURL& validated_url,
1119     ui::PageTransition transition_type) {
1120   if (render_frame_host->GetParent())
1121     return;
1122   prerender_data_->ClearPendingSwap();
1123 }
1124
1125 void PrerenderManager::PendingSwap::DidFailProvisionalLoad(
1126     content::RenderFrameHost* render_frame_host,
1127     const GURL& validated_url,
1128     int error_code,
1129     const base::string16& error_description) {
1130   if (render_frame_host->GetParent())
1131     return;
1132   prerender_data_->ClearPendingSwap();
1133 }
1134
1135 void PrerenderManager::PendingSwap::WebContentsDestroyed() {
1136   prerender_data_->ClearPendingSwap();
1137 }
1138
1139 void PrerenderManager::PendingSwap::RecordEvent(PrerenderEvent event) const {
1140   manager_->RecordEvent(prerender_data_->contents(), event);
1141 }
1142
1143 void PrerenderManager::PendingSwap::OnMergeCompleted(
1144     SessionStorageNamespace::MergeResult result) {
1145   UMA_HISTOGRAM_TIMES("Prerender.SessionStorageNamespaceMergeTime",
1146                       base::TimeTicks::Now() - start_time_);
1147   RecordEvent(PRERENDER_EVENT_MERGE_RESULT_MERGE_DONE);
1148
1149   // Log the exact merge result in a histogram.
1150   switch (result) {
1151     case SessionStorageNamespace::MERGE_RESULT_NAMESPACE_NOT_FOUND:
1152       RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NAMESPACE_NOT_FOUND);
1153       break;
1154     case SessionStorageNamespace::MERGE_RESULT_NAMESPACE_NOT_ALIAS:
1155       RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NAMESPACE_NOT_ALIAS);
1156       break;
1157     case SessionStorageNamespace::MERGE_RESULT_NOT_LOGGING:
1158       RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NOT_LOGGING);
1159       break;
1160     case SessionStorageNamespace::MERGE_RESULT_NO_TRANSACTIONS:
1161       RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NO_TRANSACTIONS);
1162       break;
1163     case SessionStorageNamespace::MERGE_RESULT_TOO_MANY_TRANSACTIONS:
1164       RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_TOO_MANY_TRANSACTIONS);
1165       break;
1166     case SessionStorageNamespace::MERGE_RESULT_NOT_MERGEABLE:
1167       RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NOT_MERGEABLE);
1168       break;
1169     case SessionStorageNamespace::MERGE_RESULT_MERGEABLE:
1170       RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_MERGEABLE);
1171       break;
1172     default:
1173       NOTREACHED();
1174   }
1175
1176   if (result != SessionStorageNamespace::MERGE_RESULT_MERGEABLE &&
1177       result != SessionStorageNamespace::MERGE_RESULT_NO_TRANSACTIONS) {
1178     RecordEvent(PRERENDER_EVENT_MERGE_RESULT_MERGE_FAILED);
1179     prerender_data_->ClearPendingSwap();
1180     return;
1181   }
1182
1183   RecordEvent(PRERENDER_EVENT_MERGE_RESULT_SWAPPING_IN);
1184
1185   // Note that SwapInternal will, on success, delete |prerender_data_| and
1186   // |this|. It will also delete |this| in some failure cases. Pass in a new
1187   // GURL object rather than a reference to |url_|. Also hold on to |manager_|
1188   // and |prerender_data_|.
1189   //
1190   // TODO(davidben): Can we make this less fragile?
1191   PrerenderManager* manager = manager_;
1192   PrerenderData* prerender_data = prerender_data_;
1193   WebContents* new_web_contents =
1194       manager_->SwapInternal(GURL(url_),
1195                              web_contents(),
1196                              prerender_data_,
1197                              should_replace_current_entry_);
1198   if (!new_web_contents) {
1199     manager->RecordEvent(prerender_data->contents(),
1200                          PRERENDER_EVENT_MERGE_RESULT_SWAPIN_FAILED);
1201     // Depending on whether SwapInternal called Destroy() or simply failed to
1202     // swap, |this| may or may not be deleted. Either way, if the swap failed,
1203     // |prerender_data| is deleted asynchronously, so this call is a no-op if
1204     // |this| is already gone.
1205     prerender_data->ClearPendingSwap();
1206   }
1207 }
1208
1209 void PrerenderManager::PendingSwap::OnMergeTimeout() {
1210   RecordEvent(PRERENDER_EVENT_MERGE_RESULT_TIMED_OUT);
1211   prerender_data_->ClearPendingSwap();
1212 }
1213
1214 void PrerenderManager::SetPrerenderContentsFactory(
1215     PrerenderContents::Factory* prerender_contents_factory) {
1216   DCHECK(CalledOnValidThread());
1217   prerender_contents_factory_.reset(prerender_contents_factory);
1218 }
1219
1220 void PrerenderManager::SourceNavigatedAway(PrerenderData* prerender_data) {
1221   // The expiry time of our prerender data will likely change because of
1222   // this navigation. This requires a resort of active_prerenders_.
1223   ScopedVector<PrerenderData>::iterator it =
1224       std::find(active_prerenders_.begin(), active_prerenders_.end(),
1225                 prerender_data);
1226   if (it == active_prerenders_.end())
1227     return;
1228
1229   (*it)->set_expiry_time(
1230       std::min((*it)->expiry_time(),
1231                GetExpiryTimeForNavigatedAwayPrerender()));
1232   SortActivePrerenders();
1233 }
1234
1235 net::URLRequestContextGetter* PrerenderManager::GetURLRequestContext() {
1236   return content::BrowserContext::GetDefaultStoragePartition(profile_)->
1237       GetURLRequestContext();
1238 }
1239
1240
1241 // private
1242 PrerenderHandle* PrerenderManager::AddPrerender(
1243     Origin origin,
1244     int process_id,
1245     const GURL& url_arg,
1246     const content::Referrer& referrer,
1247     const gfx::Size& size,
1248     SessionStorageNamespace* session_storage_namespace) {
1249   DCHECK(CalledOnValidThread());
1250
1251   if (!IsEnabled())
1252     return NULL;
1253
1254   if ((origin == ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN ||
1255        origin == ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN) &&
1256       IsGoogleSearchResultURL(referrer.url)) {
1257     origin = ORIGIN_GWS_PRERENDER;
1258   }
1259
1260   GURL url = url_arg;
1261   GURL alias_url;
1262   uint8 experiment = GetQueryStringBasedExperiment(url_arg);
1263   if (IsControlGroup(experiment) &&
1264       MaybeGetQueryStringBasedAliasURL(url, &alias_url)) {
1265     url = alias_url;
1266   }
1267
1268   // From here on, we will record a FinalStatus so we need to register with the
1269   // histogram tracking.
1270   histograms_->RecordPrerender(origin, url_arg);
1271
1272   if (PrerenderData* preexisting_prerender_data =
1273           FindPrerenderData(url, session_storage_namespace)) {
1274     RecordFinalStatusWithoutCreatingPrerenderContents(
1275         url, origin, experiment, FINAL_STATUS_DUPLICATE);
1276     return new PrerenderHandle(preexisting_prerender_data);
1277   }
1278
1279   // Do not prerender if there are too many render processes, and we would
1280   // have to use an existing one.  We do not want prerendering to happen in
1281   // a shared process, so that we can always reliably lower the CPU
1282   // priority for prerendering.
1283   // In single-process mode, ShouldTryToUseExistingProcessHost() always returns
1284   // true, so that case needs to be explicitly checked for.
1285   // TODO(tburkard): Figure out how to cancel prerendering in the opposite
1286   // case, when a new tab is added to a process used for prerendering.
1287   // TODO(ppi): Check whether there are usually enough render processes
1288   // available on Android. If not, kill an existing renderers so that we can
1289   // create a new one.
1290   if (content::RenderProcessHost::ShouldTryToUseExistingProcessHost(
1291           profile_, url) &&
1292       !content::RenderProcessHost::run_renderer_in_process()) {
1293     RecordFinalStatusWithoutCreatingPrerenderContents(
1294         url, origin, experiment, FINAL_STATUS_TOO_MANY_PROCESSES);
1295     return NULL;
1296   }
1297
1298   // Check if enough time has passed since the last prerender.
1299   if (!DoesRateLimitAllowPrerender(origin)) {
1300     // Cancel the prerender. We could add it to the pending prerender list but
1301     // this doesn't make sense as the next prerender request will be triggered
1302     // by a navigation and is unlikely to be the same site.
1303     RecordFinalStatusWithoutCreatingPrerenderContents(
1304         url, origin, experiment, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
1305     return NULL;
1306   }
1307
1308   if (IsPrerenderCookieStoreEnabled() && !cookie_store_loaded()) {
1309     // Only prerender if the cookie store for this profile has been loaded.
1310     // This is required by PrerenderCookieMonster.
1311     RecordFinalStatusWithoutCreatingPrerenderContents(
1312         url, origin, experiment, FINAL_STATUS_COOKIE_STORE_NOT_LOADED);
1313     return NULL;
1314   }
1315
1316   PrerenderContents* prerender_contents = CreatePrerenderContents(
1317       url, referrer, origin, experiment);
1318   DCHECK(prerender_contents);
1319   active_prerenders_.push_back(
1320       new PrerenderData(this, prerender_contents,
1321                         GetExpiryTimeForNewPrerender(origin)));
1322   if (!prerender_contents->Init()) {
1323     DCHECK(active_prerenders_.end() ==
1324            FindIteratorForPrerenderContents(prerender_contents));
1325     return NULL;
1326   }
1327
1328   histograms_->RecordPrerenderStarted(origin);
1329   DCHECK(!prerender_contents->prerendering_has_started());
1330
1331   PrerenderHandle* prerender_handle =
1332       new PrerenderHandle(active_prerenders_.back());
1333   SortActivePrerenders();
1334
1335   last_prerender_start_time_ = GetCurrentTimeTicks();
1336
1337   gfx::Size contents_size =
1338       size.IsEmpty() ? config_.default_tab_bounds.size() : size;
1339
1340   net::URLRequestContextGetter* request_context =
1341       (IsPrerenderCookieStoreEnabled() ? GetURLRequestContext() : NULL);
1342
1343   prerender_contents->StartPrerendering(process_id, contents_size,
1344                                         session_storage_namespace,
1345                                         request_context);
1346
1347   DCHECK(IsControlGroup(experiment) ||
1348          prerender_contents->prerendering_has_started() ||
1349          (origin == ORIGIN_LOCAL_PREDICTOR &&
1350           IsLocalPredictorPrerenderAlwaysControlEnabled()));
1351
1352   if (GetMode() == PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP)
1353     histograms_->RecordConcurrency(active_prerenders_.size());
1354
1355   // Query the history to see if the URL being prerendered has ever been
1356   // visited before.
1357   HistoryService* history_service = HistoryServiceFactory::GetForProfile(
1358       profile_, Profile::EXPLICIT_ACCESS);
1359   if (history_service) {
1360     history_service->QueryURL(
1361         url,
1362         false,
1363         base::Bind(&PrerenderManager::OnHistoryServiceDidQueryURL,
1364                    base::Unretained(this),
1365                    origin,
1366                    experiment),
1367         &query_url_tracker_);
1368   }
1369
1370   StartSchedulingPeriodicCleanups();
1371   return prerender_handle;
1372 }
1373
1374 void PrerenderManager::StartSchedulingPeriodicCleanups() {
1375   DCHECK(CalledOnValidThread());
1376   if (repeating_timer_.IsRunning())
1377     return;
1378   repeating_timer_.Start(FROM_HERE,
1379       base::TimeDelta::FromMilliseconds(kPeriodicCleanupIntervalMs),
1380       this,
1381       &PrerenderManager::PeriodicCleanup);
1382 }
1383
1384 void PrerenderManager::StopSchedulingPeriodicCleanups() {
1385   DCHECK(CalledOnValidThread());
1386   repeating_timer_.Stop();
1387 }
1388
1389 void PrerenderManager::PeriodicCleanup() {
1390   DCHECK(CalledOnValidThread());
1391
1392   base::ElapsedTimer resource_timer;
1393
1394   // Grab a copy of the current PrerenderContents pointers, so that we
1395   // will not interfere with potential deletions of the list.
1396   std::vector<PrerenderContents*>
1397       prerender_contents(active_prerenders_.size());
1398   std::transform(active_prerenders_.begin(), active_prerenders_.end(),
1399                  prerender_contents.begin(),
1400                  std::mem_fun(&PrerenderData::contents));
1401
1402   // And now check for prerenders using too much memory.
1403   std::for_each(prerender_contents.begin(), prerender_contents.end(),
1404                 std::mem_fun(
1405                     &PrerenderContents::DestroyWhenUsingTooManyResources));
1406
1407   // Measure how long the resource checks took. http://crbug.com/305419.
1408   UMA_HISTOGRAM_TIMES("Prerender.PeriodicCleanupResourceCheckTime",
1409                       resource_timer.Elapsed());
1410
1411   base::ElapsedTimer cleanup_timer;
1412
1413   // Perform deferred cleanup work.
1414   DeleteOldWebContents();
1415   DeleteOldEntries();
1416   if (active_prerenders_.empty())
1417     StopSchedulingPeriodicCleanups();
1418
1419   to_delete_prerenders_.clear();
1420
1421   // Measure how long a the various cleanup tasks took. http://crbug.com/305419.
1422   UMA_HISTOGRAM_TIMES("Prerender.PeriodicCleanupDeleteContentsTime",
1423                       cleanup_timer.Elapsed());
1424 }
1425
1426 void PrerenderManager::PostCleanupTask() {
1427   DCHECK(CalledOnValidThread());
1428   base::MessageLoop::current()->PostTask(
1429       FROM_HERE,
1430       base::Bind(&PrerenderManager::PeriodicCleanup, AsWeakPtr()));
1431 }
1432
1433 base::TimeTicks PrerenderManager::GetExpiryTimeForNewPrerender(
1434     Origin origin) const {
1435   base::TimeDelta ttl = config_.time_to_live;
1436   if (origin == ORIGIN_LOCAL_PREDICTOR)
1437     ttl = base::TimeDelta::FromSeconds(GetLocalPredictorTTLSeconds());
1438   return GetCurrentTimeTicks() + ttl;
1439 }
1440
1441 base::TimeTicks PrerenderManager::GetExpiryTimeForNavigatedAwayPrerender()
1442     const {
1443   return GetCurrentTimeTicks() + config_.abandon_time_to_live;
1444 }
1445
1446 void PrerenderManager::DeleteOldEntries() {
1447   DCHECK(CalledOnValidThread());
1448   while (!active_prerenders_.empty()) {
1449     PrerenderData* prerender_data = active_prerenders_.front();
1450     DCHECK(prerender_data);
1451     DCHECK(prerender_data->contents());
1452
1453     if (prerender_data->expiry_time() > GetCurrentTimeTicks())
1454       return;
1455     prerender_data->contents()->Destroy(FINAL_STATUS_TIMED_OUT);
1456   }
1457 }
1458
1459 base::Time PrerenderManager::GetCurrentTime() const {
1460   return base::Time::Now();
1461 }
1462
1463 base::TimeTicks PrerenderManager::GetCurrentTimeTicks() const {
1464   return base::TimeTicks::Now();
1465 }
1466
1467 PrerenderContents* PrerenderManager::CreatePrerenderContents(
1468     const GURL& url,
1469     const content::Referrer& referrer,
1470     Origin origin,
1471     uint8 experiment_id) {
1472   DCHECK(CalledOnValidThread());
1473   return prerender_contents_factory_->CreatePrerenderContents(
1474       this, profile_, url, referrer, origin, experiment_id);
1475 }
1476
1477 void PrerenderManager::SortActivePrerenders() {
1478   std::sort(active_prerenders_.begin(), active_prerenders_.end(),
1479             PrerenderData::OrderByExpiryTime());
1480 }
1481
1482 PrerenderManager::PrerenderData* PrerenderManager::FindPrerenderData(
1483     const GURL& url,
1484     const SessionStorageNamespace* session_storage_namespace) {
1485   for (ScopedVector<PrerenderData>::iterator it = active_prerenders_.begin();
1486        it != active_prerenders_.end(); ++it) {
1487     if ((*it)->contents()->Matches(url, session_storage_namespace))
1488       return *it;
1489   }
1490   return NULL;
1491 }
1492
1493 PrerenderManager::PrerenderData*
1494 PrerenderManager::FindPrerenderDataForTargetContents(
1495     WebContents* target_contents) {
1496   for (ScopedVector<PrerenderData>::iterator it = active_prerenders_.begin();
1497        it != active_prerenders_.end(); ++it) {
1498     if ((*it)->pending_swap() &&
1499         (*it)->pending_swap()->web_contents() == target_contents)
1500       return *it;
1501   }
1502   return NULL;
1503 }
1504
1505 ScopedVector<PrerenderManager::PrerenderData>::iterator
1506 PrerenderManager::FindIteratorForPrerenderContents(
1507     PrerenderContents* prerender_contents) {
1508   for (ScopedVector<PrerenderData>::iterator it = active_prerenders_.begin();
1509        it != active_prerenders_.end(); ++it) {
1510     if (prerender_contents == (*it)->contents())
1511       return it;
1512   }
1513   return active_prerenders_.end();
1514 }
1515
1516 bool PrerenderManager::DoesRateLimitAllowPrerender(Origin origin) const {
1517   DCHECK(CalledOnValidThread());
1518   base::TimeDelta elapsed_time =
1519       GetCurrentTimeTicks() - last_prerender_start_time_;
1520   histograms_->RecordTimeBetweenPrerenderRequests(origin, elapsed_time);
1521   if (!config_.rate_limit_enabled)
1522     return true;
1523   // The LocalPredictor may issue multiple prerenders simultaneously (if so
1524   // configured), so no throttling.
1525   if (origin == ORIGIN_LOCAL_PREDICTOR)
1526     return true;
1527   return elapsed_time >=
1528       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
1529 }
1530
1531 void PrerenderManager::DeleteOldWebContents() {
1532   while (!old_web_contents_list_.empty()) {
1533     WebContents* web_contents = old_web_contents_list_.front();
1534     old_web_contents_list_.pop_front();
1535     // TODO(dominich): should we use Instant Unload Handler here?
1536     delete web_contents;
1537   }
1538 }
1539
1540 void PrerenderManager::CleanUpOldNavigations() {
1541   DCHECK(CalledOnValidThread());
1542
1543   // Cutoff.  Navigations before this cutoff can be discarded.
1544   base::TimeTicks cutoff = GetCurrentTimeTicks() -
1545       base::TimeDelta::FromMilliseconds(kNavigationRecordWindowMs);
1546   while (!navigations_.empty()) {
1547     if (navigations_.front().time > cutoff)
1548       break;
1549     navigations_.pop_front();
1550   }
1551 }
1552
1553 void PrerenderManager::ScheduleDeleteOldWebContents(
1554     WebContents* tab,
1555     OnCloseWebContentsDeleter* deleter) {
1556   old_web_contents_list_.push_back(tab);
1557   PostCleanupTask();
1558
1559   if (deleter) {
1560     ScopedVector<OnCloseWebContentsDeleter>::iterator i = std::find(
1561         on_close_web_contents_deleters_.begin(),
1562         on_close_web_contents_deleters_.end(),
1563         deleter);
1564     DCHECK(i != on_close_web_contents_deleters_.end());
1565     on_close_web_contents_deleters_.erase(i);
1566   }
1567 }
1568
1569 void PrerenderManager::AddToHistory(PrerenderContents* contents) {
1570   PrerenderHistory::Entry entry(contents->prerender_url(),
1571                                 contents->final_status(),
1572                                 contents->origin(),
1573                                 base::Time::Now());
1574   prerender_history_->AddEntry(entry);
1575 }
1576
1577 base::Value* PrerenderManager::GetActivePrerendersAsValue() const {
1578   base::ListValue* list_value = new base::ListValue();
1579   for (ScopedVector<PrerenderData>::const_iterator it =
1580            active_prerenders_.begin();
1581        it != active_prerenders_.end(); ++it) {
1582     if (base::Value* prerender_value = (*it)->contents()->GetAsValue())
1583       list_value->Append(prerender_value);
1584   }
1585   return list_value;
1586 }
1587
1588 void PrerenderManager::DestroyAllContents(FinalStatus final_status) {
1589   DeleteOldWebContents();
1590   while (!active_prerenders_.empty()) {
1591     PrerenderContents* contents = active_prerenders_.front()->contents();
1592     contents->Destroy(final_status);
1593   }
1594   to_delete_prerenders_.clear();
1595 }
1596
1597 void PrerenderManager::DestroyAndMarkMatchCompleteAsUsed(
1598     PrerenderContents* prerender_contents,
1599     FinalStatus final_status) {
1600   prerender_contents->set_match_complete_status(
1601       PrerenderContents::MATCH_COMPLETE_REPLACED);
1602   histograms_->RecordFinalStatus(prerender_contents->origin(),
1603                                  prerender_contents->experiment_id(),
1604                                  PrerenderContents::MATCH_COMPLETE_REPLACEMENT,
1605                                  FINAL_STATUS_WOULD_HAVE_BEEN_USED);
1606   prerender_contents->Destroy(final_status);
1607 }
1608
1609 void PrerenderManager::RecordFinalStatusWithoutCreatingPrerenderContents(
1610     const GURL& url, Origin origin, uint8 experiment_id,
1611     FinalStatus final_status) const {
1612   PrerenderHistory::Entry entry(url, final_status, origin, base::Time::Now());
1613   prerender_history_->AddEntry(entry);
1614   RecordFinalStatusWithMatchCompleteStatus(
1615       origin, experiment_id,
1616       PrerenderContents::MATCH_COMPLETE_DEFAULT,
1617       final_status);
1618 }
1619
1620 void PrerenderManager::Observe(int type,
1621                                const content::NotificationSource& source,
1622                                const content::NotificationDetails& details) {
1623   switch (type) {
1624     case chrome::NOTIFICATION_COOKIE_CHANGED: {
1625       Profile* profile = content::Source<Profile>(source).ptr();
1626       if (!profile || !profile_->IsSameProfile(profile) ||
1627           profile->IsOffTheRecord()) {
1628         return;
1629       }
1630       CookieChanged(content::Details<ChromeCookieDetails>(details).ptr());
1631       break;
1632     }
1633     case chrome::NOTIFICATION_PROFILE_DESTROYED:
1634       DestroyAllContents(FINAL_STATUS_PROFILE_DESTROYED);
1635       on_close_web_contents_deleters_.clear();
1636       break;
1637     default:
1638       NOTREACHED() << "Unexpected notification sent.";
1639       break;
1640   }
1641 }
1642
1643 void PrerenderManager::OnCreatingAudioStream(int render_process_id,
1644                                              int render_frame_id) {
1645   content::RenderFrameHost* render_frame_host =
1646       content::RenderFrameHost::FromID(render_process_id, render_frame_id);
1647   WebContents* tab = WebContents::FromRenderFrameHost(render_frame_host);
1648   if (!tab)
1649     return;
1650
1651   PrerenderContents* prerender_contents = GetPrerenderContents(tab);
1652   if (!prerender_contents)
1653     return;
1654
1655   prerender_contents->Destroy(prerender::FINAL_STATUS_CREATING_AUDIO_STREAM);
1656 }
1657
1658 void PrerenderManager::RecordLikelyLoginOnURL(const GURL& url) {
1659   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1660   if (!url.SchemeIsHTTPOrHTTPS())
1661     return;
1662   if (logged_in_predictor_table_.get()) {
1663     BrowserThread::PostTask(
1664         BrowserThread::DB,
1665         FROM_HERE,
1666         base::Bind(&LoggedInPredictorTable::AddDomainFromURL,
1667                    logged_in_predictor_table_,
1668                    url));
1669   }
1670   std::string key = LoggedInPredictorTable::GetKey(url);
1671   if (!logged_in_state_.get())
1672     return;
1673   if (logged_in_state_->count(key))
1674     return;
1675   (*logged_in_state_)[key] = base::Time::Now().ToInternalValue();
1676 }
1677
1678 void PrerenderManager::CheckIfLikelyLoggedInOnURL(
1679     const GURL& url,
1680     bool* lookup_result,
1681     bool* database_was_present,
1682     const base::Closure& result_cb) {
1683   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1684   if (!logged_in_predictor_table_.get()) {
1685     *database_was_present = false;
1686     *lookup_result = false;
1687     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, result_cb);
1688     return;
1689   }
1690   BrowserThread::PostTaskAndReply(
1691       BrowserThread::DB, FROM_HERE,
1692       base::Bind(&LoggedInPredictorTable::HasUserLoggedIn,
1693                  logged_in_predictor_table_,
1694                  url,
1695                  lookup_result,
1696                  database_was_present),
1697       result_cb);
1698 }
1699
1700
1701 void PrerenderManager::CookieChanged(ChromeCookieDetails* details) {
1702   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1703
1704   if (!logged_in_predictor_table_.get())
1705     return;
1706
1707   // We only care when a cookie has been removed.
1708   if (!details->removed)
1709     return;
1710
1711   std::string domain_key =
1712       LoggedInPredictorTable::GetKeyFromDomain(details->cookie->Domain());
1713
1714   // If we have no record of this domain as a potentially logged in domain,
1715   // nothing to do here.
1716   if (logged_in_state_.get() && logged_in_state_->count(domain_key) < 1)
1717     return;
1718
1719   net::URLRequestContextGetter* rq_context = profile_->GetRequestContext();
1720   if (!rq_context)
1721     return;
1722
1723   BrowserThread::PostTask(
1724       BrowserThread::IO, FROM_HERE,
1725       base::Bind(&CheckIfCookiesExistForDomainOnIOThread,
1726                  base::Unretained(rq_context),
1727                  domain_key,
1728                  base::Bind(
1729                      &PrerenderManager::CookieChangedAnyCookiesLeftLookupResult,
1730                      AsWeakPtr(),
1731                      domain_key)
1732                  ));
1733 }
1734
1735 void PrerenderManager::CookieChangedAnyCookiesLeftLookupResult(
1736     const std::string& domain_key,
1737     bool cookies_exist) {
1738   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1739
1740   if (cookies_exist)
1741     return;
1742
1743   if (logged_in_predictor_table_.get()) {
1744     BrowserThread::PostTask(BrowserThread::DB,
1745                             FROM_HERE,
1746                             base::Bind(&LoggedInPredictorTable::DeleteDomain,
1747                                        logged_in_predictor_table_,
1748                                        domain_key));
1749   }
1750
1751   if (logged_in_state_.get())
1752     logged_in_state_->erase(domain_key);
1753 }
1754
1755 void PrerenderManager::LoggedInPredictorDataReceived(
1756     scoped_ptr<LoggedInStateMap> new_map) {
1757   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1758   logged_in_state_.swap(new_map);
1759 }
1760
1761 void PrerenderManager::RecordEvent(PrerenderContents* contents,
1762                                    PrerenderEvent event) const {
1763   if (!contents)
1764     histograms_->RecordEvent(ORIGIN_NONE, kNoExperiment, event);
1765   else
1766     histograms_->RecordEvent(contents->origin(), contents->experiment_id(),
1767                              event);
1768 }
1769
1770 // static
1771 void PrerenderManager::RecordCookieEvent(int process_id,
1772                                          int frame_id,
1773                                          const GURL& url,
1774                                          const GURL& frame_url,
1775                                          bool is_for_blocking_resource,
1776                                          PrerenderContents::CookieEvent event,
1777                                          const net::CookieList* cookie_list) {
1778   RenderFrameHost* rfh = RenderFrameHost::FromID(process_id, frame_id);
1779   WebContents* web_contents = WebContents::FromRenderFrameHost(rfh);
1780   if (!web_contents)
1781     return;
1782
1783   bool is_main_frame = (rfh == web_contents->GetMainFrame());
1784
1785   bool is_third_party_cookie =
1786     (!frame_url.is_empty() &&
1787      !net::registry_controlled_domains::SameDomainOrHost(
1788          url, frame_url,
1789          net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES));
1790
1791   PrerenderContents* prerender_contents =
1792       PrerenderContents::FromWebContents(web_contents);
1793
1794   if (!prerender_contents)
1795     return;
1796
1797   base::Time earliest_create_date;
1798   if (event == PrerenderContents::COOKIE_EVENT_SEND) {
1799     if (!cookie_list || cookie_list->empty())
1800       return;
1801     for (size_t i = 0; i < cookie_list->size(); i++) {
1802       if (earliest_create_date.is_null() ||
1803           (*cookie_list)[i].CreationDate() < earliest_create_date) {
1804         earliest_create_date = (*cookie_list)[i].CreationDate();
1805       }
1806     }
1807   }
1808
1809   prerender_contents->RecordCookieEvent(event,
1810                                         is_main_frame && url == frame_url,
1811                                         is_third_party_cookie,
1812                                         is_for_blocking_resource,
1813                                         earliest_create_date);
1814 }
1815
1816 void PrerenderManager::RecordCookieStatus(Origin origin,
1817                                           uint8 experiment_id,
1818                                           int cookie_status) const {
1819   histograms_->RecordCookieStatus(origin, experiment_id, cookie_status);
1820 }
1821
1822 void PrerenderManager::RecordCookieSendType(Origin origin,
1823                                             uint8 experiment_id,
1824                                             int cookie_send_type) const {
1825   histograms_->RecordCookieSendType(origin, experiment_id, cookie_send_type);
1826 }
1827
1828 void PrerenderManager::OnHistoryServiceDidQueryURL(
1829     Origin origin,
1830     uint8 experiment_id,
1831     bool success,
1832     const history::URLRow& url_row,
1833     const history::VisitVector& /*visits*/) {
1834   histograms_->RecordPrerenderPageVisitedStatus(origin, experiment_id, success);
1835 }
1836
1837 // static
1838 void PrerenderManager::HangSessionStorageMergesForTesting() {
1839   g_hang_session_storage_merges_for_testing = true;
1840 }
1841
1842 void PrerenderManager::RecordNetworkBytes(Origin origin,
1843                                           bool used,
1844                                           int64 prerender_bytes) {
1845   if (!ActuallyPrerendering())
1846     return;
1847   int64 recent_profile_bytes =
1848       profile_network_bytes_ - last_recorded_profile_network_bytes_;
1849   last_recorded_profile_network_bytes_ = profile_network_bytes_;
1850   DCHECK_GE(recent_profile_bytes, 0);
1851   histograms_->RecordNetworkBytes(
1852       origin, used, prerender_bytes, recent_profile_bytes);
1853 }
1854
1855 bool PrerenderManager::IsEnabled() const {
1856   DCHECK(CalledOnValidThread());
1857
1858   return chrome_browser_net::CanPrefetchAndPrerenderUI(profile_->GetPrefs());
1859 }
1860
1861 void PrerenderManager::AddProfileNetworkBytesIfEnabled(int64 bytes) {
1862   DCHECK_GE(bytes, 0);
1863   if (IsEnabled() && ActuallyPrerendering())
1864     profile_network_bytes_ += bytes;
1865 }
1866
1867 void PrerenderManager::OnCookieStoreLoaded() {
1868   cookie_store_loaded_ = true;
1869   if (!on_cookie_store_loaded_cb_for_testing_.is_null())
1870     on_cookie_store_loaded_cb_for_testing_.Run();
1871 }
1872
1873 void PrerenderManager::AddPrerenderProcessHost(
1874     content::RenderProcessHost* process_host) {
1875   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1876   DCHECK(prerender_process_hosts_.find(process_host) ==
1877          prerender_process_hosts_.end());
1878   prerender_process_hosts_.insert(process_host);
1879   process_host->AddObserver(this);
1880 }
1881
1882 bool PrerenderManager::MayReuseProcessHost(
1883     content::RenderProcessHost* process_host) {
1884   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1885   // If prerender cookie stores are disabled, there is no need to require
1886   // isolated prerender processes.
1887   if (!IsPrerenderCookieStoreEnabled())
1888     return true;
1889   return (prerender_process_hosts_.find(process_host) ==
1890           prerender_process_hosts_.end());
1891 }
1892
1893 void PrerenderManager::RenderProcessHostDestroyed(
1894     content::RenderProcessHost* host) {
1895   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1896   prerender_process_hosts_.erase(host);
1897   BrowserThread::PostTask(
1898       BrowserThread::IO, FROM_HERE,
1899       base::Bind(&PrerenderTracker::RemovePrerenderCookieStoreOnIOThread,
1900                  base::Unretained(prerender_tracker()), host->GetID(), false));
1901 }
1902
1903 }  // namespace prerender