Revert 219709 "Remove the Extensions URLRequestContext."

trunk/src/net/cookies/cookie_monster.h

 // 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.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_COOKIES_COOKIE_MONSTER_H_
 #define NET_COOKIES_COOKIE_MONSTER_H_
 
 #include <deque>
@@ skipping 19 matching lines @@
 class GURL;
 
 namespace base {
 class Histogram;
 class HistogramBase;
 class TimeTicks;
 }  // namespace base
 
 namespace net {
 
-class CookieMonsterDelegate;
 class ParsedCookie;
 
 // The cookie monster is the system for storing and retrieving cookies. It has
 // an in-memory list of all cookies, and synchronizes non-session cookies to an
 // optional permanent storage that implements the PersistentCookieStore
 // interface.
 //
 // This class IS thread-safe. Normally, it is only used on the I/O thread, but
 // is also accessed directly through Automation for UI testing.
 //
 // All cookie tasks are handled asynchronously. Tasks may be deferred if
 // all affected cookies are not yet loaded from the backing store. Otherwise,
 // the callback may be invoked immediately (prior to return of the asynchronous
 // function).
 //
 // A cookie task is either pending loading of the entire cookie store, or
 // loading of cookies for a specfic domain key(eTLD+1). In the former case, the
 // cookie task will be queued in tasks_pending_ while PersistentCookieStore
 // chain loads the cookie store on DB thread. In the latter case, the cookie
 // task will be queued in tasks_pending_for_key_ while PermanentCookieStore
 // loads cookies for the specified domain key(eTLD+1) on DB thread.
 //
 // Callbacks are guaranteed to be invoked on the calling thread.
 //
 // TODO(deanm) Implement CookieMonster, the cookie database.
 //  - Verify that our domain enforcement and non-dotted handling is correct
 class NET_EXPORT CookieMonster : public CookieStore {
  public:
+  class Delegate;
   class PersistentCookieStore;
-  typedef CookieMonsterDelegate Delegate;
 
   // Terminology:
   //    * The 'top level domain' (TLD) of an internet domain name is
   //      the terminal "." free substring (e.g. "com" for google.com
   //      or world.std.com).
   //    * The 'effective top level domain' (eTLD) is the longest
   //      "." initiated terminal substring of an internet domain name
   //      that is controlled by a general domain registrar.
   //      (e.g. "co.uk" for news.bbc.co.uk).
   //    * The 'effective top level domain plus one' (eTLD+1) is the
@@ skipping 51 matching lines @@
   static const size_t kDomainCookiesQuotaLow;
   static const size_t kDomainCookiesQuotaMedium;
   static const size_t kDomainCookiesQuotaHigh;
 
   // The store passed in should not have had Init() called on it yet. This
   // class will take care of initializing it. The backing store is NOT owned by
   // this class, but it must remain valid for the duration of the cookie
   // monster's existence. If |store| is NULL, then no backing store will be
   // updated. If |delegate| is non-NULL, it will be notified on
   // creation/deletion of cookies.
-  CookieMonster(PersistentCookieStore* store, CookieMonsterDelegate* delegate);
+  CookieMonster(PersistentCookieStore* store, Delegate* delegate);
 
   // Only used during unit testing.
   CookieMonster(PersistentCookieStore* store,
-                CookieMonsterDelegate* delegate,
+                Delegate* delegate,
                 int last_access_threshold_milliseconds);
 
   // Helper function that adds all cookies from |list| into this instance.
   bool InitializeFrom(const CookieList& list);
 
   typedef base::Callback<void(const CookieList& cookies)> GetCookieListCallback;
   typedef base::Callback<void(bool success)> DeleteCookieCallback;
   typedef base::Callback<void(bool cookies_exist)> HasCookiesForETLDP1Callback;
 
   // Sets a cookie given explicit user-provided cookie attributes. The cookie
@@ skipping 61 matching lines @@
   void HasCookiesForETLDP1Async(const std::string& etldp1,
                                 const HasCookiesForETLDP1Callback& callback);
 
   // Resets the list of cookieable schemes to the supplied schemes.
   // If this this method is called, it must be called before first use of
   // the instance (i.e. as part of the instance initialization process).
   void SetCookieableSchemes(const char* schemes[], size_t num_schemes);
 
   // Resets the list of cookieable schemes to kDefaultCookieableSchemes with or
   // without 'file' being included.
-  //
-  // 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.
   void SetEnableFileScheme(bool accept);
 
   // Instructs the cookie monster to not delete expired cookies. This is used
   // in cases where the cookie monster is used as a data structure to keep
   // arbitrary cookies.
   void SetKeepExpiredCookies();
 
   // Protects session cookies from deletion on shutdown.
   void SetForceKeepSessionState();
 
+  // 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();
+
   // Flush the backing store (if any) to disk and post the given callback when
   // done.
   // WARNING: THE CALLBACK WILL RUN ON A RANDOM THREAD. IT MUST BE THREAD SAFE.
   // It may be posted to the current thread, or it may run on the thread that
   // actually does the flushing. Your Task should generally post a notification
   // to the thread you actually want to be notified on.
   void FlushStore(const base::Closure& callback);
 
   // CookieStore implementation.
 
@@ skipping 92 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest, GetKey);
   FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest, TestGetKey);
 
   // For FindCookiesForKey.
   FRIEND_TEST_ALL_PREFIXES(CookieMonsterTest, ShortLivedSessionCookies);
 
   // Internal reasons for deletion, used to populate informative histograms
   // and to provide a public cause for onCookieChange notifications.
   //
   // If you add or remove causes from this list, please be sure to also update
-  // the CookieMonsterDelegate::ChangeCause mapping inside ChangeCauseMapping.
-  // Moreover, these are used as array indexes, so avoid reordering to keep the
+  // the Delegate::ChangeCause mapping inside ChangeCauseMapping. Moreover,
+  // these are used as array indexes, so avoid reordering to keep the
   // histogram buckets consistent. New items (if necessary) should be added
   // at the end of the list, just before DELETE_COOKIE_LAST_ENTRY.
   enum DeletionCause {
     DELETE_COOKIE_EXPLICIT = 0,
     DELETE_COOKIE_OVERWRITE,
     DELETE_COOKIE_EXPIRED,
     DELETE_COOKIE_EVICTED,
     DELETE_COOKIE_DUPLICATE_IN_BACKING_STORE,
     DELETE_COOKIE_DONT_RECORD,  // e.g. For final cleanup after flush to store.
     DELETE_COOKIE_EVICTED_DOMAIN,
@@ skipping 166 matching lines @@
   // Helper function that sets a canonical cookie, deleting equivalents and
   // performing garbage collection.
   bool SetCanonicalCookie(scoped_ptr<CanonicalCookie>* cc,
                           const base::Time& creation_time,
                           const CookieOptions& options);
 
   void InternalUpdateCookieAccessTime(CanonicalCookie* cc,
                                       const base::Time& current_time);
 
   // |deletion_cause| argument is used for collecting statistics and choosing
-  // the correct CookieMonsterDelegate::ChangeCause for OnCookieChanged
-  // notifications.
+  // the correct Delegate::ChangeCause for OnCookieChanged notifications.
   void InternalDeleteCookie(CookieMap::iterator it, bool sync_to_store,
                             DeletionCause deletion_cause);
 
   // If the number of cookies for CookieMap key |key|, or globally, are
   // over the preset maximums above, garbage collect, first for the host and
   // then globally.  See comments above garbage collection threshold
   // constants for details.
   //
   // Returns the number of cookies deleted (useful for debugging).
   int GarbageCollect(const base::Time& current, const std::string& key);
@@ skipping 101 matching lines @@
   base::Time earliest_access_time_;
 
   // During loading, holds the set of all loaded cookie creation times. Used to
   // avoid ever letting cookies with duplicate creation times into the store;
   // that way we don't have to worry about what sections of code are safe
   // to call while it's in that state.
   std::set<int64> creation_times_;
 
   std::vector<std::string> cookieable_schemes_;
 
-  scoped_refptr<CookieMonsterDelegate> delegate_;
+  scoped_refptr<Delegate> delegate_;
 
   // Lock for thread-safety
   base::Lock lock_;
 
   base::Time last_statistic_record_time_;
 
   bool keep_expired_cookies_;
   bool persist_session_cookies_;
   bool priority_aware_garbage_collection_;
 
   // Static setting for whether or not file scheme cookies are allows when
   // a new CookieMonster is created, or the accepted schemes on a CookieMonster
   // instance are reset back to defaults.
   static bool default_enable_file_scheme_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieMonster);
 };
 
-class NET_EXPORT CookieMonsterDelegate
-    : public base::RefCountedThreadSafe<CookieMonsterDelegate> {
+class NET_EXPORT CookieMonster::Delegate
+    : public base::RefCountedThreadSafe<CookieMonster::Delegate> {
  public:
   // The publicly relevant reasons a cookie might be changed.
   enum ChangeCause {
     // The cookie was changed directly by a consumer's action.
     CHANGE_COOKIE_EXPLICIT,
     // The cookie was automatically removed due to an insert operation that
     // overwrote it.
     CHANGE_COOKIE_OVERWRITE,
     // The cookie was automatically removed as it expired.
     CHANGE_COOKIE_EXPIRED,
@@ skipping 11 matching lines @@
   //
   // As a special case, note that updating a cookie's properties is implemented
   // as a two step process: the cookie to be updated is first removed entirely,
   // generating a notification with cause CHANGE_COOKIE_OVERWRITE.  Afterwards,
   // a new cookie is written with the updated values, generating a notification
   // with cause CHANGE_COOKIE_EXPLICIT.
   virtual void OnCookieChanged(const CanonicalCookie& cookie,
                                bool removed,
                                ChangeCause cause) = 0;
  protected:
-  friend class base::RefCountedThreadSafe<CookieMonsterDelegate>;
-  virtual ~CookieMonsterDelegate() {}
+  friend class base::RefCountedThreadSafe<CookieMonster::Delegate>;
+  virtual ~Delegate() {}
 };
 
 typedef base::RefCountedThreadSafe<CookieMonster::PersistentCookieStore>
     RefcountedPersistentCookieStore;
 
 class NET_EXPORT CookieMonster::PersistentCookieStore
     : public RefcountedPersistentCookieStore {
  public:
   typedef base::Callback<void(const std::vector<CanonicalCookie*>&)>
       LoadedCallback;
@@ skipping 26 matching lines @@
   virtual ~PersistentCookieStore() {}
 
  private:
   friend class base::RefCountedThreadSafe<PersistentCookieStore>;
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_MONSTER_H_