Add observer interface to PrerenderContents.

chrome/browser/prerender/prerender_contents.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_CONTENTS_H_
 #define CHROME_BROWSER_PRERENDER_PRERENDER_CONTENTS_H_
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_origin.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/referrer.h"
 #include "ui/gfx/size.h"
 
@@ skipping 13 matching lines @@
 
 namespace history {
 struct HistoryAddPageArgs;
 }
 
 namespace prerender {
 
 class PrerenderHandle;
 class PrerenderManager;
 class PrerenderRenderViewHostObserver;
-class PrerenderTracker;
 
 class PrerenderContents : public content::NotificationObserver,
                           public content::WebContentsObserver {
  public:
   // PrerenderContents::Create uses the currently registered Factory to create
   // the PrerenderContents. Factory is intended for testing.
   class Factory {
    public:
     Factory() {}
     virtual ~Factory() {}
 
     // Ownership is not transfered through this interface as prerender_manager,
     // prerender_tracker, and profile are stored as weak pointers.
     virtual PrerenderContents* CreatePrerenderContents(
         PrerenderManager* prerender_manager,
-        PrerenderTracker* prerender_tracker,
         Profile* profile,
         const GURL& url,
         const content::Referrer& referrer,
         Origin origin,
         uint8 experiment_id) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Factory);
   };
 
+  class Observer {
+   public:
+    // Signals that the prerender has started running.
+    virtual void OnPrerenderStart(PrerenderContents* contents) = 0;
+
+    // Signals that the prerender has stopped running.
+    virtual void OnPrerenderStop(PrerenderContents* contents) = 0;
+
+   protected:
+    Observer();
+    virtual ~Observer() = 0;
+  };
+
   // A container for extra data on pending prerenders.
   struct PendingPrerenderInfo {
    public:
     PendingPrerenderInfo(
         base::WeakPtr<PrerenderHandle> weak_prerender_handle,
         Origin origin,
         const GURL& url,
         const content::Referrer& referrer,
         const gfx::Size& size);
 
@@ skipping 24 matching lines @@
     // we record in MatchComplete but not Match.
     MATCH_COMPLETE_REPLACEMENT,
     // A prerender that is a MatchComplete dummy, early in the process of being
     // created. This prerender should not fail. Record for MatchComplete, but
     // not Match.
     MATCH_COMPLETE_REPLACEMENT_PENDING,
   };
 
   virtual ~PrerenderContents();
 
+  // All observers of a PrerenderContents are removed after the OnPrerenderStop
+  // event is sent, so there is no need for a RemoveObserver() method.
+  void AddObserver(Observer* observer);
+
   // For MatchComplete correctness, create a dummy replacement prerender
   // contents to stand in for this prerender contents that (which we are about
   // to destroy).
   PrerenderContents* CreateMatchCompleteReplacement() const;
 
   bool Init();
 
   static Factory* CreateFactory();
 
   // Start rendering the contents in the prerendered state. If
   // |is_control_group| is true, this will go through some of the mechanics of
   // starting a prerender, without actually creating the RenderView.
   // |creator_child_id| is the id of the child process that caused the prerender
   // to be created, and is needed so that the prerendered URLs can be sent to it
   // so render-initiated navigations will swap in the prerendered page. |size|
   // indicates the rectangular dimensions that the prerendered page should be.
   // |session_storage_namespace| indicates the namespace that the prerendered
   // page should be part of.
   virtual void StartPrerendering(
       int creator_child_id,
       const gfx::Size& size,
-      content::SessionStorageNamespace* session_storage_namespace,
-      bool is_control_group);
+      content::SessionStorageNamespace* session_storage_namespace);
 
   // Verifies that the prerendering is not using too many resources, and kills
   // it if not.
   void DestroyWhenUsingTooManyResources();
 
   content::RenderViewHost* GetRenderViewHostMutable();
   const content::RenderViewHost* GetRenderViewHost() const;
 
+  PrerenderManager* prerender_manager() { return prerender_manager_; }
+
   string16 title() const { return title_; }
   int32 page_id() const { return page_id_; }
   GURL icon_url() const { return icon_url_; }
   const GURL& prerender_url() const { return prerender_url_; }
   const content::Referrer& referrer() const { return referrer_; }
   bool has_stopped_loading() const { return has_stopped_loading_; }
   bool has_finished_loading() const { return has_finished_loading_; }
   bool prerendering_has_started() const { return prerendering_has_started_; }
   MatchCompleteStatus match_complete_status() const {
     return match_complete_status_;
   }
   void set_match_complete_status(MatchCompleteStatus status) {
     match_complete_status_ = status;
   }
 
   // Sets the parameter to the value of the associated RenderViewHost's child id
   // and returns a boolean indicating the validity of that id.
   virtual bool GetChildId(int* child_id) const;
 
   // Sets the parameter to the value of the associated RenderViewHost's route id
   // and returns a boolean indicating the validity of that id.
   virtual bool GetRouteId(int* route_id) const;
 
   // Set the final status for how the PrerenderContents was used. This
   // should only be called once, and should be called before the prerender
   // contents are destroyed.
-  void set_final_status(FinalStatus final_status);
+  void SetFinalStatus(FinalStatus final_status);
   FinalStatus final_status() const { return final_status_; }
 
   Origin origin() const { return origin_; }
   uint8 experiment_id() const { return experiment_id_; }
 
   base::TimeTicks load_start_time() const { return load_start_time_; }
 
   // Indicates whether this prerendered page can be used for the provided
   // |url| and |session_storage_namespace|.
   bool Matches(
@@ skipping 62 matching lines @@
   // exists when this page is made visible, it will be launched.
   virtual void AddPendingPrerender(
       scoped_ptr<PendingPrerenderInfo> pending_prerender_info);
 
   // Reissues any pending prerender requests from the prerendered page.  Also
   // clears the list of pending requests.
   void StartPendingPrerenders();
 
  protected:
   PrerenderContents(PrerenderManager* prerender_manager,
-                    PrerenderTracker* prerender_tracker,
                     Profile* profile,
                     const GURL& url,
                     const content::Referrer& referrer,
                     Origin origin,
                     uint8 experiment_id);
 
+  // These call out to methods on our Observers, using our observer_list_. Note
+  // that NotifyPrerenderStop() also clears the observer list.
+  void NotifyPrerenderStart();
+  void NotifyPrerenderStop();
+
   // Called whenever a RenderViewHost is created for prerendering.  Only called
   // once the RenderViewHost has a RenderView and RenderWidgetHostView.
   virtual void OnRenderViewHostCreated(
       content::RenderViewHost* new_render_view_host);
 
   content::NotificationRegistrar& notification_registrar() {
     return notification_registrar_;
   }
 
   size_t pending_prerender_count() const;
@@ skipping 19 matching lines @@
   friend class PrerenderContentsFactoryImpl;
 
   friend class PrerenderRenderViewHostObserver;
 
   // Returns the RenderViewHost Delegate for this prerender.
   content::WebContents* GetWebContents();
 
   // Returns the ProcessMetrics for the render process, if it exists.
   base::ProcessMetrics* MaybeGetProcessMetrics();
 
+  ObserverList<Observer> observer_list_;
+
   // The prerender manager owning this object.
   PrerenderManager* prerender_manager_;
 
-  // The prerender tracker tracking prerenders.
-  PrerenderTracker* prerender_tracker_;
-
   // The URL being prerendered.
   GURL prerender_url_;
 
   // The referrer.
   content::Referrer referrer_;
 
   // The profile being used
   Profile* profile_;
 
   // Information about the title and URL of the page that this class as a
@@ skipping 70 matching lines @@
 
   // Caches pages to be added to the history.
   AddPageVector add_page_vector_;
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderContents);
 };
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_CONTENTS_H_