Only commit cookie changes in prerenders after a prerender is shown

chrome/browser/prerender/prerender_tracker.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_tracker.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "chrome/browser/prerender/prerender_pending_swap_throttle.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 
 namespace prerender {
 
 PrerenderTracker::PrerenderTracker() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 PrerenderTracker::~PrerenderTracker() {
+  for (PrerenderProcessSet::const_iterator it =
+           prerender_process_hosts_.begin();
+       it != prerender_process_hosts_.end();
+       ++it) {
+    (*it)->RemoveObserver(this);
+  }
 }
 
 bool PrerenderTracker::IsPendingSwapRequestOnIOThread(
     int render_process_id, int render_frame_id, const GURL& url) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   ChildRouteIdPair render_frame_route_id_pair(
       render_process_id, render_frame_id);
   PendingSwapThrottleMap::const_iterator it =
       pending_swap_throttle_map_.find(render_frame_route_id_pair);
@@ skipping 65 matching lines @@
 }
 
 PrerenderTracker::PendingSwapThrottleData::PendingSwapThrottleData(
     const GURL& swap_url)
     : url(swap_url) {
 }
 
 PrerenderTracker::PendingSwapThrottleData::~PendingSwapThrottleData() {
 }
 
+scoped_refptr<PrerenderCookieStore>
+PrerenderTracker::GetPrerenderCookieStoreForRenderProcess(
+    int process_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  PrerenderCookieStoreMap::const_iterator it =
+      prerender_cookie_store_map_.find(process_id);
+
+  if (it == prerender_cookie_store_map_.end())
+    return NULL;
+
+  return it->second;
+}
+
+bool PrerenderTracker::IsProcessPrerendering(
+    content::RenderProcessHost* process_host) {
+  return (prerender_process_hosts_.find(process_host) !=
+          prerender_process_hosts_.end());
+}
+
+void PrerenderTracker::OnCookieChangedForURL(int process_id, const GURL& url) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  for (PrerenderCookieStoreMap::iterator it =
+           prerender_cookie_store_map_.begin();
+       it != prerender_cookie_store_map_.end();
+       ++it) {
+    // Report the change to all prerender cookie stores which may be affected.
+    // This does not include the one for the render process originating the
+    // change.
+    if (it->first != process_id)
+      it->second->OnCookieChangedForURL(url);
+  }
+}
+
+void PrerenderTracker::RenderProcessHostDestroyed(
+    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(this), host->GetID(), false));
+}
+
+void PrerenderTracker::RemovePrerenderCookieStoreOnIOThread(int process_id,
+                                                            bool was_swapped) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  PrerenderCookieStoreMap::iterator it =
+      prerender_cookie_store_map_.find(process_id);
+
+  if (it == prerender_cookie_store_map_.end())
+    return;
+
+  if (was_swapped)
+    it->second->ApplyChanges();
+
+  prerender_cookie_store_map_.erase(it);
+}
+
+void PrerenderTracker::OnPrerenderSwapped(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(this), host->GetID(), true));
+}
+
+void PrerenderTracker::AddPrerender(
+    content::RenderProcessHost* host,
+    net::URLRequestContextGetter* request_context,
+    const base::Closure& cookie_conflict_cb) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(request_context != NULL);
+  DCHECK(prerender_process_hosts_.find(host)== prerender_process_hosts_.end());
+  prerender_process_hosts_.insert(host);
+  host->AddObserver(this);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&PrerenderTracker::AddPrerenderCookieStoreOnIOThread,
+                 base::Unretained(this), host->GetID(),
+                 make_scoped_refptr(request_context),
+                 cookie_conflict_cb));
+}
+
+void PrerenderTracker::AddPrerenderCookieStoreOnIOThread(
+    int process_id,
+    scoped_refptr<net::URLRequestContextGetter> request_context,
+    const base::Closure& cookie_conflict_cb) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(request_context != NULL);
+  net::CookieMonster* cookie_monster =
+      request_context->GetURLRequestContext()->cookie_store()->
+      GetCookieMonster();
+  DCHECK(cookie_monster != NULL);
+  bool exists = (prerender_cookie_store_map_.find(process_id) !=
+                 prerender_cookie_store_map_.end());
+  DCHECK(!exists);
+  if (exists)
+    return;
+  prerender_cookie_store_map_[process_id] =
+      new PrerenderCookieStore(make_scoped_refptr(cookie_monster),
+                               cookie_conflict_cb);
+}
+
 }  // namespace prerender