Add a separate cookie store that's used for extensions....

net/base/cookie_monster.cc

 // Copyright (c) 2006-2008 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 76 matching lines @@
 // static
 void CookieMonster::EnableFileScheme() {
   enable_file_scheme_ = true;
 }
 
 CookieMonster::CookieMonster()
     : initialized_(false),
       store_(NULL),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)) {
+  SetDefaultCookieableSchemes();
 }
 
 CookieMonster::CookieMonster(PersistentCookieStore* store)
     : initialized_(false),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)) {
+  SetDefaultCookieableSchemes();
 }
 
 CookieMonster::~CookieMonster() {
   DeleteAll(false);
 }
 
 void CookieMonster::InitStore() {
   DCHECK(store_) << "Store must exist to initialize";
 
   // Initialize the store and sync in any saved persistent cookies.  We don't
   // care if it's expired, insert it so it can be garbage collected, removed,
   // and sync'd.
   std::vector<KeyedCanonicalCookie> cookies;
   // Reserve space for the maximum amount of cookies a database should have.
   // This prevents multiple vector growth / copies as we append cookies.
   cookies.reserve(kNumCookiesTotal);
   store_->Load(&cookies);
   for (std::vector<KeyedCanonicalCookie>::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
     InternalInsertCookie(it->first, it->second, false);
   }
 }
 
+void CookieMonster::SetDefaultCookieableSchemes() {
+  // Note: file must be the last scheme.
+  static const char* kDefaultCookieableSchemes[] = { "http", "https", "file" };
+  int num_schemes = enable_file_scheme_ ? 3 : 2;
+  SetCookieableSchemes(kDefaultCookieableSchemes, num_schemes);

[Dean McNamee, 2009/05/14 07:34:38]

This is so much simpler, thanks.

+}
+
 // 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));
 }
 
 // Parse a cookie expiration time.  We try to be lenient, but we need to
 // assume some order to distinguish the fields.  The basic rules:
@@ skipping 214 matching lines @@
   }
 
   // Try the Expires attribute.
   if (pc.HasExpires())
     return CookieMonster::ParseCookieTime(pc.Expires());
 
   // Invalid or no expiration, persistent cookie.
   return Time();
 }
 
-static bool HasCookieableScheme(const GURL& url) {
-  static const char* kCookieableSchemes[]  = { "http", "https", "file" };
-  static const int   kCookieableSchemesLen = arraysize(kCookieableSchemes);
-  static const int   kCookieableSchemesFileIndex = 2;
-
+bool CookieMonster::HasCookieableScheme(const GURL& url) {
   // Make sure the request is on a cookie-able url scheme.
-  for (int i = 0; i < kCookieableSchemesLen; ++i) {
+  for (size_t i = 0; i < cookieable_schemes_.size(); ++i) {
     // We matched a scheme.
-    if (url.SchemeIs(kCookieableSchemes[i])) {
-      // This is file:// scheme
-      if (i == kCookieableSchemesFileIndex)
-        return CookieMonster::enable_file_scheme_;
+    if (url.SchemeIs(cookieable_schemes_[i].c_str())) {
       // We've matched a supported scheme.
       return true;
     }
   }
 
   // The scheme didn't match any in our whitelist.
   COOKIE_DLOG(WARNING) << "Unsupported cookie scheme: " << url.scheme();
   return false;
 }
 
+void CookieMonster::SetCookieableSchemes(
+    const char* schemes[], size_t num_schemes) {
+  cookieable_schemes_.clear();
+  cookieable_schemes_.insert(cookieable_schemes_.end(),
+                             schemes, schemes + num_schemes);
+}
+
 bool CookieMonster::SetCookie(const GURL& url,
                               const std::string& cookie_line) {
   CookieOptions options;
   return SetCookieWithOptions(url, cookie_line, options);
 }
 
 bool CookieMonster::SetCookieWithOptions(const GURL& url,
                                          const std::string& cookie_line,
                                          const CookieOptions& options) {
   Time creation_date;
@@ skipping 19 matching lines @@
 }
 
 bool CookieMonster::SetCookieWithCreationTimeWithOptions(
                                               const GURL& url,
                                               const std::string& cookie_line,
                                               const Time& creation_time,
                                               const CookieOptions& options) {
   DCHECK(!creation_time.is_null());
 
   if (!HasCookieableScheme(url)) {
-    DLOG(WARNING) << "Unsupported cookie scheme: " << url.scheme();
     return false;
   }
 
   AutoLock autolock(lock_);
   InitIfNecessary();
 
   COOKIE_DLOG(INFO) << "SetCookie() line: " << cookie_line;
 
   // Parse the cookie.
   ParsedCookie pc(cookie_line);
@@ skipping 293 matching lines @@
 // keys that are a prefix of our hostname.  I think the hash probing
 // should be fast and simple enough for now.
 std::string CookieMonster::GetCookies(const GURL& url) {
   CookieOptions options;
   return GetCookiesWithOptions(url, options);
 }
 
 std::string CookieMonster::GetCookiesWithOptions(const GURL& url,
                                                  const CookieOptions& options) {
   if (!HasCookieableScheme(url)) {
-    DLOG(WARNING) << "Unsupported cookie scheme: " << url.scheme();
     return std::string();
   }
 
   // Get the cookies for this host and its domain(s).
   std::vector<CanonicalCookie*> cookies;
   FindCookiesForHostAndDomain(url, options, &cookies);
   std::sort(cookies.begin(), cookies.end(), CookieSorter);
 
   std::string cookie_line;
   for (std::vector<CanonicalCookie*>::const_iterator it = cookies.begin();
@@ skipping 368 matching lines @@
   return true;
 }
 
 std::string CookieMonster::CanonicalCookie::DebugString() const {
   return StringPrintf("name: %s value: %s path: %s creation: %llu",
                       name_.c_str(), value_.c_str(), path_.c_str(),
                       creation_date_.ToTimeT());
 }
 
 }  // namespace