Clang format slam.

net/disk_cache/blockfile/file_win.cc

Index: net/disk_cache/blockfile/file_win.cc
diff --git a/net/disk_cache/blockfile/file_win.cc b/net/disk_cache/blockfile/file_win.cc
index bf313128b4631d5bb517a9c54d8fa6657b957c7d..735aa73497e8b4960d775c4e29365180ecaccd53 100644
--- a/net/disk_cache/blockfile/file_win.cc
+++ b/net/disk_cache/blockfile/file_win.cc
@@ -14,12 +14,11 @@ namespace {
 
 // Structure used for asynchronous operations.
 struct MyOverlapped {
-  MyOverlapped(disk_cache::File* file, size_t offset,
+  MyOverlapped(disk_cache::File* file,
+               size_t offset,
                disk_cache::FileIOCallback* callback);
   ~MyOverlapped() {}
-  OVERLAPPED* overlapped() {
-    return &context_.overlapped;
-  }
+  OVERLAPPED* overlapped() { return &context_.overlapped; }
 
   base::MessageLoopForIO::IOContext context_;
   scoped_refptr<disk_cache::File> file_;
@@ -56,7 +55,8 @@ void CompletionHandler::OnIOCompleted(
   delete data;
 }
 
-MyOverlapped::MyOverlapped(disk_cache::File* file, size_t offset,
+MyOverlapped::MyOverlapped(disk_cache::File* file,
+                           size_t offset,
                            disk_cache::FileIOCallback* callback) {
   memset(this, 0, sizeof(*this));
   context_.handler = g_completion_handler.Pointer();
@@ -70,9 +70,7 @@ MyOverlapped::MyOverlapped(disk_cache::File* file, size_t offset,
 namespace disk_cache {
 
 File::File(base::File file)
-    : init_(true),
-      mixed_(true),
-      sync_base_file_(file.Pass()) {
+    : init_(true), mixed_(true), sync_base_file_(file.Pass()) {
 }
 
 bool File::Init(const base::FilePath& name) {
@@ -82,9 +80,13 @@ bool File::Init(const base::FilePath& name) {
 
   DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
   DWORD access = GENERIC_READ | GENERIC_WRITE | DELETE;
-  base_file_ =
-      base::File(CreateFile(name.value().c_str(), access, sharing, NULL,
-                            OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL));
+  base_file_ = base::File(CreateFile(name.value().c_str(),
+                                     access,
+                                     sharing,
+                                     NULL,
+                                     OPEN_EXISTING,
+                                     FILE_FLAG_OVERLAPPED,
+                                     NULL));
 
   if (!base_file_.IsValid())
     return false;
@@ -93,9 +95,8 @@ bool File::Init(const base::FilePath& name) {
       base_file_.GetPlatformFile(), g_completion_handler.Pointer());
 
   init_ = true;
-  sync_base_file_  =
-    base::File(CreateFile(name.value().c_str(), access, sharing, NULL,
-                          OPEN_EXISTING, 0, NULL));
+  sync_base_file_ = base::File(CreateFile(
+      name.value().c_str(), access, sharing, NULL, OPEN_EXISTING, 0, NULL));
 
   if (!sync_base_file_.IsValid())
     return false;
@@ -114,8 +115,8 @@ bool File::Read(void* buffer, size_t buffer_len, size_t offset) {
   if (buffer_len > ULONG_MAX || offset > LONG_MAX)
     return false;
 
-  int ret = sync_base_file_.Read(offset, static_cast<char*>(buffer),
-                                 buffer_len);
+  int ret =
+      sync_base_file_.Read(offset, static_cast<char*>(buffer), buffer_len);
   return static_cast<int>(buffer_len) == ret;
 }
 
@@ -124,16 +125,19 @@ bool File::Write(const void* buffer, size_t buffer_len, size_t offset) {
   if (buffer_len > ULONG_MAX || offset > ULONG_MAX)
     return false;
 
-  int ret = sync_base_file_.Write(offset, static_cast<const char*>(buffer),
-                                 buffer_len);
+  int ret = sync_base_file_.Write(
+      offset, static_cast<const char*>(buffer), buffer_len);
   return static_cast<int>(buffer_len) == ret;
 }
 
 // We have to increase the ref counter of the file before performing the IO to
 // prevent the completion to happen with an invalid handle (if the file is
 // closed while the IO is in flight).
-bool File::Read(void* buffer, size_t buffer_len, size_t offset,
-                FileIOCallback* callback, bool* completed) {
+bool File::Read(void* buffer,
+                size_t buffer_len,
+                size_t offset,
+                FileIOCallback* callback,
+                bool* completed) {
   DCHECK(init_);
   if (!callback) {
     if (completed)
@@ -148,7 +152,10 @@ bool File::Read(void* buffer, size_t buffer_len, size_t offset,
   DWORD size = static_cast<DWORD>(buffer_len);
 
   DWORD actual;
-  if (!ReadFile(base_file_.GetPlatformFile(), buffer, size, &actual,
+  if (!ReadFile(base_file_.GetPlatformFile(),
+                buffer,
+                size,
+                &actual,
                 data->overlapped())) {
     *completed = false;
     if (GetLastError() == ERROR_IO_PENDING)
@@ -165,8 +172,11 @@ bool File::Read(void* buffer, size_t buffer_len, size_t offset,
   return *completed;
 }
 
-bool File::Write(const void* buffer, size_t buffer_len, size_t offset,
-                 FileIOCallback* callback, bool* completed) {
+bool File::Write(const void* buffer,
+                 size_t buffer_len,
+                 size_t offset,
+                 FileIOCallback* callback,
+                 bool* completed) {
   DCHECK(init_);
   if (!callback) {
     if (completed)
@@ -182,12 +192,15 @@ File::~File() {
 
 base::PlatformFile File::platform_file() const {
   DCHECK(init_);
-  return base_file_.IsValid() ? base_file_.GetPlatformFile() :
-                                sync_base_file_.GetPlatformFile();
+  return base_file_.IsValid() ? base_file_.GetPlatformFile()
+                              : sync_base_file_.GetPlatformFile();
 }
 
-bool File::AsyncWrite(const void* buffer, size_t buffer_len, size_t offset,
-                      FileIOCallback* callback, bool* completed) {
+bool File::AsyncWrite(const void* buffer,
+                      size_t buffer_len,
+                      size_t offset,
+                      FileIOCallback* callback,
+                      bool* completed) {
   DCHECK(init_);
   DCHECK(callback);
   DCHECK(completed);
@@ -198,7 +211,10 @@ bool File::AsyncWrite(const void* buffer, size_t buffer_len, size_t offset,
   DWORD size = static_cast<DWORD>(buffer_len);
 
   DWORD actual;
-  if (!WriteFile(base_file_.GetPlatformFile(), buffer, size, &actual,
+  if (!WriteFile(base_file_.GetPlatformFile(),
+                 buffer,
+                 size,
+                 &actual,
                  data->overlapped())) {
     *completed = false;
     if (GetLastError() == ERROR_IO_PENDING)