Revert 219709 "Remove the Extensions URLRequestContext."

trunk/src/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 238 matching lines @@
 // first iterator with access date >= |access_date|, or cookie_its_end if this
 // holds for all.
 CookieMonster::CookieItVector::iterator LowerBoundAccessDate(
     const CookieMonster::CookieItVector::iterator its_begin,
     const CookieMonster::CookieItVector::iterator its_end,
     const Time& access_date) {
   return std::lower_bound(its_begin, its_end, access_date,
                           LowerBoundAccessDateComparator);
 }
 
-// Mapping between DeletionCause and CookieMonsterDelegate::ChangeCause; the
-// mapping also provides a boolean that specifies whether or not an
-// OnCookieChanged notification ought to be generated.
+// Mapping between DeletionCause and Delegate::ChangeCause; the mapping also
+// provides a boolean that specifies whether or not an OnCookieChanged
+// notification ought to be generated.
 typedef struct ChangeCausePair_struct {
-  CookieMonsterDelegate::ChangeCause cause;
+  CookieMonster::Delegate::ChangeCause cause;
   bool notify;
 } ChangeCausePair;
 ChangeCausePair ChangeCauseMapping[] = {
   // DELETE_COOKIE_EXPLICIT
-  { CookieMonsterDelegate::CHANGE_COOKIE_EXPLICIT, true },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EXPLICIT, true },
   // DELETE_COOKIE_OVERWRITE
-  { CookieMonsterDelegate::CHANGE_COOKIE_OVERWRITE, true },
+  { CookieMonster::Delegate::CHANGE_COOKIE_OVERWRITE, true },
   // DELETE_COOKIE_EXPIRED
-  { CookieMonsterDelegate::CHANGE_COOKIE_EXPIRED, true },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EXPIRED, true },
   // DELETE_COOKIE_EVICTED
-  { CookieMonsterDelegate::CHANGE_COOKIE_EVICTED, true },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EVICTED, true },
   // DELETE_COOKIE_DUPLICATE_IN_BACKING_STORE
-  { CookieMonsterDelegate::CHANGE_COOKIE_EXPLICIT, false },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EXPLICIT, false },
   // DELETE_COOKIE_DONT_RECORD
-  { CookieMonsterDelegate::CHANGE_COOKIE_EXPLICIT, false },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EXPLICIT, false },
   // DELETE_COOKIE_EVICTED_DOMAIN
-  { CookieMonsterDelegate::CHANGE_COOKIE_EVICTED, true },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EVICTED, true },
   // DELETE_COOKIE_EVICTED_GLOBAL
-  { CookieMonsterDelegate::CHANGE_COOKIE_EVICTED, true },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EVICTED, true },
   // DELETE_COOKIE_EVICTED_DOMAIN_PRE_SAFE
-  { CookieMonsterDelegate::CHANGE_COOKIE_EVICTED, true },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EVICTED, true },
   // DELETE_COOKIE_EVICTED_DOMAIN_POST_SAFE
-  { CookieMonsterDelegate::CHANGE_COOKIE_EVICTED, true },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EVICTED, true },
   // DELETE_COOKIE_EXPIRED_OVERWRITE
-  { CookieMonsterDelegate::CHANGE_COOKIE_EXPIRED_OVERWRITE, true },
+  { CookieMonster::Delegate::CHANGE_COOKIE_EXPIRED_OVERWRITE, true },
   // DELETE_COOKIE_LAST_ENTRY
-  { CookieMonsterDelegate::CHANGE_COOKIE_EXPLICIT, false }
+  { CookieMonster::Delegate::CHANGE_COOKIE_EXPLICIT, false }
 };
 
 std::string BuildCookieLine(const CanonicalCookieVector& cookies) {
   std::string cookie_line;
   for (CanonicalCookieVector::const_iterator it = cookies.begin();
        it != cookies.end(); ++it) {
     if (it != cookies.begin())
       cookie_line += "; ";
     // In Mozilla if you set a cookie like AAAA, it will have an empty token
     // and a value of AAAA.  When it sends the cookie back, it will send AAAA,
     // so we need to avoid sending =AAAA for a blank token value.
     if (!(*it)->Name().empty())
       cookie_line += (*it)->Name() + "=";
     cookie_line += (*it)->Value();
   }
   return cookie_line;
 }
 
 }  // namespace
 
-CookieMonster::CookieMonster(PersistentCookieStore* store,
-                             CookieMonsterDelegate* delegate)
+// static
+bool CookieMonster::default_enable_file_scheme_ = false;
+
+CookieMonster::CookieMonster(PersistentCookieStore* store, Delegate* delegate)
     : initialized_(false),
       loaded_(false),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)),
       delegate_(delegate),
       last_statistic_record_time_(Time::Now()),
       keep_expired_cookies_(false),
       persist_session_cookies_(false),
       priority_aware_garbage_collection_(false) {
   InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
-                             CookieMonsterDelegate* delegate,
+                             Delegate* delegate,
                              int last_access_threshold_milliseconds)
     : initialized_(false),
       loaded_(false),
       store_(store),
       last_access_threshold_(base::TimeDelta::FromMilliseconds(
           last_access_threshold_milliseconds)),
       delegate_(delegate),
       last_statistic_record_time_(base::Time::Now()),
       keep_expired_cookies_(false),
       persist_session_cookies_(false),
@@ skipping 931 matching lines @@
   // above kDefaultCookieableSchemes.
   int num_schemes = accept ? kDefaultCookieableSchemesCount :
       kDefaultCookieableSchemesCount - 1;
   SetCookieableSchemes(kDefaultCookieableSchemes, num_schemes);
 }
 
 void CookieMonster::SetKeepExpiredCookies() {
   keep_expired_cookies_ = true;
 }
 
+// static
+void CookieMonster::EnableFileScheme() {
+  default_enable_file_scheme_ = true;
+}
+
 void CookieMonster::FlushStore(const base::Closure& callback) {
   base::AutoLock autolock(lock_);
   if (initialized_ && store_.get())
     store_->Flush(callback);
   else if (!callback.is_null())
     base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 bool CookieMonster::SetCookieWithOptions(const GURL& url,
                                          const std::string& cookie_line,
@@ skipping 338 matching lines @@
   return num_duplicates;
 }
 
 // Note: file must be the last scheme.
 const char* CookieMonster::kDefaultCookieableSchemes[] =
     { "http", "https", "file" };
 const int CookieMonster::kDefaultCookieableSchemesCount =
     arraysize(CookieMonster::kDefaultCookieableSchemes);
 
 void CookieMonster::SetDefaultCookieableSchemes() {
-  // Always disable file scheme unless SetEnableFileScheme(true) is called.
-  SetCookieableSchemes(kDefaultCookieableSchemes,
-                       kDefaultCookieableSchemesCount - 1);
+  int num_schemes = default_enable_file_scheme_ ?
+      kDefaultCookieableSchemesCount : kDefaultCookieableSchemesCount - 1;
+  SetCookieableSchemes(kDefaultCookieableSchemes, num_schemes);
 }
 
 void CookieMonster::FindCookiesForHostAndDomain(
     const GURL& url,
     const CookieOptions& options,
     bool update_access_time,
     std::vector<CanonicalCookie*>* cookies) {
   lock_.AssertAcquired();
 
   const Time current_time(CurrentTime());
@@ skipping 79 matching lines @@
                                          CanonicalCookie* cc,
                                          bool sync_to_store) {
   lock_.AssertAcquired();
 
   if ((cc->IsPersistent() || persist_session_cookies_) && store_.get() &&
       sync_to_store)
     store_->AddCookie(*cc);
   cookies_.insert(CookieMap::value_type(key, cc));
   if (delegate_.get()) {
     delegate_->OnCookieChanged(
-        *cc, false, CookieMonsterDelegate::CHANGE_COOKIE_EXPLICIT);
+        *cc, false, CookieMonster::Delegate::CHANGE_COOKIE_EXPLICIT);
   }
 }
 
 bool CookieMonster::SetCookieWithCreationTimeAndOptions(
     const GURL& url,
     const std::string& cookie_line,
     const Time& creation_time_or_null,
     const CookieOptions& options) {
   lock_.AssertAcquired();
 
@@ skipping 456 matching lines @@
 
 // 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));
 }
 
 }  // namespace net