Clang format slam.

net/socket/buffered_write_stream_socket.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/socket/buffered_write_stream_socket.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/io_buffer.h"
@@ skipping 18 matching lines @@
       backup_buffer_(new GrowableIOBuffer()),
       callback_pending_(false),
       wrapped_write_in_progress_(false),
       error_(0),
       weak_factory_(this) {
 }
 
 BufferedWriteStreamSocket::~BufferedWriteStreamSocket() {
 }
 
-int BufferedWriteStreamSocket::Read(IOBuffer* buf, int buf_len,
+int BufferedWriteStreamSocket::Read(IOBuffer* buf,
+                                    int buf_len,
                                     const CompletionCallback& callback) {
   return wrapped_socket_->Read(buf, buf_len, callback);
 }
 
-int BufferedWriteStreamSocket::Write(IOBuffer* buf, int buf_len,
+int BufferedWriteStreamSocket::Write(IOBuffer* buf,
+                                     int buf_len,
                                      const CompletionCallback& callback) {
   if (error_) {
     return error_;
   }
   GrowableIOBuffer* idle_buffer =
       wrapped_write_in_progress_ ? backup_buffer_.get() : io_buffer_.get();
   AppendBuffer(idle_buffer, buf, buf_len);
   if (!callback_pending_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
@@ skipping 79 matching lines @@
     wrapped_write_in_progress_ = true;
   } else {
     OnIOComplete(result);
   }
 }
 
 void BufferedWriteStreamSocket::OnIOComplete(int result) {
   callback_pending_ = false;
   wrapped_write_in_progress_ = false;
   if (backup_buffer_->RemainingCapacity()) {
-    AppendBuffer(io_buffer_.get(), backup_buffer_.get(),
+    AppendBuffer(io_buffer_.get(),
+                 backup_buffer_.get(),
                  backup_buffer_->RemainingCapacity());
     backup_buffer_->SetCapacity(0);
   }
   if (result < 0) {
     error_ = result;
     io_buffer_->SetCapacity(0);
   } else {
     io_buffer_->set_offset(io_buffer_->offset() + result);
     if (io_buffer_->RemainingCapacity()) {
       DoDelayedWrite();
     } else {
       io_buffer_->SetCapacity(0);
     }
   }
 }
 
 }  // namespace net