Remove PrerenderLocalPredictor, part 1.

chrome/browser/prerender/prerender_tab_helper.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_tab_helper.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
-#include "chrome/browser/password_manager/chrome_password_manager_client.h"
 #include "chrome/browser/prerender/prerender_histograms.h"
-#include "chrome/browser/prerender/prerender_local_predictor.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
-#include "components/password_manager/core/browser/password_manager.h"
-#include "content/public/browser/navigation_details.h"
-#include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/common/frame_navigate_params.h"
 
 using content::WebContents;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(prerender::PrerenderTabHelper);
 
 namespace prerender {
 
-namespace {
-
-void ReportTabHelperURLSeenToLocalPredictor(
-    PrerenderManager* prerender_manager,
-    const GURL& url,
-    WebContents* web_contents) {
-  if (!prerender_manager)
-    return;
-  PrerenderLocalPredictor* local_predictor =
-      prerender_manager->local_predictor();
-  if (!local_predictor)
-    return;
-  local_predictor->OnTabHelperURLSeen(url, web_contents);
-}
-
-}  // namespace
-
 PrerenderTabHelper::PrerenderTabHelper(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       origin_(ORIGIN_NONE),
       next_load_is_control_prerender_(false),
       next_load_origin_(ORIGIN_NONE),
       weak_factory_(this) {
-  ChromePasswordManagerClient* client =
-      ChromePasswordManagerClient::FromWebContents(web_contents);
-  // May be NULL during testing.
-  if (client) {
-    client->GetPasswordManager()->AddSubmissionCallback(base::Bind(
-        &PrerenderTabHelper::PasswordSubmitted, weak_factory_.GetWeakPtr()));
-  }
-
   // Determine if this is a prerender.
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (prerender_manager &&
       prerender_manager->IsWebContentsPrerendering(web_contents, &origin_)) {
     navigation_type_ = NAVIGATION_TYPE_PRERENDERED;
   } else {
     navigation_type_ = NAVIGATION_TYPE_NORMAL;
   }
 }
 
 PrerenderTabHelper::~PrerenderTabHelper() {
 }
 
 void PrerenderTabHelper::DidGetRedirectForResourceRequest(
     content::RenderFrameHost* render_frame_host,
     const content::ResourceRedirectDetails& details) {
   if (details.resource_type != content::RESOURCE_TYPE_MAIN_FRAME)
     return;
 
   MainFrameUrlDidChange(details.new_url);
 }
 
 void PrerenderTabHelper::DidCommitProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     ui::PageTransition transition_type) {
   if (render_frame_host->GetParent())
     return;
-  RecordEvent(EVENT_MAINFRAME_COMMIT);
-  RecordEventIfLoggedInURL(EVENT_MAINFRAME_COMMIT_DOMAIN_LOGGED_IN,
-                           validated_url);
   url_ = validated_url;
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
     return;
   if (prerender_manager->IsWebContentsPrerendering(web_contents(), NULL))
     return;
   prerender_manager->RecordNavigation(validated_url);
-  ReportTabHelperURLSeenToLocalPredictor(prerender_manager, validated_url,
-                                         web_contents());
 }
 
 void PrerenderTabHelper::DidStopLoading() {
   // Compute the PPLT metric and report it in a histogram, if needed. If the
   // page is still prerendering, record the not swapped in page load time
   // instead.
   if (!pplt_load_start_.is_null()) {
     base::TimeTicks now = base::TimeTicks::Now();
     if (IsPrerendering()) {
       PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
@@ skipping 45 matching lines @@
     origin_ = next_load_origin_;
     next_load_is_control_prerender_ = false;
     next_load_origin_ = ORIGIN_NONE;
   }
 
   MainFrameUrlDidChange(validated_url);
 }
 
 void PrerenderTabHelper::MainFrameUrlDidChange(const GURL& url) {
   url_ = url;
-  RecordEvent(EVENT_MAINFRAME_CHANGE);
-  RecordEventIfLoggedInURL(EVENT_MAINFRAME_CHANGE_DOMAIN_LOGGED_IN, url);
-  PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
-  if (!prerender_manager)
-    return;
-  if (prerender_manager->IsWebContentsPrerendering(web_contents(), NULL))
-    return;
-  ReportTabHelperURLSeenToLocalPredictor(prerender_manager, url,
-                                         web_contents());
-}
-
-void PrerenderTabHelper::PasswordSubmitted(const autofill::PasswordForm& form) {
-  PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
-  if (prerender_manager) {
-    prerender_manager->RecordLikelyLoginOnURL(form.origin);
-    RecordEvent(EVENT_LOGIN_ACTION_ADDED);
-    if (form.password_value.empty())
-      RecordEvent(EVENT_LOGIN_ACTION_ADDED_PW_EMPTY);
-  }
 }
 
 PrerenderManager* PrerenderTabHelper::MaybeGetPrerenderManager() const {
   return PrerenderManagerFactory::GetForProfile(
       Profile::FromBrowserContext(web_contents()->GetBrowserContext()));
 }
 
 bool PrerenderTabHelper::IsPrerendering() {
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
@@ skipping 15 matching lines @@
     actual_load_start_ = pplt_load_start_;
     pplt_load_start_ = base::TimeTicks::Now();
   }
 }
 
 void PrerenderTabHelper::WouldHavePrerenderedNextLoad(Origin origin) {
   next_load_is_control_prerender_ = true;
   next_load_origin_ = origin;
 }
 
-void PrerenderTabHelper::RecordEvent(PrerenderTabHelper::Event event) const {
-  UMA_HISTOGRAM_ENUMERATION("Prerender.TabHelperEvent",
-                            event, PrerenderTabHelper::EVENT_MAX_VALUE);
-}
-
-void PrerenderTabHelper::RecordEventIfLoggedInURL(
-    PrerenderTabHelper::Event event, const GURL& url) {
-  PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
-  if (!prerender_manager)
-    return;
-  scoped_ptr<bool> is_present(new bool);
-  scoped_ptr<bool> lookup_succeeded(new bool);
-  bool* is_present_ptr = is_present.get();
-  bool* lookup_succeeded_ptr = lookup_succeeded.get();
-  prerender_manager->CheckIfLikelyLoggedInOnURL(
-      url,
-      is_present_ptr,
-      lookup_succeeded_ptr,
-      base::Bind(&PrerenderTabHelper::RecordEventIfLoggedInURLResult,
-                 weak_factory_.GetWeakPtr(),
-                 event,
-                 base::Passed(&is_present),
-                 base::Passed(&lookup_succeeded)));
-}
-
-void PrerenderTabHelper::RecordEventIfLoggedInURLResult(
-    PrerenderTabHelper::Event event,
-    scoped_ptr<bool> is_present,
-    scoped_ptr<bool> lookup_succeeded) {
-  if (*lookup_succeeded && *is_present)
-    RecordEvent(event);
-}
-
 void PrerenderTabHelper::RecordPerceivedPageLoadTime(
     base::TimeDelta perceived_page_load_time,
     double fraction_plt_elapsed_at_swap_in) {
   DCHECK(!IsPrerendering());
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
     return;
 
   // Note: it is possible for |next_load_is_control_prerender_| to be true at
   // this point. This does not affect the classification of the current load,
   // but only the next load. (This occurs if a WOULD_HAVE_BEEN_PRERENDERED
   // navigation interrupts and aborts another navigation.)
   prerender_manager->RecordPerceivedPageLoadTime(
       origin_, navigation_type_, perceived_page_load_time,
       fraction_plt_elapsed_at_swap_in, url_);
 
   // Reset state for the next navigation.
   navigation_type_ = NAVIGATION_TYPE_NORMAL;
   origin_ = ORIGIN_NONE;
 }
 
 }  // namespace prerender