Format and Refactor Flip Server.

net/tools/flip_server/ring_buffer.cc

 // Copyright (c) 2009 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/tools/flip_server/ring_buffer.h"
 #include "base/logging.h"
 
 namespace net {
 
 RingBuffer::RingBuffer(int buffer_size)
     : buffer_(new char[buffer_size]),
       buffer_size_(buffer_size),
       bytes_used_(0),
       read_idx_(0),
-      write_idx_(0) {
-}
+      write_idx_(0) {}
 
 RingBuffer::~RingBuffer() {}
 
-////////////////////////////////////////////////////////////////////////////////
+int RingBuffer::ReadableBytes() const { return bytes_used_; }
 
-int RingBuffer::ReadableBytes() const {
-  return bytes_used_;
-}
+int RingBuffer::BufferSize() const { return buffer_size_; }
 
-////////////////////////////////////////////////////////////////////////////////
+int RingBuffer::BytesFree() const { return BufferSize() - ReadableBytes(); }
 
-int RingBuffer::BufferSize() const {
-  return buffer_size_;
-}
+bool RingBuffer::Empty() const { return ReadableBytes() == 0; }
 
-////////////////////////////////////////////////////////////////////////////////
-
-int RingBuffer::BytesFree() const {
-  return BufferSize() - ReadableBytes();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-bool RingBuffer::Empty() const {
-  return ReadableBytes() == 0;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-bool RingBuffer::Full() const {
-  return ReadableBytes() == BufferSize();
-}
-
-////////////////////////////////////////////////////////////////////////////////
+bool RingBuffer::Full() const { return ReadableBytes() == BufferSize(); }
 
 // Returns the number of characters written.
 // Appends up-to-'size' bytes to the ringbuffer.
 int RingBuffer::Write(const char* bytes, int size) {
   CHECK_GE(size, 0);
 #if 1
   char* wptr;
   int wsize;
   GetWritablePtr(&wptr, &wsize);
   int bytes_remaining = size;
@@ skipping 26 matching lines @@
     ++this->write_idx_;
     if (this->write_idx_ >= this->buffer_size_) {
       this->write_idx_ = 0;
     }
   }
   bytes_used_ += bytes_to_write;
   return bytes_to_write;
 #endif
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 // Sets *ptr to the beginning of writable memory, and sets *size to the size
 // available for writing using this pointer.
 void RingBuffer::GetWritablePtr(char** ptr, int* size) const {
   *ptr = buffer_.get() + write_idx_;
 
   if (bytes_used_ == buffer_size_) {
     *size = 0;
   } else if (read_idx_ > write_idx_) {
     *size = read_idx_ - write_idx_;
   } else {
     *size = buffer_size_ - write_idx_;
   }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 // Sets *ptr to the beginning of readable memory, and sets *size to the size
 // available for reading using this pointer.
 void RingBuffer::GetReadablePtr(char** ptr, int* size) const {
   *ptr = buffer_.get() + read_idx_;
 
   if (bytes_used_ == 0) {
     *size = 0;
   } else if (write_idx_ > read_idx_) {
     *size = write_idx_ - read_idx_;
   } else {
     *size = buffer_size_ - read_idx_;
   }
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 // returns the number of bytes read into
 int RingBuffer::Read(char* bytes, int size) {
   CHECK_GE(size, 0);
 #if 1
   char* rptr;
   int rsize;
   GetReadablePtr(&rptr, &rsize);
   int bytes_remaining = size;
   int bytes_read = 0;
 
@@ skipping 23 matching lines @@
     ++this->read_idx_;
     if (this->read_idx_ >= this->buffer_size_) {
       this->read_idx_ = 0;
     }
   }
   this->bytes_used_ -= bytes_to_read;
   return bytes_to_read;
 #endif
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 void RingBuffer::Clear() {
   bytes_used_ = 0;
   write_idx_ = 0;
   read_idx_ = 0;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 bool RingBuffer::Reserve(int size) {
-  DCHECK(size > 0);
+  DCHECK_GT(size, 0);
   char* write_ptr = NULL;
   int write_size = 0;
   GetWritablePtr(&write_ptr, &write_size);
 
   if (write_size < size) {
     char* read_ptr = NULL;
     int read_size = 0;
     GetReadablePtr(&read_ptr, &read_size);
     if (size <= BytesFree()) {
       // The fact that the total Free size is big enough but writable size is
       // not means that the writeable region is broken into two pieces: only
       // possible if the read_idx < write_idx. If write_idx < read_idx, then
       // the writeable region must be contiguous: [write_idx, read_idx). There
       // is no work to be done for the latter.
-      DCHECK(read_idx_ <= write_idx_);
-      DCHECK(read_size == ReadableBytes());
+      DCHECK_LE(read_idx_, write_idx_);
+      DCHECK_EQ(read_size, ReadableBytes());
       if (read_idx_ < write_idx_) {
         // Writeable area fragmented, consolidate it.
         memmove(buffer_.get(), read_ptr, read_size);
         read_idx_ = 0;
         write_idx_ = read_size;
       } else if (read_idx_ == write_idx_) {
         // No unconsumed data in the buffer, simply reset the indexes.
-        DCHECK(ReadableBytes() == 0);
+        DCHECK_EQ(ReadableBytes(), 0);
         read_idx_ = 0;
         write_idx_ = 0;
       }
     } else {
       Resize(ReadableBytes() + size);
     }
   }
   DCHECK_LE(size, buffer_size_ - write_idx_);
   return true;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 void RingBuffer::AdvanceReadablePtr(int amount_to_consume) {
   CHECK_GE(amount_to_consume, 0);
   if (amount_to_consume >= bytes_used_) {
     Clear();
     return;
   }
   read_idx_ += amount_to_consume;
   read_idx_ %= buffer_size_;
   bytes_used_ -= amount_to_consume;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 void RingBuffer::AdvanceWritablePtr(int amount_to_produce) {
   CHECK_GE(amount_to_produce, 0);
   CHECK_LE(amount_to_produce, BytesFree());
   write_idx_ += amount_to_produce;
   write_idx_ %= buffer_size_;
   bytes_used_ += amount_to_produce;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 void RingBuffer::Resize(int buffer_size) {
   CHECK_GE(buffer_size, 0);
-  if (buffer_size == buffer_size_) return;
+  if (buffer_size == buffer_size_)
+    return;
 
   char* new_buffer = new char[buffer_size];
   if (buffer_size < bytes_used_) {
     // consume the oldest data.
     AdvanceReadablePtr(bytes_used_ - buffer_size);
   }
 
   int bytes_written = 0;
   int bytes_used = bytes_used_;
   while (true) {
     int size;
     char* ptr;
     GetReadablePtr(&ptr, &size);
-    if (size == 0) break;
+    if (size == 0)
+      break;
     if (size > buffer_size) {
       size = buffer_size;
     }
     memcpy(new_buffer + bytes_written, ptr, size);
     bytes_written += size;
     AdvanceReadablePtr(size);
   }
   buffer_.reset(new_buffer);
 
   buffer_size_ = buffer_size;
   bytes_used_ = bytes_used;
   read_idx_ = 0;
   write_idx_ = bytes_used_ % buffer_size_;
 }
 
 }  // namespace net
-