Handle interface to prerenders.

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
new file mode 100644
index 0000000000000000000000000000000000000000..24de791cdb0a9427ffd5ec3343c9d3ac4bcdb62c
--- /dev/null
+++ b/chrome/browser/prerender/prerender_handle.cc
@@ -0,0 +1,71 @@
+// 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::~PrerenderHandle() {
+  DCHECK(!IsValid());
+  // This shouldn't occur, but we also shouldn't leak if it does.
+  if (IsValid())
+    OnCancel();
+}
+
+void PrerenderHandle::OnNavigateAway() {
+  DCHECK(CalledOnValidThread());
+  if (!IsValid())

[dominich, 2012/07/13 15:01:43]

I like this a lot. I wonder if we should be stricter about it - DCHECK to ensure
people aren't calling it twice. A code path that calls both OnNavigateAway and
OnCancel might expect the second call to override the first call, like setting
the final status.

[gavinp, 2012/07/13 16:42:43]

I had the same thought, and yesterday had that coded up in my repo. I moved away
from it, because of course, PrerenderHandles can become invalid behind your back
too (say the system comes under memory pressure). Anywhere that prerenders were
being canceled or navigated away from, I had to include this check just in case
of that. Same thing in the call to OnCancel or OnNavigateAway in destructors.

It felt like our API was doing the wrong thing: taking our objects complexity
and pushing it out into the users.

I do think that requiring an explicit choice about NavigateAway or Cancel before
deletion is good though. Neither default made me happy.

+    return;
+  prerender_data_->OnNavigateAwayByHandle();
+  prerender_data_.reset();
+}
+
+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();
+}
+
+bool PrerenderHandle::IsPrerendering() const {
+  DCHECK(CalledOnValidThread());
+  return prerender_data_ && prerender_data_->contents();
+}
+
+bool PrerenderHandle::IsFinishedLoading() const {
+  DCHECK(CalledOnValidThread());
+  if (!prerender_data_ || IsPending())
+    return false;
+  return prerender_data_->contents()->has_finished_loading();
+}
+
+PrerenderHandle::PrerenderHandle(
+    PrerenderManager::PrerenderData* prerender_data)
+    : prerender_data_(prerender_data->AsWeakPtr()),
+      weak_ptr_factory_(this) {
+  prerender_data->OnNewHandle();
+}
+
+void PrerenderHandle::SwapPrerenderDataWith(
+    PrerenderHandle* other_prerender_handle) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(other_prerender_handle);
+  std::swap(prerender_data_, other_prerender_handle->prerender_data_);
+}
+
+}  // namespace prerender