Second patch in making destructors of refcounted objects private.

net/disk_cache/file_posix.cc

 // Copyright (c) 2006-2008 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 "net/disk_cache/file.h"
 
 #include <fcntl.h>
 
 #include <set>
 
@@ skipping 17 matching lines @@
   // is keeping track of all operations. When done, we notify the controller
   // (we do NOT invoke the callback), in the worker thead that completed the
   // operation.
   BackgroundIO(disk_cache::File* file, const void* buf, size_t buf_len,
                size_t offset, disk_cache::FileIOCallback* callback,
                InFlightIO* controller)
       : io_completed_(true, false), callback_(callback), file_(file), buf_(buf),
         buf_len_(buf_len), offset_(offset), controller_(controller),
         bytes_(0) {}
 
-  ~BackgroundIO() {}
-
   // Read and Write are the operations that can be performed asynchronously.
   // The actual parameters for the operation are setup in the constructor of
   // the object, with the exception of |delete_buffer|, that allows a write
   // without a callback. Both methods should be called from a worker thread, by
   // posting a task to the WorkerPool (they are RunnableMethods). When finished,
   // controller->OnIOComplete() is called.
   void Read();
   void Write(bool delete_buffer);
 
   // This method signals the controller that this operation is finished, in the
@@ skipping 18 matching lines @@
 
   disk_cache::FileIOCallback* callback() {
     return callback_;
   }
 
   disk_cache::File* file() {
     return file_;
   }
 
  private:
+  friend class base::RefCountedThreadSafe<BackgroundIO>;
+  ~BackgroundIO() {}
+
   // An event to signal when the operation completes, and the user callback that
   // has to be invoked. These members are accessed directly by the controller.
   base::WaitableEvent io_completed_;
   disk_cache::FileIOCallback* callback_;
 
   disk_cache::File* file_;
   const void* buf_;
   size_t buf_len_;
   size_t offset_;
   InFlightIO* controller_;  // The controller that tracks all operations.
@@ skipping 281 matching lines @@
   return ret;
 }
 
 // Static.
 void File::WaitForPendingIO(int* num_pending_io) {
   if (*num_pending_io)
     Singleton<InFlightIO>::get()->WaitForPendingIO();
 }
 
 }  // namespace disk_cache