Handle should_replace_current_entry in prerender.

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 476 matching lines @@
   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));
+        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);
+  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) {
+    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;
   }
@@ skipping 111 matching lines @@
   WebContents* new_web_contents =
       prerender_contents->ReleasePrerenderContents();
   WebContents* old_web_contents = web_contents;
   DCHECK(new_web_contents);
   DCHECK(old_web_contents);
 
   MarkWebContentsAsPrerendered(new_web_contents, prerender_contents->origin());
 
   // Merge the browsing history.
   new_web_contents->GetController().CopyStateFromAndPrune(
-      &old_web_contents->GetController());
+      &old_web_contents->GetController(),
+      should_replace_current_entry);
   CoreTabHelper::FromWebContents(old_web_contents)->delegate()->
       SwapTabContents(old_web_contents, new_web_contents);
   prerender_contents->CommitHistory(new_web_contents);
 
   GURL icon_url = prerender_contents->icon_url();
 
   if (!icon_url.is_empty()) {
 #if defined(OS_ANDROID)
     // Do the delayed icon fetch since we didn't download
     // the favicon during prerendering on mobile devices.
@@ skipping 489 matching lines @@
 }
 
 PrerenderContents* PrerenderManager::PrerenderData::ReleaseContents() {
   return contents_.release();
 }
 
 PrerenderManager::PendingSwap::PendingSwap(
     PrerenderManager* manager,
     content::WebContents* target_contents,
     PrerenderData* prerender_data,
-    const GURL& url)
+    const GURL& url,
+    bool should_replace_current_entry)
     : content::WebContentsObserver(target_contents),
       manager_(manager),
       target_contents_(target_contents),
       prerender_data_(prerender_data),
       url_(url),
+      should_replace_current_entry_(should_replace_current_entry),
       start_time_(base::TimeTicks::Now()),
       swap_successful_(false),
       weak_factory_(this) {
   RenderViewCreated(target_contents->GetRenderViewHost());
 }
 
 PrerenderManager::PendingSwap::~PendingSwap() {
   for (size_t i = 0; i < rvh_ids_.size(); i++) {
     manager_->prerender_tracker()->RemovePrerenderPendingSwap(
         rvh_ids_[i], swap_successful_);
@@ skipping 116 matching lines @@
     return;
   }
 
   RecordEvent(PRERENDER_EVENT_MERGE_RESULT_SWAPPING_IN);
   // Note that SwapInternal, on success, will delete |prerender_data_| and
   // |this|. Pass in a new GURL object rather than a reference to |url_|.
   //
   // TODO(davidben): See about deleting PrerenderData asynchronously so this
   // behavior is more reasonable.
   WebContents* new_web_contents =
-      manager_->SwapInternal(GURL(url_), target_contents_, prerender_data_);
+      manager_->SwapInternal(GURL(url_), target_contents_, prerender_data_,
+                             should_replace_current_entry_);
   if (!new_web_contents) {
     RecordEvent(PRERENDER_EVENT_MERGE_RESULT_SWAPIN_FAILED);
     prerender_data_->ClearPendingSwap();
   }
 }
 
 void PrerenderManager::PendingSwap::OnMergeTimeout() {
   RecordEvent(PRERENDER_EVENT_MERGE_RESULT_TIMED_OUT);
   prerender_data_->ClearPendingSwap();
 }
@@ skipping 566 matching lines @@
 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);
 }
 
 }  // namespace prerender