chrome/browser/prerender/prerender_tab_helper.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_tab_helper.h"
   6
   7 #include "base/bind.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/time/time.h"
  10 #include "chrome/browser/password_manager/password_manager.h"
  11 #include "chrome/browser/prerender/prerender_histograms.h"
  12 #include "chrome/browser/prerender/prerender_local_predictor.h"
  13 #include "chrome/browser/prerender/prerender_manager.h"
  14 #include "chrome/browser/prerender/prerender_manager_factory.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "content/public/browser/navigation_details.h"
  17 #include "content/public/browser/navigation_entry.h"
  18 #include "content/public/browser/render_view_host.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "content/public/common/frame_navigate_params.h"
  21
  22 using content::WebContents;
  23
  24 DEFINE_WEB_CONTENTS_USER_DATA_KEY(prerender::PrerenderTabHelper);
  25
  26 namespace prerender {
  27
  28 namespace {
  29
  30 void ReportTabHelperURLSeenToLocalPredictor(
  31     PrerenderManager* prerender_manager,
  32     const GURL& url,
  33     WebContents* web_contents) {
  34   if (!prerender_manager)
  35     return;
  36   PrerenderLocalPredictor* local_predictor =
  37       prerender_manager->local_predictor();
  38   if (!local_predictor)
  39     return;
  40   local_predictor->OnTabHelperURLSeen(url, web_contents);
  41 }
  42
  43 }  // namespace
  44
  45 // static
  46 void PrerenderTabHelper::CreateForWebContentsWithPasswordManager(
  47     content::WebContents* web_contents,
  48     PasswordManager* password_manager) {
  49   if (!FromWebContents(web_contents)) {
  50     web_contents->SetUserData(UserDataKey(),
  51                               new PrerenderTabHelper(web_contents,
  52                                                      password_manager));
  53   }
  54 }
  55
  56 PrerenderTabHelper::PrerenderTabHelper(content::WebContents* web_contents,
  57                                        PasswordManager* password_manager)
  58     : content::WebContentsObserver(web_contents),
  59       origin_(ORIGIN_NONE),
  60       next_load_is_control_prerender_(false),
  61       next_load_origin_(ORIGIN_NONE),
  62       weak_factory_(this) {
  63   if (password_manager) {
  64     // May be NULL in testing.
  65     password_manager->AddSubmissionCallback(
  66         base::Bind(&PrerenderTabHelper::PasswordSubmitted,
  67                    weak_factory_.GetWeakPtr()));
  68   }
  69
  70   // Determine if this is a prerender.
  71   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
  72   if (prerender_manager &&
  73       prerender_manager->IsWebContentsPrerendering(web_contents, &origin_)) {
  74     navigation_type_ = NAVIGATION_TYPE_PRERENDERED;
  75   } else {
  76     navigation_type_ = NAVIGATION_TYPE_NORMAL;
  77   }
  78 }
  79
  80 PrerenderTabHelper::~PrerenderTabHelper() {
  81 }
  82
  83 void PrerenderTabHelper::ProvisionalChangeToMainFrameUrl(
  84     const GURL& url,
  85     content::RenderFrameHost* render_frame_host) {
  86   url_ = url;
  87   RecordEvent(EVENT_MAINFRAME_CHANGE);
  88   RecordEventIfLoggedInURL(EVENT_MAINFRAME_CHANGE_DOMAIN_LOGGED_IN, url);
  89   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
  90   if (!prerender_manager)
  91     return;
  92   if (prerender_manager->IsWebContentsPrerendering(web_contents(), NULL))
  93     return;
  94   ReportTabHelperURLSeenToLocalPredictor(prerender_manager, url,
  95                                          web_contents());
  96 }
  97
  98 void PrerenderTabHelper::DidCommitProvisionalLoadForFrame(
  99     int64 frame_id,
 100     const base::string16& frame_unique_name,
 101     bool is_main_frame,
 102     const GURL& validated_url,
 103     content::PageTransition transition_type,
 104     content::RenderViewHost* render_view_host) {
 105   if (!is_main_frame)
 106     return;
 107   RecordEvent(EVENT_MAINFRAME_COMMIT);
 108   RecordEventIfLoggedInURL(EVENT_MAINFRAME_COMMIT_DOMAIN_LOGGED_IN,
 109                            validated_url);
 110   url_ = validated_url;
 111   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
 112   if (!prerender_manager)
 113     return;
 114   if (prerender_manager->IsWebContentsPrerendering(web_contents(), NULL))
 115     return;
 116   prerender_manager->RecordNavigation(validated_url);
 117   ReportTabHelperURLSeenToLocalPredictor(prerender_manager, validated_url,
 118                                          web_contents());
 119 }
 120
 121 void PrerenderTabHelper::DidStopLoading(
 122     content::RenderViewHost* render_view_host) {
 123   // Compute the PPLT metric and report it in a histogram, if needed. If the
 124   // page is still prerendering, record the not swapped in page load time
 125   // instead.
 126   if (!pplt_load_start_.is_null()) {
 127     base::TimeTicks now = base::TimeTicks::Now();
 128     if (IsPrerendering()) {
 129       PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
 130       if (prerender_manager) {
 131         prerender_manager->RecordPageLoadTimeNotSwappedIn(
 132             origin_, now - pplt_load_start_, url_);
 133       } else {
 134         NOTREACHED();
 135       }
 136     } else {
 137       double fraction_elapsed_at_swapin = -1.0;
 138       if (!actual_load_start_.is_null()) {
 139         double plt = (now - actual_load_start_).InMillisecondsF();
 140         if (plt > 0.0) {
 141           fraction_elapsed_at_swapin = 1.0 -
 142               (now - pplt_load_start_).InMillisecondsF() / plt;
 143         } else {
 144           fraction_elapsed_at_swapin = 1.0;
 145         }
 146         DCHECK_GE(fraction_elapsed_at_swapin, 0.0);
 147         DCHECK_LE(fraction_elapsed_at_swapin, 1.0);
 148       }
 149
 150       RecordPerceivedPageLoadTime(
 151           now - pplt_load_start_, fraction_elapsed_at_swapin);
 152     }
 153   }
 154
 155   // Reset the PPLT metric.
 156   pplt_load_start_ = base::TimeTicks();
 157   actual_load_start_ = base::TimeTicks();
 158 }
 159
 160 void PrerenderTabHelper::DidStartProvisionalLoadForFrame(
 161       int64 frame_id,
 162       int64 parent_frame_id,
 163       bool is_main_frame,
 164       const GURL& validated_url,
 165       bool is_error_page,
 166       bool is_iframe_srcdoc,
 167       content::RenderViewHost* render_view_host) {
 168   if (!is_main_frame)
 169     return;
 170
 171   // Record PPLT state for the beginning of a new navigation.
 172   pplt_load_start_ = base::TimeTicks::Now();
 173   actual_load_start_ = base::TimeTicks();
 174
 175   if (next_load_is_control_prerender_) {
 176     DCHECK_EQ(NAVIGATION_TYPE_NORMAL, navigation_type_);
 177     navigation_type_ = NAVIGATION_TYPE_WOULD_HAVE_BEEN_PRERENDERED;
 178     origin_ = next_load_origin_;
 179     next_load_is_control_prerender_ = false;
 180     next_load_origin_ = ORIGIN_NONE;
 181   }
 182 }
 183
 184 void PrerenderTabHelper::PasswordSubmitted(const autofill::PasswordForm& form) {
 185   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
 186   if (prerender_manager) {
 187     prerender_manager->RecordLikelyLoginOnURL(form.origin);
 188     RecordEvent(EVENT_LOGIN_ACTION_ADDED);
 189     if (form.password_value.empty())
 190       RecordEvent(EVENT_LOGIN_ACTION_ADDED_PW_EMPTY);
 191   }
 192 }
 193
 194 PrerenderManager* PrerenderTabHelper::MaybeGetPrerenderManager() const {
 195   return PrerenderManagerFactory::GetForProfile(
 196       Profile::FromBrowserContext(web_contents()->GetBrowserContext()));
 197 }
 198
 199 bool PrerenderTabHelper::IsPrerendering() {
 200   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
 201   if (!prerender_manager)
 202     return false;
 203   return prerender_manager->IsWebContentsPrerendering(web_contents(), NULL);
 204 }
 205
 206 void PrerenderTabHelper::PrerenderSwappedIn() {
 207   // Ensure we are not prerendering any more.
 208   DCHECK_EQ(NAVIGATION_TYPE_PRERENDERED, navigation_type_);
 209   DCHECK(!IsPrerendering());
 210   if (pplt_load_start_.is_null()) {
 211     // If we have already finished loading, report a 0 PPLT.
 212     RecordPerceivedPageLoadTime(base::TimeDelta(), 1.0);
 213     DCHECK_EQ(NAVIGATION_TYPE_NORMAL, navigation_type_);
 214   } else {
 215     // If we have not finished loading yet, record the actual load start, and
 216     // rebase the start time to now.
 217     actual_load_start_ = pplt_load_start_;
 218     pplt_load_start_ = base::TimeTicks::Now();
 219   }
 220 }
 221
 222 void PrerenderTabHelper::WouldHavePrerenderedNextLoad(Origin origin) {
 223   next_load_is_control_prerender_ = true;
 224   next_load_origin_ = origin;
 225 }
 226
 227 void PrerenderTabHelper::RecordEvent(PrerenderTabHelper::Event event) const {
 228   UMA_HISTOGRAM_ENUMERATION("Prerender.TabHelperEvent",
 229                             event, PrerenderTabHelper::EVENT_MAX_VALUE);
 230 }
 231
 232 void PrerenderTabHelper::RecordEventIfLoggedInURL(
 233     PrerenderTabHelper::Event event, const GURL& url) {
 234   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
 235   if (!prerender_manager)
 236     return;
 237   scoped_ptr<bool> is_present(new bool);
 238   scoped_ptr<bool> lookup_succeeded(new bool);
 239   bool* is_present_ptr = is_present.get();
 240   bool* lookup_succeeded_ptr = lookup_succeeded.get();
 241   prerender_manager->CheckIfLikelyLoggedInOnURL(
 242       url,
 243       is_present_ptr,
 244       lookup_succeeded_ptr,
 245       base::Bind(&PrerenderTabHelper::RecordEventIfLoggedInURLResult,
 246                  weak_factory_.GetWeakPtr(),
 247                  event,
 248                  base::Passed(&is_present),
 249                  base::Passed(&lookup_succeeded)));
 250 }
 251
 252 void PrerenderTabHelper::RecordEventIfLoggedInURLResult(
 253     PrerenderTabHelper::Event event,
 254     scoped_ptr<bool> is_present,
 255     scoped_ptr<bool> lookup_succeeded) {
 256   if (*lookup_succeeded && *is_present)
 257     RecordEvent(event);
 258 }
 259
 260 void PrerenderTabHelper::RecordPerceivedPageLoadTime(
 261     base::TimeDelta perceived_page_load_time,
 262     double fraction_plt_elapsed_at_swap_in) {
 263   DCHECK(!IsPrerendering());
 264   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
 265   if (!prerender_manager)
 266     return;
 267
 268   // Note: it is possible for |next_load_is_control_prerender_| to be true at
 269   // this point. This does not affect the classification of the current load,
 270   // but only the next load. (This occurs if a WOULD_HAVE_BEEN_PRERENDERED
 271   // navigation interrupts and aborts another navigation.)
 272   prerender_manager->RecordPerceivedPageLoadTime(
 273       origin_, navigation_type_, perceived_page_load_time,
 274       fraction_plt_elapsed_at_swap_in, url_);
 275
 276   // Reset state for the next navigation.
 277   navigation_type_ = NAVIGATION_TYPE_NORMAL;
 278   origin_ = ORIGIN_NONE;
 279 }
 280
 281 }  // namespace prerender