Make PrerenderHandle an observer of PrerenderContents.

chrome/browser/prerender/prerender_handle.cc

Index: chrome/browser/prerender/prerender_handle.cc
diff --git a/chrome/browser/prerender/prerender_handle.cc b/chrome/browser/prerender/prerender_handle.cc
index 24de791cdb0a9427ffd5ec3343c9d3ac4bcdb62c..ccdac3ccd879c9a4ebaf05dc75bd04694ed4e453 100644
--- a/chrome/browser/prerender/prerender_handle.cc
+++ b/chrome/browser/prerender/prerender_handle.cc
@@ -10,62 +10,116 @@
 
 namespace prerender {
 
+PrerenderHandle::Observer::~Observer() {
+}
+
+PrerenderHandle::Observer::Observer() {
+}
+
 PrerenderHandle::~PrerenderHandle() {
-  DCHECK(!IsValid());
-  // This shouldn't occur, but we also shouldn't leak if it does.
-  if (IsValid())
-    OnCancel();
+  if (prerender_data_)
+    prerender_data_->contents()->RemoveObserver(this);
 }
 
-void PrerenderHandle::OnNavigateAway() {
-  DCHECK(CalledOnValidThread());
-  if (!IsValid())
-    return;
-  prerender_data_->OnNavigateAwayByHandle();
-  prerender_data_.reset();
+void PrerenderHandle::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
 }
 
-void PrerenderHandle::OnCancel() {
-  DCHECK(CalledOnValidThread());
-  if (!IsValid())
-    return;
-  prerender_data_->OnCancelByHandle();
-  prerender_data_.reset();
+void PrerenderHandle::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
 }
 
-bool PrerenderHandle::IsValid() const {
-  return prerender_data_ != NULL;
+void PrerenderHandle::OnNavigateAway() {
+  DCHECK(CalledOnValidThread());
+  if (prerender_data_)
+    prerender_data_->OnHandleNavigatedAway(this);
 }
 
-bool PrerenderHandle::IsPending() const {
+void PrerenderHandle::OnCancel() {
   DCHECK(CalledOnValidThread());
-  return prerender_data_ && !prerender_data_->contents();
+  DCHECK(!has_been_canceled_);
+  has_been_canceled_ = true;
+  if (prerender_data_)
+    prerender_data_->OnHandleCanceled(this);
 }
 
 bool PrerenderHandle::IsPrerendering() const {
   DCHECK(CalledOnValidThread());
-  return prerender_data_ && prerender_data_->contents();
+  return prerender_data_ != NULL;
 }
 
 bool PrerenderHandle::IsFinishedLoading() const {
   DCHECK(CalledOnValidThread());
-  if (!prerender_data_ || IsPending())
+  if (!prerender_data_)
     return false;
   return prerender_data_->contents()->has_finished_loading();
 }
 
 PrerenderHandle::PrerenderHandle(
     PrerenderManager::PrerenderData* prerender_data)
-    : prerender_data_(prerender_data->AsWeakPtr()),
+    : has_been_canceled_(false),
       weak_ptr_factory_(this) {
-  prerender_data->OnNewHandle();
+  if (prerender_data) {
+    prerender_data_ = prerender_data->AsWeakPtr();
+    prerender_data->OnHandleCreated(this);
+  }
+}
+
+void PrerenderHandle::AdoptPrerenderDataFrom(PrerenderHandle* other_handle) {
+  DCHECK_EQ(static_cast<PrerenderManager::PrerenderData*>(NULL),
+            prerender_data_);
+  if (other_handle->prerender_data_ &&
+      other_handle->prerender_data_->contents()) {
+    other_handle->prerender_data_->contents()->RemoveObserver(other_handle);
+  }
+
+  prerender_data_ = other_handle->prerender_data_;
+  other_handle->prerender_data_.reset();
+
+  if (prerender_data_) {
+    DCHECK_NE(static_cast<PrerenderContents*>(NULL),
+              prerender_data_->contents());
+    prerender_data_->contents()->AddObserver(this);
+    // We are joining a prerender that has already started so we fire off an
+    // extra start event at ourselves.
+    OnPrerenderStart(prerender_data_->contents());
+  }
+}
+
+void PrerenderHandle::OnPrerenderStart(PrerenderContents* prerender_contents) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_EQ(prerender_data_->contents(), prerender_contents);
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnPrerenderStart(this));
+}
+
+void PrerenderHandle::OnPrerenderAddAlias(PrerenderContents* prerender_contents,
+                                          const GURL& alias_url) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_EQ(prerender_data_->contents(), prerender_contents);
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnPrerenderAddAlias(this,
+                                                                  alias_url));
 }
 
-void PrerenderHandle::SwapPrerenderDataWith(
-    PrerenderHandle* other_prerender_handle) {
+void PrerenderHandle::OnPrerenderStop(PrerenderContents* prerender_contents) {
   DCHECK(CalledOnValidThread());
-  DCHECK(other_prerender_handle);
-  std::swap(prerender_data_, other_prerender_handle->prerender_data_);
+  // No DCHECKs on the underlying prerender_data, since prerenders are deleted
+  // asyncronously and so the handle may have no prerender data at the time it's
+  // notified of the prerender ending.

[mmenke, 2012/12/12 16:54:12]

This comment isn't correct.  OnPrerenderStop is called synchronously in
Destroy(FinalStatus), or in PrepareForUse.  Both happen before the funky
deletion stuff.  However, PrepareForUse is currently called after we destroy the
data, so you're right about a DCHECK not working, without more information.

[gavinp, 2012/12/13 13:38:03]

Done.

+  FOR_EACH_OBSERVER(Observer, observer_list_, OnPrerenderStop(this));
+}
+
+void PrerenderHandle::OnPrerenderCreatedMatchCompleteReplacement(
+    PrerenderContents* contents, PrerenderContents* replacement) {
+  DCHECK(CalledOnValidThread());
+
+  // This should occur in the middle of the surgery on the PrerenderData, and
+  // so we expect to not have our new contents in our PrerenderData yet. The
+  // switch occurs in
+  // PrerenderManager::PrerenderData::MakeIntoMatchCompleteReplacement, so
+  // this method only needs to switch observing.
+
+  contents->RemoveObserver(this);
+  replacement->AddObserver(this);

[mmenke, 2012/12/11 19:53:45]

The replacement won't send the stop message, since it was never started.

[gavinp, 2012/12/13 13:38:03]

Fixed, now sent. Overall, your comment elsewhere about leaks is well taken and
related... although thankfully we track OnChannelClosed so they're only life of
renderer at worst.

 }
 
 }  // namespace prerender