Clang format slam.

net/websockets/websocket_inflater.cc

 // Copyright 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.
 
 #include "net/websockets/websocket_inflater.h"
 
 #include <algorithm>
 #include <deque>
 #include <vector>
 
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "third_party/zlib/zlib.h"
 
 namespace net {
 
 namespace {
 
 class ShrinkableIOBufferWithSize : public IOBufferWithSize {
  public:
-  explicit ShrinkableIOBufferWithSize(int size)
-      : IOBufferWithSize(size) {}
+  explicit ShrinkableIOBufferWithSize(int size) : IOBufferWithSize(size) {}
 
   void Shrink(int new_size) {
     DCHECK_LE(new_size, size_);
     size_ = new_size;
   }
 
  private:
   virtual ~ShrinkableIOBufferWithSize() {}
 };
 
 }  // namespace
 
 WebSocketInflater::WebSocketInflater()
     : input_queue_(kDefaultInputIOBufferCapacity),
-      output_buffer_(kDefaultBufferCapacity) {}
+      output_buffer_(kDefaultBufferCapacity) {
+}
 
 WebSocketInflater::WebSocketInflater(size_t input_queue_capacity,
                                      size_t output_buffer_capacity)
     : input_queue_(input_queue_capacity),
       output_buffer_(output_buffer_capacity) {
   DCHECK_GT(input_queue_capacity, 0u);
   DCHECK_GT(output_buffer_capacity, 0u);
 }
 
 bool WebSocketInflater::Initialize(int window_bits) {
@@ skipping 115 matching lines @@
       break;
     }
   }
   return result;
 }
 
 WebSocketInflater::OutputBuffer::OutputBuffer(size_t capacity)
     : capacity_(capacity),
       buffer_(capacity_ + 1),  // 1 for sentinel
       head_(0),
-      tail_(0) {}
+      tail_(0) {
+}
 
-WebSocketInflater::OutputBuffer::~OutputBuffer() {}
+WebSocketInflater::OutputBuffer::~OutputBuffer() {
+}
 
 size_t WebSocketInflater::OutputBuffer::Size() const {
   return (tail_ + buffer_.size() - head_) % buffer_.size();
 }
 
 std::pair<char*, size_t> WebSocketInflater::OutputBuffer::GetTail() {
   DCHECK_LT(tail_, buffer_.size());
   return std::make_pair(&buffer_[tail_],
                         std::min(capacity_ - Size(), buffer_.size() - tail_));
 }
@@ skipping 27 matching lines @@
   DCHECK_LE(advance, Size());
   head_ = (head_ + advance) % buffer_.size();
 }
 
 void WebSocketInflater::OutputBuffer::AdvanceTail(size_t advance) {
   DCHECK_LE(advance + Size(), capacity_);
   tail_ = (tail_ + advance) % buffer_.size();
 }
 
 WebSocketInflater::InputQueue::InputQueue(size_t capacity)
-    : capacity_(capacity), head_of_first_buffer_(0), tail_of_last_buffer_(0) {}
+    : capacity_(capacity), head_of_first_buffer_(0), tail_of_last_buffer_(0) {
+}
 
-WebSocketInflater::InputQueue::~InputQueue() {}
+WebSocketInflater::InputQueue::~InputQueue() {
+}
 
 std::pair<char*, size_t> WebSocketInflater::InputQueue::Top() {
   DCHECK(!IsEmpty());
   if (buffers_.size() == 1) {
     return std::make_pair(&buffers_.front()->data()[head_of_first_buffer_],
                           tail_of_last_buffer_ - head_of_first_buffer_);
   }
   return std::make_pair(&buffers_.front()->data()[head_of_first_buffer_],
                         capacity_ - head_of_first_buffer_);
 }
@@ skipping 38 matching lines @@
   size_t num_bytes_to_copy = std::min(size, capacity_ - tail_of_last_buffer_);
   if (!num_bytes_to_copy)
     return 0;
   IOBufferWithSize* buffer = buffers_.back().get();
   memcpy(&buffer->data()[tail_of_last_buffer_], data, num_bytes_to_copy);
   tail_of_last_buffer_ += num_bytes_to_copy;
   return num_bytes_to_copy;
 }
 
 }  // namespace net