Deprecate remove_rewritelength flag.

net/spdy/core/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/core/spdy_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <cctype>
@@ skipping 125 matching lines @@
       probable_http_response_(false),
       end_stream_when_done_(false) {
   static_assert(
       kMaxControlFrameSize <= kSpdyInitialFrameSizeLimit + kFrameHeaderSize,
       "Our send limit should be at most our receive limit");
   Reset();
 
   if (adapter_factory != nullptr) {
     decoder_adapter_ = adapter_factory(this);
   }
-  skip_rewritelength_ = FLAGS_chromium_http2_flag_remove_rewritelength;
 }
 
 SpdyFramer::SpdyFramer(CompressionOption option)
     : SpdyFramer(&DecoderAdapterFactory, option) {}
 
 SpdyFramer::~SpdyFramer() {}
 
 void SpdyFramer::Reset() {
   if (decoder_adapter_ != nullptr) {
     decoder_adapter_->Reset();
@@ skipping 1713 matching lines @@
 
 SpdySerializedFrame SpdyFramer::SerializeDataFrameHeaderWithPaddingLengthField(
     const SpdyDataIR& data_ir) const {
   uint8_t flags = DATA_FLAG_NONE;
   size_t frame_size = 0;
   size_t num_padding_fields = 0;
   SerializeDataFrameHeaderWithPaddingLengthFieldBuilderHelper(
       data_ir, &flags, &frame_size, &num_padding_fields);
 
   SpdyFrameBuilder builder(frame_size);
-  if (!skip_rewritelength_) {
-    builder.BeginNewFrame(*this, SpdyFrameType::DATA, flags,
-                          data_ir.stream_id());
-    if (data_ir.padded()) {
-      builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
-    }
-    builder.OverwriteLength(*this, num_padding_fields + data_ir.data_len() +
-                                       data_ir.padding_payload_len());
-  } else {
-    builder.BeginNewFrame(*this, SpdyFrameType::DATA, flags,
-                          data_ir.stream_id(),
-                          num_padding_fields + data_ir.data_len() +
-                              data_ir.padding_payload_len());
-    if (data_ir.padded()) {
-      builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
-    }
+  builder.BeginNewFrame(
+      *this, SpdyFrameType::DATA, flags, data_ir.stream_id(),
+      num_padding_fields + data_ir.data_len() + data_ir.padding_payload_len());
+  if (data_ir.padded()) {
+    builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
   }
   DCHECK_EQ(frame_size, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeRstStream(
     const SpdyRstStreamIR& rst_stream) const {
   size_t expected_length = GetRstStreamSize();
   SpdyFrameBuilder builder(expected_length);
 
@@ skipping 141 matching lines @@
   // The size of this frame, including padding (if there is any) and
   // variable-length header block.
   size_t size = 0;
   SpdyString hpack_encoding;
   int weight = 0;
   size_t length_field = 0;
   SerializeHeadersBuilderHelper(headers, &flags, &size, &hpack_encoding,
                                 &weight, &length_field);
 
   SpdyFrameBuilder builder(size);
+  builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
+                        headers.stream_id(), length_field);
 
-  if (!skip_rewritelength_) {
-    builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
-                          headers.stream_id());
-  } else {
-    builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
-                          headers.stream_id(), length_field);
-  }
   DCHECK_EQ(GetHeadersMinimumSize(), builder.length());
 
   int padding_payload_len = 0;
   if (headers.padded()) {
     builder.WriteUInt8(headers.padding_payload_len());
     padding_payload_len = headers.padding_payload_len();
   }
   if (headers.has_priority()) {
     builder.WriteUInt32(PackStreamDependencyValues(headers.exclusive(),
                                                    headers.parent_stream_id()));
@@ skipping 55 matching lines @@
 
 SpdySerializedFrame SpdyFramer::SerializePushPromise(
     const SpdyPushPromiseIR& push_promise) {
   uint8_t flags = 0;
   size_t size = 0;
   SpdyString hpack_encoding;
   SerializePushPromiseBuilderHelper(push_promise, &flags, &hpack_encoding,
                                     &size);
 
   SpdyFrameBuilder builder(size);
-  if (!skip_rewritelength_) {
-    builder.BeginNewFrame(*this, SpdyFrameType::PUSH_PROMISE, flags,
-                          push_promise.stream_id());
-  } else {
-    size_t length = std::min(size, kMaxControlFrameSize) - GetFrameHeaderSize();
-    builder.BeginNewFrame(*this, SpdyFrameType::PUSH_PROMISE, flags,
-                          push_promise.stream_id(), length);
-  }
+  size_t length = std::min(size, kMaxControlFrameSize) - GetFrameHeaderSize();
+  builder.BeginNewFrame(*this, SpdyFrameType::PUSH_PROMISE, flags,
+                        push_promise.stream_id(), length);
   int padding_payload_len = 0;
   if (push_promise.padded()) {
     builder.WriteUInt8(push_promise.padding_payload_len());
     builder.WriteUInt32(push_promise.promised_stream_id());
     DCHECK_EQ(GetPushPromiseMinimumSize() + kPadLengthFieldSize,
               builder.length());
 
     padding_payload_len = push_promise.padding_payload_len();
   } else {
     builder.WriteUInt32(push_promise.promised_stream_id());
@@ skipping 283 matching lines @@
     const SpdyDataIR& data_ir,
     ZeroCopyOutputBuffer* output) const {
   uint8_t flags = DATA_FLAG_NONE;
   size_t frame_size = 0;
   size_t num_padding_fields = 0;
   SerializeDataFrameHeaderWithPaddingLengthFieldBuilderHelper(
       data_ir, &flags, &frame_size, &num_padding_fields);
 
   SpdyFrameBuilder builder(frame_size, output);
   bool ok = true;
-  if (!skip_rewritelength_) {
-    ok = builder.BeginNewFrame(*this, SpdyFrameType::DATA, flags,
-                               data_ir.stream_id());
-    if (data_ir.padded()) {
-      ok = ok && builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
-    }
-    ok = ok && builder.OverwriteLength(*this,
-                                       num_padding_fields + data_ir.data_len() +
-                                           data_ir.padding_payload_len());
-  } else {
-    ok = ok && builder.BeginNewFrame(*this, SpdyFrameType::DATA, flags,
-                                     data_ir.stream_id(),
-                                     num_padding_fields + data_ir.data_len() +
-                                         data_ir.padding_payload_len());
-    if (data_ir.padded()) {
-      ok = ok && builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
-    }
+  ok = ok && builder.BeginNewFrame(*this, SpdyFrameType::DATA, flags,
+                                   data_ir.stream_id(),
+                                   num_padding_fields + data_ir.data_len() +
+                                       data_ir.padding_payload_len());
+  if (data_ir.padded()) {
+    ok = ok && builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
   }
   DCHECK_EQ(frame_size, builder.length());
   return ok;
 }
 
 bool SpdyFramer::SerializeRstStream(const SpdyRstStreamIR& rst_stream,
                                     ZeroCopyOutputBuffer* output) const {
   size_t expected_length = GetRstStreamSize();
   SpdyFrameBuilder builder(expected_length, output);
   bool ok = builder.BeginNewFrame(*this, SpdyFrameType::RST_STREAM, 0,
@@ skipping 76 matching lines @@
   // variable-length header block.
   size_t size = 0;
   SpdyString hpack_encoding;
   int weight = 0;
   size_t length_field = 0;
   SerializeHeadersBuilderHelper(headers, &flags, &size, &hpack_encoding,
                                 &weight, &length_field);
 
   bool ok = true;
   SpdyFrameBuilder builder(size, output);
-  if (!skip_rewritelength_) {
-    ok = builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
-                               headers.stream_id());
-  } else {
-    ok = ok && builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
-                                     headers.stream_id(), length_field);
-  }
+  ok = ok && builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
+                                   headers.stream_id(), length_field);
   DCHECK_EQ(GetHeadersMinimumSize(), builder.length());
 
   int padding_payload_len = 0;
   if (headers.padded()) {
     ok = ok && builder.WriteUInt8(headers.padding_payload_len());
     padding_payload_len = headers.padding_payload_len();
   }
   if (headers.has_priority()) {
     ok = ok &&
          builder.WriteUInt32(PackStreamDependencyValues(
@@ skipping 31 matching lines @@
 bool SpdyFramer::SerializePushPromise(const SpdyPushPromiseIR& push_promise,
                                       ZeroCopyOutputBuffer* output) {
   uint8_t flags = 0;
   size_t size = 0;
   SpdyString hpack_encoding;
   SerializePushPromiseBuilderHelper(push_promise, &flags, &hpack_encoding,
                                     &size);
 
   bool ok = true;
   SpdyFrameBuilder builder(size, output);
-  if (!skip_rewritelength_) {
-    ok = builder.BeginNewFrame(*this, SpdyFrameType::PUSH_PROMISE, flags,
-                               push_promise.stream_id());
-  } else {
-    size_t length = std::min(size, kMaxControlFrameSize) - GetFrameHeaderSize();
-    ok = builder.BeginNewFrame(*this, SpdyFrameType::PUSH_PROMISE, flags,
-                               push_promise.stream_id(), length);
-  }
+  size_t length = std::min(size, kMaxControlFrameSize) - GetFrameHeaderSize();
+  ok = builder.BeginNewFrame(*this, SpdyFrameType::PUSH_PROMISE, flags,
+                             push_promise.stream_id(), length);
 
   int padding_payload_len = 0;
   if (push_promise.padded()) {
     ok = ok && builder.WriteUInt8(push_promise.padding_payload_len()) &&
          builder.WriteUInt32(push_promise.promised_stream_id());
     DCHECK_EQ(GetPushPromiseMinimumSize() + kPadLengthFieldSize,
               builder.length());
 
     padding_payload_len = push_promise.padding_payload_len();
   } else {
@@ skipping 245 matching lines @@
   bytes_remaining =
       hpack_encoding.size() -
       std::min(hpack_encoding.size(),
                kMaxControlFrameSize - builder->length() - padding_payload_len);
   bool ret = builder->WriteBytes(&hpack_encoding[0],
                                  hpack_encoding.size() - bytes_remaining);
   if (padding_payload_len > 0) {
     SpdyString padding = SpdyString(padding_payload_len, 0);
     ret &= builder->WriteBytes(padding.data(), padding.length());
   }
-  if (bytes_remaining > 0 && !skip_rewritelength_) {
-    ret &= builder->OverwriteLength(
-        *this, kMaxControlFrameSize - GetFrameHeaderSize());
-  }
 
   // Tack on CONTINUATION frames for the overflow.
   while (bytes_remaining > 0 && ret) {
     size_t bytes_to_write = std::min(
         bytes_remaining, kMaxControlFrameSize - GetContinuationMinimumSize());
     // Write CONTINUATION frame prefix.
     if (bytes_remaining == bytes_to_write) {
       flags |= end_flag;
     }
-    if (!skip_rewritelength_) {
-      ret &= builder->BeginNewFrame(*this, SpdyFrameType::CONTINUATION, flags,
-                                    stream_id);
-    } else {
-      ret &= builder->BeginNewFrame(*this, SpdyFrameType::CONTINUATION, flags,
-                                    stream_id, bytes_to_write);
-    }
+    ret &= builder->BeginNewFrame(*this, SpdyFrameType::CONTINUATION, flags,
+                                  stream_id, bytes_to_write);
     // Write payload fragment.
     ret &= builder->WriteBytes(
         &hpack_encoding[hpack_encoding.size() - bytes_remaining],
         bytes_to_write);
     bytes_remaining -= bytes_to_write;
   }
   return ret;
 }
 
 HpackEncoder* SpdyFramer::GetHpackEncoder() {
@@ skipping 63 matching lines @@
   builder->WriteUInt32(header_block.size());
 
   // Serialize each header.
   for (const auto& header : header_block) {
     builder->WriteStringPiece32(base::ToLowerASCII(header.first));
     builder->WriteStringPiece32(header.second);
   }
 }
 
 }  // namespace net