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 573 matching lines @@
         domain_(domain),
         path_(path),
         expiration_time_(expiration_time),
         secure_(secure),
         http_only_(http_only),
         callback_(callback) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~SetCookieWithDetailsTask() {}
+
   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 15 matching lines @@
     : public CookieMonster::CookieMonsterTask {
  public:
   GetAllCookiesTask(CookieMonster* cookie_monster,
                     const CookieMonster::GetCookieListCallback& callback)
       : CookieMonsterTask(cookie_monster),
         callback_(callback) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~GetAllCookiesTask() {}
+
   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));
@@ skipping 10 matching lines @@
       const CookieOptions& options,
       const CookieMonster::GetCookieListCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
         callback_(callback) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~GetAllCookiesForURLWithOptionsTask() {}
+
   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) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~DeleteAllTask() {}
+
   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));
@@ skipping 10 matching lines @@
       const Time& delete_end,
       const CookieMonster::DeleteCallback& callback)
       : CookieMonsterTask(cookie_monster),
         delete_begin_(delete_begin),
         delete_end_(delete_end),
         callback_(callback) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~DeleteAllCreatedBetweenTask() {}
+
   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_);
@@ skipping 10 matching lines @@
   DeleteAllForHostTask(CookieMonster* cookie_monster,
                        const GURL& url,
                        const CookieMonster::DeleteCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         callback_(callback) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~DeleteAllForHostTask() {}
+
   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) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~DeleteCanonicalCookieTask() {}
+
   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,
@@ skipping 12 matching lines @@
                            const CookieMonster::SetCookiesCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         cookie_line_(cookie_line),
         options_(options),
         callback_(callback) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~SetCookieWithOptionsTask() {}
+
   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()->
@@ skipping 13 matching lines @@
                             const CookieOptions& options,
                             const CookieMonster::GetCookiesCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
         callback_(callback) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~GetCookiesWithOptionsTask() {}
+
   GURL url_;
   CookieOptions options_;
   CookieMonster::GetCookiesCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetCookiesWithOptionsTask);
 };
 
 void CookieMonster::GetCookiesWithOptionsTask::Run() {
   std::string cookie = this->cookie_monster()->
       GetCookiesWithOptions(url_, options_);
@@ skipping 12 matching lines @@
                          const CookieOptions& options,
                          const CookieMonster::GetCookieInfoCallback& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         options_(options),
         callback_(callback) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~GetCookiesWithInfoTask() {}
+
   GURL url_;
   CookieOptions options_;
   CookieMonster::GetCookieInfoCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetCookiesWithInfoTask);
 };
 
 void CookieMonster::GetCookiesWithInfoTask::Run() {
   if (!callback_.is_null()) {
     std::string cookie_line;
@@ skipping 15 matching lines @@
                    const std::string& cookie_name,
                    const base::Closure& callback)
       : CookieMonsterTask(cookie_monster),
         url_(url),
         cookie_name_(cookie_name),
         callback_(callback) { }
 
   virtual void Run() OVERRIDE;
 
  private:
+  virtual ~DeleteCookieTask() {}
+
   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()) {
@@ skipping 1815 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