Make PrerenderHandle an observer of PrerenderContents.

chrome/browser/prerender/prerender_handle.h

 // 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.
 
 #ifndef CHROME_BROWSER_PRERENDER_PRERENDER_HANDLE_H_
 #define CHROME_BROWSER_PRERENDER_PRERENDER_HANDLE_H_
 
 #include "base/basictypes.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 
 class GURL;
 
 namespace content {
 class SessionStorageNamespace;
 }
 
 namespace prerender {
 
 class PrerenderContents;
 
 // A class representing a running prerender to a client of the PrerenderManager.
 // Methods on PrerenderManager which start prerenders return a caller-owned
 // PrerenderHandle* to the client (or NULL if they are unable to start a
-// prerender). Because the PrerenderManager can stop running prerenders at any
-// time, callers may wish to check PrerenderHandle::IsValid() before operating
-// on their prerenders.
-class PrerenderHandle : public base::NonThreadSafe {
+// prerender). Calls on the handle of a prerender that is not running at no-ops.
+// Destroying a handle before a prerender starts will prevent it from ever
+// starting. Destroying a handle while a prerendering is running will stop the
+// prerender.

[mmenke, 2012/12/13 18:27:16]

Think it's worth mentioning that destroying "will stop the prerender without
making any calls to the Observer".

[gavinp, 2012/12/13 20:45:34]

Done.

+class PrerenderHandle : public base::NonThreadSafe,
+                        public PrerenderContents::Observer {
  public:
+  class Observer {
+   public:
+    virtual ~Observer();

[mmenke, 2012/12/13 18:27:16]

Could make this protected as well - mostly as a promise we aren't going to go
around destroying anybody.

[gavinp, 2012/12/13 20:45:34]

Done.

+
+    // Signals that the prerender has started running.
+    virtual void OnPrerenderStart(PrerenderHandle* handle) = 0;
+
+    // Signals that the prerender has stopped running.
+    virtual void OnPrerenderStop(PrerenderHandle* handle) = 0;
+
+    // Signals the discovery, through redirects, of a new alias for this
+    // prerender.
+    virtual void OnPrerenderAddAlias(PrerenderHandle* handle,
+                                     const GURL& alias_url) = 0;
+
+   protected:
+    Observer();
+  };
+
   // Before calling the destructor, the caller must invalidate the handle by
   // calling either OnNavigateAway or OnCancel.
-  ~PrerenderHandle();
+  virtual ~PrerenderHandle();
+
+  void set_observer(Observer* observer) {
+    DCHECK(!observer_);

[mmenke, 2012/12/13 18:27:16]

We need to include "base/logging.h" for DCHECK.

While someone in some header up there apparently disagrees with me,
base/logging.h is a sufficiently busy header that I prefer to keep it out of
header files unless we really need it.  I'd suggest switching to SetObserver,
and de-inlining this, though I think I've also seen similar cases where
set_observer naming style was used, but the body with the DCHECK was in the cc
file.

In terms of compile time, it's also unclear what DCHECK expands out into, though
think that makes this no longer a "simple setter" in debug builds.

Also doesn't look to me like a whole lot of header files currently use DCHECKs
like this.

[gavinp, 2012/12/13 20:45:34]

Done.

+    observer_ = observer;
+  }
 
   // The launcher is navigating away from the context that launched this
   // prerender. The prerender will likely stay alive briefly though, in case we
   // are going through a redirect chain that will target it. This call
   // invalidates the handle. If the prerender handle is already invalid, this
   // call does nothing.
   void OnNavigateAway();
 
-  // The launcher has taken explicit action to remove this prerender (for
-  // instance, removing a link element from a document). This call invalidates
-  // the handle. If the prerender handle is already invalid, this call does
-  // nothing.
-  void OnCancel();
-
-  // True if the prerender handle is still connected to a (pending or running)
-  // prerender. Handles can become invalid through explicit requests by the
-  // client, such as calling OnCancel() or OnNavigateAway(), and handles
-  // also become invalid when the PrerenderManager cancels prerenders.
-  bool IsValid() const;
-
-  // True if this prerender was launched by a page that was itself being
-  // prerendered, and so has not yet been started.
-  bool IsPending() const;
-
   // True if this prerender is currently active.
   bool IsPrerendering() const;
 
   // True if we started a prerender, and it has finished loading.
   bool IsFinishedLoading() const;
 
  private:
   friend class PrerenderManager;
 
   explicit PrerenderHandle(PrerenderManager::PrerenderData* prerender_data);
 
-  void SwapPrerenderDataWith(PrerenderHandle* other_prerender_handle);
+  void AdoptPrerenderDataFrom(PrerenderHandle* other_handle);
+
+  // From PrerenderContents::Observer:
+  virtual void OnPrerenderStart(PrerenderContents* prerender_contents) OVERRIDE;
+  virtual void OnPrerenderStop(PrerenderContents* prerender_contents) OVERRIDE;
+  virtual void OnPrerenderAddAlias(PrerenderContents* prerender_contents,
+                                   const GURL& alias_url) OVERRIDE;
+  virtual void OnPrerenderCreatedMatchCompleteReplacement(
+      PrerenderContents* contents, PrerenderContents* replacement) OVERRIDE;
+
+  Observer* observer_;
 
   base::WeakPtr<PrerenderManager::PrerenderData> prerender_data_;
   base::WeakPtrFactory<PrerenderHandle> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderHandle);
 };
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_HANDLE_H_