Add a way to query a cookie store whether any cookies exist for a given

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 747 matching lines @@
 };
 
 void CookieMonster::DeleteSessionCookiesTask::Run() {
   int num_deleted = this->cookie_monster()->DeleteSessionCookies();
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
                                     base::Unretained(&callback_), num_deleted));
   }
 }
 
+// Task class for HasCookiesForETLDP1Task call.
+class CookieMonster::HasCookiesForETLDP1Task
+    : public CookieMonster::CookieMonsterTask {
+ public:
+  HasCookiesForETLDP1Task(
+      CookieMonster* cookie_monster,
+      const std::string& etldp1,
+      const CookieMonster::HasCookiesForETLDP1Callback& callback)
+      : CookieMonsterTask(cookie_monster),
+        etldp1_(etldp1),
+        callback_(callback) {
+  }
+
+  // CookieMonster::CookieMonsterTask:
+  virtual void Run() OVERRIDE;
+
+ protected:
+  virtual ~HasCookiesForETLDP1Task() {}
+
+ private:
+  std::string etldp1_;
+  CookieMonster::HasCookiesForETLDP1Callback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(HasCookiesForETLDP1Task);
+};
+
+void CookieMonster::HasCookiesForETLDP1Task::Run() {
+  bool result = this->cookie_monster()->HasCookiesForETLDP1(etldp1_);
+  if (!callback_.is_null()) {
+    this->InvokeCallback(
+        base::Bind(&CookieMonster::HasCookiesForETLDP1Callback::Run,
+                   base::Unretained(&callback_), result));
+  }
+}
+
 // Asynchronous CookieMonster API
 
 void CookieMonster::SetCookieWithDetailsAsync(
     const GURL& url,
     const std::string& name,
     const std::string& value,
     const std::string& domain,
     const std::string& path,
     const base::Time& expiration_time,
     bool secure,
@@ skipping 28 matching lines @@
 void CookieMonster::GetAllCookiesForURLAsync(
     const GURL& url, const GetCookieListCallback& callback) {
   CookieOptions options;
   options.set_include_httponly();
   scoped_refptr<GetAllCookiesForURLWithOptionsTask> task =
       new GetAllCookiesForURLWithOptionsTask(this, url, options, callback);
 
   DoCookieTaskForURL(task, url);
 }
 
+void CookieMonster::HasCookiesForETLDP1Async(
+    const std::string& etldp1,
+    const HasCookiesForETLDP1Callback& callback) {
+  scoped_refptr<HasCookiesForETLDP1Task> task =
+      new HasCookiesForETLDP1Task(this, etldp1, callback);
+
+  DoCookieTaskForURL(task, GURL("http://" + etldp1));
+}
+
 void CookieMonster::DeleteAllAsync(const DeleteCallback& callback) {
   scoped_refptr<DeleteAllTask> task =
       new DeleteAllTask(this, callback);
 
   DoCookieTask(task);
 }
 
 void CookieMonster::DeleteAllCreatedBetweenAsync(
     const Time& delete_begin, const Time& delete_end,
     const DeleteCallback& callback) {
@@ skipping 399 matching lines @@
       InternalDeleteCookie(curit,
                            true,  /*sync_to_store*/
                            DELETE_COOKIE_EXPIRED);
       ++num_deleted;
     }
   }
 
   return num_deleted;
 }
 
+bool CookieMonster::HasCookiesForETLDP1(const std::string& etldp1) {
+  base::AutoLock autolock(lock_);
+
+  const std::string key(GetKey(etldp1));
+
+  CookieMapItPair its = cookies_.equal_range(key);
+  return its.first != its.second;
+}
+
 CookieMonster* CookieMonster::GetCookieMonster() {
   return this;
 }
 
 void CookieMonster::SetPersistSessionCookies(bool persist_session_cookies) {
   // This function must be called before the CookieMonster is used.
   DCHECK(!initialized_);
   persist_session_cookies_ = persist_session_cookies;
 }
 
@@ skipping 766 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