Revert 269855 "Only commit cookie changes in prerenders after a ..."

trunk/src/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_(store == NULL),
+      loaded_(false),
       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_(store == NULL),
+      loaded_(false),
       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