Clang format slam.

net/disk_cache/blockfile/in_flight_io.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 NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_IO_H_
 #define NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_IO_H_
 
 #include <set>
 
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 23 matching lines @@
   // Allows the cancellation of the task to notify the controller (step number 8
   // in the diagram below). In practice, if the controller waits for the
   // operation to finish it doesn't have to wait for the final task to be
   // processed by the message loop so calling this method prevents its delivery.
   // Note that this method is not intended to cancel the actual IO operation or
   // to prevent the first notification to take place (OnIOComplete).
   void Cancel();
 
   int result() { return result_; }
 
-  base::WaitableEvent* io_completed() {
-    return &io_completed_;
-  }
+  base::WaitableEvent* io_completed() { return &io_completed_; }
 
  protected:
   virtual ~BackgroundIO();
 
   // 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>;
 
   // An event to signal when the operation completes.
   base::WaitableEvent io_completed_;
-  InFlightIO* controller_;  // The controller that tracks all operations.
+  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 45 matching lines @@
   // be executed on a background thread. This method must be called on the same
   // thread used to create this object.
   void OnOperationPosted(BackgroundIO* operation);
 
  private:
   typedef std::set<scoped_refptr<BackgroundIO> > IOList;
 
   IOList io_list_;  // List of pending, in-flight io operations.
   scoped_refptr<base::MessageLoopProxy> callback_thread_;
 
-  bool running_;  // True after the first posted operation completes.
+  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_BLOCKFILE_IN_FLIGHT_IO_H_