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

net/base/cookie_monster.h

 // 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.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_BASE_COOKIE_MONSTER_H_
 #define NET_BASE_COOKIE_MONSTER_H_
 
 #include <map>
@@ skipping 58 matching lines @@
   // class, but it must remain valid for the duration of the cookie monster's
   // existence.
   CookieMonster(PersistentCookieStore* store);
 
 #ifdef UNIT_TEST
   CookieMonster(int last_access_threshold_seconds)
       : initialized_(false),
         store_(NULL),
         last_access_threshold_(
             base::TimeDelta::FromSeconds(last_access_threshold_seconds)) {
+    SetDefaultCookieableSchemes();
   }
 #endif
 
   ~CookieMonster();
 
   // Parse the string with the cookie time (very forgivingly).
   static base::Time ParseCookieTime(const std::string& time_string);
 
   // Set a single cookie.  Expects a cookie line, like "a=1; domain=b.com".
   bool SetCookie(const GURL& url, const std::string& cookie_line);
@@ skipping 37 matching lines @@
                               bool sync_to_store);
   // Delete all of the cookies that have a creation_date more recent than the
   // one passed into the function via |delete_after|.
   int DeleteAllCreatedAfter(const base::Time& delete_begin, bool sync_to_store);
 
   // Delete one specific cookie.
   bool DeleteCookie(const std::string& domain,
                     const CanonicalCookie& cookie,
                     bool sync_to_store);
 
+  // Override the default list of schemes that are allowed to be set in
+  // this cookie store.  Calling his overrides the value of
+  // "enable_file_scheme_".
+  void SetCookieableSchemes(const char* schemes[], size_t num_schemes);
+
   // There are some unknowns about how to correctly handle file:// cookies,
   // and our implementation for this is not robust enough. This allows you
   // to enable support, but it should only be used for testing. Bug 1157243.
+  // Must be called before creating a CookieMonster instance.
   static void EnableFileScheme();
   static bool enable_file_scheme_;
 
  private:
   // Called by all non-static functions to ensure that the cookies store has
   // been initialized. This is not done during creating so it doesn't block
   // the window showing.
   // Note: this method should always be called with lock_ held.
   void InitIfNecessary() {
     if (!initialized_) {
       if (store_)
         InitStore();
       initialized_ = true;
     }
   }
 
   // Initializes the backing store and reads existing cookies from it.
   // Should only be called by InitIfNecessary().
   void InitStore();
 
+  void SetDefaultCookieableSchemes();
+
   void FindCookiesForHostAndDomain(const GURL& url,
                                    const CookieOptions& options,
                                    std::vector<CanonicalCookie*>* cookies);
 
   void FindCookiesForKey(const std::string& key,
                          const GURL& url,
                          const CookieOptions& options,
                          const base::Time& current,
                          std::vector<CanonicalCookie*>* cookies);
 
@@ skipping 34 matching lines @@
 
   // Helper for GarbageCollectRange(); can be called directly as well.  Deletes
   // all expired cookies in |itpair|.  If |cookie_its| is non-NULL, it is
   // populated with all the non-expired cookies from |itpair|.
   //
   // Returns the number of cookies deleted.
   int GarbageCollectExpired(const base::Time& current,
                             const CookieMapItPair& itpair,
                             std::vector<CookieMap::iterator>* cookie_its);
 
+  bool HasCookieableScheme(const GURL& url);
+
   CookieMap cookies_;
 
   // Indicates whether the cookie store has been initialized. This happens
   // lazily in InitStoreIfNecessary().
   bool initialized_;
 
   PersistentCookieStore* store_;
 
   // The resolution of our time isn't enough, so we do something
   // ugly and increment when we've seen the same time twice.
   base::Time CurrentTime();
   base::Time last_time_seen_;
 
   // Minimum delay after updating a cookie's LastAccessDate before we will
   // update it again.
   const base::TimeDelta last_access_threshold_;
 
+  std::vector<std::string> cookieable_schemes_;
+
   // Lock for thread-safety
   Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieMonster);
 };
 
 class CookieMonster::ParsedCookie {
  public:
   typedef std::pair<std::string, std::string> TokenValuePair;
   typedef std::vector<TokenValuePair> PairList;
@@ skipping 143 matching lines @@
  protected:
   PersistentCookieStore() { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_COOKIE_MONSTER_H_