Only commit cookie changes in prerenders after a prerender is shown

net/cookies/cookie_monster.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 35 matching lines @@
 
 #include <algorithm>
 #include <functional>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 #include "url/gurl.h"
@@ skipping 238 matching lines @@
     cookie_line += (*it)->Value();
   }
   return cookie_line;
 }
 
 }  // namespace
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              CookieMonsterDelegate* delegate)
     : initialized_(false),
-      loaded_(false),
+      loaded_(store == NULL),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)),
       delegate_(delegate),
       last_statistic_record_time_(Time::Now()),
       keep_expired_cookies_(false),
       persist_session_cookies_(false) {
   InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              CookieMonsterDelegate* delegate,
                              int last_access_threshold_milliseconds)
     : initialized_(false),
-      loaded_(false),
+      loaded_(store == NULL),
       store_(store),
       last_access_threshold_(base::TimeDelta::FromMilliseconds(
           last_access_threshold_milliseconds)),
       delegate_(delegate),
       last_statistic_record_time_(base::Time::Now()),
       keep_expired_cookies_(false),
       persist_session_cookies_(false) {
   InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
@@ skipping 1085 matching lines @@
 }
 
 void CookieMonster::InitStore() {
   DCHECK(store_.get()) << "Store must exist to initialize";
 
   // We bind in the current time so that we can report the wall-clock time for
   // loading cookies.
   store_->Load(base::Bind(&CookieMonster::OnLoaded, this, TimeTicks::Now()));
 }
 
+void CookieMonster::ReportLoaded() {
+  if (delegate_.get())
+    delegate_->OnLoaded();
+}
+
 void CookieMonster::OnLoaded(TimeTicks beginning_time,
                              const std::vector<CanonicalCookie*>& cookies) {
   StoreLoadedCookies(cookies);
   histogram_time_blocked_on_load_->AddTime(TimeTicks::Now() - beginning_time);
 
   // Invoke the task queue of cookie request.
   InvokeQueue();
+
+  ReportLoaded();
 }
 
 void CookieMonster::OnKeyLoaded(const std::string& key,
                                 const std::vector<CanonicalCookie*>& cookies) {
   // This function does its own separate locking.
   StoreLoadedCookies(cookies);
 
   std::deque<scoped_refptr<CookieMonsterTask> > tasks_pending_for_key;
 
   // We need to do this repeatedly until no more tasks were added to the queue
@@ skipping 785 matching lines @@
 
 
 // The system resolution is not high enough, so we can have multiple
 // set cookies that result in the same system time.  When this happens, we
 // increment by one Time unit.  Let's hope computers don't get too fast.
 Time CookieMonster::CurrentTime() {
   return std::max(Time::Now(),
       Time::FromInternalValue(last_time_seen_.ToInternalValue() + 1));
 }
 
+bool CookieMonster::CopyCookiesForKeyToOtherCookieMonster(
+    std::string key,
+    CookieMonster* other) {
+  ScopedVector<CanonicalCookie> duplicated_cookies;
+
+  {
+    base::AutoLock autolock(lock_);
+    DCHECK(other);
+    if (!loaded_)
+      return false;
+
+    for (CookieMapItPair its = cookies_.equal_range(key);
+         its.first != its.second;
+         ++its.first) {
+      CookieMap::iterator curit = its.first;
+      CanonicalCookie* cc = curit->second;
+
+      duplicated_cookies.push_back(cc->Duplicate());
+    }
+  }
+
+  {
+    base::AutoLock autolock(other->lock_);
+    if (!other->loaded_)
+      return false;
+
+    // There must not exist any entries for the key to be copied in |other|.
+    CookieMapItPair its = other->cookies_.equal_range(key);
+    if (its.first != its.second)
+      return false;
+
+    // Store the copied cookies in |other|.
+    for (ScopedVector<CanonicalCookie>::const_iterator it =
+             duplicated_cookies.begin();
+         it != duplicated_cookies.end();
+         ++it) {
+      other->InternalInsertCookie(key, *it, true);
+    }
+
+    // Since the cookies are owned by |other| now, weak clear must be used.
+    duplicated_cookies.weak_clear();
+  }
+
+  return true;
+}
+
+bool CookieMonster::loaded() {
+  base::AutoLock autolock(lock_);
+  return loaded_;
+}
+
 }  // namespace net