RefCounted types should not have public destructors, webkit/

webkit/fileapi/obfuscated_file_util.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_FILEAPI_OBFUSCATED_FILE_UTIL_H_
 #define WEBKIT_FILEAPI_OBFUSCATED_FILE_UTIL_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 25 matching lines @@
 // backing file than have a database entry whose backing file is missing.  When
 // doing FSCK operations, if you find a loose backing file with no reference,
 // you may safely delete it.
 //
 // This class is RefCountedThreadSafe because it may gain a reference on the IO
 // thread, but must be deleted on the FILE thread because that's where
 // DropDatabases needs to be called.  References will be held by the
 // SandboxMountPointProvider [and the task it uses to drop the reference] and
 // SandboxMountPointProvider::GetFileSystemRootPathTask.  Without that last one,
 // we wouldn't need ref counting.
-class ObfuscatedFileUtil : public FileSystemFileUtil,
+class ObfuscatedFileUtil :
+    public FileSystemFileUtil,
     public base::RefCountedThreadSafe<ObfuscatedFileUtil> {
  public:
   // Origin enumerator interface.
   // An instance of this interface is assumed to be called on the file thread.
   class AbstractOriginEnumerator {
    public:
     virtual ~AbstractOriginEnumerator() {}
 
     // Returns the next origin.  Returns empty if there are no more origins.
     virtual GURL Next() = 0;
 
     // Returns the current origin's information.
     virtual bool HasFileSystemType(FileSystemType type) const = 0;
   };
 
   // |underlying_file_util| is owned by the instance.  It will be deleted by
   // the owner instance.  For example, it can be instanciated as follows:
   // FileSystemFileUtil* file_util =
   //     new ObfuscatedFileUtil(new NativeFileUtil());
   ObfuscatedFileUtil(const FilePath& file_system_directory,
                      FileSystemFileUtil* underlying_file_util);
-  virtual ~ObfuscatedFileUtil();
 
   virtual base::PlatformFileError CreateOrOpen(
       FileSystemOperationContext* context,
       const FileSystemPath& path,
       int file_flags,
       base::PlatformFile* file_handle,
       bool* created) OVERRIDE;
 
   virtual base::PlatformFileError EnsureFileExists(
       FileSystemOperationContext* context,
@@ skipping 101 matching lines @@
   bool DestroyDirectoryDatabase(const GURL& origin, FileSystemType type);
 
   // Computes a cost for storing a given file in the obfuscated FSFU.
   // As the cost of a file is independent of the cost of its parent directories,
   // this ignores all but the BaseName of the supplied path.  In order to
   // compute the cost of adding a multi-segment directory recursively, call this
   // on each path segment and add the results.
   static int64 ComputeFilePathCost(const FilePath& path);
 
  private:
+  friend class base::RefCountedThreadSafe<ObfuscatedFileUtil>;
+
   typedef FileSystemDirectoryDatabase::FileId FileId;
   typedef FileSystemDirectoryDatabase::FileInfo FileInfo;
 
+  virtual ~ObfuscatedFileUtil();
+
   base::PlatformFileError GetFileInfoInternal(
       FileSystemDirectoryDatabase* db,
       FileSystemOperationContext* context,
       const GURL& origin,
       FileSystemType type,
       FileId file_id,
       FileInfo* local_info,
       base::PlatformFileInfo* file_info,
       FilePath* platform_file_path);
 
@@ skipping 52 matching lines @@
   scoped_ptr<FileSystemOriginDatabase> origin_database_;
   FilePath file_system_directory_;
   base::OneShotTimer<ObfuscatedFileUtil> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtil);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_OBFUSCATED_FILE_UTIL_H_