Various Prerender Service / Prerender LocalPredictor related changes.

chrome/browser/prerender/prerender_local_predictor.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_local_predictor.h"
 
 #include <ctype.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 14 matching lines @@
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_histograms.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
+#include "chrome/common/prefetch_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_transition_types.h"
 #include "crypto/secure_hash.h"
 #include "grit/browser_resources.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "url/url_canon.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
 using content::BrowserThread;
 using content::PageTransition;
+using content::RenderFrameHost;
 using content::SessionStorageNamespace;
 using content::WebContents;
 using history::URLID;
 using net::URLFetcher;
 using predictors::LoggedInPredictorTable;
 using std::string;
 using std::vector;
 
 namespace prerender {
 
 namespace {
 
 static const size_t kURLHashSize = 5;
 static const int kNumPrerenderCandidates = 5;
+static const int kInvalidProcessId = -1;
+static const int kInvalidFrameId = -1;
 
 }  // namespace
 
 // When considering a candidate URL to be prerendered, we need to collect the
 // data in this struct to make the determination whether we should issue the
 // prerender or not.
 struct PrerenderLocalPredictor::LocalPredictorURLInfo {
   URLID id;
   GURL url;
   bool url_lookup_success;
   bool logged_in;
   bool logged_in_lookup_ok;
   bool local_history_based;
   bool service_whitelist;
   bool service_whitelist_lookup_ok;
   bool service_whitelist_reported;
   double priority;
 };
 
 // A struct consisting of everything needed for launching a potential prerender
 // on a navigation: The navigation URL (source) triggering potential prerenders,
 // and a set of candidate URLs.
 struct PrerenderLocalPredictor::CandidatePrerenderInfo {
   LocalPredictorURLInfo source_url_;
   vector<LocalPredictorURLInfo> candidate_urls_;
   scoped_refptr<SessionStorageNamespace> session_storage_namespace_;
+  // Render Process ID and Route ID of the page causing the prerender to be
+  // issued. Needed so that we can cause its renderer to issue prefetches within
+  // its context.
+  int render_process_id_;
+  int render_frame_id_;
   scoped_ptr<gfx::Size> size_;
   base::Time start_time_;  // used for various time measurements
-  explicit CandidatePrerenderInfo(URLID source_id) {
+  explicit CandidatePrerenderInfo(URLID source_id)
+      : render_process_id_(kInvalidProcessId),
+        render_frame_id_(kInvalidFrameId) {
     source_url_.id = source_id;
   }
   void MaybeAddCandidateURLFromLocalData(URLID id, double priority) {
     LocalPredictorURLInfo info;
     info.id = id;
     info.local_history_based = true;
     info.service_whitelist = false;
     info.service_whitelist_lookup_ok = false;
     info.service_whitelist_reported = false;
     info.priority = priority;
@@ skipping 485 matching lines @@
   if (!source_web_contents) {
     RecordEvent(EVENT_PRERENDER_URL_LOOKUP_NO_SOURCE_WEBCONTENTS_FOUND);
     return;
   }
 
   if (multiple_source_web_contents_candidates)
     RecordEvent(EVENT_PRERENDER_URL_LOOKUP_MULTIPLE_SOURCE_WEBCONTENTS_FOUND);
 
   info->session_storage_namespace_ =
       source_web_contents->GetController().GetDefaultSessionStorageNamespace();
+  RenderFrameHost* rfh = source_web_contents->GetMainFrame();
+  info->render_process_id_ = rfh->GetProcess()->GetID();
+  info->render_frame_id_ = rfh->GetRoutingID();
 
   gfx::Rect container_bounds = source_web_contents->GetContainerBounds();
   info->size_.reset(new gfx::Size(container_bounds.size()));
 
   RecordEvent(EVENT_PRERENDER_URL_LOOKUP_SUCCESS);
 
   DoPrerenderServiceCheck(info.Pass());
 }
 
 void PrerenderLocalPredictor::DoPrerenderServiceCheck(
@@ skipping 435 matching lines @@
   if (prerender && prerender->start_time < GetCurrentTime() - plt) {
     if (prerender->url.is_empty())
       RecordEvent(EVENT_ERROR_NO_PRERENDER_URL_FOR_PLT);
     return (prerender->url == url);
   } else {
     return false;
   }
 }
 
 PrerenderLocalPredictor::PrerenderProperties*
-PrerenderLocalPredictor::GetIssuedPrerenderSlotForPriority(double priority) {
+PrerenderLocalPredictor::GetIssuedPrerenderSlotForPriority(const GURL& url,
+                                                           double priority) {
   int num_prerenders = GetLocalPredictorMaxConcurrentPrerenders();
   while (static_cast<int>(issued_prerenders_.size()) < num_prerenders)
     issued_prerenders_.push_back(new PrerenderProperties());
+  // First, check if we already have a prerender for the same URL issued.
+  // If yes, we don't want to prerender this URL again, so we return NULL
+  // (on matching slot found).
+  for (int i = 0; i < static_cast<int>(issued_prerenders_.size()); i++) {
+    PrerenderProperties* p = issued_prerenders_[i];
+    DCHECK(p != NULL);
+    if (p->prerender_handle && p->prerender_handle->IsPrerendering() &&
+        p->prerender_handle->Matches(url, NULL)) {
+      return NULL;
+    }
+  }
+  // Otherwise, let's see if there are any empty slots. If yes, return the first
+  // one we find. Otherwise, if the lowest priority prerender has a lower
+  // priority than the page we want to prerender, use its slot.
   PrerenderProperties* lowest_priority_prerender = NULL;
   for (int i = 0; i < static_cast<int>(issued_prerenders_.size()); i++) {
     PrerenderProperties* p = issued_prerenders_[i];
     DCHECK(p != NULL);
     if (!p->prerender_handle || !p->prerender_handle->IsPrerendering())
       return p;
     double decayed_priority = p->GetCurrentDecayedPriority();
     if (decayed_priority > priority)
       continue;
     if (lowest_priority_prerender == NULL ||
@@ skipping 14 matching lines @@
   if (info->candidate_urls_.size() == 0) {
     RecordEvent(EVENT_NO_PRERENDER_CANDIDATES);
     return;
   }
   scoped_ptr<LocalPredictorURLInfo> url_info;
 #if defined(FULL_SAFE_BROWSING)
   scoped_refptr<SafeBrowsingDatabaseManager> sb_db_manager =
       g_browser_process->safe_browsing_service()->database_manager();
 #endif
   PrerenderProperties* prerender_properties = NULL;
-
+  int num_issued = 0;
   for (int i = 0; i < static_cast<int>(info->candidate_urls_.size()); i++) {
+    if (num_issued > GetLocalPredictorMaxLaunchPrerenders())
+      return;
     RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_EXAMINE_NEXT_URL);
     url_info.reset(new LocalPredictorURLInfo(info->candidate_urls_[i]));
     if (url_info->local_history_based) {
       if (SkipLocalPredictorLocalCandidates()) {
         url_info.reset(NULL);
         continue;
       }
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_EXAMINE_NEXT_URL_LOCAL);
     }
     if (!url_info->local_history_based) {
@@ skipping 13 matching lines @@
     // URL), or it can be sufficient to issue the prerender without any
     // further checks (in which case we just break).
     // The order of the checks is critical, because it prescribes the logic
     // we use here to decide what to prerender.
     if (!url_info->url_lookup_success) {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_NO_URL);
       url_info.reset(NULL);
       continue;
     }
     prerender_properties =
-        GetIssuedPrerenderSlotForPriority(url_info->priority);
+        GetIssuedPrerenderSlotForPriority(url_info->url, url_info->priority);
     if (!prerender_properties) {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_PRIORITY_TOO_LOW);
       url_info.reset(NULL);
       continue;
     }
     if (!SkipLocalPredictorFragment() &&
         URLsIdenticalIgnoringFragments(info->source_url_.url,
                                        url_info->url)) {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_URLS_IDENTICAL_BUT_FRAGMENT);
       url_info.reset(NULL);
       continue;
     }
     if (!SkipLocalPredictorHTTPS() && url_info->url.SchemeIs("https")) {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_HTTPS);
       url_info.reset(NULL);
       continue;
     }
     if (IsRootPageURL(url_info->url)) {
       // For root pages, we assume that they are reasonably safe, and we
       // will just prerender them without any additional checks.
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_ROOT_PAGE);
-      break;
+      IssuePrerender(info.get(), url_info.get(), prerender_properties);
+      num_issued++;
+      continue;
     }
     if (IsLogOutURL(url_info->url)) {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_LOGOUT_URL);
       url_info.reset(NULL);
       continue;
     }
     if (IsLogInURL(url_info->url)) {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_LOGIN_URL);
       url_info.reset(NULL);
       continue;
     }
 #if defined(FULL_SAFE_BROWSING)
     if (!SkipLocalPredictorWhitelist() && sb_db_manager &&
         sb_db_manager->CheckSideEffectFreeWhitelistUrl(url_info->url)) {
       // If a page is on the side-effect free whitelist, we will just prerender
       // it without any additional checks.
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_ON_SIDE_EFFECT_FREE_WHITELIST);
-      break;
+      IssuePrerender(info.get(), url_info.get(), prerender_properties);
+      num_issued++;
+      continue;
     }
 #endif
     if (!SkipLocalPredictorServiceWhitelist() &&
         url_info->service_whitelist && url_info->service_whitelist_lookup_ok) {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_ON_SERVICE_WHITELIST);
-      break;
+      IssuePrerender(info.get(), url_info.get(), prerender_properties);
+      num_issued++;
+      continue;
     }
     if (!SkipLocalPredictorLoggedIn() &&
         !url_info->logged_in && url_info->logged_in_lookup_ok) {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_NOT_LOGGED_IN);
-      break;
+      IssuePrerender(info.get(), url_info.get(), prerender_properties);
+      num_issued++;
+      continue;
     }
     if (!SkipLocalPredictorDefaultNoPrerender()) {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_FALLTHROUGH_NOT_PRERENDERING);
       url_info.reset(NULL);
     } else {
       RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_FALLTHROUGH_PRERENDERING);
+      IssuePrerender(info.get(), url_info.get(), prerender_properties);
+      num_issued++;
+      continue;
     }
   }
-  if (!url_info.get())
-    return;
-  RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_ISSUING_PRERENDER);
-  DCHECK(prerender_properties != NULL);
-  if (IsLocalPredictorPrerenderLaunchEnabled()) {
-    IssuePrerender(info.Pass(), url_info.Pass(), prerender_properties);
-  }
 }
 
 void PrerenderLocalPredictor::IssuePrerender(
-    scoped_ptr<CandidatePrerenderInfo> info,
-    scoped_ptr<LocalPredictorURLInfo> url_info,
+    CandidatePrerenderInfo* info,
+    LocalPredictorURLInfo* url_info,
     PrerenderProperties* prerender_properties) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  RecordEvent(EVENT_CONTINUE_PRERENDER_CHECK_ISSUING_PRERENDER);
+  DCHECK(prerender_properties != NULL);
+  DCHECK(info != NULL);
+  DCHECK(url_info != NULL);
+  if (!IsLocalPredictorPrerenderLaunchEnabled())
+    return;
   URLID url_id = url_info->id;
   const GURL& url = url_info->url;
   double priority = url_info->priority;
   base::Time current_time = GetCurrentTime();
   RecordEvent(EVENT_ISSUING_PRERENDER);
 
   // Issue the prerender and obtain a new handle.
   scoped_ptr<prerender::PrerenderHandle> new_prerender_handle(
       prerender_manager_->AddPrerenderFromLocalPredictor(
           url, info->session_storage_namespace_.get(), *(info->size_)));
@@ skipping 23 matching lines @@
     prerender_properties->start_time = current_time;
     prerender_properties->actual_start_time = current_time;
     prerender_properties->would_have_matched = false;
     prerender_properties->prerender_handle.swap(new_prerender_handle);
     // new_prerender_handle now represents the old previou prerender that we
     // are replacing. So we need to cancel it.
     if (new_prerender_handle) {
       new_prerender_handle->OnCancel();
       RecordEvent(EVENT_ISSUE_PRERENDER_CANCELLED_OLD_PRERENDER);
     }
+    // If we are prefetching rather than prerendering, now is the time to launch
+    // the prefetch.
+    if (IsLocalPredictorPrerenderPrefetchEnabled()) {
+      // Obtain the render frame host that caused this prefetch.
+      RenderFrameHost* rfh = RenderFrameHost::FromID(info->render_process_id_,
+                                                     info->render_frame_id_);
+      // If it is still alive, launch the prefresh.
+      if (rfh)
+        rfh->Send(new PrefetchMsg_Prefetch(rfh->GetRoutingID(), url));
+    }
   }
 
   RecordEvent(EVENT_ADD_VISIT_PRERENDERING);
   if (current_prerender_.get() && current_prerender_->url_id == url_id) {
     RecordEvent(EVENT_ADD_VISIT_PRERENDERING_EXTENDED);
     if (priority > current_prerender_->priority)
       current_prerender_->priority = priority;
     // If the prerender already existed, we want to extend it.  However,
     // we do not want to set its start_time to the current time to
     // disadvantage PLT computations when the prerender is swapped in.
@@ skipping 106 matching lines @@
       break;
     case content::SessionStorageNamespace::MERGE_RESULT_MERGEABLE:
       RecordEvent(EVENT_NAMESPACE_MISMATCH_MERGE_RESULT_MERGEABLE);
       break;
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace prerender