Add CookieMonster::SetEnableFileScheme and CookieMonster::IsCookieableScheme

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 341 matching lines @@
     cookie_info.mac_key = cookie->MACKey();
     cookie_info.mac_algorithm = cookie->MACAlgorithm();
 
     cookie_infos->push_back(cookie_info);
   }
 }
 
 }  // namespace
 
 // static
-bool CookieMonster::enable_file_scheme_ = false;
+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),
@@ skipping 989 matching lines @@
   base::AutoLock autolock(lock_);
 
   // Cookieable Schemes must be set before first use of function.
   DCHECK(!initialized_);
 
   cookieable_schemes_.clear();
   cookieable_schemes_.insert(cookieable_schemes_.end(),
                              schemes, schemes + num_schemes);
 }
 
+#if defined(OS_ANDROID)
+void CookieMonster::SetEnableFileScheme(bool accept) {
+  // This assumes "file" is always at the end of the array. See the comment
+  // above kDefaultCookieableSchemes.
+  int num_schemes = accept ? kDefaultCookieableSchemesCount :
+      kDefaultCookieableSchemesCount - 1;
+  SetCookieableSchemes(kDefaultCookieableSchemes, num_schemes);
+}
+#endif  // defined(OS_ANDROID)
+
 void CookieMonster::SetKeepExpiredCookies() {
   keep_expired_cookies_ = true;
 }
 
 // static
 void CookieMonster::EnableFileScheme() {
-  enable_file_scheme_ = true;
+  default_enable_file_scheme_ = true;
 }
 
 void CookieMonster::FlushStore(const base::Closure& callback) {
   base::AutoLock autolock(lock_);
   if (initialized_ && store_)
     store_->Flush(callback);
   else if (!callback.is_null())
     MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
@@ skipping 345 matching lines @@
                            DELETE_COOKIE_DUPLICATE_IN_BACKING_STORE);
     }
   }
   DCHECK_EQ(num_duplicates, num_duplicates_found);
 
   return num_duplicates;
 }
 
 // Note: file must be the last scheme.
 const char* CookieMonster::kDefaultCookieableSchemes[] =
     { "http", "https", "file" };

[felipeg_google, 2012/06/11 09:45:52]

FYI: this is just a comment, address if you wish.
Your call.

I would make "file" as a new const char* .
In line 240 of file cookie_manager.cc you could use that const instead of the
plain string "file", like it is currently done:
  *accept = monster->IsCookieableScheme("file");


Also, with a separate const for the "file", it will not need to have a special
comment saying that the file must be the last scheme, which, seems flaky.

When calling SetCookiableSchemes() you can build the array accordingly (it could
be a vector<>). The size of the array is so small that it will not incur in
performance issues.

 const int CookieMonster::kDefaultCookieableSchemesCount =
     arraysize(CookieMonster::kDefaultCookieableSchemes);
 
 void CookieMonster::SetDefaultCookieableSchemes() {
-  int num_schemes = enable_file_scheme_ ?
+  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) {
@@ skipping 400 matching lines @@
   std::string effective_domain(
       RegistryControlledDomainService::GetDomainAndRegistry(domain));
   if (effective_domain.empty())
     effective_domain = domain;
 
   if (!effective_domain.empty() && effective_domain[0] == '.')
     return effective_domain.substr(1);
   return effective_domain;
 }
 
+#if defined(OS_ANDROID)
+bool CookieMonster::IsCookieableScheme(const std::string& scheme) {
+  base::AutoLock autolock(lock_);
+
+  return std::find(cookieable_schemes_.begin(), cookieable_schemes_.end(),
+                   scheme) != cookieable_schemes_.end();
+}
+#endif  // defined(OS_ANDROID)
+
 bool CookieMonster::HasCookieableScheme(const GURL& url) {
   lock_.AssertAcquired();
 
   // Make sure the request is on a cookie-able url scheme.
   for (size_t i = 0; i < cookieable_schemes_.size(); ++i) {
     // We matched a scheme.
     if (url.SchemeIs(cookieable_schemes_[i].c_str())) {
       // We've matched a supported scheme.
       return true;
     }
@@ skipping 660 matching lines @@
 std::string CookieMonster::CanonicalCookie::DebugString() const {
   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