RefCounted types should not have public destructors, webkit/

webkit/quota/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/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 
@@ skipping 626 matching lines @@
  public:
   explicit DatabaseTaskBase(QuotaManager* manager)
       : QuotaThreadTask(manager, manager->db_thread_),
         manager_(manager),
         database_(manager->database_.get()),
         db_disabled_(false) {
     DCHECK(database_);
   }
 
  protected:
+  virtual ~DatabaseTaskBase() {}
+
   virtual void DatabaseTaskCompleted() = 0;
 
+  // QuotaThreadTask:
   virtual void Completed() OVERRIDE {
     manager_->db_disabled_ = db_disabled_;
     DatabaseTaskCompleted();
   }
 
   bool db_disabled() const { return db_disabled_; }
   void set_db_disabled(bool db_disabled) {
     db_disabled_ = db_disabled;
   }
 
   QuotaManager* manager() const { return manager_; }
   QuotaDatabase* database() const { return database_; }
 
  private:
   QuotaManager* manager_;
   QuotaDatabase* database_;
   bool db_disabled_;
 };
 
 class QuotaManager::InitializeTask : public QuotaManager::DatabaseTaskBase {
  public:
   InitializeTask(QuotaManager* manager)
       : DatabaseTaskBase(manager),
         temporary_quota_override_(-1),
         desired_available_space_(-1) {
   }
 
  protected:
+  virtual ~InitializeTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     // See if we have overriding temporary quota configuration.
     database()->GetQuotaConfigValue(QuotaDatabase::kTemporaryQuotaOverrideKey,
                                     &temporary_quota_override_);
     database()->GetQuotaConfigValue(QuotaDatabase::kDesiredAvailableSpaceKey,
                                     &desired_available_space_);
   }
 
+  // DatabaseTaskBase:
   virtual void DatabaseTaskCompleted() OVERRIDE {
     manager()->temporary_quota_override_ = temporary_quota_override_;
     manager()->desired_available_space_ = desired_available_space_;
     manager()->temporary_quota_initialized_ = true;
     manager()->DidRunInitializeTask();
   }
 
  private:
   int64 temporary_quota_override_;
   int64 desired_available_space_;
 };
 
 class QuotaManager::UpdateTemporaryQuotaOverrideTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   UpdateTemporaryQuotaOverrideTask(
       QuotaManager* manager,
       int64 new_quota,
       const QuotaCallback& callback)
       : DatabaseTaskBase(manager),
         new_quota_(new_quota),
         callback_(callback) {}
 
  protected:
+  virtual ~UpdateTemporaryQuotaOverrideTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->SetQuotaConfigValue(
             QuotaDatabase::kTemporaryQuotaOverrideKey, new_quota_)) {
       set_db_disabled(true);
       new_quota_ = -1;
       return;
     }
   }
 
+  // DatabaseTaskBase:
   virtual void DatabaseTaskCompleted() OVERRIDE {
     if (!db_disabled()) {
       manager()->temporary_quota_override_ = new_quota_;
       CallCallback(kQuotaStatusOk, kStorageTypeTemporary, new_quota_);
     } else {
       CallCallback(kQuotaErrorInvalidAccess, kStorageTypeTemporary, new_quota_);
     }
   }
 
  private:
@@ skipping 13 matching lines @@
  public:
   GetPersistentHostQuotaTask(
       QuotaManager* manager,
       const std::string& host,
       const HostQuotaCallback& callback)
       : DatabaseTaskBase(manager),
         host_(host),
         quota_(-1),
         callback_(callback) {
   }
+
  protected:
+  virtual ~GetPersistentHostQuotaTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->GetHostQuota(host_, kStorageTypePersistent, &quota_))
       quota_ = 0;
   }
+
+  // DatabaseTaskBase:
   virtual void DatabaseTaskCompleted() OVERRIDE {
     callback_.Run(kQuotaStatusOk,
                   host_, kStorageTypePersistent, quota_);
   }
+
  private:
   std::string host_;
   int64 quota_;
   HostQuotaCallback callback_;
 };
 
 class QuotaManager::UpdatePersistentHostQuotaTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   UpdatePersistentHostQuotaTask(
       QuotaManager* manager,
       const std::string& host,
       int64 new_quota,
       const HostQuotaCallback& callback)
       : DatabaseTaskBase(manager),
         host_(host),
         new_quota_(new_quota),
         callback_(callback) {
     DCHECK_GE(new_quota_, 0);
   }
+
  protected:
+  virtual ~UpdatePersistentHostQuotaTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->SetHostQuota(host_, kStorageTypePersistent, new_quota_)) {
       set_db_disabled(true);
       new_quota_ = 0;
     }
   }
 
-  virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_.Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
-                  host_, kStorageTypePersistent, new_quota_);
-  }
-
   virtual void Aborted() OVERRIDE {
     callback_.Reset();
   }
 
+  // DatabaseTaskBase:
+  virtual void DatabaseTaskCompleted() OVERRIDE {
+    callback_.Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
+                  host_, kStorageTypePersistent, new_quota_);
+  }
+
  private:
   std::string host_;
   int64 new_quota_;
   HostQuotaCallback callback_;
 };
 
 class QuotaManager::GetLRUOriginTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   GetLRUOriginTask(
@@ skipping 14 matching lines @@
     }
     for (std::map<GURL, int>::const_iterator p = origins_in_error.begin();
          p != origins_in_error.end();
          ++p) {
       if (p->second > QuotaManager::kThresholdOfErrorsToBeBlacklisted)
         exceptions_.insert(p->first);
     }
   }
 
  protected:
+  virtual ~GetLRUOriginTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     database()->GetLRUOrigin(
         type_, exceptions_, special_storage_policy_, &url_);
   }
 
-  virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_.Run(url_);
-  }
-
   virtual void Aborted() OVERRIDE {
     callback_.Reset();
   }
 
+  // DatabaseTaskBase:
+  virtual void DatabaseTaskCompleted() OVERRIDE {
+    callback_.Run(url_);
+  }
+
  private:
   StorageType type_;
   std::set<GURL> exceptions_;
   GetLRUOriginCallback callback_;
   scoped_refptr<SpecialStoragePolicy> special_storage_policy_;
   GURL url_;
 };
 
 class QuotaManager::DeleteOriginInfo
     : public QuotaManager::DatabaseTaskBase {
  public:
   DeleteOriginInfo(
       QuotaManager* manager,
       const GURL& origin,
       StorageType type)
       : DatabaseTaskBase(manager),
         origin_(origin),
         type_(type) {}
 
  protected:
+  virtual ~DeleteOriginInfo() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->DeleteOriginInfo(origin_, type_)) {
       set_db_disabled(true);
     }
   }
+
+  // DatabaseTaskBase:
   virtual void DatabaseTaskCompleted() OVERRIDE {}
 
  private:
   GURL origin_;
   StorageType type_;
 };
 
 class QuotaManager::InitializeTemporaryOriginsInfoTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   InitializeTemporaryOriginsInfoTask(
       QuotaManager* manager,
       UsageTracker* temporary_usage_tracker)
       : DatabaseTaskBase(manager),
         has_registered_origins_(false) {
     DCHECK(temporary_usage_tracker);
     temporary_usage_tracker->GetCachedOrigins(&origins_);
   }
 
  protected:
+  virtual ~InitializeTemporaryOriginsInfoTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->IsOriginDatabaseBootstrapped()) {
       // Register existing origins with 0 last time access.
       if (!database()->RegisterInitialOriginInfo(
               origins_, kStorageTypeTemporary)) {
         set_db_disabled(true);
       } else {
         has_registered_origins_ = true;
         database()->SetOriginDatabaseBootstrapped(true);
       }
     }
   }
+
+  // DatabaseTaskBase:
   virtual void DatabaseTaskCompleted() OVERRIDE {
     if (has_registered_origins_)
       manager()->StartEviction();
   }
 
  private:
   std::set<GURL> origins_;
   bool has_registered_origins_;
 };
 
 class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {
  public:
   AvailableSpaceQueryTask(
       QuotaManager* manager,
       const AvailableSpaceCallback& callback)
       : QuotaThreadTask(manager, manager->db_thread_),
         profile_path_(manager->profile_path_),
         space_(-1),
         callback_(callback) {
   }
+
+ protected:
   virtual ~AvailableSpaceQueryTask() {}
 
- protected:
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     space_ = base::SysInfo::AmountOfFreeDiskSpace(profile_path_);
   }
 
   virtual void Aborted() OVERRIDE {
     callback_.Reset();
   }
 
   virtual void Completed() OVERRIDE {
     callback_.Run(kQuotaStatusOk, space_);
@@ skipping 12 matching lines @@
       QuotaManager* manager,
       const GURL& origin,
       StorageType type,
       base::Time accessed_time)
       : DatabaseTaskBase(manager),
         origin_(origin),
         type_(type),
         accessed_time_(accessed_time) {}
 
  protected:
+  virtual ~UpdateAccessTimeTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->SetOriginLastAccessTime(origin_, type_, accessed_time_)) {
       set_db_disabled(true);
     }
   }
+
+  // DatabaseTaskBase:
   virtual void DatabaseTaskCompleted() OVERRIDE {}
 
  private:
   GURL origin_;
   StorageType type_;
   base::Time accessed_time_;
 };
 
 class QuotaManager::UpdateModifiedTimeTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   UpdateModifiedTimeTask(
       QuotaManager* manager,
       const GURL& origin,
       StorageType type,
       base::Time modified_time)
       : DatabaseTaskBase(manager),
         origin_(origin),
         type_(type),
         modified_time_(modified_time) {}
 
  protected:
+  virtual ~UpdateModifiedTimeTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->SetOriginLastModifiedTime(
             origin_, type_, modified_time_)) {
       set_db_disabled(true);
     }
   }
+
+  // DatabaseTaskBase:
   virtual void DatabaseTaskCompleted() OVERRIDE {}
 
  private:
   GURL origin_;
   StorageType type_;
   base::Time modified_time_;
 };
 
 class QuotaManager::GetModifiedSinceTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   GetModifiedSinceTask(
       QuotaManager* manager,
       StorageType type,
       base::Time modified_since,
       GetOriginsCallback callback)
       : DatabaseTaskBase(manager),
         type_(type),
         modified_since_(modified_since),
         callback_(callback) {}
 
  protected:
+  virtual ~GetModifiedSinceTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->GetOriginsModifiedSince(
             type_, &origins_, modified_since_)) {
       set_db_disabled(true);
     }
   }
 
-  virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_.Run(origins_, type_);
-  }
-
   virtual void Aborted() OVERRIDE {
     callback_.Run(std::set<GURL>(), type_);
   }
 
+  // DatabaseTaskBase:
+  virtual void DatabaseTaskCompleted() OVERRIDE {
+    callback_.Run(origins_, type_);
+  }
+
  private:
   StorageType type_;
   base::Time modified_since_;
   std::set<GURL> origins_;
   GetOriginsCallback callback_;
 };
 
 class QuotaManager::DumpQuotaTableTask
     : public QuotaManager::DatabaseTaskBase {
  private:
   typedef QuotaManager::DumpQuotaTableTask self_type;
   typedef QuotaManager::DumpQuotaTableCallback Callback;
   typedef QuotaManager::QuotaTableEntry TableEntry;
   typedef QuotaManager::QuotaTableEntries TableEntries;
   typedef QuotaDatabase::QuotaTableCallback TableCallback;
 
  public:
   DumpQuotaTableTask(
       QuotaManager* manager,
       const Callback& callback)
       : DatabaseTaskBase(manager),
         callback_(callback) {
   }
+
  protected:
+  virtual ~DumpQuotaTableTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->DumpQuotaTable(
             new TableCallback(
                 base::Bind(&self_type::AppendEntry, this))))
       set_db_disabled(true);
   }
 
   virtual void Aborted() OVERRIDE {
     callback_.Run(TableEntries());
   }
 
+  // DatabaseTaskBase:
   virtual void DatabaseTaskCompleted() OVERRIDE {
     callback_.Run(entries_);
   }
 
  private:
   bool AppendEntry(const TableEntry& entry) {
     entries_.push_back(entry);
     return true;
   }
 
@@ skipping 10 matching lines @@
   typedef QuotaManager::OriginInfoTableEntries TableEntries;
   typedef QuotaDatabase::OriginInfoTableCallback TableCallback;
 
  public:
   DumpOriginInfoTableTask(
       QuotaManager* manager,
       const Callback& callback)
       : DatabaseTaskBase(manager),
         callback_(callback) {
   }
+
  protected:
+  virtual ~DumpOriginInfoTableTask() {}
+
+  // QuotaThreadTask:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->DumpOriginInfoTable(
             new TableCallback(
                 base::Bind(&self_type::AppendEntry, this))))
       set_db_disabled(true);
   }
 
   virtual void Aborted() OVERRIDE {
     callback_.Run(TableEntries());
   }
 
+  // DatabaseTaskBase:
   virtual void DatabaseTaskCompleted() OVERRIDE {
     callback_.Run(entries_);
   }
 
  private:
   bool AppendEntry(const TableEntry& entry) {
     entries_.push_back(entry);
     return true;
   }
 
@@ skipping 16 matching lines @@
     eviction_disabled_(false),
     io_thread_(io_thread),
     db_thread_(db_thread),
     temporary_quota_initialized_(false),
     temporary_quota_override_(-1),
     desired_available_space_(-1),
     special_storage_policy_(special_storage_policy),
     weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
-QuotaManager::~QuotaManager() {
-  proxy_->manager_ = NULL;
-  std::for_each(clients_.begin(), clients_.end(),
-                std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
-  if (database_.get())
-    db_thread_->DeleteSoon(FROM_HERE, database_.release());
-}
-
 void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
   LazyInitialize();
   GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
   get_usage_info->Start();
 }
 
 void QuotaManager::GetUsageAndQuota(
     const GURL& origin, StorageType type,
     const GetUsageAndQuotaCallback& callback) {
   GetUsageAndQuotaInternal(origin, type, false /* global */,
@@ skipping 110 matching lines @@
 }
 
 void QuotaManager::GetOriginsModifiedSince(StorageType type,
                                            base::Time modified_since,
                                            const GetOriginsCallback& callback) {
   LazyInitialize();
   make_scoped_refptr(new GetModifiedSinceTask(
       this, type, modified_since, callback))->Start();
 }
 
+QuotaManager::~QuotaManager() {
+  proxy_->manager_ = NULL;
+  std::for_each(clients_.begin(), clients_.end(),
+                std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
+  if (database_.get())
+    db_thread_->DeleteSoon(FROM_HERE, database_.release());
+}
+
 void QuotaManager::LazyInitialize() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_.get()) {
     // Initialization seems to be done already.
     return;
   }
 
   // Use an empty path to open an in-memory only databse for incognito.
   database_.reset(new QuotaDatabase(is_incognito_ ? FilePath() :
       profile_path_.AppendASCII(kDatabaseName)));
@@ skipping 474 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota