RefCounted types should not have public destructors, webkit/

webkit/quota/quota_manager.h

 // 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.
 
 #ifndef WEBKIT_QUOTA_QUOTA_MANAGER_H_
 #define WEBKIT_QUOTA_QUOTA_MANAGER_H_
 #pragma once
 
 #include <deque>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sequenced_task_runner_helpers.h"
 #include "webkit/quota/quota_database.h"
 #include "webkit/quota/quota_client.h"
 #include "webkit/quota/quota_task.h"
 #include "webkit/quota/quota_types.h"
 #include "webkit/quota/special_storage_policy.h"
 
 class FilePath;
 
 namespace base {
 class MessageLoopProxy;
@@ skipping 68 matching lines @@
                               int64 /* usage */,
                               int64 /* quota */)>
       GetUsageAndQuotaCallback;
 
   QuotaManager(bool is_incognito,
                const FilePath& profile_path,
                base::MessageLoopProxy* io_thread,
                base::MessageLoopProxy* db_thread,
                SpecialStoragePolicy* special_storage_policy);
 
-  virtual ~QuotaManager();
-
   // Returns a proxy object that can be used on any thread.
   QuotaManagerProxy* proxy() { return proxy_.get(); }
 
   // Called by clients or webapps. Returns usage per host.
   void GetUsageInfo(const GetUsageInfoCallback& callback);
 
   // Called by clients or webapps.
   // This method is declared as virtual to allow test code to override it.
   // note: returns host usage and quota
   virtual void GetUsageAndQuota(const GURL& origin,
@@ skipping 73 matching lines @@
   // Determines the portion of the temp pool that can be
   // utilized by a single host (ie. 5 for 20%).
   static const int kPerHostTemporaryPortion;
 
   static const char kDatabaseName[];
 
   static const int kThresholdOfErrorsToBeBlacklisted;
 
   static const int kEvictionIntervalInMilliSeconds;
 
+ protected:
+  virtual ~QuotaManager();
+
  private:
+  friend class base::DeleteHelper<QuotaManager>;
+  friend class MockQuotaManager;
+  friend class MockStorageClient;
+  friend class quota_internals::QuotaInternalsProxy;
+  friend class QuotaManagerProxy;
+  friend class QuotaManagerTest;
+  friend class QuotaTemporaryStorageEvictor;
+  friend struct QuotaManagerDeleter;
+
   class DatabaseTaskBase;
   class InitializeTask;
   class UpdateTemporaryQuotaOverrideTask;
   class GetPersistentHostQuotaTask;
   class UpdatePersistentHostQuotaTask;
   class GetLRUOriginTask;
   class DeleteOriginInfo;
   class InitializeTemporaryOriginsInfoTask;
   class UpdateAccessTimeTask;
   class UpdateModifiedTimeTask;
@@ skipping 31 matching lines @@
     EvictOriginDataCallback evict_origin_data_callback;
   };
 
   typedef std::pair<std::string, StorageType> HostAndType;
   typedef std::map<HostAndType, UsageAndQuotaDispatcherTask*>
       UsageAndQuotaDispatcherTaskMap;
 
   typedef QuotaEvictionHandler::GetUsageAndQuotaForEvictionCallback
       UsageAndQuotaDispatcherCallback;
 
-  friend class quota_internals::QuotaInternalsProxy;
-  friend struct QuotaManagerDeleter;
-  friend class MockStorageClient;
-  friend class QuotaManagerProxy;
-  friend class QuotaManagerTest;
-  friend class QuotaTemporaryStorageEvictor;
-  friend class MockQuotaManager;
-
   // This initialization method is lazily called on the IO thread
   // when the first quota manager API is called.
   // Initialize must be called after all quota clients are added to the
   // manager by RegisterStorage.
   void LazyInitialize();
 
   // Called by clients via proxy.
   // Registers a quota client to the manager.
   // The client must remain valid until OnQuotaManagerDestored is called.
   void RegisterClient(QuotaClient* client);
@@ skipping 143 matching lines @@
 
   QuotaManager* manager_;  // only accessed on the io thread
   scoped_refptr<base::MessageLoopProxy> io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManagerProxy);
 };
 
 }  // namespace quota
 
 #endif  // WEBKIT_QUOTA_QUOTA_MANAGER_H_