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/observer_list.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 {
+class PrerenderHandle : public base::NonThreadSafe,
+                        public PrerenderContents::Observer {
  public:
+  class Observer {
+   public:
+    virtual ~Observer();
+
+    // 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 AddObserver(Observer* observer);
+  void RemoveObserver(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.
+  // True if this prerender handle has been canceled.
+  bool has_been_canceled() const {
+    return has_been_canceled_;
+  }
+
+  // True if this prerender handle has associated prerender data. It is false
+  // for canceled prerenders, and also for pending prerenders.
   bool IsValid() const;

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

I suggest getting rid of this, and just relying on IsPrerendering, which has a
clearer name (And now has the same behavior).  Or just use the name
"StartedPrerender" or "HasStarted" or some such.  Could also inline, but I'm
fine with it as-is.

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

Done. I was halfway there already (remember seeing me treating this function
with less than respect randomly throughout these CLs; that was this decision
kind of half done and not split out).

 
-  // 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;
+
+  ObserverList<Observer> observer_list_;
+
+  bool has_been_canceled_;
   base::WeakPtr<PrerenderManager::PrerenderData> prerender_data_;

[mmenke, 2012/12/07 16:46:08]

This can *almost* be made a normal pointer - the only reason that doesn't
currently work is pending prerenders.

   base::WeakPtrFactory<PrerenderHandle> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderHandle);
 };
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_HANDLE_H_