Refactor prerender pending swap logic.

chrome/browser/prerender/prerender_manager.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_MANAGER_H_
 #define CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_
 
 #include <list>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/cancelable_callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/predictors/logged_in_predictor_table.h"
@@ skipping 397 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(PrerenderData);
   };
 
   // When a swap can't happen immediately, due to a sesison storage namespace
   // merge, there will be a pending swap object while the merge is in
   // progress. It retains all the data needed to do the merge, maintains
   // throttles for the navigation in the target WebContents that needs to be
   // delayed, and handles all conditions which would cancel a pending swap.
   class PendingSwap : public content::WebContentsObserver {
    public:
-    PendingSwap(PrerenderTracker* prerender_tracker,
+    PendingSwap(PrerenderManager* manager,
                 content::WebContents* target_contents,
                 PrerenderData* prerender_data,
-                const GURL& url,
-                const base::Closure& timeout_cb,
-                const content::SessionStorageNamespace::MergeResultCallback&
-                merge_result_cb);
+                const GURL& url);
     virtual ~PendingSwap();
-    const base::Closure& GetTimeoutCallback();
-    const content::SessionStorageNamespace::MergeResultCallback&
-    GetMergeResultCallback();
+
+    void set_swap_successful(bool swap_successful) {
+      swap_successful_ = swap_successful;
+    }
+
+    void BeginSwap();
 
     // content::WebContentsObserver implementation.
     virtual void ProvisionalChangeToMainFrameUrl(
         const GURL& url,
         content::RenderViewHost* render_view_host) OVERRIDE;
     virtual void DidCommitProvisionalLoadForFrame(
         int64 frame_id,
         const string16& frame_unique_name,
         bool is_main_frame,
         const GURL& validated_url,
         content::PageTransition transition_type,
         content::RenderViewHost* render_view_host) OVERRIDE;
     virtual void RenderViewCreated(
         content::RenderViewHost* render_view_host) OVERRIDE;
     virtual void DidFailProvisionalLoad(
         int64 frame_id,
         const string16& frame_unique_name,
         bool is_main_frame,
         const GURL& validated_url,
         int error_code,
         const string16& error_description,
         content::RenderViewHost* render_view_host) OVERRIDE;
     virtual void WebContentsDestroyed(content::WebContents* web_contents)
         OVERRIDE;
 
-    base::TimeDelta GetElapsedTime();
-    void SwapSuccessful();
-    const GURL& url() const { return url_; }
-    content::WebContents* target_contents() const { return target_contents_; }
+   private:
+    void RecordEvent(PrerenderEvent event) const;
 
-   private:
-    PrerenderTracker* prerender_tracker_;
+    void OnMergeCompleted(content::SessionStorageNamespace::MergeResult result);
+    void OnMergeTimeout();
+
+    PrerenderManager* manager_;
     content::WebContents* target_contents_;
     PrerenderData* prerender_data_;
     GURL url_;
-    base::CancelableClosure timeout_cb_;
-    base::CancelableCallback<
-      void(content::SessionStorageNamespace::MergeResult)> merge_result_cb_;
     base::TimeTicks start_time_;
     std::vector<PrerenderTracker::ChildRouteIdPair> rvh_ids_;
+    base::OneShotTimer<PendingSwap> merge_timeout_;
+    bool swap_successful_;
+
+    base::WeakPtrFactory<PendingSwap> weak_factory_;
   };
 
   void SetPrerenderContentsFactory(
       PrerenderContents::Factory* prerender_contents_factory);
 
   // Adds prerenders from the pending Prerenders, called by
   // PrerenderContents::StartPendingPrerenders.
   void StartPendingPrerenders(
       int process_id,
       ScopedVector<PrerenderContents::PendingPrerenderInfo>* pending_prerenders,
@@ skipping 156 matching lines @@
 
   // Returns whether prerendering is currently enabled for this manager.
   // Must be called on the UI thread.
   bool IsEnabled() const;
 
   void CookieChanged(ChromeCookieDetails* details);
   void CookieChangedAnyCookiesLeftLookupResult(const std::string& domain_key,
                                                bool cookies_exist);
   void LoggedInPredictorDataReceived(scoped_ptr<LoggedInStateMap> new_map);
 
-  void ProcessMergeResult(PrerenderData* prerender_data,
-                          bool timed_out,
-                          content::SessionStorageNamespace::MergeResult result);
-
   void RecordEvent(PrerenderContents* contents, PrerenderEvent event) const;
 
-  // Swaps a prerender for |url| into the tab, replacing |web_contents|.
-  // Returns the new WebContents that was swapped in, or NULL if a swap-in
-  // was not possible. Optionally, a |swap_candidate| can be specified.
-  // Must be supplied if a merge has completed and we retry swap.
-  // That's because we must skip the check whether a PrerenderData object that
-  // could be swapped in is used for a pending merge, if the PrerenderData
-  // object being considered is the one for which the merge has just completed
-  // and which is intended to be swapped in.
+  // Swaps a prerender |prerender_data| for |url| into the tab, replacing
+  // |web_contents|.  Returns the new WebContents that was swapped in, or NULL
+  // if a swap-in was not possible.
   content::WebContents* SwapInternal(const GURL& url,
                                      content::WebContents* web_contents,
-                                     PrerenderData* swap_candidate);
+                                     PrerenderData* prerender_data);
 
   // The configuration.
   Config config_;
 
   // Specifies whether prerendering is currently enabled for this
   // manager. The value can change dynamically during the lifetime
   // of the PrerenderManager.
   bool enabled_;
 
   static bool is_prefetch_enabled_;
@@ skipping 73 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderManager);
 };
 
 PrerenderManager* FindPrerenderManagerUsingRenderProcessId(
     int render_process_id);
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_