RefCounted types should not have public destructors, net/

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 514 matching lines @@
   // Invokes the callback immediately, if the current thread is the one
   // that originated the task, or queues the callback for execution on the
   // appropriate thread. Maintains a reference to this CookieMonsterTask
   // instance until the callback completes.
   void InvokeCallback(base::Closure callback);
 
   CookieMonster* cookie_monster() {
     return cookie_monster_;
   }
 
+ private:
   friend class base::RefCountedThreadSafe<CookieMonsterTask>;
 
- private:
   CookieMonster* cookie_monster_;
   scoped_refptr<base::MessageLoopProxy> thread_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieMonsterTask);
 };
 
 CookieMonster::CookieMonsterTask::CookieMonsterTask(
     CookieMonster* cookie_monster)
     : cookie_monster_(cookie_monster),
-      thread_(base::MessageLoopProxy::current()) { }
+      thread_(base::MessageLoopProxy::current()) {
+}
 
-CookieMonster::CookieMonsterTask::~CookieMonsterTask() { }
+CookieMonster::CookieMonsterTask::~CookieMonsterTask() {}
 
 // Unfortunately, one cannot re-bind a Callback with parameters into a closure.
 // Therefore, the closure passed to InvokeCallback is a clumsy binding of
 // Callback::Run on a wrapped Callback instance. Since Callback is not
 // reference counted, we bind to an instance that is a member of the
 // CookieMonsterTask subclass. Then, we cannot simply post the callback to a
 // message loop because the underlying instance may be destroyed (along with the
 // CookieMonsterTask instance) in the interim. Therefore, we post a callback
 // bound to the CookieMonsterTask, which *is* reference counted (thus preventing
 // destruction of the original callback), and which invokes the closure (which
@@ skipping 19 matching lines @@
       const CookieMonster::SetCookiesCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         name_(name),
         value_(value),
         domain_(domain),
         path_(path),
         expiration_time_(expiration_time),
         secure_(secure),
         http_only_(http_only),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~SetCookieWithDetailsTask() {}
+
  private:
   GURL url_;
   std::string name_;
   std::string value_;
   std::string domain_;
   std::string path_;
   base::Time expiration_time_;
   bool secure_;
   bool http_only_;
   CookieMonster::SetCookiesCallback callback_;
@@ skipping 11 matching lines @@
   }
 }
 
 // Task class for GetAllCookies call.
 class CookieMonster::GetAllCookiesTask
     : public CookieMonster::CookieMonsterTask {
  public:
   GetAllCookiesTask(CookieMonster* cookie_monster,
                     const CookieMonster::GetCookieListCallback& callback)
       : CookieMonsterTask(cookie_monster),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~GetAllCookiesTask() {}
+
  private:
   CookieMonster::GetCookieListCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetAllCookiesTask);
 };
 
 void CookieMonster::GetAllCookiesTask::Run() {
   if (!callback_.is_null()) {
     CookieList cookies = this->cookie_monster()->GetAllCookies();
     this->InvokeCallback(base::Bind(&CookieMonster::GetCookieListCallback::Run,
                                     base::Unretained(&callback_), cookies));
     }
 }
 
 // Task class for GetAllCookiesForURLWithOptions call.
 class CookieMonster::GetAllCookiesForURLWithOptionsTask
     : public CookieMonster::CookieMonsterTask {
  public:
   GetAllCookiesForURLWithOptionsTask(
       CookieMonster* cookie_monster,
       const GURL& url,
       const CookieOptions& options,
       const CookieMonster::GetCookieListCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~GetAllCookiesForURLWithOptionsTask() {}
+
  private:
   GURL url_;
   CookieOptions options_;
   CookieMonster::GetCookieListCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetAllCookiesForURLWithOptionsTask);
 };
 
 void CookieMonster::GetAllCookiesForURLWithOptionsTask::Run() {
   if (!callback_.is_null()) {
     CookieList cookies = this->cookie_monster()->
         GetAllCookiesForURLWithOptions(url_, options_);
     this->InvokeCallback(base::Bind(&CookieMonster::GetCookieListCallback::Run,
                                     base::Unretained(&callback_), cookies));
   }
 }
 
 // Task class for DeleteAll call.
 class CookieMonster::DeleteAllTask : public CookieMonster::CookieMonsterTask {
  public:
   DeleteAllTask(CookieMonster* cookie_monster,
                 const CookieMonster::DeleteCallback& callback)
       : CookieMonsterTask(cookie_monster),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~DeleteAllTask() {}
+
  private:
   CookieMonster::DeleteCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllTask);
 };
 
 void CookieMonster::DeleteAllTask::Run() {
   int num_deleted = this->cookie_monster()->DeleteAll(true);
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
                                     base::Unretained(&callback_), num_deleted));
   }
 }
 
 // Task class for DeleteAllCreatedBetween call.
 class CookieMonster::DeleteAllCreatedBetweenTask
     : public CookieMonster::CookieMonsterTask {
  public:
   DeleteAllCreatedBetweenTask(
       CookieMonster* cookie_monster,
       const Time& delete_begin,
       const Time& delete_end,
       const CookieMonster::DeleteCallback& callback)
       : CookieMonsterTask(cookie_monster),
         delete_begin_(delete_begin),
         delete_end_(delete_end),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~DeleteAllCreatedBetweenTask() {}
+
  private:
   Time delete_begin_;
   Time delete_end_;
   CookieMonster::DeleteCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllCreatedBetweenTask);
 };
 
 void CookieMonster::DeleteAllCreatedBetweenTask::Run() {
   int num_deleted = this->cookie_monster()->
       DeleteAllCreatedBetween(delete_begin_, delete_end_);
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
                                     base::Unretained(&callback_), num_deleted));
   }
 }
 
 // Task class for DeleteAllForHost call.
 class CookieMonster::DeleteAllForHostTask
     : public CookieMonster::CookieMonsterTask {
  public:
   DeleteAllForHostTask(CookieMonster* cookie_monster,
                        const GURL& url,
                        const CookieMonster::DeleteCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~DeleteAllForHostTask() {}
+
  private:
   GURL url_;
   CookieMonster::DeleteCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteAllForHostTask);
 };
 
 void CookieMonster::DeleteAllForHostTask::Run() {
   int num_deleted = this->cookie_monster()->DeleteAllForHost(url_);
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
                                     base::Unretained(&callback_), num_deleted));
   }
 }
 
 // Task class for DeleteCanonicalCookie call.
 class CookieMonster::DeleteCanonicalCookieTask
     : public CookieMonster::CookieMonsterTask {
  public:
   DeleteCanonicalCookieTask(
       CookieMonster* cookie_monster,
       const CookieMonster::CanonicalCookie& cookie,
       const CookieMonster::DeleteCookieCallback& callback)
       : CookieMonsterTask(cookie_monster),
         cookie_(cookie),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~DeleteCanonicalCookieTask() {}
+
  private:
   CookieMonster::CanonicalCookie cookie_;
   CookieMonster::DeleteCookieCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCanonicalCookieTask);
 };
 
 void CookieMonster::DeleteCanonicalCookieTask::Run() {
   bool result = this->cookie_monster()->DeleteCanonicalCookie(cookie_);
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&CookieMonster::DeleteCookieCallback::Run,
                                     base::Unretained(&callback_), result));
   }
 }
 
 // Task class for SetCookieWithOptions call.
 class CookieMonster::SetCookieWithOptionsTask
     : public CookieMonster::CookieMonsterTask {
  public:
   SetCookieWithOptionsTask(CookieMonster* cookie_monster,
                            const GURL& url,
                            const std::string& cookie_line,
                            const CookieOptions& options,
                            const CookieMonster::SetCookiesCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         cookie_line_(cookie_line),
         options_(options),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~SetCookieWithOptionsTask() {}
+
  private:
   GURL url_;
   std::string cookie_line_;
   CookieOptions options_;
   CookieMonster::SetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetCookieWithOptionsTask);
 };
 
 void CookieMonster::SetCookieWithOptionsTask::Run() {
   bool result = this->cookie_monster()->
       SetCookieWithOptions(url_, cookie_line_, options_);
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&CookieMonster::SetCookiesCallback::Run,
                                     base::Unretained(&callback_), result));
   }
 }
 
 // Task class for GetCookiesWithOptions call.
 class CookieMonster::GetCookiesWithOptionsTask
     : public CookieMonster::CookieMonsterTask {
  public:
   GetCookiesWithOptionsTask(CookieMonster* cookie_monster,
                             const GURL& url,
                             const CookieOptions& options,
                             const CookieMonster::GetCookiesCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~GetCookiesWithOptionsTask() {}
+
  private:
   GURL url_;
   CookieOptions options_;
   CookieMonster::GetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetCookiesWithOptionsTask);
 };
 
 void CookieMonster::GetCookiesWithOptionsTask::Run() {
   std::string cookie = this->cookie_monster()->
@@ skipping 10 matching lines @@
  public:
   GetCookiesWithInfoTask(CookieMonster* cookie_monster,
                          const GURL& url,
                          const CookieOptions& options,
                          const CookieMonster::GetCookieInfoCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
         callback_(callback) { }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~GetCookiesWithInfoTask() {}
+
  private:
   GURL url_;
   CookieOptions options_;
   CookieMonster::GetCookieInfoCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetCookiesWithInfoTask);
 };
 
 void CookieMonster::GetCookiesWithInfoTask::Run() {
   if (!callback_.is_null()) {
@@ skipping 13 matching lines @@
  public:
   DeleteCookieTask(CookieMonster* cookie_monster,
                    const GURL& url,
                    const std::string& cookie_name,
                    const base::Closure& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         cookie_name_(cookie_name),
         callback_(callback) { }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~DeleteCookieTask() {}
+
  private:
   GURL url_;
   std::string cookie_name_;
   base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteCookieTask);
 };
 
 void CookieMonster::DeleteCookieTask::Run() {
   this->cookie_monster()->DeleteCookie(url_, cookie_name_);
   if (!callback_.is_null()) {
     this->InvokeCallback(callback_);
   }
 }
 
 // Task class for DeleteSessionCookies call.
 class CookieMonster::DeleteSessionCookiesTask
     : public CookieMonster::CookieMonsterTask {
  public:
   DeleteSessionCookiesTask(
       CookieMonster* cookie_monster,
       const CookieMonster::DeleteCallback& callback)
       : CookieMonsterTask(cookie_monster),
-        callback_(callback) { }
+        callback_(callback) {
+  }
 
+  // CookieMonster::CookieMonsterTask:
   virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~DeleteSessionCookiesTask() {}
+
  private:
   CookieMonster::DeleteCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteSessionCookiesTask);
 };
 
 void CookieMonster::DeleteSessionCookiesTask::Run() {
   int num_deleted = this->cookie_monster()->DeleteSessionCookies();
   if (!callback_.is_null()) {
     this->InvokeCallback(base::Bind(&CookieMonster::DeleteCallback::Run,
@@ skipping 1843 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