Make PrerenderHandle an observer of PrerenderContents.

chrome/browser/prerender/prerender_handle.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_handle.h"
 
 #include <algorithm>
 
 #include "chrome/browser/prerender/prerender_contents.h"
 
 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::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void PrerenderHandle::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
 }
 
 void PrerenderHandle::OnNavigateAway() {
   DCHECK(CalledOnValidThread());
-  if (!IsValid())
-    return;
-  prerender_data_->OnNavigateAwayByHandle();
-  prerender_data_.reset();
+  if (prerender_data_)
+    prerender_data_->OnHandleNavigatedAway(this);
 }
 
 void PrerenderHandle::OnCancel() {
   DCHECK(CalledOnValidThread());
-  if (!IsValid())
-    return;
-  prerender_data_->OnCancelByHandle();
-  prerender_data_.reset();
-}
-
-bool PrerenderHandle::IsValid() const {
-  return prerender_data_ != NULL;
-}
-
-bool PrerenderHandle::IsPending() const {
-  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::SwapPrerenderDataWith(
-    PrerenderHandle* other_prerender_handle) {
+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(other_prerender_handle);
-  std::swap(prerender_data_, other_prerender_handle->prerender_data_);
+  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::OnPrerenderStop(PrerenderContents* prerender_contents) {
+  DCHECK(CalledOnValidThread());
+  // 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