Add observer interface to 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>
 
@@ skipping 55 matching lines @@
   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,
+      PrerenderManager* prerender_manager, Profile* profile,
+      const GURL& url, const content::Referrer& referrer,
       Origin origin, uint8 experiment_id) OVERRIDE {
-    return new PrerenderContents(prerender_manager, prerender_tracker, profile,
+    return new PrerenderContents(prerender_manager, profile,
                                  url, referrer, origin, experiment_id);
   }
 };
 
 // TabContentsDelegateImpl -----------------------------------------------------
 
 class PrerenderContents::TabContentsDelegateImpl
     : public content::WebContentsDelegate {
  public:
   explicit TabContentsDelegateImpl(PrerenderContents* prerender_contents) :
@@ skipping 70 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_;
 };
 
+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) {
@@ skipping 15 matching lines @@
         prerender_contents_->web_contents()->GetController()
             .GetDefaultSessionStorageNamespace();
   }
   prerender_manager_->StartPendingPrerenders(
       child_id_, &pending_prerenders_, session_storage_namespace);
   pending_prerenders_.clear();
 }
 
 PrerenderContents::PrerenderContents(
     PrerenderManager* prerender_manager,
-    PrerenderTracker* prerender_tracker,
     Profile* profile,
     const GURL& url,
     const content::Referrer& referrer,
     Origin origin,
     uint8 experiment_id)
     : prerendering_has_started_(false),
       prerender_manager_(prerender_manager),
-      prerender_tracker_(prerender_tracker),
       prerender_url_(url),
       referrer_(referrer),
       profile_(profile),
       page_id_(0),
       session_storage_namespace_id_(-1),
       has_stopped_loading_(false),
       has_finished_loading_(false),
       final_status_(FINAL_STATUS_MAX),
       match_complete_status_(MATCH_COMPLETE_DEFAULT),
       prerendering_has_been_cancelled_(false),
@@ skipping 53 matching lines @@
   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 (is_control_group)
     return;

[mmenke, 2012/12/06 19:54:22]

This is Weird.  We use prerender_manager_->IsControlGroup() for
NotifyPrerenderStop(), but a function argument here.  Should do the same thing
in both cases.  I'd just go with the callback, but caching the value of
is_control_group works, too.

[gavinp, 2012/12/07 17:37:04]

Done.

 
   prerendering_has_started_ = true;
 
   WebContents* new_contents = CreateWebContents(session_storage_namespace);
   prerender_contents_.reset(
       TabContents::Factory::CreateTabContents(new_contents));
   content::WebContentsObserver::Observe(new_contents);
 
   tab_contents_delegate_.reset(new TabContentsDelegateImpl(this));
   new_contents->SetDelegate(tab_contents_delegate_.get());
 
   // Set the size of the prerender WebContents.
   prerender_contents_->web_contents()->GetView()->SizeContents(size_);
 
   // Register as an observer of the RenderViewHost so we get messages.
   render_view_host_observer_.reset(
       new PrerenderRenderViewHostObserver(this, GetRenderViewHostMutable()));
 
   child_id_ = GetRenderViewHost()->GetProcess()->GetID();
   route_id_ = GetRenderViewHost()->GetRoutingID();
 
   // Register this with the ResourceDispatcherHost as a prerender
   // RenderViewHost. This must be done before the Navigate message to catch all
   // resource requests, but as it is on the same thread as the Navigate message
   // (IO) there is no race condition.
-  prerender_tracker_->OnPrerenderingStarted(
-      child_id_,
-      route_id_,
-      prerender_manager_);
+  AddObserver(prerender_manager()->prerender_tracker());
+  NotifyPrerenderStart();
 
   // Close ourselves when the application is shutting down.
   notification_registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                               content::NotificationService::AllSources());
 
   // Register for our parent profile to shutdown, so we can shut ourselves down
   // as well (should only be called for OTR profiles, as we should receive
   // APP_TERMINATING before non-OTR profiles are destroyed).
   // TODO(tburkard): figure out if this is needed.
   notification_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
@@ skipping 32 matching lines @@
   return child_id_ != -1;
 }
 
 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) {
+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() && prerendering_has_started())
+    NotifyPrerenderStop();
 }
 
 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 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::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 64 matching lines @@
 WebContents* PrerenderContents::CreateWebContents(
     SessionStorageNamespace* session_storage_namespace) {
   // TODO(ajwong): Remove the temporary map once prerendering is aware of
   // multiple session storage namespaces per tab.
   content::SessionStorageNamespaceMap session_storage_namespace_map;
   session_storage_namespace_map[""] = session_storage_namespace;
   return  WebContents::CreateWithSessionStorage(
       profile_, NULL, MSG_ROUTING_NONE, NULL, session_storage_namespace_map);
 }
 
+void PrerenderContents::NotifyPrerenderStart() {
+  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::OnUpdateFaviconURL(
     int32 page_id,
     const std::vector<FaviconURL>& urls) {
   VLOG(1) << "PrerenderContents::OnUpdateFaviconURL" << icon_url_;
   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;
@@ skipping 76 matching lines @@
 
 void PrerenderContents::Destroy(FinalStatus final_status) {
   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_tracker_->TryCancel(
+    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_tracker_->GetFinalStatus(child_id_, route_id_,
-                                            &final_status)) {
+    if (!prerender_manager()->prerender_tracker()->
+            GetFinalStatus(child_id_, route_id_, &final_status)) {
       NOTREACHED();
     }
   }
-  set_final_status(final_status);
+  SetFinalStatus(final_status);
 
   prerendering_has_been_cancelled_ = true;
   prerender_manager_->AddToHistory(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_)
     render_view_host_observer_->set_prerender_contents(NULL);
@@ skipping 80 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