RefCounted types should not have public destructors, content/browser part 1

content/browser/in_process_webkit/indexed_db_quota_client.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.
 
 #include "content/browser/in_process_webkit/indexed_db_quota_client.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
  protected:
   HelperTask(
       IndexedDBQuotaClient* client,
       base::MessageLoopProxy* webkit_thread_message_loop)
       : QuotaThreadTask(client, webkit_thread_message_loop),
         client_(client), indexed_db_context_(client->indexed_db_context_) {
   }
 
   IndexedDBQuotaClient* client_;
   scoped_refptr<IndexedDBContextImpl> indexed_db_context_;
+
+ protected:
+  virtual ~HelperTask() {}
 };
 
 class IndexedDBQuotaClient::DeleteOriginTask : public HelperTask {
  public:
   DeleteOriginTask(IndexedDBQuotaClient* client,
                    base::MessageLoopProxy* webkit_thread_message_loop,
                    const GURL& origin_url,
                    const DeletionCallback& callback)
       : HelperTask(client, webkit_thread_message_loop),
         origin_url_(origin_url), callback_(callback) {
   }
+
  private:
+  virtual ~DeleteOriginTask() {}
+
   virtual void RunOnTargetThread() OVERRIDE {
     indexed_db_context_->DeleteForOrigin(origin_url_);
   }
+
   virtual void Aborted() OVERRIDE {
     callback_.Reset();
   }
+
   virtual void Completed() OVERRIDE {
     callback_.Run(quota::kQuotaStatusOk);
     callback_.Reset();
   }
+
   GURL origin_url_;
   DeletionCallback callback_;
 };
 
 class IndexedDBQuotaClient::GetOriginUsageTask : public HelperTask {
  public:
   GetOriginUsageTask(
       IndexedDBQuotaClient* client,
       base::MessageLoopProxy* webkit_thread_message_loop,
       const GURL& origin_url)
       : HelperTask(client, webkit_thread_message_loop),
         origin_url_(origin_url), usage_(0) {
   }
 
  private:
+  virtual ~GetOriginUsageTask() {}
+
   virtual void RunOnTargetThread() OVERRIDE {
     usage_ = indexed_db_context_->GetOriginDiskUsage(origin_url_);
   }
+
   virtual void Completed() OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     client_->DidGetOriginUsage(origin_url_, usage_);
   }
+
   GURL origin_url_;
   int64 usage_;
 };
 
 class IndexedDBQuotaClient::GetOriginsTaskBase : public HelperTask {
  protected:
   GetOriginsTaskBase(
       IndexedDBQuotaClient* client,
       base::MessageLoopProxy* webkit_thread_message_loop)
       : HelperTask(client, webkit_thread_message_loop) {
   }
 
   virtual bool ShouldAddOrigin(const GURL& origin) = 0;
 
   virtual void RunOnTargetThread() OVERRIDE {
     std::vector<GURL> origins =  indexed_db_context_->GetAllOrigins();
     for (std::vector<GURL>::const_iterator iter = origins.begin();
          iter != origins.end(); ++iter) {
       if (ShouldAddOrigin(*iter))
         origins_.insert(*iter);
     }
   }
 
   std::set<GURL> origins_;
+
+ protected:
+  virtual ~GetOriginsTaskBase() {}
 };
 
 class IndexedDBQuotaClient::GetAllOriginsTask : public GetOriginsTaskBase {
  public:
   GetAllOriginsTask(
       IndexedDBQuotaClient* client,
       base::MessageLoopProxy* webkit_thread_message_loop,
       quota::StorageType type)
       : GetOriginsTaskBase(client, webkit_thread_message_loop),
         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 IndexedDBQuotaClient::GetOriginsForHostTask : public GetOriginsTaskBase {
  public:
   GetOriginsForHostTask(
       IndexedDBQuotaClient* client,
       base::MessageLoopProxy* webkit_thread_message_loop,
       const std::string& host,
       quota::StorageType type)
       : GetOriginsTaskBase(client, webkit_thread_message_loop),
         host_(host),
         type_(type) {
   }
 
  private:
+  virtual ~GetOriginsForHostTask() {}
+
   virtual bool ShouldAddOrigin(const GURL& origin) OVERRIDE {
     return host_ == net::GetHostOrSpecFromURL(origin);
   }
+
   virtual void Completed() OVERRIDE {
     client_->DidGetOriginsForHost(host_, origins_, type_);
   }
+
   std::string host_;
   quota::StorageType type_;
 };
 
 // IndexedDBQuotaClient --------------------------------------------------------
 
 IndexedDBQuotaClient::IndexedDBQuotaClient(
     base::MessageLoopProxy* webkit_thread_message_loop,
     IndexedDBContextImpl* indexed_db_context)
     : webkit_thread_message_loop_(webkit_thread_message_loop),
@@ skipping 98 matching lines @@
   DCHECK(origins_for_type_callbacks_.HasCallbacks());
   origins_for_type_callbacks_.Run(origins, type);
 }
 
 void IndexedDBQuotaClient::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);
 }