Prerendering: Add MatchComplete PPLT

chrome/browser/prerender/prerender_contents.cc

 // Copyright (c) 2011 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_contents.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/process_util.h"
@@ skipping 185 matching lines @@
       prerendering_has_been_cancelled_(false),
       child_id_(-1),
       route_id_(-1),
       starting_page_id_(-1),
       origin_(origin),
       experiment_id_(experiment_id) {
   DCHECK(prerender_manager != NULL);
 }
 
 bool PrerenderContents::Init() {
-  return AddAliasURL(prerender_url_);
+  return AddAliasURL(prerender_url_, false/*destroy_on_failure*/);
 }
 
 // static
 PrerenderContents::Factory* PrerenderContents::CreateFactory() {
   return new PrerenderContentsFactoryImpl();
 }
 
 void PrerenderContents::StartPrerendering(
     const RenderViewHost* source_render_view_host,
     SessionStorageNamespace* session_storage_namespace) {
@@ skipping 125 matching lines @@
 bool PrerenderContents::GetRouteId(int* route_id) const {
   CHECK(route_id);
   DCHECK_GE(route_id_, -1);
   *route_id = route_id_;
   return route_id_ != -1;
 }
 
 void PrerenderContents::set_final_status(FinalStatus final_status) {
   DCHECK(final_status >= FINAL_STATUS_USED && final_status < FINAL_STATUS_MAX);
   DCHECK(final_status_ == FINAL_STATUS_MAX ||
-         final_status_ == FINAL_STATUS_CONTROL_GROUP);
+         final_status_ == FINAL_STATUS_CONTROL_GROUP ||
+         final_status_ == FINAL_STATUS_MATCH_COMPLETE_DUMMY);
 
-  // Don't override final_status_ if it's FINAL_STATUS_CONTROL_GROUP,
-  // otherwise data will be collected in the Prerender.FinalStatus histogram.
-  if (final_status_ == FINAL_STATUS_CONTROL_GROUP)
+  // Don't override final_status_ if it's FINAL_STATUS_CONTROL_GROUP or
+  // FINAL_STATUS_MATCH_COMPLETE_DUMMY, otherwise data will be collected
+  // in the Prerender.FinalStatus histogram.
+  if (final_status_ == FINAL_STATUS_CONTROL_GROUP ||
+      final_status_ == FINAL_STATUS_MATCH_COMPLETE_DUMMY)
     return;
 
   final_status_ = final_status;
 }
 
 PrerenderContents::~PrerenderContents() {
   DCHECK(final_status_ != FINAL_STATUS_MAX);
   DCHECK(prerendering_has_been_cancelled_ ||
          final_status_ == FINAL_STATUS_USED ||
-         final_status_ == FINAL_STATUS_CONTROL_GROUP);
+         final_status_ == FINAL_STATUS_CONTROL_GROUP ||
+         final_status_ == FINAL_STATUS_MATCH_COMPLETE_DUMMY);
   DCHECK(origin_ != ORIGIN_MAX);
 
   // If we haven't even started prerendering, we were just in the control
-  // group, which means we do not want to record the status.
+  // group (or a match complete dummy), which means we do not want to record
+  // the status.
   if (prerendering_has_started())
     prerender_manager_->RecordFinalStatus(origin_, experiment_id_,
                                           final_status_);
 
   if (child_id_ != -1 && route_id_ != -1)
     prerender_tracker_->OnPrerenderingFinished(child_id_, route_id_);
 
   // If we still have a TabContents, clean up anything we need to and then
   // destroy it.
   if (prerender_contents_.get())
@@ skipping 21 matching lines @@
       // to be remembered for future matching, and if it redirects to
       // an https resource, it needs to be canceled. If a subresource
       // is redirected, nothing changes.
       DCHECK(content::Source<RenderViewHostDelegate>(source).ptr() ==
              GetRenderViewHostDelegate());
       ResourceRedirectDetails* resource_redirect_details =
           content::Details<ResourceRedirectDetails>(details).ptr();
       CHECK(resource_redirect_details);
       if (resource_redirect_details->resource_type() ==
           ResourceType::MAIN_FRAME) {
-        if (!AddAliasURL(resource_redirect_details->new_url()))
+        if (!AddAliasURL(resource_redirect_details->new_url(),
+                         true/*destroy_on_failure*/))
           return;
       }
       break;
     }
 
     case content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB: {
       if (prerender_contents_.get()) {
         DCHECK_EQ(content::Source<TabContents>(source).ptr(),
                   prerender_contents_->tab_contents());
 
@@ skipping 50 matching lines @@
   for (std::vector<FaviconURL>::const_iterator it = urls.begin();
        it != urls.end(); ++it) {
     if (it->icon_type == FaviconURL::FAVICON) {
       icon_url_ = it->icon_url;
       VLOG(1) << icon_url_;
       return;
     }
   }
 }
 
-bool PrerenderContents::AddAliasURL(const GURL& url) {
+bool PrerenderContents::AddAliasURL(const GURL& url, bool destroy_on_failure) {

[dominich, 2011/11/11 20:02:09]

How does the caller know what final status to give it when destroying it?

   const bool http = url.SchemeIs(chrome::kHttpScheme);
   const bool https = url.SchemeIs(chrome::kHttpsScheme);
   if (!(http || https)) {
-    Destroy(FINAL_STATUS_UNSUPPORTED_SCHEME);
+    if (destroy_on_failure)
+      Destroy(FINAL_STATUS_UNSUPPORTED_SCHEME);
     return false;
   }
   if (https && !prerender_manager_->config().https_allowed) {
-    Destroy(FINAL_STATUS_HTTPS);
+    if (destroy_on_failure)
+      Destroy(FINAL_STATUS_HTTPS);
     return false;
   }
   if (prerender_manager_->HasRecentlyBeenNavigatedTo(url)) {
-    Destroy(FINAL_STATUS_RECENTLY_VISITED);
+    if (destroy_on_failure)
+      Destroy(FINAL_STATUS_RECENTLY_VISITED);
     return false;
   }
 
   alias_urls_.push_back(url);
   prerender_tracker_->AddPrerenderURLOnUIThread(url);
   return true;
 }
 
 bool PrerenderContents::MatchesURL(const GURL& url, GURL* matching_url) const {
   std::vector<GURL>::const_iterator matching_url_iterator =
@@ skipping 20 matching lines @@
   has_stopped_loading_ = true;
 }
 
 void PrerenderContents::DidStartProvisionalLoadForFrame(
     int64 frame_id,
     bool is_main_frame,
     const GURL& validated_url,
     bool is_error_page,
     RenderViewHost* render_view_host) {
   if (is_main_frame) {
-    if (!AddAliasURL(validated_url))
+    if (!AddAliasURL(validated_url, true/*destroy_on_failure*/))
       return;
 
     // Usually, this event fires if the user clicks or enters a new URL.
     // Neither of these can happen in the case of an invisible prerender.
     // So the cause is: Some JavaScript caused a new URL to be loaded.  In that
     // case, the spinner would start again in the browser, so we must reset
     // has_stopped_loading_ so that the spinner won't be stopped.
     has_stopped_loading_ = false;
   }
 }
@@ skipping 25 matching lines @@
     if (!prerender_tracker_->GetFinalStatus(child_id_, route_id_,
                                             &final_status)) {
       NOTREACHED();
     }
   }
   set_final_status(final_status);
 
   prerendering_has_been_cancelled_ = true;
   // This has to be done after setting the final status, as it adds the
   // prerender to the history.
-  prerender_manager_->MoveEntryToPendingDelete(this);
+  prerender_manager_->MoveEntryToPendingDelete(this, final_status);
 
   // We may destroy the PrerenderContents before we have initialized the
   // RenderViewHost. Otherwise set the Observer's PrerenderContents to NULL to
   // avoid any more messages being sent.
   if (render_view_host_observer_.get())
     render_view_host_observer_->set_prerender_contents(NULL);
 }
 
 base::ProcessMetrics* PrerenderContents::MaybeGetProcessMetrics() {
   if (process_metrics_.get() == NULL) {
@@ skipping 69 matching lines @@
 bool PrerenderContents::IsCrossSiteNavigationPending() const {
   if (!prerender_contents_.get() || !prerender_contents_->tab_contents())
     return false;
   const TabContents* tab_contents = prerender_contents_->tab_contents();
   return (tab_contents->GetSiteInstance() !=
           tab_contents->GetPendingSiteInstance());
 }
 
 
 }  // namespace prerender