Clang format slam.

net/tools/balsa/simple_buffer.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/tools/balsa/simple_buffer.h"
 #include "base/logging.h"
 
 // Some of the following member functions are marked inlined, even though they
 // are virtual. This may seem counter-intuitive, since virtual functions are
 // generally not eligible for inlining. Profiling results indicate that these
 // large amount of runtime is spent on virtual function dispatch on these
 // simple functions. They are virtual because of the interface this class
 // inherits from. However, it is very unlikely that anyone will sub-class
 // SimpleBuffer and change their implementation. To get rid of this baggage,
 // internal implementation (e.g., Write) explicitly use SimpleBuffer:: to
 // qualify the method calls, thus disabling the virtual dispatch and enable
 // inlining.
 
 namespace net {
 
 static const int kInitialSimpleBufferSize = 10;
 
 SimpleBuffer::SimpleBuffer()
-  : storage_(new char[kInitialSimpleBufferSize]),
-    write_idx_(0),
-    read_idx_(0),
-    storage_size_(kInitialSimpleBufferSize) {
+    : storage_(new char[kInitialSimpleBufferSize]),
+      write_idx_(0),
+      read_idx_(0),
+      storage_size_(kInitialSimpleBufferSize) {
 }
 
 SimpleBuffer::SimpleBuffer(int size)
-  : write_idx_(0),
-    read_idx_(0),
-    storage_size_(size) {
+    : write_idx_(0), read_idx_(0), storage_size_(size) {
   // Callers may try to allocate overly large blocks, but negative sizes are
   // obviously wrong.
   CHECK_GE(size, 0);
   storage_ = new char[size];
 }
 
 SimpleBuffer::~SimpleBuffer() {
   delete[] storage_;
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 
 int SimpleBuffer::ReadableBytes() const {
   return write_idx_ - read_idx_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 std::string SimpleBuffer::str() const {
   std::string s;
-  char * readable_ptr;
+  char* readable_ptr;
   int readable_size;
   GetReadablePtr(&readable_ptr, &readable_size);
   s.append(readable_ptr, readable_ptr + readable_size);
   return s;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 int SimpleBuffer::BufferSize() const {
   return storage_size_;
@@ skipping 29 matching lines @@
   memcpy(storage_ + write_idx_, bytes, size);
   SimpleBuffer::AdvanceWritablePtr(size);
   return size;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // stores a pointer into the simple buffer in *ptr,
 // and stores the number of characters which are allowed
 // to be written in *size.
-inline void SimpleBuffer::GetWritablePtr(char **ptr, int* size) const {
+inline void SimpleBuffer::GetWritablePtr(char** ptr, int* size) const {
   *ptr = storage_ + write_idx_;
   *size = SimpleBuffer::BytesFree();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // stores a pointer into the simple buffer in *ptr,
 // and stores the number of characters which are allowed
 // to be read in *size.
-void SimpleBuffer::GetReadablePtr(char **ptr, int* size) const {
+void SimpleBuffer::GetReadablePtr(char** ptr, int* size) const {
   *ptr = storage_ + read_idx_;
   *size = write_idx_ - read_idx_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // returns the number of bytes read into 'bytes'
 int SimpleBuffer::Read(char* bytes, int size) {
-  char * read_ptr = NULL;
+  char* read_ptr = NULL;
   int read_size = 0;
   GetReadablePtr(&read_ptr, &read_size);
   if (read_size > size) {
     read_size = size;
   }
   memcpy(bytes, read_ptr, read_size);
   AdvanceReadablePtr(read_size);
   return read_size;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // removes all data from the simple buffer
 void SimpleBuffer::Clear() {
   read_idx_ = write_idx_ = 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Attempts to reserve a contiguous block of buffer space by either reclaiming
 // old data that is already read, and reallocate large storage as needed.
 bool SimpleBuffer::Reserve(int size) {
   if (size > 0 && BytesFree() < size) {
-    char * read_ptr = NULL;
+    char* read_ptr = NULL;
     int read_size = 0;
     GetReadablePtr(&read_ptr, &read_size);
 
     if (read_size + size <= BufferSize()) {
       // Can reclaim space from already read bytes by shifting
       memmove(storage_, read_ptr, read_size);
       read_idx_ = 0;
       write_idx_ = read_size;
       CHECK_GE(BytesFree(), size);
     } else {
@@ skipping 40 matching lines @@
 // amount of data specified here is expected to
 // already be resident (as if it was Written)
 inline void SimpleBuffer::AdvanceWritablePtr(int amount_to_advance) {
   write_idx_ += amount_to_advance;
   if (write_idx_ > storage_size_) {
     write_idx_ = storage_size_;
   }
 }
 
 }  // namespace net