RefCounted types should not have public destructors, webkit/

webkit/quota/mock_quota_manager.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 "webkit/quota/mock_quota_manager.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_task.h"
 #include "webkit/quota/quota_types.h"
 
 namespace quota {
 
 class MockQuotaManager::GetModifiedSinceTask : public QuotaThreadTask {
  public:
   GetModifiedSinceTask(MockQuotaManager* manager,
                        const std::set<GURL>& origins,
                        StorageType type,
                        const GetOriginsCallback& callback)
       : QuotaThreadTask(manager, manager->io_thread_),
         origins_(origins),
         type_(type),
-        callback_(callback) {}
+        callback_(callback) {
+  }
 
  protected:
+  virtual ~GetModifiedSinceTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {}
 
   virtual void Completed() OVERRIDE {
     callback_.Run(origins_, type_);
   }
 
   virtual void Aborted() OVERRIDE {
     callback_.Run(std::set<GURL>(), type_);
   }
 
  private:
   std::set<GURL> origins_;
   StorageType type_;
   GetOriginsCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetModifiedSinceTask);
 };
 
 class MockQuotaManager::DeleteOriginDataTask : public QuotaThreadTask {
  public:
   DeleteOriginDataTask(MockQuotaManager* manager,
                        const StatusCallback& callback)
       : QuotaThreadTask(manager, manager->io_thread_),
-        callback_(callback) {}
+        callback_(callback) {
+  }
 
  protected:
+  virtual ~DeleteOriginDataTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {}
 
   virtual void Completed() OVERRIDE {
     callback_.Run(quota::kQuotaStatusOk);
   }
 
   virtual void Aborted() OVERRIDE {
     callback_.Run(quota::kQuotaErrorAbort);
   }
 
@@ skipping 19 matching lines @@
 MockQuotaManager::MockQuotaManager(
     bool is_incognito,
     const FilePath& profile_path,
     base::MessageLoopProxy* io_thread,
     base::MessageLoopProxy* db_thread,
     SpecialStoragePolicy* special_storage_policy)
     : QuotaManager(is_incognito, profile_path, io_thread, db_thread,
         special_storage_policy) {
 }
 
-MockQuotaManager::~MockQuotaManager() {}
-
 bool MockQuotaManager::AddOrigin(
     const GURL& origin,
     StorageType type,
     int quota_client_mask,
     base::Time modified) {
   origins_.push_back(OriginInfo(origin, type, quota_client_mask, modified));
   return true;
 }
 
 bool MockQuotaManager::OriginHasData(
@@ skipping 38 matching lines @@
       // Modify the mask: if it's 0 after "deletion", remove the origin.
       current->quota_client_mask &= ~quota_client_mask;
       if (current->quota_client_mask == 0)
         origins_.erase(current);
       break;
     }
   }
   make_scoped_refptr(new DeleteOriginDataTask(this, callback))->Start();
 }
 
+MockQuotaManager::~MockQuotaManager() {}
+
 }  // namespace quota