clang_tidy net/spdy

net/spdy/spdy_framer.cc

 // Copyright (c) 2012 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/spdy/spdy_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 2968 matching lines @@
 // so disable compression in that case.
 // TODO(phajdan.jr): Remove the special case when it's no longer necessary.
 static const int kCompressorLevel = 0;
 #else  // !defined(USE_SYSTEM_ZLIB)
 static const int kCompressorLevel = 9;
 #endif  // !defined(USE_SYSTEM_ZLIB)
 static const int kCompressorWindowSizeInBits = 11;
 static const int kCompressorMemLevel = 1;
 
 z_stream* SpdyFramer::GetHeaderCompressor() {
-  if (header_compressor_.get())
+  if (header_compressor_.get()) {
     return header_compressor_.get();  // Already initialized.
+  }
 
   header_compressor_.reset(new z_stream);
   memset(header_compressor_.get(), 0, sizeof(z_stream));
 
   int success = deflateInit2(header_compressor_.get(),
                              kCompressorLevel,
                              Z_DEFLATED,
                              kCompressorWindowSizeInBits,
                              kCompressorMemLevel,
                              Z_DEFAULT_STRATEGY);
   if (success == Z_OK) {
     const char* dictionary = (protocol_version() <= SPDY2) ?
         kV2Dictionary : kV3Dictionary;
     const int dictionary_size = (protocol_version() <= SPDY2) ?
         kV2DictionarySize : kV3DictionarySize;
     success = deflateSetDictionary(header_compressor_.get(),
                                    reinterpret_cast<const Bytef*>(dictionary),
                                    dictionary_size);
   }
   if (success != Z_OK) {
     LOG(WARNING) << "deflateSetDictionary failure: " << success;
     header_compressor_.reset(NULL);
     return NULL;
   }
   return header_compressor_.get();
 }
 
 z_stream* SpdyFramer::GetHeaderDecompressor() {
-  if (header_decompressor_.get())
+  if (header_decompressor_.get()) {
     return header_decompressor_.get();  // Already initialized.
+  }
 
   header_decompressor_.reset(new z_stream);
   memset(header_decompressor_.get(), 0, sizeof(z_stream));
 
   int success = inflateInit(header_decompressor_.get());
   if (success != Z_OK) {
     LOG(WARNING) << "inflateInit failure: " << success;
     header_decompressor_.reset(NULL);
     return NULL;
   }
@@ skipping 62 matching lines @@
       const int dictionary_size = (protocol_version() <= SPDY2) ?
           kV2DictionarySize : kV3DictionarySize;
       const DictionaryIds& ids = g_dictionary_ids.Get();
       const uLong dictionary_id = (protocol_version() <= SPDY2) ?
           ids.v2_dictionary_id : ids.v3_dictionary_id;
       // Need to try again with the right dictionary.
       if (decomp->adler == dictionary_id) {
         rv = inflateSetDictionary(decomp,
                                   reinterpret_cast<const Bytef*>(dictionary),
                                   dictionary_size);
-        if (rv == Z_OK)
+        if (rv == Z_OK) {
           rv = inflate(decomp, Z_SYNC_FLUSH);
+        }
       }
     }
 
     // Inflate will generate a Z_BUF_ERROR if it runs out of input
     // without producing any output.  The input is consumed and
     // buffered internally by zlib so we can detect this condition by
     // checking if avail_in is 0 after the call to inflate.
     bool input_exhausted = ((rv == Z_BUF_ERROR) && (decomp->avail_in == 0));
     if ((rv == Z_OK) || input_exhausted) {
       size_t decompressed_len = arraysize(buffer) - decomp->avail_out;
@@ skipping 119 matching lines @@
 #else
   WriteHeaderBlockToZ(&frame.header_block(), compressor);
 #endif  // defined(USE_SYSTEM_ZLIB)
 
   int compressed_size = compressed_max_size - compressor->avail_out;
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 }
 
 }  // namespace net