Clang format slam.

net/disk_cache/simple/simple_backend_impl.h

 // Copyright (c) 2013 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_SIMPLE_SIMPLE_BACKEND_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_
 
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 14 matching lines @@
 
 namespace base {
 class SingleThreadTaskRunner;
 class TaskRunner;
 }
 
 namespace disk_cache {
 
 // SimpleBackendImpl is a new cache backend that stores entries in individual
 // files.
-// See http://www.chromium.org/developers/design-documents/network-stack/disk-cache/very-simple-backend
+// See
+// http://www.chromium.org/developers/design-documents/network-stack/disk-cache/very-simple-backend
 //
 // The non-static functions below must be called on the IO thread unless
 // otherwise stated.
 
 class SimpleEntryImpl;
 class SimpleIndex;
 
-class NET_EXPORT_PRIVATE SimpleBackendImpl : public Backend,
-    public SimpleIndexDelegate,
-    public base::SupportsWeakPtr<SimpleBackendImpl> {
+class NET_EXPORT_PRIVATE SimpleBackendImpl
+    : public Backend,
+      public SimpleIndexDelegate,
+      public base::SupportsWeakPtr<SimpleBackendImpl> {
  public:
-  SimpleBackendImpl(const base::FilePath& path, int max_bytes,
+  SimpleBackendImpl(const base::FilePath& path,
+                    int max_bytes,
                     net::CacheType cache_type,
                     base::SingleThreadTaskRunner* cache_thread,
                     net::NetLog* net_log);
 
   virtual ~SimpleBackendImpl();
 
   net::CacheType cache_type() const { return cache_type_; }
   SimpleIndex* index() { return index_.get(); }
 
   base::TaskRunner* worker_pool() { return worker_pool_.get(); }
@@ skipping 22 matching lines @@
   // doom completed.
   void OnDoomComplete(uint64 entry_hash);
 
   // SimpleIndexDelegate:
   virtual void DoomEntries(std::vector<uint64>* entry_hashes,
                            const CompletionCallback& callback) OVERRIDE;
 
   // Backend:
   virtual net::CacheType GetCacheType() const OVERRIDE;
   virtual int32 GetEntryCount() const OVERRIDE;
-  virtual int OpenEntry(const std::string& key, Entry** entry,
+  virtual int OpenEntry(const std::string& key,
+                        Entry** entry,
                         const CompletionCallback& callback) OVERRIDE;
-  virtual int CreateEntry(const std::string& key, Entry** entry,
+  virtual int CreateEntry(const std::string& key,
+                          Entry** entry,
                           const CompletionCallback& callback) OVERRIDE;
   virtual int DoomEntry(const std::string& key,
                         const CompletionCallback& callback) OVERRIDE;
   virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
   virtual int DoomEntriesBetween(base::Time initial_time,
                                  base::Time end_time,
                                  const CompletionCallback& callback) OVERRIDE;
   virtual int DoomEntriesSince(base::Time initial_time,
                                const CompletionCallback& callback) OVERRIDE;
-  virtual int OpenNextEntry(void** iter, Entry** next_entry,
+  virtual int OpenNextEntry(void** iter,
+                            Entry** next_entry,
                             const CompletionCallback& callback) OVERRIDE;
   virtual void EndEnumeration(void** iter) OVERRIDE;
   virtual void GetStats(
       std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE;
   virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
 
  private:
   typedef base::hash_map<uint64, base::WeakPtr<SimpleEntryImpl> > EntryMap;
 
   typedef base::Callback<void(base::Time mtime, uint64 max_size, int result)>
@@ skipping 32 matching lines @@
   // corresponding to |hash| in the map of active entries, opens it. Otherwise,
   // a new empty Entry will be created, opened and filled with information from
   // the disk.
   int OpenEntryFromHash(uint64 entry_hash,
                         Entry** entry,
                         const CompletionCallback& callback);
 
   // Doom the entry corresponding to |entry_hash|, if it's active or currently
   // pending doom. This function does not block if there is an active entry,
   // which is very important to prevent races in DoomEntries() above.
-  int DoomEntryFromHash(uint64 entry_hash, const CompletionCallback & callback);
+  int DoomEntryFromHash(uint64 entry_hash, const CompletionCallback& callback);
 
   // Called when the index is initilized to find the next entry in the iterator
   // |iter|. If there are no more hashes in the iterator list, net::ERR_FAILED
   // is returned. Otherwise, calls OpenEntryFromHash.
   void GetNextEntryInIterator(void** iter,
                               Entry** next_entry,
                               const CompletionCallback& callback,
                               int error_code);
 
   // Called when we tried to open an entry with hash alone. When a blank entry
@@ skipping 44 matching lines @@
   // is complete. The base::Closure map target is used to store deferred
   // operations to be run at the completion of the Doom.
   base::hash_map<uint64, std::vector<base::Closure> > entries_pending_doom_;
 
   net::NetLog* const net_log_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_