Make PrerenderHandle an observer of PrerenderContents.

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>
 
-#include "base/process_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/history/history_tab_helper.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_render_view_host_observer.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 14 matching lines @@
 
 using content::DownloadItem;
 using content::OpenURLParams;
 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, Profile* profile,
       const GURL& url, const content::Referrer& referrer,
       Origin origin, uint8 experiment_id) OVERRIDE {
     return new PrerenderContents(prerender_manager, profile,
                                  url, referrer, origin, experiment_id);
   }
 };
@@ skipping 77 matching lines @@
                                        bool user_gesture) OVERRIDE {
     // TODO(mmenke): Consider supporting this if it is a common case during
     // prerenders.
     prerender_contents_->Destroy(FINAL_STATUS_REGISTER_PROTOCOL_HANDLER);
   }
 
  private:
   PrerenderContents* prerender_contents_;
 };
 
+void PrerenderContents::Observer::OnPrerenderAddAlias(
+    PrerenderContents* contents,
+    const GURL& alias_url) {
+}
+
+void PrerenderContents::Observer::OnPrerenderCreatedMatchCompleteReplacement(
+    PrerenderContents* contents, PrerenderContents* replacement) {
+}
+
 PrerenderContents::Observer::Observer() {
 }
 
 PrerenderContents::Observer::~Observer() {
 }
 
 PrerenderContents::PendingPrerenderInfo::PendingPrerenderInfo(
     base::WeakPtr<PrerenderHandle> weak_prerender_handle,
     Origin origin,
     const GURL& url,
     const content::Referrer& referrer,
     const gfx::Size& size) : weak_prerender_handle(weak_prerender_handle),
                              origin(origin),
                              url(url),
                              referrer(referrer),
                              size(size) {
 }
 
 PrerenderContents::PendingPrerenderInfo::~PendingPrerenderInfo() {
 }
 
 void PrerenderContents::AddPendingPrerender(
     scoped_ptr<PendingPrerenderInfo> pending_prerender_info) {
   pending_prerenders_.push_back(pending_prerender_info.release());
 }
 
-void PrerenderContents::StartPendingPrerenders() {
+void PrerenderContents::PrepareForUse() {
+  NotifyPrerenderStop();
+
   SessionStorageNamespace* session_storage_namespace = NULL;
   if (prerender_contents_) {
     // TODO(ajwong): This does not correctly handle storage for isolated apps.
     session_storage_namespace = prerender_contents_->
         GetController().GetDefaultSessionStorageNamespace();
   }
   prerender_manager_->StartPendingPrerenders(
       child_id_, &pending_prerenders_, session_storage_namespace);
   pending_prerenders_.clear();
 }
@@ skipping 18 matching lines @@
       match_complete_status_(MATCH_COMPLETE_DEFAULT),
       prerendering_has_been_cancelled_(false),
       child_id_(-1),
       route_id_(-1),
       origin_(origin),
       experiment_id_(experiment_id),
       creator_child_id_(-1) {
   DCHECK(prerender_manager != NULL);
 }
 
-PrerenderContents* PrerenderContents::CreateMatchCompleteReplacement() const {
+PrerenderContents* PrerenderContents::CreateMatchCompleteReplacement() {
   PrerenderContents* new_contents = prerender_manager_->CreatePrerenderContents(
       prerender_url(), referrer(), origin(), experiment_id());
 
   new_contents->load_start_time_ = load_start_time_;
   new_contents->session_storage_namespace_id_ = session_storage_namespace_id_;
   new_contents->set_match_complete_status(
       PrerenderContents::MATCH_COMPLETE_REPLACEMENT_PENDING);
 
   const bool did_init = new_contents->Init();
   DCHECK(did_init);
   DCHECK_EQ(alias_urls_.front(), new_contents->alias_urls_.front());
   DCHECK_EQ(1u, new_contents->alias_urls_.size());
   new_contents->alias_urls_ = alias_urls_;
   new_contents->set_match_complete_status(
       PrerenderContents::MATCH_COMPLETE_REPLACEMENT);
+  NotifyPrerenderCreatedMatchCompleteReplacement(new_contents);
   return new_contents;
 }
 
 bool PrerenderContents::Init() {
   return AddAliasURL(prerender_url_);
 }
 
 // static
 PrerenderContents::Factory* PrerenderContents::CreateFactory() {
   return new PrerenderContentsFactoryImpl();
 }
 
 void PrerenderContents::StartPrerendering(
     int creator_child_id,
     const gfx::Size& size,
     SessionStorageNamespace* session_storage_namespace) {
   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;
   session_storage_namespace_id_ = session_storage_namespace->id();
   size_ = size;
 
-  InformRenderProcessAboutPrerender(prerender_url_, true,
-                                    creator_child_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 (prerender_manager_->IsControlGroup(experiment_id()))
     return;
 
   prerendering_has_started_ = true;
@@ skipping 70 matching lines @@
   DCHECK_GE(route_id_, -1);
   *route_id = route_id_;
   return route_id_ != -1;
 }
 
 void PrerenderContents::SetFinalStatus(FinalStatus final_status) {
   DCHECK(final_status >= FINAL_STATUS_USED && final_status < FINAL_STATUS_MAX);
   DCHECK(final_status_ == FINAL_STATUS_MAX);
 
   final_status_ = final_status;
-
-  if (!prerender_manager_->IsControlGroup(experiment_id()) &&
-      prerendering_has_started()) {
-    NotifyPrerenderStop();
-  }
 }
 
 PrerenderContents::~PrerenderContents() {
   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());
 
-  if (child_id_ != -1 && route_id_ != -1) {
-    for (std::vector<GURL>::const_iterator it = alias_urls_.begin();
-         it != alias_urls_.end();
-         ++it) {
-      InformRenderProcessAboutPrerender(*it, false, creator_child_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::AddObserver(Observer* observer) {
   DCHECK_EQ(FINAL_STATUS_MAX, final_status_);
   observer_list_.AddObserver(observer);
 }
 
+void PrerenderContents::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
 void PrerenderContents::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_DESTROYED:
       Destroy(FINAL_STATUS_PROFILE_DESTROYED);
       return;
 
     case chrome::NOTIFICATION_APP_TERMINATING:
       Destroy(FINAL_STATUS_APP_TERMINATING);
@@ skipping 76 matching lines @@
   DCHECK_EQ(FINAL_STATUS_MAX, final_status_);
   FOR_EACH_OBSERVER(Observer, observer_list_, OnPrerenderStart(this));
 }
 
 void PrerenderContents::NotifyPrerenderStop() {
   DCHECK_NE(FINAL_STATUS_MAX, final_status_);
   FOR_EACH_OBSERVER(Observer, observer_list_, OnPrerenderStop(this));
   observer_list_.Clear();
 }
 
+void PrerenderContents::NotifyPrerenderAddAlias(const GURL& alias_url) {
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnPrerenderAddAlias(this,
+                                                                  alias_url));
+}
+
+void PrerenderContents::NotifyPrerenderCreatedMatchCompleteReplacement(
+    PrerenderContents* replacement) {
+  FOR_EACH_OBSERVER(Observer, observer_list_,
+                    OnPrerenderCreatedMatchCompleteReplacement(this,
+                                                               replacement));
+}
+
 void PrerenderContents::DidUpdateFaviconURL(
     int32 page_id,
     const std::vector<content::FaviconURL>& urls) {
   VLOG(1) << "PrerenderContents::OnUpdateFaviconURL" << icon_url_;
   for (std::vector<content::FaviconURL>::const_iterator it = urls.begin();
        it != urls.end(); ++it) {
     if (it->icon_type == content::FaviconURL::FAVICON) {
       icon_url_ = it->icon_url;
       VLOG(1) << icon_url_;
       return;
@@ skipping 14 matching lines @@
     Destroy(FINAL_STATUS_HTTPS);
     return false;
   }
   if (match_complete_status_ != MATCH_COMPLETE_REPLACEMENT_PENDING &&
       prerender_manager_->HasRecentlyBeenNavigatedTo(origin(), url)) {
     Destroy(FINAL_STATUS_RECENTLY_VISITED);
     return false;
   }
 
   alias_urls_.push_back(url);
-  InformRenderProcessAboutPrerender(url, true, creator_child_id_);
+  NotifyPrerenderAddAlias(url);
   return true;
 }
 
 bool PrerenderContents::Matches(
     const GURL& url,
     const SessionStorageNamespace* session_storage_namespace) const {
   DCHECK(child_id_ == -1 || session_storage_namespace);
   if (session_storage_namespace &&
       session_storage_namespace_id_ != session_storage_namespace->id())
     return false;
@@ skipping 33 matching lines @@
 
 void PrerenderContents::DidFinishLoad(int64 frame_id,
                                       const GURL& validated_url,
                                       bool is_main_frame,
                                       RenderViewHost* render_view_host) {
   if (is_main_frame)
     has_finished_loading_ = true;
 }
 
 void PrerenderContents::Destroy(FinalStatus final_status) {
+  DCHECK_NE(final_status, FINAL_STATUS_USED);
+
   if (prerendering_has_been_cancelled_)
     return;
 
   if (child_id_ != -1 && route_id_ != -1) {
     // Cancel the prerender in the PrerenderTracker.  This is needed
     // because destroy may be called directly from the UI thread without calling
     // TryCancel().  This is difficult to completely avoid, since prerendering
     // can be cancelled before a RenderView is created.
     bool is_cancelled = prerender_manager()->prerender_tracker()->TryCancel(
         child_id_, route_id_, final_status);
     CHECK(is_cancelled);
 
     // A different final status may have been set already from another thread.
     // If so, use it instead.
     if (!prerender_manager()->prerender_tracker()->
             GetFinalStatus(child_id_, route_id_, &final_status)) {
       NOTREACHED();
     }
   }
   SetFinalStatus(final_status);
 
   prerendering_has_been_cancelled_ = true;
   prerender_manager_->AddToHistory(this);
   prerender_manager_->MoveEntryToPendingDelete(this, final_status);
 
+  if (!prerender_manager_->IsControlGroup(experiment_id()) &&
+      (prerendering_has_started() ||
+       match_complete_status() == MATCH_COMPLETE_REPLACEMENT)) {
+    NotifyPrerenderStop();
+  }
+
   // 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_)
     render_view_host_observer_->set_prerender_contents(NULL);
 }
 
 base::ProcessMetrics* PrerenderContents::MaybeGetProcessMetrics() {
   if (process_metrics_.get() == NULL) {
     // If a PrenderContents hasn't started prerending, don't be fully formed.
@@ skipping 67 matching lines @@
 
 bool PrerenderContents::IsCrossSiteNavigationPending() const {
   if (!prerender_contents_)
     return false;
   return (prerender_contents_->GetSiteInstance() !=
           prerender_contents_->GetPendingSiteInstance());
 }
 
 
 }  // namespace prerender