Clang format slam.

net/disk_cache/blockfile/file_posix.cc

 // 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.
 
 #include "net/disk_cache/blockfile/file.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 17 matching lines @@
 };
 
 base::LazyInstance<FileWorkerPool>::Leaky s_worker_pool =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace disk_cache {
 
 File::File(base::File file)
-    : init_(true),
-      mixed_(true),
-      base_file_(file.Pass()) {
+    : init_(true), mixed_(true), base_file_(file.Pass()) {
 }
 
 bool File::Init(const base::FilePath& name) {
   if (base_file_.IsValid())
     return false;
 
-  int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
-              base::File::FLAG_WRITE;
+  int flags =
+      base::File::FLAG_OPEN | base::File::FLAG_READ | base::File::FLAG_WRITE;
   base_file_.Initialize(name, flags);
   return base_file_.IsValid();
 }
 
 bool File::IsValid() const {
   return base_file_.IsValid();
 }
 
 bool File::Read(void* buffer, size_t buffer_len, size_t offset) {
   DCHECK(base_file_.IsValid());
   if (buffer_len > static_cast<size_t>(kint32max) ||
       offset > static_cast<size_t>(kint32max)) {
     return false;
   }
 
   int ret = base_file_.Read(offset, static_cast<char*>(buffer), buffer_len);
   return (static_cast<size_t>(ret) == buffer_len);
 }
 
 bool File::Write(const void* buffer, size_t buffer_len, size_t offset) {
   DCHECK(base_file_.IsValid());
   if (buffer_len > static_cast<size_t>(kint32max) ||
       offset > static_cast<size_t>(kint32max)) {
     return false;
   }
 
-  int ret = base_file_.Write(offset, static_cast<const char*>(buffer),
-                             buffer_len);
+  int ret =
+      base_file_.Write(offset, static_cast<const char*>(buffer), buffer_len);
   return (static_cast<size_t>(ret) == buffer_len);
 }
 
-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(base_file_.IsValid());
   if (!callback) {
     if (completed)
       *completed = true;
     return Read(buffer, buffer_len, offset);
   }
 
   if (buffer_len > static_cast<size_t>(kint32max) ||
       offset > static_cast<size_t>(kint32max)) {
     return false;
   }
 
   base::PostTaskAndReplyWithResult(
-      s_worker_pool.Pointer(), FROM_HERE,
+      s_worker_pool.Pointer(),
+      FROM_HERE,
       base::Bind(&File::DoRead, this, buffer, buffer_len, offset),
       base::Bind(&File::OnOperationComplete, this, callback));
 
   *completed = false;
   return true;
 }
 
-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(base_file_.IsValid());
   if (!callback) {
     if (completed)
       *completed = true;
     return Write(buffer, buffer_len, offset);
   }
 
   if (buffer_len > static_cast<size_t>(kint32max) ||
       offset > static_cast<size_t>(kint32max)) {
     return false;
   }
 
   base::PostTaskAndReplyWithResult(
-      s_worker_pool.Pointer(), FROM_HERE,
+      s_worker_pool.Pointer(),
+      FROM_HERE,
       base::Bind(&File::DoWrite, this, buffer, buffer_len, offset),
       base::Bind(&File::OnOperationComplete, this, callback));
 
   *completed = false;
   return true;
 }
 
 bool File::SetLength(size_t length) {
   DCHECK(base_file_.IsValid());
   if (length > kuint32max)
@@ skipping 18 matching lines @@
   // worker pool only waits for tasks on the worker pool, not the "Reply" tasks
   // so we have to let the current message loop to run.
   s_worker_pool.Get().FlushForTesting();
   base::RunLoop().RunUntilIdle();
 }
 
 // Static.
 void File::DropPendingIO() {
 }
 
-
 File::~File() {
 }
 
 base::PlatformFile File::platform_file() const {
   return base_file_.GetPlatformFile();
 }
 
 // Runs on a worker thread.
 int File::DoRead(void* buffer, size_t buffer_len, size_t offset) {
   if (Read(const_cast<void*>(buffer), buffer_len, offset))
@@ skipping 10 matching lines @@
   return net::ERR_CACHE_WRITE_FAILURE;
 }
 
 // This method actually makes sure that the last reference to the file doesn't
 // go away on the worker pool.
 void File::OnOperationComplete(FileIOCallback* callback, int result) {
   callback->OnFileIOComplete(result);
 }
 
 }  // namespace disk_cache