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..baa08c97b386dc7b0ff956f0d83d348052d3a323 100644
--- a/chrome/browser/prerender/prerender_handle.cc
+++ b/chrome/browser/prerender/prerender_handle.cc
@@ -10,38 +10,40 @@
 
 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();
+}
+
+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_->OnNavigateAwayByHandle(this);
 }
 
 void PrerenderHandle::OnCancel() {
   DCHECK(CalledOnValidThread());
-  if (!IsValid())
-    return;
-  prerender_data_->OnCancelByHandle();
-  prerender_data_.reset();
+  has_been_canceled_ = true;
+  if (prerender_data_)
+    prerender_data_->OnCancelByHandle(this);
 }
 
 bool PrerenderHandle::IsValid() const {
   return prerender_data_ != NULL;
 }
 
-bool PrerenderHandle::IsPending() const {
-  DCHECK(CalledOnValidThread());
-  return prerender_data_ && !prerender_data_->contents();
-}
-
 bool PrerenderHandle::IsPrerendering() const {
   DCHECK(CalledOnValidThread());
   return prerender_data_ && prerender_data_->contents();

[mmenke, 2012/12/06 22:22:15]

prerender_data_->contents() cannot be null.

[gavinp, 2012/12/10 17:55:10]

Done.

@@ -49,23 +51,60 @@ bool PrerenderHandle::IsPrerendering() const {
 
 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->OnNewHandle(this);
+  }
+}
+
+void PrerenderHandle::AdoptPrerenderDataFrom(PrerenderHandle* other_handle) {
+  DCHECK(!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_ && prerender_data_->contents()) {
+    prerender_data_->contents()->AddObserver(this);
+    // If we are joining a prerender that has already started, we fire off an
+    // extra start event at ourselves.
+    if (prerender_data_->contents()->prerendering_has_started())
+      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.
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnPrerenderStop(this));
 }
 
 }  // namespace prerender