Add PrerenderStatusEvent on Prerenders

chrome/browser/prerender/prerender_contents.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_contents.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
@@ skipping 18 matching lines @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_view.h"
 #include "ui/gfx/rect.h"
 
 using content::DownloadItem;
 using content::OpenURLParams;
+using content::RenderProcessHost;
 using content::RenderViewHost;
 using content::ResourceRedirectDetails;
 using content::SessionStorageNamespace;
 using content::WebContents;
 
 namespace prerender {
 
-namespace {
-
-// Tells the render process at |child_id| whether |url| is a new prerendered
-// page, or whether |url| is being removed as a prerendered page. Currently
-// this will only inform the render process that created the prerendered page
-// with <link rel="prerender"> tags about it. This means that if the user
-// clicks on a link for a prerendered URL in a different page, the prerender
-// will not be swapped in.
-void InformRenderProcessAboutPrerender(const GURL& url,
-                                       bool is_add,
-                                       int child_id) {
-  if (child_id < 0)
-    return;
-  content::RenderProcessHost* render_process_host =
-      content::RenderProcessHost::FromID(child_id);
-  if (!render_process_host)
-    return;
-  IPC::Message* message = NULL;
-  if (is_add)
-    message = new PrerenderMsg_AddPrerenderURL(url);
-  else
-    message = new PrerenderMsg_RemovePrerenderURL(url);
-  render_process_host->Send(message);
-}
-
-}  // namespace
-
 class PrerenderContentsFactoryImpl : public PrerenderContents::Factory {
  public:
   virtual PrerenderContents* CreatePrerenderContents(
       PrerenderManager* prerender_manager, PrerenderTracker* prerender_tracker,
       Profile* profile, const GURL& url, const content::Referrer& referrer,
       Origin origin, uint8 experiment_id) OVERRIDE {
     return new PrerenderContents(prerender_manager, prerender_tracker, profile,
                                  url, referrer, origin, experiment_id);
   }
 };
@@ skipping 204 matching lines @@
   return AddAliasURL(prerender_url_);
 }
 
 // static
 PrerenderContents::Factory* PrerenderContents::CreateFactory() {
   return new PrerenderContentsFactoryImpl();
 }
 
 void PrerenderContents::StartPrerendering(
     int creator_child_id,
+    int prerender_id,
     const gfx::Size& size,
     SessionStorageNamespace* session_storage_namespace,
     bool is_control_group) {
   DCHECK(profile_ != NULL);
   DCHECK(!size.IsEmpty());
   DCHECK(!prerendering_has_started_);
   DCHECK(prerender_contents_.get() == NULL);
   DCHECK_EQ(-1, creator_child_id_);
   DCHECK(size_.IsEmpty());
   DCHECK_EQ(1U, alias_urls_.size());
 
   creator_child_id_ = creator_child_id;
+  prerender_id_ = prerender_id;
   session_storage_namespace_id_ = session_storage_namespace->id();
   size_ = size;
 
-  InformRenderProcessAboutPrerender(prerender_url_, true,
-                                    creator_child_id_);
+  if (RenderProcessHost* host = RenderProcessHost::FromID(creator_child_id_))
+    host->Send(new PrerenderMsg_StartedPrerender(prerender_id_));
 
   DCHECK(load_start_time_.is_null());
   load_start_time_ = base::TimeTicks::Now();
 
   // Everything after this point sets up the WebContents object and associated
   // RenderView for the prerender page. Don't do this for members of the
   // control group.
   if (is_control_group)
     return;
 
@@ skipping 78 matching lines @@
 }
 
 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;
 }
 
 PrerenderContents::~PrerenderContents() {
-  DCHECK(final_status_ != FINAL_STATUS_MAX);
-  DCHECK(prerendering_has_been_cancelled_ ||
-         final_status_ == FINAL_STATUS_USED);
-  DCHECK(origin_ != ORIGIN_MAX);
+  DCHECK_NE(FINAL_STATUS_MAX, final_status_);
+  DCHECK(
+      prerendering_has_been_cancelled_ || final_status_ == FINAL_STATUS_USED);
+  DCHECK_NE(ORIGIN_MAX, origin_);
 
   prerender_manager_->RecordFinalStatusWithMatchCompleteStatus(
-      origin_,
-      experiment_id_,
-      match_complete_status_,
-      final_status_);
+      origin_, experiment_id_, match_complete_status_, final_status_);
 
   if (child_id_ != -1 && route_id_ != -1) {
     prerender_tracker_->OnPrerenderingFinished(child_id_, route_id_);
-    for (std::vector<GURL>::const_iterator it = alias_urls_.begin();
-         it != alias_urls_.end();
-         ++it) {
-      InformRenderProcessAboutPrerender(*it, false, creator_child_id_);
-    }
+    if (RenderProcessHost* host = RenderProcessHost::FromID(creator_child_id_))
+      host->Send(new PrerenderMsg_StoppedPrerender(prerender_id_));
   }
 
   // If we still have a WebContents, clean up anything we need to and then
   // destroy it.
   if (prerender_contents_.get())
     delete ReleasePrerenderContents();
 }
 
 void PrerenderContents::Observe(int type,
                                 const content::NotificationSource& source,
@@ skipping 102 matching lines @@
     Destroy(FINAL_STATUS_HTTPS);
     return false;
   }
   if (match_complete_status_ != MATCH_COMPLETE_REPLACEMENT_PENDING &&
       prerender_manager_->HasRecentlyBeenNavigatedTo(url)) {
     Destroy(FINAL_STATUS_RECENTLY_VISITED);
     return false;
   }
 
   alias_urls_.push_back(url);
-  InformRenderProcessAboutPrerender(url, true, creator_child_id_);
+  if (RenderProcessHost* host = RenderProcessHost::FromID(creator_child_id_))
+    host->Send(new PrerenderMsg_AddAliasToPrerender(prerender_id_, url));
   return true;
 }
 
 void PrerenderContents::AddAliasURLsFromOtherPrerenderContents(
     PrerenderContents* other_pc) {
   for (std::vector<GURL>::const_iterator it = other_pc->alias_urls_.begin();
        it != other_pc->alias_urls_.end();
        ++it) {
     alias_urls_.push_back(*it);
   }
@@ skipping 155 matching lines @@
 bool PrerenderContents::IsCrossSiteNavigationPending() const {
   if (!prerender_contents_.get() || !prerender_contents_->web_contents())
     return false;
   const WebContents* web_contents = prerender_contents_->web_contents();
   return (web_contents->GetSiteInstance() !=
           web_contents->GetPendingSiteInstance());
 }
 
 
 }  // namespace prerender