Clang format slam.

net/disk_cache/simple/simple_synchronous_entry.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_SYNCHRONOUS_ENTRY_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
 
 #include <algorithm>
 #include <map>
 #include <string>
@@ skipping 110 matching lines @@
   static void CreateEntry(net::CacheType cache_type,
                           const base::FilePath& path,
                           const std::string& key,
                           uint64 entry_hash,
                           bool had_index,
                           SimpleEntryCreationResults* out_results);
 
   // Deletes an entry from the file system without affecting the state of the
   // corresponding instance, if any (allowing operations to continue to be
   // executed through that instance). Returns a net error code.
-  static int DoomEntry(const base::FilePath& path,
-                       uint64 entry_hash);
+  static int DoomEntry(const base::FilePath& path, uint64 entry_hash);
 
   // Like |DoomEntry()| above. Deletes all entries corresponding to the
   // |key_hashes|. Succeeds only when all entries are deleted. Returns a net
   // error code.
   static int DoomEntrySet(const std::vector<uint64>* key_hashes,
                           const base::FilePath& path);
 
   // N.B. ReadData(), WriteData(), CheckEOFRecord() and Close() may block on IO.
   void ReadData(const EntryOperationData& in_entry_op,
                 net::IOBuffer* out_buf,
@@ skipping 33 matching lines @@
 
  private:
   enum CreateEntryResult {
     CREATE_ENTRY_SUCCESS = 0,
     CREATE_ENTRY_PLATFORM_FILE_ERROR = 1,
     CREATE_ENTRY_CANT_WRITE_HEADER = 2,
     CREATE_ENTRY_CANT_WRITE_KEY = 3,
     CREATE_ENTRY_MAX = 4,
   };
 
-  enum FileRequired {
-    FILE_NOT_REQUIRED,
-    FILE_REQUIRED
-  };
+  enum FileRequired { FILE_NOT_REQUIRED, FILE_REQUIRED };
 
   struct SparseRange {
     int64 offset;
     int64 length;
     uint32 data_crc32;
     int64 file_offset;
 
     bool operator<(const SparseRange& other) const {
       return offset < other.offset;
     }
   };
 
-  SimpleSynchronousEntry(
-      net::CacheType cache_type,
-      const base::FilePath& path,
-      const std::string& key,
-      uint64 entry_hash);
+  SimpleSynchronousEntry(net::CacheType cache_type,
+                         const base::FilePath& path,
+                         const std::string& key,
+                         uint64 entry_hash);
 
   // Like Entry, the SimpleSynchronousEntry self releases when Close() is
   // called.
   ~SimpleSynchronousEntry();
 
   // Tries to open one of the cache entry files. Succeeds if the open succeeds
   // or if the file was not found and is allowed to be omitted if the
   // corresponding stream is empty.
-  bool MaybeOpenFile(int file_index,
-                     base::File::Error* out_error);
+  bool MaybeOpenFile(int file_index, base::File::Error* out_error);
   // Creates one of the cache entry files if necessary. If the file is allowed
   // to be omitted if the corresponding stream is empty, and if |file_required|
   // is FILE_NOT_REQUIRED, then the file is not created; otherwise, it is.
   bool MaybeCreateFile(int file_index,
                        FileRequired file_required,
                        base::File::Error* out_error);
-  bool OpenFiles(bool had_index,
-                 SimpleEntryStat* out_entry_stat);
-  bool CreateFiles(bool had_index,
-                   SimpleEntryStat* out_entry_stat);
+  bool OpenFiles(bool had_index, SimpleEntryStat* out_entry_stat);
+  bool CreateFiles(bool had_index, SimpleEntryStat* out_entry_stat);
   void CloseFile(int index);
   void CloseFiles();
 
   // Returns a net error, i.e. net::OK on success. |had_index| is passed
   // from the main entry for metrics purposes, and is true if the index was
   // initialized when the open operation began.
   int InitializeForOpen(bool had_index,
                         SimpleEntryStat* out_entry_stat,
                         scoped_refptr<net::GrowableIOBuffer>* stream_0_data,
                         uint32* out_stream_0_crc32);
@@ skipping 40 matching lines @@
   bool TruncateSparseFile();
 
   // Scans the existing ranges in the sparse file. Populates |sparse_ranges_|
   // and sets |*out_sparse_data_size| to the total size of all the ranges (not
   // including headers).
   bool ScanSparseFile(int32* out_sparse_data_size);
 
   // Reads from a single sparse range. If asked to read the entire range, also
   // verifies the CRC32.
   bool ReadSparseRange(const SparseRange* range,
-                       int offset, int len, char* buf);
+                       int offset,
+                       int len,
+                       char* buf);
 
   // Writes to a single (existing) sparse range. If asked to write the entire
   // range, also updates the CRC32; otherwise, invalidates it.
   bool WriteSparseRange(SparseRange* range,
-                        int offset, int len, const char* buf);
+                        int offset,
+                        int len,
+                        const char* buf);
 
   // Appends a new sparse range to the sparse data file.
   bool AppendSparseRange(int64 offset, int len, const char* buf);
 
   static bool DeleteFileForEntryHash(const base::FilePath& path,
                                      uint64 entry_hash,
                                      int file_index);
   static bool DeleteFilesForEntryHash(const base::FilePath& path,
                                       uint64 entry_hash);
 
   void RecordSyncCreateResult(CreateEntryResult result, bool had_index);
 
   base::FilePath GetFilenameFromFileIndex(int file_index);
 
-  bool sparse_file_open() const {
-    return sparse_file_.IsValid();
-  }
+  bool sparse_file_open() const { return sparse_file_.IsValid(); }
 
   const net::CacheType cache_type_;
   const base::FilePath path_;
   const uint64 entry_hash_;
   std::string key_;
 
   bool have_open_files_;
   bool initialized_;
 
   base::File files_[kSimpleEntryFileCount];
@@ skipping 11 matching lines @@
   int64 sparse_tail_offset_;
 
   // True if the entry was created, or false if it was opened. Used to log
   // SimpleCache.*.EntryCreatedWithStream2Omitted only for created entries.
   bool files_created_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_