Clang format slam.

net/filter/gzip_filter.cc

 // Copyright 2014 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/filter/gzip_filter.h"
 
 #include "base/logging.h"
 #include "net/filter/gzip_header.h"
 #include "third_party/zlib/zlib.h"
 
@@ skipping 26 matching lines @@
 
   // Set decoding mode
   switch (filter_type) {
     case Filter::FILTER_TYPE_DEFLATE: {
       if (inflateInit(zlib_stream_.get()) != Z_OK)
         return false;
       decoding_mode_ = DECODE_MODE_DEFLATE;
       break;
     }
     case Filter::FILTER_TYPE_GZIP_HELPING_SDCH:
-      possible_sdch_pass_through_ =  true;  // Needed to optionally help sdch.
-      // Fall through to GZIP case.
+      possible_sdch_pass_through_ = true;  // Needed to optionally help sdch.
+                                           // Fall through to GZIP case.
     case Filter::FILTER_TYPE_GZIP: {
       gzip_header_.reset(new GZipHeader());
       if (!gzip_header_.get())
         return false;
       if (inflateInit2(zlib_stream_.get(), -MAX_WBITS) != Z_OK)
         return false;
       decoding_mode_ = DECODE_MODE_GZIP;
       break;
     }
-    default: {
-      return false;
-    }
+    default: { return false; }
   }
 
   decoding_status_ = DECODING_IN_PROGRESS;
   return true;
 }
 
 Filter::FilterStatus GZipFilter::ReadFilteredData(char* dest_buffer,
                                                   int* dest_len) {
   if (!dest_buffer || !dest_len || *dest_len <= 0)
     return Filter::FILTER_ERROR;
@@ skipping 38 matching lines @@
       case Filter::FILTER_ERROR: {
         if (possible_sdch_pass_through_ &&
             GZIP_GET_INVALID_HEADER == gzip_header_status_) {
           decoding_status_ = DECODING_DONE;  // Become a pass through filter.
           return CopyOut(dest_buffer, dest_len);
         }
         decoding_status_ = DECODING_ERROR;
         return status;
       }
       default: {
-        status = Filter::FILTER_ERROR;    // Unexpected.
+        status = Filter::FILTER_ERROR;  // Unexpected.
         decoding_status_ = DECODING_ERROR;
         return status;
       }
     }
   }
 
   int dest_orig_size = *dest_len;
   status = DoInflate(dest_buffer, dest_len);
 
   if (decoding_mode_ == DECODE_MODE_DEFLATE && status == Filter::FILTER_ERROR) {
@@ skipping 18 matching lines @@
 
 Filter::FilterStatus GZipFilter::CheckGZipHeader() {
   DCHECK_EQ(gzip_header_status_, GZIP_CHECK_HEADER_IN_PROGRESS);
 
   // Check input data in pre-filter buffer.
   if (!next_stream_data_ || stream_data_len_ <= 0)
     return Filter::FILTER_ERROR;
 
   const char* header_end = NULL;
   GZipHeader::Status header_status;
-  header_status = gzip_header_->ReadMore(next_stream_data_, stream_data_len_,
-                                         &header_end);
+  header_status =
+      gzip_header_->ReadMore(next_stream_data_, stream_data_len_, &header_end);
 
   switch (header_status) {
     case GZipHeader::INCOMPLETE_HEADER: {
       // We read all the data but only got a partial header.
       next_stream_data_ = NULL;
       stream_data_len_ = 0;
       return Filter::FILTER_NEED_MORE_DATA;
     }
     case GZipHeader::COMPLETE_HEADER: {
       // We have a complete header. Check whether there are more data.
-      int num_chars_left = static_cast<int>(stream_data_len_ -
-                                            (header_end - next_stream_data_));
+      int num_chars_left =
+          static_cast<int>(stream_data_len_ - (header_end - next_stream_data_));
       gzip_header_status_ = GZIP_GET_COMPLETE_HEADER;
 
       if (num_chars_left > 0) {
         next_stream_data_ = const_cast<char*>(header_end);
         stream_data_len_ = num_chars_left;
         return Filter::FILTER_OK;
       } else {
         next_stream_data_ = NULL;
         stream_data_len_ = 0;
         return Filter::FILTER_NEED_MORE_DATA;
       }
     }
     case GZipHeader::INVALID_HEADER: {
       gzip_header_status_ = GZIP_GET_INVALID_HEADER;
       return Filter::FILTER_ERROR;
     }
-    default: {
-      break;
-    }
+    default: { break; }
   }
 
   return Filter::FILTER_ERROR;
 }
 
 Filter::FilterStatus GZipFilter::DoInflate(char* dest_buffer, int* dest_len) {
   // Make sure we have both valid input data and output buffer.
   if (!dest_buffer || !dest_len || *dest_len <= 0)  // output
     return Filter::FILTER_ERROR;
 
@@ skipping 53 matching lines @@
     default: {
       status = Filter::FILTER_ERROR;
       break;
     }
   }
 
   return status;
 }
 
 bool GZipFilter::InsertZlibHeader() {
-  static char dummy_head[2] = { 0x78, 0x1 };
+  static char dummy_head[2] = {0x78, 0x1};
 
   char dummy_output[4];
 
   // We only try add additional header once.
   if (zlib_header_added_)
     return false;
 
   inflateReset(zlib_stream_.get());
   zlib_stream_.get()->next_in = bit_cast<Bytef*>(&dummy_head[0]);
   zlib_stream_.get()->avail_in = sizeof(dummy_head);
   zlib_stream_.get()->next_out = bit_cast<Bytef*>(&dummy_output[0]);
   zlib_stream_.get()->avail_out = sizeof(dummy_output);
 
   int code = inflate(zlib_stream_.get(), Z_NO_FLUSH);
   zlib_header_added_ = true;
 
   return (code == Z_OK);
 }
 
-
 void GZipFilter::SkipGZipFooter() {
   int footer_bytes_expected = kGZipFooterSize - gzip_footer_bytes_;
   if (footer_bytes_expected > 0) {
     int footer_byte_avail = std::min(footer_bytes_expected, stream_data_len_);
     stream_data_len_ -= footer_byte_avail;
     next_stream_data_ += footer_byte_avail;
     gzip_footer_bytes_ += footer_byte_avail;
 
     if (stream_data_len_ == 0)
       next_stream_data_ = NULL;
   }
 }
 
 }  // namespace net