RefCounted types should not have public destructors, webkit/

webkit/appcache/appcache_storage_impl.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/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 130 matching lines @@
 
 class AppCacheStorageImpl::DatabaseTask
     : public base::RefCountedThreadSafe<DatabaseTask> {
  public:
   explicit DatabaseTask(AppCacheStorageImpl* storage)
       : storage_(storage), database_(storage->database_),
         io_thread_(base::MessageLoopProxy::current()) {
     DCHECK(io_thread_);
   }
 
-  virtual ~DatabaseTask() {}
-
   void AddDelegate(DelegateReference* delegate_reference) {
     delegates_.push_back(make_scoped_refptr(delegate_reference));
   }
 
   // Schedules a task to be Run() on the DB thread. Tasks
   // are run in the order in which they are scheduled.
   void Schedule();
 
   // Called on the DB thread.
   virtual void Run() = 0;
 
   // Called on the IO thread after Run() has completed.
   virtual void RunCompleted() {}
 
   // Once scheduled a task cannot be cancelled, but the
   // call to RunCompleted may be. This method should only be
   // called on the IO thread. This is used by AppCacheStorageImpl
   // to cancel the completion calls when AppCacheStorageImpl is
   // destructed. This method may be overriden to release or delete
   // additional data associated with the task that is not DB thread
   // safe. If overriden, this base class method must be called from
   // within the override.
   virtual void CancelCompletion();
 
  protected:
+  friend class base::RefCountedThreadSafe<DatabaseTask>;
+  virtual ~DatabaseTask() {}
+
   AppCacheStorageImpl* storage_;
   AppCacheDatabase* database_;
   DelegateReferenceVector delegates_;
 
  private:
   void CallRun(base::TimeTicks schedule_time);
   void CallRunCompleted(base::TimeTicks schedule_time);
   void CallDisableStorage();
 
   scoped_refptr<base::MessageLoopProxy> io_thread_;
@@ skipping 63 matching lines @@
 
 // InitTask -------
 
 class AppCacheStorageImpl::InitTask : public DatabaseTask {
  public:
   explicit InitTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage), last_group_id_(0),
         last_cache_id_(0), last_response_id_(0),
         last_deletable_response_rowid_(0) {}
 
-  virtual void Run();
-  virtual void RunCompleted();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+  virtual void RunCompleted() OVERRIDE;
 
+ protected:
+  virtual ~InitTask() {}
+
+ private:
   int64 last_group_id_;
   int64 last_cache_id_;
   int64 last_response_id_;
   int64 last_deletable_response_rowid_;
   std::map<GURL, int64> usage_map_;
 };
 
 void AppCacheStorageImpl::InitTask::Run() {
   database_->FindLastStorageIds(
       &last_group_id_, &last_cache_id_, &last_response_id_,
@@ skipping 21 matching lines @@
     storage_->service()->quota_client()->NotifyAppCacheReady();
 }
 
 // CloseConnectionTask -------
 
 class AppCacheStorageImpl::CloseConnectionTask : public DatabaseTask {
  public:
   explicit CloseConnectionTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
-  virtual void Run() { database_->CloseConnection(); }
+  // DatabaseTask:
+  virtual void Run() OVERRIDE { database_->CloseConnection(); }
+
+ protected:
+  virtual ~CloseConnectionTask() {}
 };
 
 // DisableDatabaseTask -------
 
 class AppCacheStorageImpl::DisableDatabaseTask : public DatabaseTask {
  public:
   explicit DisableDatabaseTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
-  virtual void Run() { database_->Disable(); }
+  // DatabaseTask:
+  virtual void Run() OVERRIDE { database_->Disable(); }
+
+ protected:
+  virtual ~DisableDatabaseTask() {}
 };
 
 // GetAllInfoTask -------
 
 class AppCacheStorageImpl::GetAllInfoTask : public DatabaseTask {
  public:
   explicit GetAllInfoTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage),
         info_collection_(new AppCacheInfoCollection()) {
   }
 
-  virtual void Run();
-  virtual void RunCompleted();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+  virtual void RunCompleted() OVERRIDE;
 
+ protected:
+  virtual ~GetAllInfoTask() {}
+
+ private:
   scoped_refptr<AppCacheInfoCollection> info_collection_;
 };
 
 void AppCacheStorageImpl::GetAllInfoTask::Run() {
   std::set<GURL> origins;
   database_->FindOriginsWithGroups(&origins);
   for (std::set<GURL>::const_iterator origin = origins.begin();
        origin != origins.end(); ++origin) {
     AppCacheInfoVector& infos =
         info_collection_->infos_by_origin[*origin];
@@ skipping 22 matching lines @@
   DCHECK(delegates_.size() == 1);
   FOR_EACH_DELEGATE(delegates_, OnAllInfo(info_collection_));
 }
 
 // StoreOrLoadTask -------
 
 class AppCacheStorageImpl::StoreOrLoadTask : public DatabaseTask {
  protected:
   explicit StoreOrLoadTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
+  virtual ~StoreOrLoadTask() {}
 
   bool FindRelatedCacheRecords(int64 cache_id);
   void CreateCacheAndGroupFromRecords(
       scoped_refptr<AppCache>* cache, scoped_refptr<AppCacheGroup>* group);
 
   AppCacheDatabase::GroupRecord group_record_;
   AppCacheDatabase::CacheRecord cache_record_;
   std::vector<AppCacheDatabase::EntryRecord> entry_records_;
   std::vector<AppCacheDatabase::NamespaceRecord>
       intercept_namespace_records_;
@@ skipping 64 matching lines @@
 }
 
 // CacheLoadTask -------
 
 class AppCacheStorageImpl::CacheLoadTask : public StoreOrLoadTask {
  public:
   CacheLoadTask(int64 cache_id, AppCacheStorageImpl* storage)
       : StoreOrLoadTask(storage), cache_id_(cache_id),
         success_(false) {}
 
-  virtual void Run();
-  virtual void RunCompleted();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+  virtual void RunCompleted() OVERRIDE;
 
+ protected:
+  virtual ~CacheLoadTask() {}
+
+ private:
   int64 cache_id_;
   bool success_;
 };
 
 void AppCacheStorageImpl::CacheLoadTask::Run() {
   success_ =
       database_->FindCache(cache_id_, &cache_record_) &&
       database_->FindGroup(cache_record_.group_id, &group_record_) &&
       FindRelatedCacheRecords(cache_id_);
 
@@ skipping 14 matching lines @@
 }
 
 // GroupLoadTask -------
 
 class AppCacheStorageImpl::GroupLoadTask : public StoreOrLoadTask {
  public:
   GroupLoadTask(GURL manifest_url, AppCacheStorageImpl* storage)
       : StoreOrLoadTask(storage), manifest_url_(manifest_url),
         success_(false) {}
 
-  virtual void Run();
-  virtual void RunCompleted();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+  virtual void RunCompleted() OVERRIDE;
 
+ protected:
+  virtual ~GroupLoadTask() {}
+
+ private:
   GURL manifest_url_;
   bool success_;
 };
 
 void AppCacheStorageImpl::GroupLoadTask::Run() {
   success_ =
       database_->FindGroupForManifestUrl(manifest_url_, &group_record_) &&
       database_->FindCacheForGroup(group_record_.group_id, &cache_record_) &&
       FindRelatedCacheRecords(cache_record_.cache_id);
 
@@ skipping 25 matching lines @@
 
 class AppCacheStorageImpl::StoreGroupAndCacheTask : public StoreOrLoadTask {
  public:
   StoreGroupAndCacheTask(AppCacheStorageImpl* storage, AppCacheGroup* group,
                          AppCache* newest_cache);
 
   void GetQuotaThenSchedule();
   void OnQuotaCallback(
       quota::QuotaStatusCode status, int64 usage, int64 quota);
 
-  virtual void Run();
-  virtual void RunCompleted();
-  virtual void CancelCompletion();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+  virtual void RunCompleted() OVERRIDE;
+  virtual void CancelCompletion() OVERRIDE;
 
+ protected:
+  virtual ~StoreGroupAndCacheTask() {}
+
+ private:
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> cache_;
   bool success_;
   bool would_exceed_quota_;
   int64 space_available_;
   int64 new_origin_usage_;
   std::vector<int64> newly_deletable_response_ids_;
 };
 
 AppCacheStorageImpl::StoreGroupAndCacheTask::StoreGroupAndCacheTask(
@@ skipping 270 matching lines @@
            it != groups_in_use->end(); ++it) {
         AppCacheGroup* group = it->second;
         AppCache* cache = group->newest_complete_cache();
         if (group->is_obsolete() || !cache)
           continue;
         cache_ids_in_use_.insert(cache->cache_id());
       }
     }
   }
 
-  virtual void Run();
-  virtual void RunCompleted();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+  virtual void RunCompleted() OVERRIDE;
+
+ protected:
+  virtual ~FindMainResponseTask() {}
 
  private:
   typedef std::vector<AppCacheDatabase::NamespaceRecord*>
       NamespaceRecordPtrVector;
+
   bool FindExactMatch(int64 preferred_id);
   bool FindNamespaceMatch(int64 preferred_id);
   bool FindNamespaceHelper(
       int64 preferred_cache_id,
       AppCacheDatabase::NamespaceRecordVector* namespaces,
       NetworkNamespaceHelper* network_namespace_helper);
   bool FindFirstValidNamespace(const NamespaceRecordPtrVector& namespaces);
 
   GURL url_;
   GURL preferred_manifest_url_;
@@ skipping 172 matching lines @@
 }
 
 // MarkEntryAsForeignTask -------
 
 class AppCacheStorageImpl::MarkEntryAsForeignTask : public DatabaseTask {
  public:
   MarkEntryAsForeignTask(
       AppCacheStorageImpl* storage, const GURL& url, int64 cache_id)
       : DatabaseTask(storage), cache_id_(cache_id), entry_url_(url) {}
 
-  virtual void Run();
-  virtual void RunCompleted();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+  virtual void RunCompleted() OVERRIDE;
 
+ protected:
+  virtual ~MarkEntryAsForeignTask() {}
+
+ private:
   int64 cache_id_;
   GURL entry_url_;
 };
 
 void AppCacheStorageImpl::MarkEntryAsForeignTask::Run() {
   database_->AddEntryFlags(entry_url_, cache_id_, AppCacheEntry::FOREIGN);
 }
 
 void AppCacheStorageImpl::MarkEntryAsForeignTask::RunCompleted() {
   DCHECK(storage_->pending_foreign_markings_.front().first == entry_url_ &&
          storage_->pending_foreign_markings_.front().second == cache_id_);
   storage_->pending_foreign_markings_.pop_front();
 }
 
 // MakeGroupObsoleteTask -------
 
 class AppCacheStorageImpl::MakeGroupObsoleteTask : public DatabaseTask {
  public:
   MakeGroupObsoleteTask(AppCacheStorageImpl* storage, AppCacheGroup* group);
 
-  virtual void Run();
-  virtual void RunCompleted();
-  virtual void CancelCompletion();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+  virtual void RunCompleted() OVERRIDE;
+  virtual void CancelCompletion() OVERRIDE;
 
+ protected:
+  virtual ~MakeGroupObsoleteTask() {}
+
+ private:
   scoped_refptr<AppCacheGroup> group_;
   int64 group_id_;
   GURL origin_;
   bool success_;
   int64 new_origin_usage_;
   std::vector<int64> newly_deletable_response_ids_;
 };
 
 AppCacheStorageImpl::MakeGroupObsoleteTask::MakeGroupObsoleteTask(
     AppCacheStorageImpl* storage, AppCacheGroup* group)
@@ skipping 53 matching lines @@
   group_ = NULL;
 }
 
 // GetDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::GetDeletableResponseIdsTask : public DatabaseTask {
  public:
   GetDeletableResponseIdsTask(AppCacheStorageImpl* storage, int64 max_rowid)
       : DatabaseTask(storage), max_rowid_(max_rowid) {}
 
-  virtual void Run();
-  virtual void RunCompleted();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+  virtual void RunCompleted() OVERRIDE;
 
+ protected:
+  virtual ~GetDeletableResponseIdsTask() {}
+
+ private:
   int64 max_rowid_;
   std::vector<int64> response_ids_;
 };
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::Run() {
   const int kSqlLimit = 1000;
   database_->GetDeletableResponseIds(&response_ids_, max_rowid_, kSqlLimit);
   // TODO(michaeln): retrieve group_ids too
 }
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::RunCompleted() {
   if (!response_ids_.empty())
     storage_->StartDeletingResponses(response_ids_);
 }
 
 // InsertDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::InsertDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit InsertDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
-  virtual void Run();
+
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+
   std::vector<int64> response_ids_;
+
+ protected:
+  virtual ~InsertDeletableResponseIdsTask() {}
 };
 
 void AppCacheStorageImpl::InsertDeletableResponseIdsTask::Run() {
   database_->InsertDeletableResponseIds(response_ids_);
   // TODO(michaeln): store group_ids too
 }
 
 // DeleteDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::DeleteDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit DeleteDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
-  virtual void Run();
+
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
+
   std::vector<int64> response_ids_;
+
+ protected:
+  virtual ~DeleteDeletableResponseIdsTask() {}
 };
 
 void AppCacheStorageImpl::DeleteDeletableResponseIdsTask::Run() {
   database_->DeleteDeletableResponseIds(response_ids_);
 }
 
 // UpdateGroupLastAccessTimeTask -------
 
 class AppCacheStorageImpl::UpdateGroupLastAccessTimeTask
     : public DatabaseTask {
  public:
   UpdateGroupLastAccessTimeTask(
       AppCacheStorageImpl* storage, AppCacheGroup* group, base::Time time)
       : DatabaseTask(storage), group_id_(group->group_id()),
         last_access_time_(time) {
     storage->NotifyStorageAccessed(group->manifest_url().GetOrigin());
   }
 
-  virtual void Run();
+  // DatabaseTask:
+  virtual void Run() OVERRIDE;
 
+ protected:
+  virtual ~UpdateGroupLastAccessTimeTask() {}
+
+ private:
   int64 group_id_;
   base::Time last_access_time_;
 };
 
 void AppCacheStorageImpl::UpdateGroupLastAccessTimeTask::Run() {
   database_->UpdateGroupLastAccessTime(group_id_, last_access_time_);
 }
 
 
 // AppCacheStorageImpl ---------------------------------------------------
@@ skipping 510 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       db_thread_->PostTask(
           FROM_HERE, base::Bind(&DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache