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

chrome/browser/prerender/prerender_manager.cc

Index: chrome/browser/prerender/prerender_manager.cc
diff --git a/chrome/browser/prerender/prerender_manager.cc b/chrome/browser/prerender/prerender_manager.cc
index f3d3e245b29da9dcfa6f700af950a025492f4dcf..670c2e80a5768e60a0038eea8521eb76ff2efe7f 100644
--- a/chrome/browser/prerender/prerender_manager.cc
+++ b/chrome/browser/prerender/prerender_manager.cc
@@ -92,12 +92,6 @@ const char* const kValidHttpMethods[] = {
 // 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.
@@ -424,60 +418,10 @@ bool PrerenderManager::MaybeUsePrerenderedPage(const GURL& url,
   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;
-  }
+  DCHECK(prerender_data->contents());
 
   // No need to merge; swap synchronously.
   WebContents* new_web_contents = SwapInternal(
@@ -503,7 +447,6 @@ WebContents* PrerenderManager::SwapInternal(
   // 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;
   }
 
@@ -616,8 +559,6 @@ WebContents* PrerenderManager::SwapInternal(
                                      ++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);
@@ -700,7 +641,6 @@ void PrerenderManager::MoveEntryToPendingDelete(PrerenderContents* entry,
     (*it)->MakeIntoMatchCompleteReplacement();
   } else {
     to_delete_prerenders_.push_back(*it);
-    (*it)->ClearPendingSwap();
     active_prerenders_.weak_erase(it);
   }
 
@@ -1028,192 +968,10 @@ void PrerenderManager::PrerenderData::OnHandleCanceled(
   }
 }
 
-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());
@@ -1492,18 +1250,6 @@ PrerenderManager::PrerenderData* PrerenderManager::FindPrerenderData(
   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) {
@@ -1760,15 +1506,6 @@ void PrerenderManager::LoggedInPredictorDataReceived(
   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,
@@ -1836,11 +1573,6 @@ void PrerenderManager::OnHistoryServiceDidQueryURL(
   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) {