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

net/disk_cache/in_flight_io.h

-// Copyright (c) 2006-2010 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_IO_H_
 #define NET_DISK_CACHE_IN_FLIGHT_IO_H_
 #pragma once
 
 #include <set>
 
 #include "base/message_loop_proxy.h"
+#include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 
 namespace disk_cache {
 
 class InFlightIO;
 
 // This class represents a single asynchronous IO operation while it is being
 // bounced between threads.
 class BackgroundIO : public base::RefCountedThreadSafe<BackgroundIO> {
  public:
@@ skipping 19 matching lines @@
 
   int result() { return result_; }
 
   base::WaitableEvent* io_completed() {
     return &io_completed_;
   }
 
  protected:
   virtual ~BackgroundIO();
 
-  InFlightIO* controller_;  // The controller that tracks all operations.
+  // Notifies the controller about the end of the operation, from the background
+  // thread.
+  void NotifyController();
+
   int result_;  // Final operation result.
 
  private:
   friend class base::RefCountedThreadSafe<BackgroundIO>;
 
-  // Notifies the controller about the end of the operation, from the background
-  // thread.
-  void NotifyController();
-
   // An event to signal when the operation completes.
   base::WaitableEvent io_completed_;
+  InFlightIO* controller_;  // The controller that tracks all operations.
+  base::Lock controller_lock_;  // A lock protecting clearing of controller_.
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundIO);
 };
 
 // This class keeps track of asynchronous IO operations. A single instance
 // of this class is meant to be used to start an asynchronous operation (using
 // PostXX, exposed by a derived class). This class will post the operation to a
 // worker thread, hanlde the notification when the operation finishes and
 // perform the callback on the same thread that was used to start the operation.
 //
@@ skipping 15 matching lines @@
 // of just waiting for step 7.
 class InFlightIO {
  public:
   InFlightIO();
   virtual ~InFlightIO();
 
   // Blocks the current thread until all IO operations tracked by this object
   // complete.
   void WaitForPendingIO();
 
+  // Drops current pending operation without waiting for them to complete.
+  void DropPendingIO();
+
   // Called on a background thread when |operation| completes.
   void OnIOComplete(BackgroundIO* operation);
 
   // Invokes the users' completion callback at the end of the IO operation.
   // |cancel_task| is true if the actual task posted to the thread is still
   // queued (because we are inside WaitForPendingIO), and false if said task is
   // the one performing the call.
   void InvokeCallback(BackgroundIO* operation, bool cancel_task);
 
  protected:
@@ skipping 15 matching lines @@
 
   bool running_;  // True after the first posted operation completes.
   bool single_thread_;  // True if we only have one thread.
 
   DISALLOW_COPY_AND_ASSIGN(InFlightIO);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_IN_FLIGHT_IO_H_