RefCounted types should not have public destructors, webkit/

webkit/database/database_quota_client.cc

 // Copyright (c) 2011 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.
 
 #include "webkit/database/database_quota_client.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 14 matching lines @@
 
 class DatabaseQuotaClient::HelperTask : public quota::QuotaThreadTask {
  protected:
   HelperTask(
       DatabaseQuotaClient* client,
       base::MessageLoopProxy* db_tracker_thread)
       : QuotaThreadTask(client, db_tracker_thread),
         client_(client), db_tracker_(client->db_tracker_) {
   }
 
+  virtual ~HelperTask() {}
+
   DatabaseQuotaClient* client_;
   scoped_refptr<DatabaseTracker> db_tracker_;
 };
 
 class DatabaseQuotaClient::GetOriginUsageTask : public HelperTask {
  public:
   GetOriginUsageTask(
       DatabaseQuotaClient* client,
       base::MessageLoopProxy* db_tracker_thread,
       const GURL& origin_url)
       : HelperTask(client, db_tracker_thread),
         origin_url_(origin_url), usage_(0) {
   }
 
- private:
+ protected:
+  virtual ~GetOriginUsageTask() {}
+
   virtual void RunOnTargetThread() OVERRIDE {
     OriginInfo info;
     if (db_tracker_->GetOriginInfo(
             DatabaseUtil::GetOriginIdentifier(origin_url_),
             &info)) {
       usage_ = info.TotalSize();
     }
   }
+
   virtual void Completed() OVERRIDE {
     client_->DidGetOriginUsage(origin_url_, usage_);
   }
+
+ private:
   GURL origin_url_;
   int64 usage_;
 };
 
 class DatabaseQuotaClient::GetOriginsTaskBase : public HelperTask {
  protected:
   GetOriginsTaskBase(
       DatabaseQuotaClient* client,
       base::MessageLoopProxy* db_tracker_thread)
       : HelperTask(client, db_tracker_thread) {
   }
 
+  virtual ~GetOriginsTaskBase() {}
+
   virtual bool ShouldAddOrigin(const GURL& origin) = 0;
 
   virtual void RunOnTargetThread() OVERRIDE {
     std::vector<string16> origin_identifiers;
     if (db_tracker_->GetAllOriginIdentifiers(&origin_identifiers)) {
       for (std::vector<string16>::const_iterator iter =
                origin_identifiers.begin();
            iter != origin_identifiers.end(); ++iter) {
         GURL origin = DatabaseUtil::GetOriginFromIdentifier(*iter);
         if (ShouldAddOrigin(origin))
           origins_.insert(origin);
       }
     }
   }
 
   std::set<GURL> origins_;
 };
 
 class DatabaseQuotaClient::GetAllOriginsTask : public GetOriginsTaskBase {
  public:
   GetAllOriginsTask(
       DatabaseQuotaClient* client,
       base::MessageLoopProxy* db_tracker_thread,
       quota::StorageType type)
       : GetOriginsTaskBase(client, db_tracker_thread),
         type_(type) {
   }
 
  protected:
+  virtual ~GetAllOriginsTask() {}
+
   virtual bool ShouldAddOrigin(const GURL& origin) OVERRIDE {
     return true;
   }
   virtual void Completed() OVERRIDE {
     client_->DidGetAllOrigins(origins_, type_);
   }
 
  private:
   quota::StorageType type_;
 };
 
 class DatabaseQuotaClient::GetOriginsForHostTask : public GetOriginsTaskBase {
  public:
   GetOriginsForHostTask(
       DatabaseQuotaClient* client,
       base::MessageLoopProxy* db_tracker_thread,
       const std::string& host,
       quota::StorageType type)
       : GetOriginsTaskBase(client, db_tracker_thread),
         host_(host),
         type_(type) {
   }
 
- private:
+ protected:
+  virtual ~GetOriginsForHostTask() {}
+
   virtual bool ShouldAddOrigin(const GURL& origin) OVERRIDE {
     return host_ == net::GetHostOrSpecFromURL(origin);
   }
+
   virtual void Completed() OVERRIDE {
     client_->DidGetOriginsForHost(host_, origins_, type_);
   }
+
+ private:
   std::string host_;
   quota::StorageType type_;
 };
 
 class DatabaseQuotaClient::DeleteOriginTask : public HelperTask {
  public:
   DeleteOriginTask(
       DatabaseQuotaClient* client,
       base::MessageLoopProxy* db_tracker_thread,
       const GURL& origin_url,
       const DeletionCallback& caller_callback)
       : HelperTask(client, db_tracker_thread),
         origin_url_(origin_url),
         result_(quota::kQuotaStatusUnknown),
         caller_callback_(caller_callback) {
   }
 
- private:
+ protected:
+  virtual ~DeleteOriginTask() {}
+
   virtual void Completed() OVERRIDE {
     if (caller_callback_.is_null())
       return;
     caller_callback_.Run(result_);
     caller_callback_.Reset();
   }
 
   virtual void Aborted() OVERRIDE {
     caller_callback_.Reset();
   }
 
   virtual bool RunOnTargetThreadAsync() OVERRIDE {
     AddRef();  // balanced in OnCompletionCallback
     string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url_);
     int rv = db_tracker_->DeleteDataForOrigin(
         origin_id, base::Bind(&DeleteOriginTask::OnCompletionCallback,
                               base::Unretained(this)));
     if (rv == net::ERR_IO_PENDING)
       return false;  // we wait for the callback
     OnCompletionCallback(rv);
     return false;
   }
 
+ private:
   void OnCompletionCallback(int rv) {
     if (rv == net::OK)
       result_ = quota::kQuotaStatusOk;
     original_message_loop()->PostTask(
         FROM_HERE, base::Bind(&DeleteOriginTask::CallCompleted, this));
     Release();  // balanced in RunOnTargetThreadAsync
   }
 
   const GURL origin_url_;
   quota::QuotaStatusCode result_;
@@ skipping 110 matching lines @@
 }
 
 void DatabaseQuotaClient::DidGetOriginsForHost(
     const std::string& host, const std::set<GURL>& origins,
     quota::StorageType type) {
   DCHECK(origins_for_host_callbacks_.HasCallbacks(host));
   origins_for_host_callbacks_.Run(host, origins, type);
 }
 
 }  // namespace webkit_database