SPDY: Replace SerializeDataFrameHeader.

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.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 2013 matching lines @@
                << num_headers << ").";
       return 0;
     }
 
     // Store header.
     (*block)[name] = value;
   }
   return reader.GetBytesConsumed();
 }
 
-SpdySerializedFrame* SpdyFramer::SerializeData(const SpdyDataIR& datair) const {
+SpdySerializedFrame* SpdyFramer::SerializeData(
+    const SpdyDataIR& data_ir) const {
   uint8 flags = DATA_FLAG_NONE;
-  if (datair.fin()) {
+  if (data_ir.fin()) {
     flags = DATA_FLAG_FIN;
   }
 
   if (protocol_version() > SPDY3) {
     int num_padding_fields = 0;
-    if (datair.pad_low()) {
+    if (data_ir.pad_low()) {
       flags |= DATA_FLAG_PAD_LOW;
       ++num_padding_fields;
     }
-    if (datair.pad_high()) {
+    if (data_ir.pad_high()) {
       flags |= DATA_FLAG_PAD_HIGH;
       ++num_padding_fields;
     }
 
     const size_t size_with_padding = num_padding_fields +
-        datair.data().length() + datair.padding_payload_len() +
+        data_ir.data().length() + data_ir.padding_payload_len() +
         GetDataFrameMinimumSize();
     SpdyFrameBuilder builder(size_with_padding);
-    builder.WriteDataFrameHeader(*this, datair.stream_id(), flags);
-    if (datair.pad_high()) {
-      builder.WriteUInt8(datair.padding_payload_len() >> 8);
+    builder.WriteDataFrameHeader(*this, data_ir.stream_id(), flags);
+    if (data_ir.pad_high()) {
+      builder.WriteUInt8(data_ir.padding_payload_len() >> 8);
     }
-    if (datair.pad_low()) {
-      builder.WriteUInt8(datair.padding_payload_len() & 0xff);
+    if (data_ir.pad_low()) {
+      builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
     }
-    builder.WriteBytes(datair.data().data(), datair.data().length());
-    if (datair.padding_payload_len() > 0) {
-      string padding = string(datair.padding_payload_len(), '0');
+    builder.WriteBytes(data_ir.data().data(), data_ir.data().length());
+    if (data_ir.padding_payload_len() > 0) {
+      string padding = string(data_ir.padding_payload_len(), '0');
       builder.WriteBytes(padding.data(), padding.length());
     }
     DCHECK_EQ(size_with_padding, builder.length());
     return builder.take();
   } else {
-    const size_t size = GetDataFrameMinimumSize() + datair.data().length();
+    const size_t size = GetDataFrameMinimumSize() + data_ir.data().length();
     SpdyFrameBuilder builder(size);
-    builder.WriteDataFrameHeader(*this, datair.stream_id(), flags);
-    builder.WriteBytes(datair.data().data(), datair.data().length());
+    builder.WriteDataFrameHeader(*this, data_ir.stream_id(), flags);
+    builder.WriteBytes(data_ir.data().data(), data_ir.data().length());
     DCHECK_EQ(size, builder.length());
     return builder.take();
   }
 }
 
-SpdySerializedFrame* SpdyFramer::SerializeDataFrameHeader(
-    const SpdyDataIR& data) const {
-  const size_t kSize = GetDataFrameMinimumSize();
-
+SpdySerializedFrame* SpdyFramer::SerializeDataFrameHeaderWithPaddingLengthField(
+    const SpdyDataIR& data_ir) const {
   uint8 flags = DATA_FLAG_NONE;
-  if (data.fin()) {
+  if (data_ir.fin()) {
     flags = DATA_FLAG_FIN;
   }
+
+  size_t frame_size = GetDataFrameMinimumSize();
+  size_t num_padding_fields = 0;
   if (protocol_version() > SPDY3) {
-    if (data.pad_low()) {
+    if (data_ir.pad_low()) {
       flags |= DATA_FLAG_PAD_LOW;
+      ++num_padding_fields;
     }
-    if (data.pad_high()) {
+    if (data_ir.pad_high()) {
       flags |= DATA_FLAG_PAD_HIGH;
+      ++num_padding_fields;
     }
+    frame_size += num_padding_fields;
   }
 
-  SpdyFrameBuilder builder(kSize);
-  builder.WriteDataFrameHeader(*this, data.stream_id(), flags);
-  builder.OverwriteLength(*this, data.data().length());
-  DCHECK_EQ(kSize, builder.length());
+  SpdyFrameBuilder builder(frame_size);
+  builder.WriteDataFrameHeader(*this, data_ir.stream_id(), flags);
+  if (protocol_version() > SPDY3) {
+    if (data_ir.pad_high()) {
+      builder.WriteUInt8(data_ir.padding_payload_len() >> 8);
+    }
+    if (data_ir.pad_low()) {
+      builder.WriteUInt8(data_ir.padding_payload_len() & 0xff);
+    }
+    builder.OverwriteLength(*this,  num_padding_fields +
+        data_ir.data().length() + data_ir.padding_payload_len());
+  } else {
+    builder.OverwriteLength(*this, data_ir.data().length());
+  }
+  DCHECK_EQ(frame_size, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame* SpdyFramer::SerializeSynStream(
     const SpdySynStreamIR& syn_stream) {
   uint8 flags = 0;
   if (syn_stream.fin()) {
     flags |= CONTROL_FLAG_FIN;
   }
   if (syn_stream.unidirectional()) {
@@ skipping 757 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