Snapshot of all changes to get jumbo in blink and content.

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 157 matching lines @@
 struct OrderByCreationTimeDesc {
   bool operator()(const CookieMonster::CookieMap::iterator& a,
                   const CookieMonster::CookieMap::iterator& b) const {
     return a->second->CreationDate() > b->second->CreationDate();
   }
 };
 
 // Constants for use in VLOG
 const int kVlogPerCookieMonster = 1;
 const int kVlogGarbageCollection = 5;
-const int kVlogSetCookies = 7;
+const int kVlogSetCookies2 = 7;
 const int kVlogGetCookies = 9;
 
 // Mozilla sorts on the path length (longest first), and then it
 // sorts by creation time (oldest first).
 // The RFC says the sort order for the domain attribute is undefined.
 bool CookieSorter(CanonicalCookie* cc1, CanonicalCookie* cc2) {
   if (cc1->Path().length() == cc2->Path().length())
     return cc1->CreationDate() < cc2->CreationDate();
   return cc1->Path().length() > cc2->Path().length();
 }
@@ skipping 1171 matching lines @@
 }
 
 void CookieMonster::SetCookieWithCreationTimeAndOptions(
     const GURL& url,
     const std::string& cookie_line,
     const Time& creation_time_or_null,
     const CookieOptions& options,
     SetCookiesCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  VLOG(kVlogSetCookies) << "SetCookie() line: " << cookie_line;
+  VLOG(kVlogSetCookies2) << "SetCookie() line: " << cookie_line;
 
   Time creation_time = creation_time_or_null;
   if (creation_time.is_null()) {
     creation_time = CurrentTime();
     last_time_seen_ = creation_time;
   }
 
   std::unique_ptr<CanonicalCookie> cc(
       CanonicalCookie::Create(url, cookie_line, creation_time, options));
 
   if (!cc.get()) {
-    VLOG(kVlogSetCookies) << "WARNING: Failed to allocate CanonicalCookie";
+    VLOG(kVlogSetCookies2) << "WARNING: Failed to allocate CanonicalCookie";
     MaybeRunCookieCallback(std::move(callback), false);
     return;
   }
   SetCanonicalCookie(std::move(cc), url.SchemeIsCryptographic(),
                      !options.exclude_httponly(), std::move(callback));
 }
 
 void CookieMonster::SetCanonicalCookie(std::unique_ptr<CanonicalCookie> cc,
                                        bool secure_source,
                                        bool modify_http_only,
@@ skipping 19 matching lines @@
   }
   bool already_expired = cc->IsExpired(creation_date);
 
   if (DeleteAnyEquivalentCookie(key, *cc, secure_source, !modify_http_only,
                                 already_expired)) {
     std::string error;
     error =
         "SetCookie() not clobbering httponly cookie or secure cookie for "
         "insecure scheme";
 
-    VLOG(kVlogSetCookies) << error;
+    VLOG(kVlogSetCookies2) << error;
     MaybeRunCookieCallback(std::move(callback), false);
     return;
   }
 
-  VLOG(kVlogSetCookies) << "SetCookie() key: " << key
+  VLOG(kVlogSetCookies2) << "SetCookie() key: " << key
                         << " cc: " << cc->DebugString();
 
   // Realize that we might be setting an expired cookie, and the only point
   // was to delete the cookie which we've already done.
   if (!already_expired) {
     // See InitializeHistograms() for details.
     if (cc->IsPersistent()) {
       histogram_expiration_duration_minutes_->Add(
           (cc->ExpiryDate() - creation_date).InMinutes());
     }
 
     // Histogram the type of scheme used on URLs that set cookies. This
     // intentionally includes cookies that are set or overwritten by
     // http:// URLs, but not cookies that are cleared by http:// URLs, to
     // understand if the former behavior can be deprecated for Secure
     // cookies.
     CookieSource cookie_source_sample =
         (secure_source
              ? (cc->IsSecure()
                     ? COOKIE_SOURCE_SECURE_COOKIE_CRYPTOGRAPHIC_SCHEME
                     : COOKIE_SOURCE_NONSECURE_COOKIE_CRYPTOGRAPHIC_SCHEME)
              : (cc->IsSecure()
                     ? COOKIE_SOURCE_SECURE_COOKIE_NONCRYPTOGRAPHIC_SCHEME
                     : COOKIE_SOURCE_NONSECURE_COOKIE_NONCRYPTOGRAPHIC_SCHEME));
     histogram_cookie_source_scheme_->Add(cookie_source_sample);
 
     InternalInsertCookie(key, std::move(cc), true);
   } else {
-    VLOG(kVlogSetCookies) << "SetCookie() not storing already expired cookie.";
+    VLOG(kVlogSetCookies2) << "SetCookie() not storing already expired cookie.";
   }
 
   // We assume that hopefully setting a cookie will be less common than
   // querying a cookie.  Since setting a cookie can put us over our limits,
   // make sure that we garbage collect...  We can also make the assumption that
   // if a cookie was set, in the common case it will be used soon after,
   // and we will purge the expired cookies in GetCookies().
   GarbageCollect(creation_date, key);
 
   MaybeRunCookieCallback(std::move(callback), true);
@@ skipping 55 matching lines @@
                                          DeletionCause deletion_cause) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Ideally, this would be asserted up where we define kChangeCauseMapping,
   // but DeletionCause's visibility (or lack thereof) forces us to make
   // this check here.
   static_assert(arraysize(kChangeCauseMapping) == DELETE_COOKIE_LAST_ENTRY + 1,
                 "kChangeCauseMapping size should match DeletionCause size");
 
   CanonicalCookie* cc = it->second.get();
-  VLOG(kVlogSetCookies) << "InternalDeleteCookie()"
+  VLOG(kVlogSetCookies2) << "InternalDeleteCookie()"
                         << ", cause:" << deletion_cause
                         << ", cc: " << cc->DebugString();
 
   if ((cc->IsPersistent() || persist_session_cookies_) && store_.get() &&
       sync_to_store)
     store_->DeleteCookie(*cc);
   ChangeCausePair mapping = kChangeCauseMapping[deletion_cause];
   if (delegate_.get() && mapping.notify)
     delegate_->OnCookieChanged(*cc, true, mapping.cause);
   RunCookieChangedCallbacks(*cc, mapping.cause);
@@ skipping 486 matching lines @@
        it != hook_map_.end(); ++it) {
     std::pair<GURL, std::string> key = it->first;
     if (cookie.IncludeForRequestURL(key.first, opts) &&
         cookie.Name() == key.second) {
       it->second->Notify(cookie, cause);
     }
   }
 }
 
 }  // namespace net