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..5ef9b4d8a269fb948824db4471f43f09a36ca084 100644
--- a/chrome/browser/prerender/prerender_handle.cc
+++ b/chrome/browser/prerender/prerender_handle.cc
@@ -6,66 +6,118 @@
 
 #include <algorithm>
 
+#include "base/logging.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 
 namespace prerender {
 
-PrerenderHandle::~PrerenderHandle() {
-  DCHECK(!IsValid());
-  // This shouldn't occur, but we also shouldn't leak if it does.
-  if (IsValid())
-    OnCancel();
+PrerenderHandle::Observer::Observer() {
 }
 
-void PrerenderHandle::OnNavigateAway() {
-  DCHECK(CalledOnValidThread());
-  if (!IsValid())
-    return;
-  prerender_data_->OnNavigateAwayByHandle();
-  prerender_data_.reset();
+PrerenderHandle::Observer::~Observer() {
 }
 
-void PrerenderHandle::OnCancel() {
-  DCHECK(CalledOnValidThread());
-  if (!IsValid())
-    return;
-  prerender_data_->OnCancelByHandle();
-  prerender_data_.reset();
+PrerenderHandle::~PrerenderHandle() {
+  if (prerender_data_) {
+    prerender_data_->contents()->RemoveObserver(this);
+  }
 }
 
-bool PrerenderHandle::IsValid() const {
-  return prerender_data_ != NULL;
+void PrerenderHandle::SetObserver(Observer* observer) {
+  DCHECK_NE(static_cast<Observer*>(NULL), observer);
+  observer_ = observer;
 }
 
-bool PrerenderHandle::IsPending() const {
+void PrerenderHandle::OnNavigateAway() {
   DCHECK(CalledOnValidThread());
-  return prerender_data_ && !prerender_data_->contents();
+  if (prerender_data_)
+    prerender_data_->OnHandleNavigatedAway(this);
+}
+
+void PrerenderHandle::OnCancel() {
+  DCHECK(CalledOnValidThread());
+  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()),
+    : observer_(NULL),
       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(prerender_data_);
+  DCHECK_EQ(prerender_data_->contents(), prerender_contents);
+  if (observer_)
+    observer_->OnPrerenderStart(this);
+}
+
+void PrerenderHandle::OnPrerenderAddAlias(PrerenderContents* prerender_contents,
+                                          const GURL& alias_url) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(prerender_data_);
+  DCHECK_EQ(prerender_data_->contents(), prerender_contents);
+  if (observer_)
+    observer_->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_);
+  if (observer_)
+    observer_->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);
 }
 
 }  // namespace prerender