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

net/disk_cache/in_flight_backend_io.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_IN_FLIGHT_BACKEND_IO_H_
 #define NET_DISK_CACHE_IN_FLIGHT_BACKEND_IO_H_
 #pragma once
 
 #include <list>
 #include <string>
 
@@ skipping 15 matching lines @@
  public:
   BackendIO(InFlightIO* controller, BackendImpl* backend,
             const net::CompletionCallback& callback);
 
   // Runs the actual operation on the background thread.
   void ExecuteOperation();
 
   // Callback implementation.
   void OnIOComplete(int result);
 
+  // Called when we are finishing this operation. If |cancel| is true, the user
+  // callback will not be invoked.
+  void OnDone(bool cancel);
+
   // Returns true if this operation is directed to an entry (vs. the backend).
   bool IsEntryOperation();
 
   net::CompletionCallback callback() const { return callback_; }
 
   // Grabs an extra reference of entry_.
   void ReferenceEntry();
 
-  // Returns the time that has passed since the operation was created.
-  base::TimeDelta ElapsedTime() const;
-
   // The operations we proxy:
   void Init();
   void OpenEntry(const std::string& key, Entry** entry);
   void CreateEntry(const std::string& key, Entry** entry);
   void DoomEntry(const std::string& key);
   void DoomAllEntries();
   void DoomEntriesBetween(const base::Time initial_time,
                           const base::Time end_time);
   void DoomEntriesSince(const base::Time initial_time);
   void OpenNextEntry(void** iter, Entry** next_entry);
@@ skipping 44 matching lines @@
     OP_WRITE,
     OP_READ_SPARSE,
     OP_WRITE_SPARSE,
     OP_GET_RANGE,
     OP_CANCEL_IO,
     OP_IS_READY
   };
 
   virtual ~BackendIO();
 
+  // Returns true if this operation returns an entry.
+  bool ReturnsEntry();
+
+  // Returns the time that has passed since the operation was created.
+  base::TimeDelta ElapsedTime() const;
+
   void ExecuteBackendOperation();
   void ExecuteEntryOperation();
 
   BackendImpl* backend_;
   net::CompletionCallback callback_;
   Operation operation_;
 
   // The arguments of all the operations we proxy:
   std::string key_;
   Entry** entry_ptr_;
@@ skipping 67 matching lines @@
 
   scoped_refptr<base::MessageLoopProxy> background_thread() {
     return background_thread_;
   }
 
   // Returns true if the current thread is the background thread.
   bool BackgroundIsCurrentThread() {
     return background_thread_->BelongsToCurrentThread();
   }
 
+  base::WeakPtr<InFlightBackendIO> GetWeakPtr();
+
  protected:
   virtual void OnOperationComplete(BackgroundIO* operation,
                                    bool cancel) OVERRIDE;
 
  private:
   void PostOperation(BackendIO* operation);
 
   BackendImpl* backend_;
   scoped_refptr<base::MessageLoopProxy> background_thread_;
+  base::WeakPtrFactory<InFlightBackendIO> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InFlightBackendIO);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_IN_FLIGHT_BACKEND_IO_H_