Disk cache: Remove all non essential synchronization from the cache destructor.

net/disk_cache/sparse_control.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 NET_DISK_CACHE_SPARSE_CONTROL_H_
 #define NET_DISK_CACHE_SPARSE_CONTROL_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
@@ skipping 13 matching lines @@
 class Entry;
 class EntryImpl;
 
 // This class provides support for the sparse capabilities of the disk cache.
 // Basically, sparse IO is directed from EntryImpl to this class, and we split
 // the operation into multiple small pieces, sending each one to the
 // appropriate entry. An instance of this class is asociated with each entry
 // used directly for sparse operations (the entry passed in to the constructor).
 class SparseControl {
  public:
+  typedef net::CompletionCallback CompletionCallback;
+
   // The operation to perform.
   enum SparseOperation {
     kNoOperation,
     kReadOperation,
     kWriteOperation,
     kGetRangeOperation
   };
 
   explicit SparseControl(EntryImpl* entry);
   ~SparseControl();
 
   // Initializes the object for the current entry. If this entry already stores
   // sparse data, or can be used to do it, it updates the relevant information
   // on disk and returns net::OK. Otherwise it returns a net error code.
   int Init();
 
   // Performs a quick test to see if the entry is sparse or not, without
   // generating disk IO (so the answer provided is only a best effort).
   bool CouldBeSparse() const;
 
   // Performs an actual sparse read or write operation for this entry. |op| is
   // the operation to perform, |offset| is the desired sparse offset, |buf| and
   // |buf_len| specify the actual data to use and |callback| is the callback
   // to use for asynchronous operations. See the description of the Read /
   // WriteSparseData for details about the arguments. The return value is the
   // number of bytes read or written, or a net error code.
   int StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf,
-              int buf_len, const net::CompletionCallback& callback);
+              int buf_len, const CompletionCallback& callback);
 
   // Implements Entry::GetAvailableRange().
   int GetAvailableRange(int64 offset, int len, int64* start);
 
   // Cancels the current sparse operation (if any).
   void CancelIO();
 
   // Returns OK if the entry can be used for new IO or ERR_IO_PENDING if we are
   // busy. If the entry is busy, we'll invoke the callback when we are ready
   // again. See disk_cache::Entry::ReadyToUse() for more info.
-  int ReadyToUse(const net::CompletionCallback& completion_callback);
+  int ReadyToUse(const CompletionCallback& completion_callback);
 
   // Deletes the children entries of |entry|.
   static void DeleteChildren(EntryImpl* entry);
 
  private:
   // Creates a new sparse entry or opens an aready created entry from disk.
   // These methods just read / write the required info from disk for the current
   // entry, and verify that everything is correct. The return value is a net
   // error code.
   int CreateSparseEntry();
@@ skipping 68 matching lines @@
   bool finished_;
   bool init_;
   bool range_found_;  // True if GetAvailableRange found something.
   bool abort_;  // True if we should abort the current operation ASAP.
 
   SparseHeader sparse_header_;  // Data about the children of entry_.
   Bitmap children_map_;  // The actual bitmap of children.
   SparseData child_data_;  // Parent and allocation map of child_.
   Bitmap child_map_;  // The allocation map as a bitmap.
 
-  net::CompletionCallback user_callback_;
-  std::vector<net::CompletionCallback> abort_callbacks_;
+  CompletionCallback user_callback_;
+  std::vector<CompletionCallback> abort_callbacks_;
   int64 offset_;  // Current sparse offset.
   scoped_refptr<net::DrainableIOBuffer> user_buf_;
   int buf_len_;  // Bytes to read or write.
   int child_offset_;  // Offset to use for the current child.
   int child_len_;  // Bytes to read or write for this child.
   int result_;
 
   DISALLOW_COPY_AND_ASSIGN(SparseControl);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SPARSE_CONTROL_H_