Clang format slam.

net/tools/balsa/balsa_headers.h

 // 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.
 
 #ifndef NET_TOOLS_BALSA_BALSA_HEADERS_H_
 #define NET_TOOLS_BALSA_BALSA_HEADERS_H_
 
 #include <algorithm>
 #include <iosfwd>
 #include <iterator>
@@ skipping 58 matching lines @@
   // The BufferBlock is a structure used internally by the
   // BalsaBuffer class to store the base buffer pointers to
   // each block, as well as the important metadata for buffer
   // sizes and bytes free.
   struct BufferBlock {
    public:
     char* buffer;
     size_t buffer_size;
     size_t bytes_free;
 
-    size_t bytes_used() const {
-      return buffer_size - bytes_free;
-    }
-    char* start_of_unused_bytes() const {
-      return buffer + bytes_used();
-    }
+    size_t bytes_used() const { return buffer_size - bytes_free; }
+    char* start_of_unused_bytes() const { return buffer + bytes_used(); }
 
     BufferBlock() : buffer(NULL), buffer_size(0), bytes_free(0) {}
     ~BufferBlock() {}
 
-    BufferBlock(char* buf, size_t size, size_t free) :
-        buffer(buf), buffer_size(size), bytes_free(free) {}
+    BufferBlock(char* buf, size_t size, size_t free)
+        : buffer(buf), buffer_size(size), bytes_free(free) {}
     // Yes we want this to be copyable (it gets stuck into vectors).
     // For this reason, we don't use scoped ptrs, etc. here-- it
     // is more efficient to manage this memory externally to this
     // object.
   };
 
   typedef std::vector<BufferBlock> Blocks;
 
   ~BalsaBuffer();
 
   // Returns the total amount of memory used by the buffer blocks.
   size_t GetTotalBufferBlockSize() const;
 
   const char* GetPtr(Blocks::size_type block_idx) const {
-    DCHECK_LT(block_idx, blocks_.size())
-      << block_idx << ", " << blocks_.size();
+    DCHECK_LT(block_idx, blocks_.size()) << block_idx << ", " << blocks_.size();
     return blocks_[block_idx].buffer;
   }
 
   char* GetPtr(Blocks::size_type block_idx) {
-    DCHECK_LT(block_idx, blocks_.size())
-      << block_idx << ", " << blocks_.size();
+    DCHECK_LT(block_idx, blocks_.size()) << block_idx << ", " << blocks_.size();
     return blocks_[block_idx].buffer;
   }
 
   // This function is different from Write(), as it ensures that the data
   // stored via subsequent calls to this function are all contiguous (and in
   // the order in which these writes happened). This is essentially the same
   // as a string append.
   //
   // You may call this function at any time between object
   // construction/Clear(), and the calling of the
@@ skipping 32 matching lines @@
   // NoMoreWriteToContiguousBuffer function has been called since the last
   // Clear/Construction.
   char* Reserve(size_t size, Blocks::size_type* block_buffer_idx);
 
   void Clear();
 
   void Swap(BalsaBuffer* b);
 
   void CopyFrom(const BalsaBuffer& b);
 
-  const char* StartOfFirstBlock() const {
-    return blocks_[0].buffer;
-  }
+  const char* StartOfFirstBlock() const { return blocks_[0].buffer; }
 
   const char* EndOfFirstBlock() const {
     return blocks_[0].buffer + blocks_[0].bytes_used();
   }
 
   bool can_write_to_contiguous_buffer() const {
     return can_write_to_contiguous_buffer_;
   }
   size_t blocksize() const { return blocksize_; }
   Blocks::size_type num_blocks() const { return blocks_.size(); }
@@ skipping 62 matching lines @@
 //  erased() or modified should be valid until the object is cleared or
 //  destroyed.
 
 class BalsaHeaders {
  public:
   struct HeaderLineDescription {
     HeaderLineDescription(size_t first_character_index,
                           size_t key_end_index,
                           size_t value_begin_index,
                           size_t last_character_index,
-                          size_t buffer_base_index) :
-        first_char_idx(first_character_index),
-        key_end_idx(key_end_index),
-        value_begin_idx(value_begin_index),
-        last_char_idx(last_character_index),
-        buffer_base_idx(buffer_base_index),
-        skip(false) {}
+                          size_t buffer_base_index)
+        : first_char_idx(first_character_index),
+          key_end_idx(key_end_index),
+          value_begin_idx(value_begin_index),
+          last_char_idx(last_character_index),
+          buffer_base_idx(buffer_base_index),
+          skip(false) {}
 
-    HeaderLineDescription() :
-        first_char_idx(0),
-        key_end_idx(0),
-        value_begin_idx(0),
-        last_char_idx(0),
-        buffer_base_idx(0),
-        skip(false) {}
+    HeaderLineDescription()
+        : first_char_idx(0),
+          key_end_idx(0),
+          value_begin_idx(0),
+          last_char_idx(0),
+          buffer_base_idx(0),
+          skip(false) {}
 
     size_t first_char_idx;
     size_t key_end_idx;
     size_t value_begin_idx;
     size_t last_char_idx;
     BalsaBuffer::Blocks::size_type buffer_base_idx;
     bool skip;
   };
 
   typedef std::vector<base::StringPiece> HeaderTokenList;
@@ skipping 30 matching lines @@
     typedef ptrdiff_t difference_type;
 
     typedef iterator_base self;
 
     // default constructor.
     iterator_base();
 
     // copy constructor.
     iterator_base(const iterator_base& it);
 
-    reference operator*() const {
-      return Lookup(idx_);
-    }
+    reference operator*() const { return Lookup(idx_); }
 
-    pointer operator->() const {
-      return &(this->operator*());
-    }
+    pointer operator->() const { return &(this->operator*()); }
 
-    bool operator==(const self& it) const {
-      return idx_ == it.idx_;
-    }
+    bool operator==(const self& it) const { return idx_ == it.idx_; }
 
-    bool operator<(const self& it) const {
-      return idx_ < it.idx_;
-    }
+    bool operator<(const self& it) const { return idx_ < it.idx_; }
 
-    bool operator<=(const self& it) const {
-      return idx_ <= it.idx_;
-    }
+    bool operator<=(const self& it) const { return idx_ <= it.idx_; }
 
-    bool operator!=(const self& it) const {
-      return !(*this == it);
-    }
+    bool operator!=(const self& it) const { return !(*this == it); }
 
-    bool operator>(const self& it) const {
-      return it < *this;
-    }
+    bool operator>(const self& it) const { return it < *this; }
 
-    bool operator>=(const self& it) const {
-      return it <= *this;
-    }
+    bool operator>=(const self& it) const { return it <= *this; }
 
     // This mainly exists so that we can have interesting output for
     // unittesting. The EXPECT_EQ, EXPECT_NE functions require that
     // operator<< work for the classes it sees.  It would be better if there
     // was an additional traits-like system for the gUnit output... but oh
     // well.
     std::ostream& operator<<(std::ostream& os) const;
 
    protected:
     iterator_base(const BalsaHeaders* headers, HeaderLines::size_type index);
@@ skipping 33 matching lines @@
         idx_ = original_idx - 1;
       }
     }
 
     reference Lookup(HeaderLines::size_type index) const {
       DCHECK_LT(index, headers_->header_lines_.size());
       const HeaderLineDescription& line = headers_->header_lines_[index];
       const char* stream_begin = headers_->GetPtr(line.buffer_base_idx);
       value_ = value_type(
           base::StringPiece(stream_begin + line.first_char_idx,
-                      line.key_end_idx - line.first_char_idx),
+                            line.key_end_idx - line.first_char_idx),
           base::StringPiece(stream_begin + line.value_begin_idx,
-                      line.last_char_idx - line.value_begin_idx));
+                            line.last_char_idx - line.value_begin_idx));
       DCHECK_GE(line.key_end_idx, line.first_char_idx);
       DCHECK_GE(line.last_char_idx, line.value_begin_idx);
       return value_;
     }
 
     const BalsaHeaders* headers_;
     HeaderLines::size_type idx_;
     mutable StringPiecePair value_;
   };
 
   class reverse_iterator_base : public iterator_base {
    public:
     typedef reverse_iterator_base self;
     typedef iterator_base::reference reference;
     typedef iterator_base::pointer pointer;
     using iterator_base::headers_;
     using iterator_base::idx_;
 
     reverse_iterator_base() : iterator_base() {}
 
     // This constructor is no explicit purposely.
-    reverse_iterator_base(const iterator_base& it) :  // NOLINT
-        iterator_base(it) {
-    }
+    reverse_iterator_base(const iterator_base& it)
+        :  // NOLINT
+          iterator_base(it) {}
 
     self& operator=(const iterator_base& it) {
       idx_ = it.idx_;
       headers_ = it.headers_;
       return *this;
     }
 
     self& operator=(const reverse_iterator_base& it) {
       idx_ = it.idx_;
       headers_ = it.headers_;
       return *this;
     }
 
-    reference operator*() const {
-      return Lookup(idx_ - 1);
-    }
+    reference operator*() const { return Lookup(idx_ - 1); }
 
-    pointer operator->() const {
-      return &(this->operator*());
-    }
+    pointer operator->() const { return &(this->operator*()); }
 
-    reverse_iterator_base(const reverse_iterator_base& it) :
-        iterator_base(it) { }
+    reverse_iterator_base(const reverse_iterator_base& it)
+        : iterator_base(it) {}
 
    protected:
     void increment() {
       --idx_;
       iterator_base::decrement();
       ++idx_;
     }
 
     void decrement() {
       ++idx_;
       iterator_base::increment();
       --idx_;
     }
 
     reverse_iterator_base(const BalsaHeaders* headers,
-                          HeaderLines::size_type index) :
-        iterator_base(headers, index) {}
+                          HeaderLines::size_type index)
+        : iterator_base(headers, index) {}
   };
 
  public:
   class const_header_lines_iterator : public iterator_base {
     friend class BalsaHeaders;
+
    public:
     typedef const_header_lines_iterator self;
     const_header_lines_iterator() : iterator_base() {}
 
-    const_header_lines_iterator(const const_header_lines_iterator& it) :
-        iterator_base(it.headers_, it.idx_) {}
+    const_header_lines_iterator(const const_header_lines_iterator& it)
+        : iterator_base(it.headers_, it.idx_) {}
 
     self& operator++() {
       iterator_base::increment();
       return *this;
     }
 
     self& operator--() {
       iterator_base::decrement();
       return *this;
     }
+
    protected:
     const_header_lines_iterator(const BalsaHeaders* headers,
-                                HeaderLines::size_type index) :
-        iterator_base(headers, index) {}
+                                HeaderLines::size_type index)
+        : iterator_base(headers, index) {}
   };
 
   class const_reverse_header_lines_iterator : public reverse_iterator_base {
    public:
     typedef const_reverse_header_lines_iterator self;
     const_reverse_header_lines_iterator() : reverse_iterator_base() {}
 
-    const_reverse_header_lines_iterator(
-      const const_header_lines_iterator& it) :
-        reverse_iterator_base(it.headers_, it.idx_) {}
+    const_reverse_header_lines_iterator(const const_header_lines_iterator& it)
+        : reverse_iterator_base(it.headers_, it.idx_) {}
 
     const_reverse_header_lines_iterator(
-      const const_reverse_header_lines_iterator& it) :
-        reverse_iterator_base(it.headers_, it.idx_) {}
+        const const_reverse_header_lines_iterator& it)
+        : reverse_iterator_base(it.headers_, it.idx_) {}
 
     const_header_lines_iterator base() {
       return const_header_lines_iterator(headers_, idx_);
     }
 
     self& operator++() {
       reverse_iterator_base::increment();
       return *this;
     }
 
     self& operator--() {
       reverse_iterator_base::decrement();
       return *this;
     }
+
    protected:
     const_reverse_header_lines_iterator(const BalsaHeaders* headers,
-                                        HeaderLines::size_type index) :
-        reverse_iterator_base(headers, index) {}
+                                        HeaderLines::size_type index)
+        : reverse_iterator_base(headers, index) {}
 
     friend class BalsaHeaders;
   };
 
   // An iterator that only stops at lines with a particular key.
   // See also GetIteratorForKey.
   //
   // Check against header_lines_key_end() to determine when iteration is
   // finished. header_lines_end() will also work.
   class const_header_lines_key_iterator : public iterator_base {
     friend class BalsaHeaders;
+
    public:
     typedef const_header_lines_key_iterator self;
     const_header_lines_key_iterator(const const_header_lines_key_iterator&);
 
     self& operator++() {
       do {
         iterator_base::increment();
       } while (!AtEnd() &&
                !StringPieceUtils::EqualIgnoreCase(key_, (**this).first));
       return *this;
     }
 
-    void operator++(int ignore) {
-      ++(*this);
-    }
+    void operator++(int ignore) { ++(*this); }
 
     // Only forward-iteration makes sense, so no operator-- defined.
 
    private:
     const_header_lines_key_iterator(const BalsaHeaders* headers,
                                     HeaderLines::size_type index,
                                     const base::StringPiece& key);
 
     // Should only be used for creating an end iterator.
     const_header_lines_key_iterator(const BalsaHeaders* headers,
                                     HeaderLines::size_type index);
 
-    bool AtEnd() const {
-      return *this >= headers_->header_lines_end();
-    }
+    bool AtEnd() const { return *this >= headers_->header_lines_end(); }
 
     base::StringPiece key_;
   };
 
   // TODO(fenix): Revisit the amount of bytes initially allocated to the second
   // block of the balsa_buffer_. It may make sense to pre-allocate some amount
   // (roughly the amount we'd append in new headers such as X-User-Ip, etc.)
   BalsaHeaders();
   ~BalsaHeaders();
 
@@ skipping 209 matching lines @@
     const HeaderLines::size_type end = header_lines_.size();
     for (HeaderLines::size_type i = 0; i < end; ++i) {
       const HeaderLineDescription& line = header_lines_[i];
       if (line.skip) {
         continue;
       }
       const char* line_ptr = GetPtr(line.buffer_base_idx);
       WriteHeaderLineToBuffer(
           buffer,
           base::StringPiece(line_ptr + line.first_char_idx,
-                      line.key_end_idx - line.first_char_idx),
+                            line.key_end_idx - line.first_char_idx),
           base::StringPiece(line_ptr + line.value_begin_idx,
-                      line.last_char_idx - line.value_begin_idx));
+                            line.last_char_idx - line.value_begin_idx));
     }
   }
 
   // Takes a header line in the form of a key/value pair and append it to the
   // buffer. This function should be called after WriteToBuffer to
   // append additional header lines to the header without copying the header.
   // When the user is done with appending to the buffer,
   // WriteHeaderEndingToBuffer must be used to terminate the HTTP
   // header in the buffer. This method is a no-op if key is empty.
   template <typename Buffer>
@@ skipping 15 matching lines @@
   // This function can be called on a header object in any state. Raw header
   // data will be printed out if the header object is not completely parsed,
   // e.g., when there was an error in the middle of parsing.
   // The header content is appended to the string; the original content is not
   // cleared.
   void DumpToString(std::string* str) const;
 
   const base::StringPiece first_line() const {
     DCHECK_GE(whitespace_4_idx_, non_whitespace_1_idx_);
     return base::StringPiece(BeginningOfFirstLine() + non_whitespace_1_idx_,
-                       whitespace_4_idx_ - non_whitespace_1_idx_);
+                             whitespace_4_idx_ - non_whitespace_1_idx_);
   }
 
   // Returns the parsed value of the response code if it has been parsed.
   // Guaranteed to return 0 when unparsed (though it is a much better idea to
   // verify that the BalsaFrame had no errors while parsing).
   // This may return response codes which are outside the normal bounds of
   // HTTP response codes-- it is up to the user of this class to ensure that
   // the response code is one which is interpretable.
   size_t parsed_response_code() const { return parsed_response_code_; }
 
   const base::StringPiece request_method() const {
     DCHECK_GE(whitespace_2_idx_, non_whitespace_1_idx_);
     return base::StringPiece(BeginningOfFirstLine() + non_whitespace_1_idx_,
-                       whitespace_2_idx_ - non_whitespace_1_idx_);
+                             whitespace_2_idx_ - non_whitespace_1_idx_);
   }
 
   const base::StringPiece response_version() const {
     // Note: There is no difference between request_method() and
     // response_version(). They both could be called
     // GetFirstTokenFromFirstline()... but that wouldn't be anywhere near as
     // descriptive.
     return request_method();
   }
 
   const base::StringPiece request_uri() const {
     DCHECK_GE(whitespace_3_idx_, non_whitespace_2_idx_);
     return base::StringPiece(BeginningOfFirstLine() + non_whitespace_2_idx_,
-                       whitespace_3_idx_ - non_whitespace_2_idx_);
+                             whitespace_3_idx_ - non_whitespace_2_idx_);
   }
 
   const base::StringPiece response_code() const {
     // Note: There is no difference between request_uri() and response_code().
     // They both could be called GetSecondtTokenFromFirstline(), but, as noted
     // in an earlier comment, that wouldn't be as descriptive.
     return request_uri();
   }
 
   const base::StringPiece request_version() const {
     DCHECK_GE(whitespace_4_idx_, non_whitespace_3_idx_);
     return base::StringPiece(BeginningOfFirstLine() + non_whitespace_3_idx_,
-                       whitespace_4_idx_ - non_whitespace_3_idx_);
+                             whitespace_4_idx_ - non_whitespace_3_idx_);
   }
 
   const base::StringPiece response_reason_phrase() const {
     // Note: There is no difference between request_version() and
     // response_reason_phrase(). They both could be called
     // GetThirdTokenFromFirstline(), but, as noted in an earlier comment, that
     // wouldn't be as descriptive.
     return request_version();
   }
 
@@ skipping 64 matching lines @@
   // Note: never check this for requests. Nothing bad will happen if you do,
   // but spec does not allow requests framed by connection close.
   // TODO(vitaliyl): refactor.
   bool is_framed_by_connection_close() const {
     // We declare that response is framed by connection close if it has no
     // content-length, no transfer encoding, and is allowed to have a body by
     // the HTTP spec.
     // parsed_response_code_ is 0 for requests, so ResponseCodeImpliesNoBody
     // will return false.
     return (content_length_status_ == BalsaHeadersEnums::NO_CONTENT_LENGTH) &&
-        !transfer_encoding_is_chunked_ &&
-        !ResponseCodeImpliesNoBody(parsed_response_code_);
+           !transfer_encoding_is_chunked_ &&
+           !ResponseCodeImpliesNoBody(parsed_response_code_);
   }
 
   size_t content_length() const { return content_length_; }
   BalsaHeadersEnums::ContentLengthStatus content_length_status() const {
     return content_length_status_;
   }
 
   // SetContentLength and SetChunkEncoding modifies the header object to use
   // content-length and transfer-encoding headers in a consistent manner. They
   // set all internal flags and status so client can get a consistent view from
@@ skipping 69 matching lines @@
                                bool append);
 
   HeaderLines::const_iterator GetConstHeaderLinesIterator(
       const base::StringPiece& key,
       HeaderLines::const_iterator start) const;
 
   HeaderLines::iterator GetHeaderLinesIteratorNoSkip(
       const base::StringPiece& key,
       HeaderLines::iterator start);
 
-  HeaderLines::iterator GetHeaderLinesIterator(
-      const base::StringPiece& key,
-      HeaderLines::iterator start);
+  HeaderLines::iterator GetHeaderLinesIterator(const base::StringPiece& key,
+                                               HeaderLines::iterator start);
 
   template <typename IteratorType>
   const IteratorType HeaderLinesBeginHelper() const {
     if (header_lines_.empty()) {
       return IteratorType(this, 0);
     }
     const HeaderLines::size_type header_lines_size = header_lines_.size();
     for (HeaderLines::size_type i = 0; i < header_lines_size; ++i) {
       if (header_lines_[i].skip == false) {
         return IteratorType(this, i);
@@ skipping 18 matching lines @@
     return IteratorType(this, 0);
   }
 
   // At the moment, this function will always return the original headers.
   // In the future, it may not do so after erasing header lines, modifying
   // header lines, or modifying the first line.
   // For this reason, it is strongly suggested that use of this function is
   // only acceptable for the purpose of debugging parse errors seen by the
   // BalsaFrame class.
   base::StringPiece OriginalHeadersForDebugging() const {
-    return base::StringPiece(OriginalHeaderStreamBegin(),
-                       OriginalHeaderStreamEnd() - OriginalHeaderStreamBegin());
+    return base::StringPiece(
+        OriginalHeaderStreamBegin(),
+        OriginalHeaderStreamEnd() - OriginalHeaderStreamBegin());
   }
 
   BalsaBuffer balsa_buffer_;
 
   size_t content_length_;
   BalsaHeadersEnums::ContentLengthStatus content_length_status_;
   size_t parsed_response_code_;
   // HTTP firstlines all have the following structure:
   //  LWS         NONWS  LWS    NONWS   LWS    NONWS   NOTCRLF  CRLF
   //  [\t \r\n]+ [^\t ]+ [\t ]+ [^\t ]+ [\t ]+ [^\t ]+ [^\r\n]+ "\r\n"
@@ skipping 28 matching lines @@
   size_t end_of_firstline_idx_;
 
   bool transfer_encoding_is_chunked_;
 
   HeaderLines header_lines_;
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_BALSA_BALSA_HEADERS_H_