[Tests not passing yet] Remove prerender sessionStorage namespace merging.

chrome/browser/prerender/prerender_manager.cc

 // 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.
 
 #include "chrome/browser/prerender/prerender_manager.h"
 
 #include <algorithm>
 #include <functional>
 #include <string>
 #include <vector>
@@ skipping 74 matching lines @@
   "GET",
   "HEAD",
   "OPTIONS",
   "POST",
   "TRACE",
 };
 
 // Length of prerender history, for display in chrome://net-internals
 const int kHistoryLength = 100;
 
-// Timeout, in ms, for a session storage namespace merge.
-const int kSessionStorageNamespaceMergeTimeoutMs = 500;
-
-// If true, all session storage merges hang indefinitely.
-bool g_hang_session_storage_merges_for_testing = false;
-
 // Indicates whether a Prerender has been cancelled such that we need
 // a dummy replacement for the purpose of recording the correct PPLT for
 // the Match Complete case.
 // Traditionally, "Match" means that a prerendered page was actually visited &
 // the prerender was used.  Our goal is to have "Match" cases line up in the
 // control group & the experiment group, so that we can make meaningful
 // comparisons of improvements.  However, in the control group, since we don't
 // actually perform prerenders, many of the cancellation reasons cannot be
 // detected.  Therefore, in the Prerender group, when we cancel for one of these
 // reasons, we keep track of a dummy Prerender representing what we would
@@ skipping 306 matching lines @@
 
   DeleteOldEntries();
   to_delete_prerenders_.clear();
 
   // First, try to find prerender data with the correct session storage
   // namespace.
   // TODO(ajwong): This doesn't handle isolated apps correctly.
   PrerenderData* prerender_data = FindPrerenderData(
       url,
       web_contents->GetController().GetDefaultSessionStorageNamespace());
-
-  // If this failed, we may still find a prerender for the same URL, but a
-  // different session storage namespace. If we do, we might have to perform
-  // a merge.
-  if (!prerender_data) {
-    prerender_data = FindPrerenderData(url, NULL);
-  } else {
-    RecordEvent(prerender_data->contents(),
-                PRERENDER_EVENT_SWAPIN_CANDIDATE_NAMESPACE_MATCHES);
-  }
-
   if (!prerender_data)
     return false;
-  RecordEvent(prerender_data->contents(), PRERENDER_EVENT_SWAPIN_CANDIDATE);
+
   DCHECK(prerender_data->contents());
 
-  // If there is currently a merge pending for this prerender data, don't swap.
-  if (prerender_data->pending_swap())
-    return false;
-
-  // Abort any existing pending swap on the target contents.
-  PrerenderData* pending_swap =
-      FindPrerenderDataForTargetContents(web_contents);
-  if (pending_swap) {
-    pending_swap->ClearPendingSwap();
-    DCHECK(FindPrerenderDataForTargetContents(web_contents) == NULL);
-  }
-
-  RecordEvent(prerender_data->contents(),
-              PRERENDER_EVENT_SWAPIN_NO_MERGE_PENDING);
-  SessionStorageNamespace* target_namespace =
-      web_contents->GetController().GetDefaultSessionStorageNamespace();
-  SessionStorageNamespace* prerender_namespace =
-      prerender_data->contents()->GetSessionStorageNamespace();
-  // Only when actually prerendering is session storage namespace merging an
-  // issue. For the control group, it will be assumed that the merge succeeded.
-  if (prerender_namespace && prerender_namespace != target_namespace &&
-      !prerender_namespace->IsAliasOf(target_namespace)) {
-    if (!ShouldMergeSessionStorageNamespaces()) {
-      RecordEvent(prerender_data->contents(),
-                  PRERENDER_EVENT_SWAPIN_MERGING_DISABLED);
-      return false;
-    }
-    RecordEvent(prerender_data->contents(),
-                PRERENDER_EVENT_SWAPIN_ISSUING_MERGE);
-    prerender_data->set_pending_swap(new PendingSwap(
-        this, web_contents, prerender_data, url,
-        params->should_replace_current_entry));
-    prerender_data->pending_swap()->BeginSwap();
-    // Although this returns false, creating a PendingSwap registers with
-    // PrerenderTracker to throttle MAIN_FRAME navigations while the swap is
-    // pending.
-    return false;
-  }
-
   // No need to merge; swap synchronously.
   WebContents* new_web_contents = SwapInternal(
       url, web_contents, prerender_data,
       params->should_replace_current_entry);
   if (!new_web_contents)
     return false;
 
   // Record the new target_contents for the callers.
   params->target_contents = new_web_contents;
   return true;
 }
 
 WebContents* PrerenderManager::SwapInternal(
     const GURL& url,
     WebContents* web_contents,
     PrerenderData* prerender_data,
     bool should_replace_current_entry) {
   DCHECK(CalledOnValidThread());
   DCHECK(!IsWebContentsPrerendering(web_contents, NULL));
 
   // Only swap if the target WebContents has a CoreTabHelper delegate to swap
   // out of it. For a normal WebContents, this is if it is in a TabStripModel.
   CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(web_contents);
   if (!core_tab_helper || !core_tab_helper->delegate()) {
-    RecordEvent(prerender_data->contents(), PRERENDER_EVENT_SWAPIN_NO_DELEGATE);
     return NULL;
   }
 
   PrerenderTabHelper* target_tab_helper =
       PrerenderTabHelper::FromWebContents(web_contents);
   if (!target_tab_helper) {
     NOTREACHED();
     return NULL;
   }
 
@@ skipping 92 matching lines @@
   histograms_->RecordAbandonTimeUntilUsed(
       prerender_data->contents()->origin(),
       prerender_data->abandon_time().is_null() ?
           base::TimeDelta() :
           GetCurrentTimeTicks() - prerender_data->abandon_time());
 
   histograms_->RecordPerSessionCount(prerender_data->contents()->origin(),
                                      ++prerenders_per_session_count_);
   histograms_->RecordUsedPrerender(prerender_data->contents()->origin());
 
-  if (prerender_data->pending_swap())
-    prerender_data->pending_swap()->set_swap_successful(true);
   ScopedVector<PrerenderData>::iterator to_erase =
       FindIteratorForPrerenderContents(prerender_data->contents());
   DCHECK(active_prerenders_.end() != to_erase);
   DCHECK_EQ(prerender_data, *to_erase);
   scoped_ptr<PrerenderContents>
       prerender_contents(prerender_data->ReleaseContents());
   active_prerenders_.erase(to_erase);
 
   // Mark prerender as used.
   prerender_contents->PrepareForUse();
@@ skipping 62 matching lines @@
       ActuallyPrerendering() &&
       GetMode() == PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP) {
     // TODO(tburkard): I'd like to DCHECK that we are actually prerendering.
     // However, what if new conditions are added and
     // NeedMatchCompleteDummyForFinalStatus is not being updated.  Not sure
     // what's the best thing to do here.  For now, I will just check whether
     // we are actually prerendering.
     (*it)->MakeIntoMatchCompleteReplacement();
   } else {
     to_delete_prerenders_.push_back(*it);
-    (*it)->ClearPendingSwap();
     active_prerenders_.weak_erase(it);
   }
 
   // Destroy the old WebContents relatively promptly to reduce resource usage.
   PostCleanupTask();
 }
 
 void PrerenderManager::RecordPageLoadTimeNotSwappedIn(
     Origin origin,
     base::TimeDelta page_load_time,
@@ skipping 307 matching lines @@
     PrerenderHandle* handle) {
   DCHECK_LT(0, handle_count_);
   DCHECK_NE(static_cast<PrerenderContents*>(NULL), contents_);
 
   if (--handle_count_ == 0) {
     // This will eventually remove this object from active_prerenders_.
     contents_->Destroy(FINAL_STATUS_CANCELLED);
   }
 }
 
-void PrerenderManager::PrerenderData::ClearPendingSwap() {
-  pending_swap_.reset(NULL);
-}
-
 PrerenderContents* PrerenderManager::PrerenderData::ReleaseContents() {
   return contents_.release();
 }
 
-PrerenderManager::PendingSwap::PendingSwap(
-    PrerenderManager* manager,
-    content::WebContents* target_contents,
-    PrerenderData* prerender_data,
-    const GURL& url,
-    bool should_replace_current_entry)
-    : content::WebContentsObserver(target_contents),
-      manager_(manager),
-      prerender_data_(prerender_data),
-      url_(url),
-      should_replace_current_entry_(should_replace_current_entry),
-      start_time_(base::TimeTicks::Now()),
-      seen_target_route_id_(false),
-      swap_successful_(false),
-      weak_factory_(this) {
-}
-
-PrerenderManager::PendingSwap::~PendingSwap() {
-  manager_->prerender_tracker()->RemovePrerenderPendingSwap(
-      target_route_id_, swap_successful_);
-}
-
-void PrerenderManager::PendingSwap::BeginSwap() {
-  if (g_hang_session_storage_merges_for_testing)
-    return;
-
-  SessionStorageNamespace* target_namespace =
-      web_contents()->GetController().GetDefaultSessionStorageNamespace();
-  SessionStorageNamespace* prerender_namespace =
-      prerender_data_->contents()->GetSessionStorageNamespace();
-
-  prerender_namespace->Merge(
-      true, prerender_data_->contents()->child_id(),
-      target_namespace,
-      base::Bind(&PrerenderManager::PendingSwap::OnMergeCompleted,
-                 weak_factory_.GetWeakPtr()));
-
-  merge_timeout_.Start(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(
-          kSessionStorageNamespaceMergeTimeoutMs),
-      this, &PrerenderManager::PendingSwap::OnMergeTimeout);
-}
-
-void PrerenderManager::PendingSwap::AboutToNavigateRenderFrame(
-    RenderFrameHost* render_frame_host) {
-  // TODO(davidben): Update prerendering for --site-per-process.
-  if (render_frame_host->GetParent())
-    return;
-
-  if (seen_target_route_id_) {
-    // A second navigation began browser-side.
-    prerender_data_->ClearPendingSwap();
-    return;
-  }
-
-  seen_target_route_id_ = true;
-  target_route_id_ = PrerenderTracker::ChildRouteIdPair(
-      render_frame_host->GetProcess()->GetID(),
-      render_frame_host->GetRoutingID());
-  manager_->prerender_tracker()->AddPrerenderPendingSwap(
-      target_route_id_, url_);
-}
-
-void PrerenderManager::PendingSwap::DidStartProvisionalLoadForFrame(
-    content::RenderFrameHost* render_frame_host,
-    const GURL& validated_url,
-    bool is_error_page,
-    bool is_iframe_srcdoc) {
-  if (render_frame_host->GetParent())
-    return;
-
-  // We must only cancel the pending swap if the url navigated to is not
-  // the URL being attempted to be swapped in. That's because in the normal
-  // flow, a ProvisionalChangeToMainFrameUrl will happen for the URL attempted
-  // to be swapped in immediately after the pending swap has issued its merge.
-  if (validated_url != url_)
-    prerender_data_->ClearPendingSwap();
-}
-
-void PrerenderManager::PendingSwap::DidCommitProvisionalLoadForFrame(
-    content::RenderFrameHost* render_frame_host,
-    const GURL& validated_url,
-    ui::PageTransition transition_type) {
-  if (render_frame_host->GetParent())
-    return;
-  prerender_data_->ClearPendingSwap();
-}
-
-void PrerenderManager::PendingSwap::DidFailProvisionalLoad(
-    content::RenderFrameHost* render_frame_host,
-    const GURL& validated_url,
-    int error_code,
-    const base::string16& error_description) {
-  if (render_frame_host->GetParent())
-    return;
-  prerender_data_->ClearPendingSwap();
-}
-
-void PrerenderManager::PendingSwap::WebContentsDestroyed() {
-  prerender_data_->ClearPendingSwap();
-}
-
-void PrerenderManager::PendingSwap::RecordEvent(PrerenderEvent event) const {
-  manager_->RecordEvent(prerender_data_->contents(), event);
-}
-
-void PrerenderManager::PendingSwap::OnMergeCompleted(
-    SessionStorageNamespace::MergeResult result) {
-  UMA_HISTOGRAM_TIMES("Prerender.SessionStorageNamespaceMergeTime",
-                      base::TimeTicks::Now() - start_time_);
-  RecordEvent(PRERENDER_EVENT_MERGE_RESULT_MERGE_DONE);
-
-  // Log the exact merge result in a histogram.
-  switch (result) {
-    case SessionStorageNamespace::MERGE_RESULT_NAMESPACE_NOT_FOUND:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NAMESPACE_NOT_FOUND);
-      break;
-    case SessionStorageNamespace::MERGE_RESULT_NAMESPACE_NOT_ALIAS:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NAMESPACE_NOT_ALIAS);
-      break;
-    case SessionStorageNamespace::MERGE_RESULT_NOT_LOGGING:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NOT_LOGGING);
-      break;
-    case SessionStorageNamespace::MERGE_RESULT_NO_TRANSACTIONS:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NO_TRANSACTIONS);
-      break;
-    case SessionStorageNamespace::MERGE_RESULT_TOO_MANY_TRANSACTIONS:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_TOO_MANY_TRANSACTIONS);
-      break;
-    case SessionStorageNamespace::MERGE_RESULT_NOT_MERGEABLE:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NOT_MERGEABLE);
-      break;
-    case SessionStorageNamespace::MERGE_RESULT_MERGEABLE:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_MERGEABLE);
-      break;
-    default:
-      NOTREACHED();
-  }
-
-  if (result != SessionStorageNamespace::MERGE_RESULT_MERGEABLE &&
-      result != SessionStorageNamespace::MERGE_RESULT_NO_TRANSACTIONS) {
-    RecordEvent(PRERENDER_EVENT_MERGE_RESULT_MERGE_FAILED);
-    prerender_data_->ClearPendingSwap();
-    return;
-  }
-
-  RecordEvent(PRERENDER_EVENT_MERGE_RESULT_SWAPPING_IN);
-
-  // Note that SwapInternal will, on success, delete |prerender_data_| and
-  // |this|. It will also delete |this| in some failure cases. Pass in a new
-  // GURL object rather than a reference to |url_|. Also hold on to |manager_|
-  // and |prerender_data_|.
-  //
-  // TODO(davidben): Can we make this less fragile?
-  PrerenderManager* manager = manager_;
-  PrerenderData* prerender_data = prerender_data_;
-  WebContents* new_web_contents =
-      manager_->SwapInternal(GURL(url_),
-                             web_contents(),
-                             prerender_data_,
-                             should_replace_current_entry_);
-  if (!new_web_contents) {
-    manager->RecordEvent(prerender_data->contents(),
-                         PRERENDER_EVENT_MERGE_RESULT_SWAPIN_FAILED);
-    // Depending on whether SwapInternal called Destroy() or simply failed to
-    // swap, |this| may or may not be deleted. Either way, if the swap failed,
-    // |prerender_data| is deleted asynchronously, so this call is a no-op if
-    // |this| is already gone.
-    prerender_data->ClearPendingSwap();
-  }
-}
-
-void PrerenderManager::PendingSwap::OnMergeTimeout() {
-  RecordEvent(PRERENDER_EVENT_MERGE_RESULT_TIMED_OUT);
-  prerender_data_->ClearPendingSwap();
-}
-
 void PrerenderManager::SetPrerenderContentsFactory(
     PrerenderContents::Factory* prerender_contents_factory) {
   DCHECK(CalledOnValidThread());
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
 void PrerenderManager::SourceNavigatedAway(PrerenderData* prerender_data) {
   // The expiry time of our prerender data will likely change because of
   // this navigation. This requires a resort of active_prerenders_.
   ScopedVector<PrerenderData>::iterator it =
@@ skipping 258 matching lines @@
     const GURL& url,
     const SessionStorageNamespace* session_storage_namespace) {
   for (ScopedVector<PrerenderData>::iterator it = active_prerenders_.begin();
        it != active_prerenders_.end(); ++it) {
     if ((*it)->contents()->Matches(url, session_storage_namespace))
       return *it;
   }
   return NULL;
 }
 
-PrerenderManager::PrerenderData*
-PrerenderManager::FindPrerenderDataForTargetContents(
-    WebContents* target_contents) {
-  for (ScopedVector<PrerenderData>::iterator it = active_prerenders_.begin();
-       it != active_prerenders_.end(); ++it) {
-    if ((*it)->pending_swap() &&
-        (*it)->pending_swap()->web_contents() == target_contents)
-      return *it;
-  }
-  return NULL;
-}
-
 ScopedVector<PrerenderManager::PrerenderData>::iterator
 PrerenderManager::FindIteratorForPrerenderContents(
     PrerenderContents* prerender_contents) {
   for (ScopedVector<PrerenderData>::iterator it = active_prerenders_.begin();
        it != active_prerenders_.end(); ++it) {
     if (prerender_contents == (*it)->contents())
       return it;
   }
   return active_prerenders_.end();
 }
@@ skipping 236 matching lines @@
   if (logged_in_state_.get())
     logged_in_state_->erase(domain_key);
 }
 
 void PrerenderManager::LoggedInPredictorDataReceived(
     scoped_ptr<LoggedInStateMap> new_map) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   logged_in_state_.swap(new_map);
 }
 
-void PrerenderManager::RecordEvent(PrerenderContents* contents,
-                                   PrerenderEvent event) const {
-  if (!contents)
-    histograms_->RecordEvent(ORIGIN_NONE, kNoExperiment, event);
-  else
-    histograms_->RecordEvent(contents->origin(), contents->experiment_id(),
-                             event);
-}
-
 // static
 void PrerenderManager::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) {
   RenderFrameHost* rfh = RenderFrameHost::FromID(process_id, frame_id);
   WebContents* web_contents = WebContents::FromRenderFrameHost(rfh);
@@ skipping 47 matching lines @@
 
 void PrerenderManager::OnHistoryServiceDidQueryURL(
     Origin origin,
     uint8 experiment_id,
     bool success,
     const history::URLRow& url_row,
     const history::VisitVector& /*visits*/) {
   histograms_->RecordPrerenderPageVisitedStatus(origin, experiment_id, success);
 }
 
-// static
-void PrerenderManager::HangSessionStorageMergesForTesting() {
-  g_hang_session_storage_merges_for_testing = true;
-}
-
 void PrerenderManager::RecordNetworkBytes(Origin origin,
                                           bool used,
                                           int64 prerender_bytes) {
   if (!ActuallyPrerendering())
     return;
   int64 recent_profile_bytes =
       profile_network_bytes_ - last_recorded_profile_network_bytes_;
   last_recorded_profile_network_bytes_ = profile_network_bytes_;
   DCHECK_GE(recent_profile_bytes, 0);
   histograms_->RecordNetworkBytes(
@@ skipping 42 matching lines @@
     content::RenderProcessHost* host) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prerender_process_hosts_.erase(host);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PrerenderTracker::RemovePrerenderCookieStoreOnIOThread,
                  base::Unretained(prerender_tracker()), host->GetID(), false));
 }
 
 }  // namespace prerender