Also register read cookies in the content settings delegate.

net/base/cookie_monster.cc

 // Copyright (c) 2010 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 391 matching lines @@
 }
 
 void CookieMonster::SetExpiryAndKeyScheme(ExpiryAndKeyScheme key_scheme) {
   DCHECK(!initialized_);
   expiry_and_key_scheme_ = key_scheme;
 }
 
 // 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() {
+Time CookieMonster::StrictlyIncreasingTime() {
   return std::max(Time::Now(),
       Time::FromInternalValue(last_time_seen_.ToInternalValue() + 1));
 }
 
 // Parse a cookie expiration time.  We try to be lenient, but we need to
 // assume some order to distinguish the fields.  The basic rules:
 //  - The month name must be present and prefix the first 3 letters of the
 //    full month name (jan for January, jun for June).
 //  - If the year is <= 2 digits, it must occur after the day of month.
 //  - The time must be of the format hh:mm:ss.
@@ skipping 340 matching lines @@
     const GURL& url,
     const std::string& cookie_line,
     const Time& creation_time_or_null,
     const CookieOptions& options) {
   lock_.AssertAcquired();
 
   VLOG(kVlogSetCookies) << "SetCookie() line: " << cookie_line;
 
   Time creation_time = creation_time_or_null;
   if (creation_time.is_null()) {
-    creation_time = CurrentTime();
+    creation_time = StrictlyIncreasingTime();
     last_time_seen_ = creation_time;
   }
 
   // Parse the cookie.
   ParsedCookie pc(cookie_line);
 
   if (!pc.IsValid()) {
     VLOG(kVlogSetCookies) << "WARNING: Couldn't parse cookie";
     return false;
   }
@@ skipping 45 matching lines @@
     const std::string& domain, const std::string& path,
     const base::Time& expiration_time, bool secure, bool http_only) {
 
   AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url))
     return false;
 
   InitIfNecessary();
 
-  Time creation_time = CurrentTime();
+  Time creation_time = StrictlyIncreasingTime();
   last_time_seen_ = creation_time;
 
   scoped_ptr<CanonicalCookie> cc;
   cc.reset(CanonicalCookie::Create(
       url, name, value, domain, path,
       creation_time, expiration_time,
       secure, http_only));
 
   if (!cc.get())
     return false;
@@ skipping 494 matching lines @@
 
   CookieList cookie_list;
   cookie_list.reserve(cookie_ptrs.size());
   for (std::vector<CanonicalCookie*>::const_iterator it = cookie_ptrs.begin();
        it != cookie_ptrs.end(); ++it)
     cookie_list.push_back(**it);
 
   return cookie_list;
 }
 
-CookieMonster::CookieList CookieMonster::GetAllCookiesForURL(const GURL& url) {
+CookieMonster::CookieList CookieMonster::GetAllCookiesForURLWithOptions(
+    const GURL& url,
+    const CookieOptions& options) {
   AutoLock autolock(lock_);
   InitIfNecessary();
 
-  CookieOptions options;
-  options.set_include_httponly();
-
   std::vector<CanonicalCookie*> cookie_ptrs;
   FindCookiesForHostAndDomain(url, options, false, &cookie_ptrs);
   std::sort(cookie_ptrs.begin(), cookie_ptrs.end(), CookieSorter);
 
   CookieList cookies;
   for (std::vector<CanonicalCookie*>::const_iterator it = cookie_ptrs.begin();
        it != cookie_ptrs.end(); it++)
     cookies.push_back(**it);
 
   return cookies;
 }
 
+CookieMonster::CookieList CookieMonster::GetAllCookiesForURL(const GURL& url) {
+  CookieOptions options;
+  options.set_include_httponly();
+
+  return GetAllCookiesForURLWithOptions(url, options);
+}
+
 void CookieMonster::FindCookiesForHostAndDomain(
     const GURL& url,
     const CookieOptions& options,
     bool update_access_time,
     std::vector<CanonicalCookie*>* cookies) {
   lock_.AssertAcquired();
 
-  const Time current_time(CurrentTime());
+  const Time current_time(StrictlyIncreasingTime());
 
   // Probe to save statistics relatively frequently.  We do it here rather
   // than in the set path as many websites won't set cookies, and we
   // want to collect statistics whenever the browser's being used.
   RecordPeriodicStats(current_time);
 
   if (expiry_and_key_scheme_ == EKS_DISCARD_RECENT_AND_PURGE_DOMAIN) {
     // Can just dispatch to FindCookiesForKey
     const std::string key(GetKey(url.host()));
     FindCookiesForKey(key, url, options, current_time,
@@ skipping 600 matching lines @@
   return base::StringPrintf(
       "name: %s value: %s domain: %s path: %s creation: %"
       PRId64,
       name_.c_str(), value_.c_str(),
       domain_.c_str(), path_.c_str(),
       static_cast<int64>(creation_date_.ToTimeT()));
 }
 
 }  // namespace