Remove prerender sessionStorage namespace merging (1/2)

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/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/predictors/logged_in_predictor_table.h"
 #include "chrome/browser/prerender/prerender_config.h"
 #include "chrome/browser/prerender/prerender_contents.h"
-#include "chrome/browser/prerender/prerender_events.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_histograms.h"
 #include "chrome/browser/prerender/prerender_origin.h"
-#include "chrome/browser/prerender/prerender_tracker.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/render_process_host_observer.h"
-#include "content/public/browser/session_storage_namespace.h"
-#include "content/public/browser/web_contents_observer.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_monster.h"
 #include "url/gurl.h"
 
 class Profile;
 class InstantSearchPrerendererTest;
 struct ChromeCookieDetails;
 
 namespace base {
 class DictionaryValue;
@@ skipping 13 matching lines @@
 
 namespace net {
 class URLRequestContextGetter;
 }
 
 namespace prerender {
 
 class PrerenderHandle;
 class PrerenderHistory;
 class PrerenderLocalPredictor;
+class PrerenderTracker;
 
 // PrerenderManager is responsible for initiating and keeping prerendered
 // views of web pages. All methods must be called on the UI thread unless
 // indicated otherwise.
 class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
                          public base::NonThreadSafe,
                          public content::NotificationObserver,
                          public content::RenderProcessHostObserver,
                          public KeyedService,
                          public MediaCaptureDevicesDispatcher::Observer {
@@ skipping 255 matching lines @@
   // cookie event for a given render frame, if it is being prerendered.
   // If cookies were sent, all cookies must be supplied in |cookie_list|.
   static void RecordCookieEvent(int process_id,
                                 int frame_id,
                                 const GURL& url,
                                 const GURL& frame_url,
                                 bool is_for_blocking_resource,
                                 PrerenderContents::CookieEvent event,
                                 const net::CookieList* cookie_list);
 
-  // Arranges for all session storage merges to hang indefinitely. This is used
-  // to reliably test various swap abort cases.
-  static void HangSessionStorageMergesForTesting();
-
   // Notification that a prerender has completed and its bytes should be
   // recorded.
   void RecordNetworkBytes(Origin origin, bool used, int64 prerender_bytes);
 
   // Returns whether prerendering is currently enabled for this manager.
   bool IsEnabled() const;
 
   // Add to the running tally of bytes transferred over the network for this
   // profile if prerendering is currently enabled.
   void AddProfileNetworkBytesIfEnabled(int64 bytes);
@@ skipping 13 matching lines @@
   // To be called once the cookie store for this profile has been loaded.
   void OnCookieStoreLoaded();
 
   // For testing purposes. Issues a callback once the cookie store has been
   // loaded.
   void set_on_cookie_store_loaded_cb_for_testing(base::Closure cb) {
     on_cookie_store_loaded_cb_for_testing_ = cb;
   }
 
  protected:
-  class PendingSwap;
   class PrerenderData : public base::SupportsWeakPtr<PrerenderData> {
    public:
     struct OrderByExpiryTime;
 
     PrerenderData(PrerenderManager* manager,
                   PrerenderContents* contents,
                   base::TimeTicks expiry_time);
 
     ~PrerenderData();
 
@@ skipping 21 matching lines @@
 
     int handle_count() const { return handle_count_; }
 
     base::TimeTicks abandon_time() const { return abandon_time_; }
 
     base::TimeTicks expiry_time() const { return expiry_time_; }
     void set_expiry_time(base::TimeTicks expiry_time) {
       expiry_time_ = expiry_time;
     }
 
-    void ClearPendingSwap();
-
-    PendingSwap* pending_swap() { return pending_swap_.get(); }
-    void set_pending_swap(PendingSwap* pending_swap) {
-      pending_swap_.reset(pending_swap);
-    }
-
    private:
     PrerenderManager* manager_;
     scoped_ptr<PrerenderContents> contents_;
 
     // The number of distinct PrerenderHandles created for |this|, including
     // ones that have called PrerenderData::OnHandleNavigatedAway(), but not
     // counting the ones that have called PrerenderData::OnHandleCanceled(). For
     // pending prerenders, this will always be 1, since the PrerenderManager
     // only merges handles of running prerenders.
     int handle_count_;
 
     // The time when OnHandleNavigatedAway was called.
     base::TimeTicks abandon_time_;
 
     // After this time, this prerender is no longer fresh, and should be
     // removed.
     base::TimeTicks expiry_time_;
 
-    // If a session storage namespace merge is in progress for this object,
-    // we need to keep track of various state associated with it.
-    scoped_ptr<PendingSwap> pending_swap_;
-
     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(PrerenderManager* manager,
-                content::WebContents* target_contents,
-                PrerenderData* prerender_data,
-                const GURL& url,
-                bool should_replace_current_entry);
-    ~PendingSwap() override;
-
-    void set_swap_successful(bool swap_successful) {
-      swap_successful_ = swap_successful;
-    }
-
-    void BeginSwap();
-
-    // content::WebContentsObserver implementation.
-    void AboutToNavigateRenderFrame(
-        content::RenderFrameHost* render_frame_host) override;
-    void DidStartProvisionalLoadForFrame(
-        content::RenderFrameHost* render_frame_host,
-        const GURL& validated_url,
-        bool is_error_page,
-        bool is_iframe_srcdoc) override;
-    void DidCommitProvisionalLoadForFrame(
-        content::RenderFrameHost* render_frame_host,
-        const GURL& validated_url,
-        ui::PageTransition transition_type) override;
-    void DidFailProvisionalLoad(
-        content::RenderFrameHost* render_frame_host,
-        const GURL& validated_url,
-        int error_code,
-        const base::string16& error_description) override;
-    void WebContentsDestroyed() override;
-
-   private:
-    void RecordEvent(PrerenderEvent event) const;
-
-    void OnMergeCompleted(content::SessionStorageNamespace::MergeResult result);
-    void OnMergeTimeout();
-
-    // Prerender parameters.
-    PrerenderManager* manager_;
-    PrerenderData* prerender_data_;
-    GURL url_;
-    bool should_replace_current_entry_;
-
-    base::TimeTicks start_time_;
-    PrerenderTracker::ChildRouteIdPair target_route_id_;
-    bool seen_target_route_id_;
-    base::OneShotTimer<PendingSwap> merge_timeout_;
-    bool swap_successful_;
-
-    base::WeakPtrFactory<PendingSwap> weak_factory_;
-  };
-
   void SetPrerenderContentsFactory(
       PrerenderContents::Factory* prerender_contents_factory);
 
   // Called by a PrerenderData to signal that the launcher has navigated away
   // from the context that launched the prerender. A user may have clicked
   // a link in a page containing a <link rel=prerender> element, or the user
   // might have committed an omnibox navigation. This is used to possibly
   // shorten the TTL of the prerendered page.
   void SourceNavigatedAway(PrerenderData* prerender_data);
 
@@ skipping 61 matching lines @@
   // after every mutation of active_prerenders_ that can possibly make it
   // unsorted (e.g. an insert, or changing an expiry time).
   void SortActivePrerenders();
 
   // Finds the active PrerenderData object for a running prerender matching
   // |url| and |session_storage_namespace|.
   PrerenderData* FindPrerenderData(
       const GURL& url,
       const content::SessionStorageNamespace* session_storage_namespace);
 
-  // Finds the active PrerenderData object currently in a PendingSwap for
-  // |target_contents|. Otherwise, returns NULL.
-  PrerenderData* FindPrerenderDataForTargetContents(
-      content::WebContents* target_contents);
-
   // Given the |prerender_contents|, find the iterator in active_prerenders_
   // correponding to the given prerender.
   ScopedVector<PrerenderData>::iterator
       FindIteratorForPrerenderContents(PrerenderContents* prerender_contents);
 
   bool DoesRateLimitAllowPrerender(Origin origin) const;
 
   // Deletes old WebContents that have been replaced by prerendered ones.  This
   // is needed because they're replaced in a callback from the old WebContents,
   // so cannot immediately be deleted.
@@ skipping 32 matching lines @@
   void RecordFinalStatusWithoutCreatingPrerenderContents(
       const GURL& url, Origin origin, uint8 experiment_id,
       FinalStatus final_status) const;
 
 
   void CookieChanged(ChromeCookieDetails* details);
   void CookieChangedAnyCookiesLeftLookupResult(const std::string& domain_key,
                                                bool cookies_exist);
   void LoggedInPredictorDataReceived(scoped_ptr<LoggedInStateMap> new_map);
 
-  void RecordEvent(PrerenderContents* contents, PrerenderEvent event) const;
-
   // 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.  If |should_replace_current_entry| is true,
   // the current history entry in |web_contents| is replaced.
   content::WebContents* SwapInternal(const GURL& url,
                                      content::WebContents* web_contents,
                                      PrerenderData* prerender_data,
                                      bool should_replace_current_entry);
 
   // The configuration.
@@ skipping 68 matching lines @@
   bool cookie_store_loaded_;
 
   base::Closure on_cookie_store_loaded_cb_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderManager);
 };
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_