Changes to not use the prerendered contents when window.opener needs to be set.

chrome/browser/prerender/prerender_manager.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 393 matching lines @@
   }
   // Entry not found.
   return NULL;
 }
 
 PrerenderContents* PrerenderManager::GetEntry(const GURL& url) {
   return GetEntryButNotSpecifiedTC(url, NULL);
 }
 
 bool PrerenderManager::MaybeUsePreloadedPageOld(TabContents* tab_contents,
-                                                const GURL& url) {
+                                                const GURL& url,
+                                                bool has_opener_set) {
   DCHECK(CalledOnValidThread());
   scoped_ptr<PrerenderContents> prerender_contents(GetEntry(url));
   if (prerender_contents.get() == NULL)
     return false;
 
+  // Do not use the prerendered version if the opener window.property was
+  // supposed to be set.
+  if (has_opener_set) {
+    prerender_contents.release()->Destroy(FINAL_STATUS_WINDOW_OPENER);
+    return false;
+  }
+
   // If we are just in the control group (which can be detected by noticing
   // that prerendering hasn't even started yet), record that |tab_contents| now
   // would be showing a prerendered contents, but otherwise, don't do anything.
   if (!prerender_contents->prerendering_has_started()) {
     MarkTabContentsAsWouldBePrerendered(tab_contents);
     return false;
   }
 
   if (!prerender_contents->load_start_time().is_null())
     RecordTimeUntilUsed(GetCurrentTimeTicks() -
@@ skipping 59 matching lines @@
         urls);
   }
 
   if (prerender_contents->has_stopped_loading())
     render_view_host_delegate->DidStopLoading();
 
   return true;
 }
 
 bool PrerenderManager::MaybeUsePreloadedPage(TabContents* tab_contents,
-                                             const GURL& url) {
+                                             const GURL& url,
+                                             bool has_opener_set) {
   if (!PrerenderContents::UseTabContents()) {
     VLOG(1) << "Checking for prerender with LEGACY code";
-    return PrerenderManager::MaybeUsePreloadedPageOld(tab_contents, url);
+    return PrerenderManager::MaybeUsePreloadedPageOld(tab_contents, url,
+                                                      has_opener_set);
   }
   VLOG(1) << "Checking for prerender with NEW code";
   DCHECK(CalledOnValidThread());
   scoped_ptr<PrerenderContents> prerender_contents(
       GetEntryButNotSpecifiedTC(url, tab_contents));
   if (prerender_contents.get() == NULL)
     return false;
 
+  // Do not use the prerendered version if the opener window.property was
+  // supposed to be set.
+  if (has_opener_set) {
+    prerender_contents.release()->Destroy(FINAL_STATUS_WINDOW_OPENER);
+    return false;
+  }
+
   // If we are just in the control group (which can be detected by noticing
   // that prerendering hasn't even started yet), record that |tab_contents| now
   // would be showing a prerendered contents, but otherwise, don't do anything.
   if (!prerender_contents->prerendering_has_started()) {
     MarkTabContentsAsWouldBePrerendered(tab_contents);
     return false;
   }
 
   if (!prerender_contents->load_start_time().is_null())
     RecordTimeUntilUsed(GetCurrentTimeTicks() -
@@ skipping 50 matching lines @@
   return true;
 }
 
 void PrerenderManager::MoveEntryToPendingDelete(PrerenderContents* entry) {
   DCHECK(CalledOnValidThread());
   DCHECK(!IsPendingDelete(entry));
   for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
        it != prerender_list_.end();
        ++it) {
     if (it->contents_ == entry) {
-      pending_delete_list_.push_back(*it);
       RemovePendingPreload(entry);
       prerender_list_.erase(it);
       break;
     }
   }
+  pending_delete_list_.push_back(entry);
   DeleteOldEntries();
   StartSchedulingPeriodicCleanups();
 }
 
 bool PrerenderManager::IsPendingDelete(PrerenderContents* entry) const {
   DCHECK(CalledOnValidThread());
-  for (std::list<PrerenderContentsData>::const_iterator it =
+  for (std::list<PrerenderContents*>::const_iterator it =
           pending_delete_list_.begin();
        it != pending_delete_list_.end();
        ++it) {
-    if (it->contents_ == entry)
+    if (*it == entry)
       return true;
   }
 
   return false;
 }
 
 base::Time PrerenderManager::GetCurrentTime() const {
   return base::Time::Now();
 }
 
@@ skipping 10 matching lines @@
 PrerenderContents* PrerenderManager::CreatePrerenderContents(
     const GURL& url,
     const GURL& referrer) {
   DCHECK(CalledOnValidThread());
   return prerender_contents_factory_->CreatePrerenderContents(
       this, profile_, url, referrer);
 }
 
 void PrerenderManager::DeletePendingDeleteEntries() {
   while (!pending_delete_list_.empty()) {
-    PrerenderContentsData data = pending_delete_list_.front();
+    PrerenderContents* contents = pending_delete_list_.front();
     pending_delete_list_.pop_front();
-    delete data.contents_;
+    delete contents;
   }
 }
 
 // Helper macro for histograms.
 #define RECORD_PLT(tag, perceived_page_load_time) { \
     UMA_HISTOGRAM_CUSTOM_TIMES( \
         base::FieldTrial::MakeName(std::string("Prerender.") + tag, \
                                    "Prefetch"), \
         perceived_page_load_time, \
         base::TimeDelta::FromMilliseconds(10), \
@@ skipping 245 matching lines @@
   return prerendered_tab_contents_set_.count(tab_contents) > 0;
 }
 
 bool PrerenderManager::WouldTabContentsBePrerendered(
     TabContents* tab_contents) const {
   DCHECK(CalledOnValidThread());
   return would_be_prerendered_tab_contents_set_.count(tab_contents) > 0;
 }
 
 }  // namespace prerender