Update from https://crrev.com/312398

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 "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/stats_counters.h"
 #include "base/third_party/valgrind/memcheck.h"
@@ skipping 140 matching lines @@
     size_t len) {
   return true;
 }
 
 SpdyFramer::SpdyFramer(SpdyMajorVersion version)
     : current_frame_buffer_(new char[kControlFrameBufferSize]),
       enable_compression_(true),
       visitor_(NULL),
       debug_visitor_(NULL),
       display_protocol_("SPDY"),
-      spdy_version_(version),
+      protocol_version_(version),
       syn_frame_processed_(false),
       probable_http_response_(false),
       expect_continuation_(0),
       end_stream_when_done_(false) {
-  DCHECK_GE(spdy_version_, SPDY_MIN_VERSION);
-  DCHECK_LE(spdy_version_, SPDY_MAX_VERSION);
+  DCHECK_GE(protocol_version_, SPDY_MIN_VERSION);
+  DCHECK_LE(protocol_version_, SPDY_MAX_VERSION);
   DCHECK_LE(kMaxControlFrameSize,
-            SpdyConstants::GetFrameMaximumSize(spdy_version_) +
-                SpdyConstants::GetControlFrameHeaderSize(spdy_version_));
+            SpdyConstants::GetFrameMaximumSize(protocol_version_) +
+                SpdyConstants::GetControlFrameHeaderSize(protocol_version_));
   Reset();
 }
 
 SpdyFramer::~SpdyFramer() {
   if (header_compressor_.get()) {
     deflateEnd(header_compressor_.get());
   }
   if (header_decompressor_.get()) {
     inflateEnd(header_decompressor_.get());
   }
@@ skipping 872 matching lines @@
       break;
   }
 
   if (state_ == SPDY_ERROR) {
     return;
   }
 
   if (current_frame_length_ >
       SpdyConstants::GetFrameMaximumSize(protocol_version()) +
           SpdyConstants::GetControlFrameHeaderSize(protocol_version())) {
-    DLOG(WARNING) << "Received control frame with way too big of a payload: "
+    DLOG(WARNING) << "Received control frame of type " << current_frame_type_
+                  << " with way too big of a payload: "
                   << current_frame_length_;
     set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
     return;
   }
 
   if (current_frame_type_ == GOAWAY) {
     CHANGE_STATE(SPDY_GOAWAY_FRAME_PAYLOAD);
     return;
   }
 
@@ skipping 200 matching lines @@
   }
   WriteZ(base::StringPiece(buf, length), clas, out);
 }
 
 // WriteHeaderBlockToZ serialises |headers| to the deflate context |z| in a
 // manner that resists the length of the compressed data from compromising
 // cookie data.
 void SpdyFramer::WriteHeaderBlockToZ(const SpdyHeaderBlock* headers,
                                      z_stream* z) const {
   unsigned length_length = 4;
-  if (spdy_version_ < 3)
+  if (protocol_version() < 3)
     length_length = 2;
 
   WriteLengthZ(headers->size(), length_length, kZStandardData, z);
 
   std::map<std::string, std::string>::const_iterator it;
   for (it = headers->begin(); it != headers->end(); ++it) {
     WriteLengthZ(it->first.size(), length_length, kZStandardData, z);
     WriteZ(it->first, kZStandardData, z);
 
     if (it->first == "cookie") {
@@ skipping 1674 matching lines @@
   DCHECK_GT(size, kMaxControlFrameSize);
   size_t overflow = size - kMaxControlFrameSize;
   return overflow / (kMaxControlFrameSize - GetContinuationMinimumSize()) + 1;
 }
 
 void SpdyFramer::WritePayloadWithContinuation(SpdyFrameBuilder* builder,
                                               const string& hpack_encoding,
                                               SpdyStreamId stream_id,
                                               SpdyFrameType type,
                                               int padding_payload_len) {
-    uint8 end_flag = 0;
-    uint8 flags = 0;
-    if (type == HEADERS) {
-      end_flag = HEADERS_FLAG_END_HEADERS;
-    } else if (type == PUSH_PROMISE) {
-      end_flag = PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
-    } else {
-      DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type "
-                  << FrameTypeToString(type);
+  uint8 end_flag = 0;
+  uint8 flags = 0;
+  if (type == HEADERS) {
+    end_flag = HEADERS_FLAG_END_HEADERS;
+  } else if (type == PUSH_PROMISE) {
+    end_flag = PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
+  } else {
+    DLOG(FATAL) << "CONTINUATION frames cannot be used with frame type "
+                << FrameTypeToString(type);
+  }
+
+  // Write all the padding payload and as much of the data payload as possible
+  // into the initial frame.
+  size_t bytes_remaining = 0;
+  bytes_remaining =
+      hpack_encoding.size() -
+      std::min(hpack_encoding.size(),
+               kMaxControlFrameSize - builder->length() - padding_payload_len);
+  builder->WriteBytes(&hpack_encoding[0],
+                      hpack_encoding.size() - bytes_remaining);
+  if (padding_payload_len > 0) {
+    string padding = string(padding_payload_len, 0);
+    builder->WriteBytes(padding.data(), padding.length());
+  }
+  if (bytes_remaining > 0) {
+    builder->OverwriteLength(
+        *this, kMaxControlFrameSize - GetControlFrameHeaderSize());
+  }
+
+  // Tack on CONTINUATION frames for the overflow.
+  while (bytes_remaining > 0) {
+    size_t bytes_to_write = std::min(
+        bytes_remaining, kMaxControlFrameSize - GetContinuationMinimumSize());
+    // Write CONTINUATION frame prefix.
+    if (bytes_remaining == bytes_to_write) {
+      flags |= end_flag;
     }
-
-    // Write all the padding payload and as much of the data payload as possible
-    // into the initial frame.
-    size_t bytes_remaining = 0;
-    bytes_remaining = hpack_encoding.size() -
-                      std::min(hpack_encoding.size(),
-                               kMaxControlFrameSize - builder->length() -
-                                   padding_payload_len);
-    builder->WriteBytes(&hpack_encoding[0],
-                        hpack_encoding.size() - bytes_remaining);
-    if (padding_payload_len > 0) {
-      string padding = string(padding_payload_len, 0);
-      builder->WriteBytes(padding.data(), padding.length());
-    }
-    if (bytes_remaining > 0) {
-      builder->OverwriteLength(*this,
-          kMaxControlFrameSize - GetControlFrameHeaderSize());
-    }
-
-    // Tack on CONTINUATION frames for the overflow.
-    while (bytes_remaining > 0) {
-      size_t bytes_to_write = std::min(bytes_remaining,
-                                       kMaxControlFrameSize -
-                                       GetContinuationMinimumSize());
-      // Write CONTINUATION frame prefix.
-      if (bytes_remaining == bytes_to_write) {
-        flags |= end_flag;
-      }
-      builder->BeginNewFrame(*this,
-                             CONTINUATION,
-                             flags,
-                             stream_id);
-      // Write payload fragment.
-      builder->WriteBytes(&hpack_encoding[hpack_encoding.size() -
-                                          bytes_remaining],
-                          bytes_to_write);
-      bytes_remaining -= bytes_to_write;
-    }
+    builder->BeginNewFrame(*this, CONTINUATION, flags, stream_id);
+    // Write payload fragment.
+    builder->WriteBytes(
+        &hpack_encoding[hpack_encoding.size() - bytes_remaining],
+        bytes_to_write);
+    bytes_remaining -= bytes_to_write;
+  }
 }
 
 // The following compression setting are based on Brian Olson's analysis. See
 // https://groups.google.com/group/spdy-dev/browse_thread/thread/dfaf498542fac792
 // for more details.
 #if defined(USE_SYSTEM_ZLIB)
 // System zlib is not expected to have workaround for http://crbug.com/139744,
 // so disable compression in that case.
 // TODO(phajdan.jr): Remove the special case when it's no longer necessary.
 static const int kCompressorLevel = 0;
@@ skipping 43 matching lines @@
   int success = inflateInit(header_decompressor_.get());
   if (success != Z_OK) {
     LOG(WARNING) << "inflateInit failure: " << success;
     header_decompressor_.reset(NULL);
     return NULL;
   }
   return header_decompressor_.get();
 }
 
 HpackEncoder* SpdyFramer::GetHpackEncoder() {
-  DCHECK_LT(SPDY3, spdy_version_);
-  if (hpack_encoder_.get() == NULL) {
+  DCHECK_LT(SPDY3, protocol_version());
+  if (hpack_encoder_.get() == nullptr) {
     hpack_encoder_.reset(new HpackEncoder(ObtainHpackHuffmanTable()));
   }
   return hpack_encoder_.get();
 }
 
 HpackDecoder* SpdyFramer::GetHpackDecoder() {
-  DCHECK_LT(SPDY3, spdy_version_);
-  if (hpack_decoder_.get() == NULL) {
+  DCHECK_LT(SPDY3, protocol_version());
+  if (hpack_decoder_.get() == nullptr) {
     hpack_decoder_.reset(new HpackDecoder(ObtainHpackHuffmanTable()));
   }
   return hpack_decoder_.get();
 }
 
 uint8 SpdyFramer::MapPriorityToWeight(SpdyPriority priority) {
   const float kSteps = 255.9f / 7.f;
   return static_cast<uint8>(kSteps * (7.f - priority));
 }
 
@@ skipping 181 matching lines @@
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net