Only commit cookie changes in prerenders after a prerender is shown

chrome/browser/prerender/prerender_contents.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_contents.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
@@ skipping 21 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/frame_navigate_params.h"
 #include "content/public/common/page_transition_types.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "ui/gfx/rect.h"
 
+using content::BrowserThread;
 using content::DownloadItem;
 using content::OpenURLParams;
 using content::RenderViewHost;
 using content::ResourceRedirectDetails;
 using content::SessionStorageNamespace;
 using content::WebContents;
 
 namespace prerender {
 
 namespace {
@@ skipping 230 matching lines @@
   PrerenderManager* prerender_manager = PrerenderManagerFactory::GetForProfile(
       Profile::FromBrowserContext(web_contents->GetBrowserContext()));
   if (!prerender_manager)
     return NULL;
   return prerender_manager->GetPrerenderContents(web_contents);
 }
 
 void PrerenderContents::StartPrerendering(
     int creator_child_id,
     const gfx::Size& size,
-    SessionStorageNamespace* session_storage_namespace) {
+    SessionStorageNamespace* session_storage_namespace,
+    net::URLRequestContextGetter* request_context) {
   DCHECK(profile_ != NULL);
   DCHECK(!size.IsEmpty());
   DCHECK(!prerendering_has_started_);
   DCHECK(prerender_contents_.get() == NULL);
   DCHECK_EQ(-1, creator_child_id_);
   DCHECK(size_.IsEmpty());
   DCHECK_EQ(1U, alias_urls_.size());
 
   creator_child_id_ = creator_child_id;
   session_storage_namespace_id_ = session_storage_namespace->id();
@@ skipping 27 matching lines @@
   // Set the size of the prerender WebContents.
   apps::ResizeWebContents(prerender_contents_.get(), size_);
 
   child_id_ = GetRenderViewHost()->GetProcess()->GetID();
   route_id_ = GetRenderViewHost()->GetRoutingID();
 
   // Log transactions to see if we could merge session storage namespaces in
   // the event of a mismatch.
   alias_session_storage_namespace->AddTransactionLogProcessId(child_id_);
 
+  // Add the RenderProcessHost to the Prerender Manager.
+  prerender_manager()->AddPrerenderProcessHost(
+      GetRenderViewHost()->GetProcess());
+
+  // In the prerender tracker, create a Prerender Cookie Store to keep track of
+  // cookie changes performed by the prerender. Once the prerender is shown,
+  // the cookie changes will be committed to the actual cookie store,
+  // otherwise, they will be discarded.
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&PrerenderTracker::AddPrerenderCookieStoreOnIOThread,
+                 base::Unretained(prerender_manager()->prerender_tracker()),
+                 GetRenderViewHost()->GetProcess()->GetID(),
+                 make_scoped_refptr(request_context),
+                 base::Bind(&PrerenderContents::Destroy,
+                            AsWeakPtr(),
+                            FINAL_STATUS_COOKIE_CONFLICT)));
+
   NotifyPrerenderStart();
 
   // Close ourselves when the application is shutting down.
   notification_registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                               content::NotificationService::AllSources());
 
   // Register to inform new RenderViews that we're prerendering.
   notification_registrar_.Add(
       this, content::NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
       content::Source<WebContents>(prerender_contents_.get()));
@@ skipping 437 matching lines @@
 void PrerenderContents::PrepareForUse() {
   SetFinalStatus(FINAL_STATUS_USED);
 
   if (prerender_contents_.get()) {
     prerender_contents_->SendToAllFrames(
         new PrerenderMsg_SetIsPrerendering(MSG_ROUTING_NONE, false));
   }
 
   NotifyPrerenderStop();
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
+  BrowserThread::PostTask(
+      BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ResumeThrottles, resource_throttles_));
   resource_throttles_.clear();
 }
 
 SessionStorageNamespace* PrerenderContents::GetSessionStorageNamespace() const {
   if (!prerender_contents())
     return NULL;
   return prerender_contents()->GetController().
       GetDefaultSessionStorageNamespace();
@@ skipping 67 matching lines @@
  void PrerenderContents::AddResourceThrottle(
      const base::WeakPtr<PrerenderResourceThrottle>& throttle) {
    resource_throttles_.push_back(throttle);
  }
 
  void PrerenderContents::AddNetworkBytes(int64 bytes) {
    network_bytes_ += bytes;
  }
 
 }  // namespace prerender