Factor out the code to write control frame headers into a new constructor of SpdyFrameBuilder.

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 33 matching lines @@
       v3_dictionary_id(CalculateDictionaryId(kV3Dictionary, kV3DictionarySize))
   {}
   const uLong v2_dictionary_id;
   const uLong v3_dictionary_id;
 };
 
 // Adler ID for the SPDY header compressor dictionaries. Note that they are
 // initialized lazily to avoid static initializers.
 base::LazyInstance<DictionaryIds>::Leaky g_dictionary_ids;
 
-// Creates a FlagsAndLength.
-FlagsAndLength CreateFlagsAndLength(SpdyControlFlags flags, size_t length) {
-  DCHECK_EQ(0u, length & ~static_cast<size_t>(kLengthMask));
-  FlagsAndLength flags_length;
-  flags_length.length_ = htonl(static_cast<uint32>(length));
-  DCHECK_EQ(0, flags & ~kControlFlagsMask);
-  flags_length.flags_[0] = flags;
-  return flags_length;
-}
-
 // By default is compression on or off.
 bool g_enable_compression_default = true;
 
 }  // namespace
 
 // The initial size of the control frame buffer; this is used internally
 // as we parse through control frames. (It is exposed here for unit test
 // purposes.)
 size_t SpdyFramer::kControlFrameBufferInitialSize = 32 * 1024;
 
@@ skipping 991 matching lines @@
     SpdyStreamId associated_stream_id,
     SpdyPriority priority,
     uint8 credential_slot,
     SpdyControlFlags flags,
     bool compressed,
     const SpdyHeaderBlock* headers) {
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
   DCHECK_EQ(0u, associated_stream_id & ~kStreamIdMask);
 
   // Find our length.
-  size_t expected_frame_size = SpdySynStreamControlFrame::size() +
-                               GetSerializedLength(headers);
+  size_t frame_size = SpdySynStreamControlFrame::size() +
+                      GetSerializedLength(headers);
 
-  // Create our FlagsAndLength.
-  FlagsAndLength flags_length = CreateFlagsAndLength(
-      flags,
-      expected_frame_size - SpdyFrame::kHeaderSize);
-
-  SpdyFrameBuilder frame(expected_frame_size);
-  frame.WriteUInt16(kControlFlagMask | spdy_version_);
-  frame.WriteUInt16(SYN_STREAM);
-  frame.WriteBytes(&flags_length, sizeof(flags_length));
+  SpdyFrameBuilder frame(SYN_STREAM, flags, spdy_version_, frame_size);
   frame.WriteUInt32(stream_id);
   frame.WriteUInt32(associated_stream_id);
   // Cap as appropriate.
   if (priority > GetLowestPriority()) {
     DLOG(ERROR) << "Priority out-of-bounds.";
     priority = GetLowestPriority();
   }
   // Priority is 2 bits for <spdy3, 3 bits otherwise.
   frame.WriteUInt8(priority << ((spdy_version_ < 3) ? 6 : 5));
   frame.WriteUInt8((spdy_version_ < 3) ? 0 : credential_slot);
   WriteHeaderBlock(&frame, headers);
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
 
   scoped_ptr<SpdySynStreamControlFrame> syn_frame(
       reinterpret_cast<SpdySynStreamControlFrame*>(frame.take()));
   if (compressed) {
     return reinterpret_cast<SpdySynStreamControlFrame*>(
         CompressControlFrame(*syn_frame.get()));
   }
   return syn_frame.release();
 }
 
 SpdySynReplyControlFrame* SpdyFramer::CreateSynReply(
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
     bool compressed,
     const SpdyHeaderBlock* headers) {
   DCHECK_GT(stream_id, 0u);
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
 
   // Find our length.
-  size_t expected_frame_size = SpdySynReplyControlFrame::size() +
-                               GetSerializedLength(headers);
+  size_t frame_size = SpdySynReplyControlFrame::size() +
+                      GetSerializedLength(headers);
   // In SPDY 2, there were 2 unused bytes before payload.
   if (spdy_version_ < 3) {
-    expected_frame_size += 2;
+    frame_size += 2;
   }
 
-  // Create our FlagsAndLength.
-  FlagsAndLength flags_length = CreateFlagsAndLength(
-      flags,
-      expected_frame_size - SpdyFrame::kHeaderSize);
-
-  SpdyFrameBuilder frame(expected_frame_size);
-  frame.WriteUInt16(kControlFlagMask | spdy_version_);
-  frame.WriteUInt16(SYN_REPLY);
-  frame.WriteBytes(&flags_length, sizeof(flags_length));
+  SpdyFrameBuilder frame(SYN_REPLY, flags, spdy_version_, frame_size);
   frame.WriteUInt32(stream_id);
   if (spdy_version_ < 3) {
     frame.WriteUInt16(0);  // Unused
   }
   WriteHeaderBlock(&frame, headers);
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
 
   scoped_ptr<SpdySynReplyControlFrame> reply_frame(
       reinterpret_cast<SpdySynReplyControlFrame*>(frame.take()));
   if (compressed) {
     return reinterpret_cast<SpdySynReplyControlFrame*>(
         CompressControlFrame(*reply_frame.get()));
   }
   return reply_frame.release();
 }
 
 SpdyRstStreamControlFrame* SpdyFramer::CreateRstStream(
     SpdyStreamId stream_id,
     SpdyStatusCodes status) const {
   DCHECK_GT(stream_id, 0u);
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
   DCHECK_NE(status, INVALID);
   DCHECK_LT(status, NUM_STATUS_CODES);
 
-  SpdyFrameBuilder frame(SpdyRstStreamControlFrame::size());
-  frame.WriteUInt16(kControlFlagMask | spdy_version_);
-  frame.WriteUInt16(RST_STREAM);
-  frame.WriteUInt32(8);
+  size_t frame_size = SpdyRstStreamControlFrame::size();
+  SpdyFrameBuilder frame(RST_STREAM, CONTROL_FLAG_NONE, spdy_version_,
+                         frame_size);
   frame.WriteUInt32(stream_id);
   frame.WriteUInt32(status);
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
   return reinterpret_cast<SpdyRstStreamControlFrame*>(frame.take());
 }
 
 SpdySettingsControlFrame* SpdyFramer::CreateSettings(
     const SpdySettings& values) const {
-  SpdyFrameBuilder frame(SpdySettingsControlFrame::size() + 8 * values.size());
-  frame.WriteUInt16(kControlFlagMask | spdy_version_);
-  frame.WriteUInt16(SETTINGS);
-  size_t settings_size =
-      SpdySettingsControlFrame::size() - SpdyFrame::kHeaderSize +
-      8 * values.size();
-  frame.WriteUInt32(settings_size);
+  size_t frame_size = SpdySettingsControlFrame::size() + 8 * values.size();
+  SpdyFrameBuilder frame(SETTINGS, CONTROL_FLAG_NONE, spdy_version_,
+                         frame_size);
   frame.WriteUInt32(values.size());
   SpdySettings::const_iterator it = values.begin();
   while (it != values.end()) {
     uint32 id_and_flags_wire = it->first.GetWireFormat(spdy_version_);
     frame.WriteBytes(&id_and_flags_wire, 4);
     frame.WriteUInt32(it->second);
     ++it;
   }
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
   return reinterpret_cast<SpdySettingsControlFrame*>(frame.take());
 }
 
 SpdyPingControlFrame* SpdyFramer::CreatePingFrame(uint32 unique_id) const {
-  SpdyFrameBuilder frame(SpdyPingControlFrame::size());
-  frame.WriteUInt16(kControlFlagMask | spdy_version_);
-  frame.WriteUInt16(PING);
-  size_t ping_size = SpdyPingControlFrame::size() - SpdyFrame::kHeaderSize;
-  frame.WriteUInt32(ping_size);
+  size_t frame_size = SpdyPingControlFrame::size();
+  SpdyFrameBuilder frame(PING, CONTROL_FLAG_NONE, spdy_version_, frame_size);
   frame.WriteUInt32(unique_id);
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
   return reinterpret_cast<SpdyPingControlFrame*>(frame.take());
 }
 
 SpdyGoAwayControlFrame* SpdyFramer::CreateGoAway(
     SpdyStreamId last_accepted_stream_id,
     SpdyGoAwayStatus status) const {
   DCHECK_EQ(0u, last_accepted_stream_id & ~kStreamIdMask);
 
   // SPDY 2 GOAWAY frames are 4 bytes smaller than in SPDY 3. We account for
   // this difference via a separate offset variable, since
   // SpdyGoAwayControlFrame::size() returns the SPDY 3 size.
   const size_t goaway_offset = (protocol_version() < 3) ? 4 : 0;
-  SpdyFrameBuilder frame(SpdyGoAwayControlFrame::size() - goaway_offset);
-  frame.WriteUInt16(kControlFlagMask | spdy_version_);
-  frame.WriteUInt16(GOAWAY);
-  size_t go_away_size =
-      SpdyGoAwayControlFrame::size() - SpdyFrame::kHeaderSize - goaway_offset;
-  frame.WriteUInt32(go_away_size);
+  size_t frame_size = SpdyGoAwayControlFrame::size() - goaway_offset;
+  SpdyFrameBuilder frame(GOAWAY, CONTROL_FLAG_NONE, spdy_version_, frame_size);
   frame.WriteUInt32(last_accepted_stream_id);
   if (protocol_version() >= 3) {
     frame.WriteUInt32(status);
   }
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
   return reinterpret_cast<SpdyGoAwayControlFrame*>(frame.take());
 }
 
 SpdyHeadersControlFrame* SpdyFramer::CreateHeaders(
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
     bool compressed,
     const SpdyHeaderBlock* headers) {
   // Basically the same as CreateSynReply().
   DCHECK_GT(stream_id, 0u);
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
 
   // Find our length.
-  size_t expected_frame_size = SpdyHeadersControlFrame::size() +
-                               GetSerializedLength(headers);
+  size_t frame_size = SpdyHeadersControlFrame::size() +
+                       GetSerializedLength(headers);
   // In SPDY 2, there were 2 unused bytes before payload.
   if (spdy_version_ < 3) {
-    expected_frame_size += 2;
+    frame_size += 2;
   }
 
-  // Create our FlagsAndLength.
-  FlagsAndLength flags_length = CreateFlagsAndLength(
-      flags,
-      expected_frame_size - SpdyFrame::kHeaderSize);
-
-  SpdyFrameBuilder frame(expected_frame_size);
-  frame.WriteUInt16(kControlFlagMask | spdy_version_);
-  frame.WriteUInt16(HEADERS);
-  frame.WriteBytes(&flags_length, sizeof(flags_length));
+  SpdyFrameBuilder frame(HEADERS, flags, spdy_version_, frame_size);
   frame.WriteUInt32(stream_id);
   if (spdy_version_ < 3) {
     frame.WriteUInt16(0);  // Unused
   }
   WriteHeaderBlock(&frame, headers);
-  DCHECK_EQ(static_cast<size_t>(frame.length()), expected_frame_size);
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
 
   scoped_ptr<SpdyHeadersControlFrame> headers_frame(
       reinterpret_cast<SpdyHeadersControlFrame*>(frame.take()));
   if (compressed) {
     return reinterpret_cast<SpdyHeadersControlFrame*>(
         CompressControlFrame(*headers_frame.get()));
   }
   return headers_frame.release();
 }
 
 SpdyWindowUpdateControlFrame* SpdyFramer::CreateWindowUpdate(
     SpdyStreamId stream_id,
     uint32 delta_window_size) const {
   DCHECK_GT(stream_id, 0u);
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
   DCHECK_GT(delta_window_size, 0u);
   DCHECK_LE(delta_window_size,
             static_cast<uint32>(kSpdyStreamMaximumWindowSize));
 
-  SpdyFrameBuilder frame(SpdyWindowUpdateControlFrame::size());
-  frame.WriteUInt16(kControlFlagMask | spdy_version_);
-  frame.WriteUInt16(WINDOW_UPDATE);
-  size_t window_update_size = SpdyWindowUpdateControlFrame::size() -
-      SpdyFrame::kHeaderSize;
-  frame.WriteUInt32(window_update_size);
+  size_t frame_size = SpdyWindowUpdateControlFrame::size();
+  SpdyFrameBuilder frame(WINDOW_UPDATE, CONTROL_FLAG_NONE, spdy_version_,
+                         frame_size);
   frame.WriteUInt32(stream_id);
   frame.WriteUInt32(delta_window_size);
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
   return reinterpret_cast<SpdyWindowUpdateControlFrame*>(frame.take());
 }
 
 SpdyCredentialControlFrame* SpdyFramer::CreateCredentialFrame(
     const SpdyCredential& credential) const {
   // Calculate the size of the frame by adding the size of the
   // variable length data to the size of the fixed length data.
   size_t frame_size =  SpdyCredentialControlFrame::size() +
       credential.proof.length();
   DCHECK_EQ(SpdyCredentialControlFrame::size(), 14u);
   for (std::vector<std::string>::const_iterator cert = credential.certs.begin();
        cert != credential.certs.end();
        ++cert) {
     frame_size += sizeof(uint32);  // size of the cert_length field
     frame_size += cert->length();     // size of the cert_data field
   }
-  size_t payload_size = frame_size - SpdyFrame::kHeaderSize;
 
-  SpdyFrameBuilder frame(frame_size);
-  // Create our FlagsAndLength.
-  SpdyControlFlags flags = CONTROL_FLAG_NONE;
-  FlagsAndLength flags_length = CreateFlagsAndLength(flags, payload_size);
-
-  frame.WriteUInt16(kControlFlagMask | spdy_version_);
-  frame.WriteUInt16(CREDENTIAL);
-  frame.WriteBytes(&flags_length, sizeof(flags_length));
+  SpdyFrameBuilder frame(CREDENTIAL, CONTROL_FLAG_NONE, spdy_version_,
+                         frame_size);
   frame.WriteUInt16(credential.slot);
   frame.WriteUInt32(credential.proof.size());
   frame.WriteBytes(credential.proof.c_str(), credential.proof.size());
   for (std::vector<std::string>::const_iterator cert = credential.certs.begin();
        cert != credential.certs.end();
        ++cert) {
     frame.WriteUInt32(cert->length());
     frame.WriteBytes(cert->c_str(), cert->length());
   }
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
   return reinterpret_cast<SpdyCredentialControlFrame*>(frame.take());
 }
 
 SpdyDataFrame* SpdyFramer::CreateDataFrame(SpdyStreamId stream_id,
                                            const char* data,
                                            uint32 len, SpdyDataFlags flags) {
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
 
-  SpdyFrameBuilder frame(SpdyDataFrame::size() + len);
-  frame.WriteUInt32(stream_id);
-
-  DCHECK_EQ(0u, len & ~static_cast<size_t>(kLengthMask));
-  FlagsAndLength flags_length;
-  flags_length.length_ = htonl(len);
-  DCHECK_EQ(0, flags & ~kDataFlagsMask);
-  flags_length.flags_[0] = flags;
-  frame.WriteBytes(&flags_length, sizeof(flags_length));
-
+  size_t frame_size = SpdyDataFrame::size() + len;
+  SpdyFrameBuilder frame(stream_id, flags, frame_size);
   frame.WriteBytes(data, len);
+  DCHECK_EQ(static_cast<size_t>(frame.length()), frame_size);
   scoped_ptr<SpdyFrame> data_frame(frame.take());
   SpdyDataFrame* rv;
   if (flags & DATA_FLAG_COMPRESSED) {
     LOG(DFATAL) << "DATA_FLAG_COMPRESSED invalid for " << display_protocol_
                 << ".";
   }
   rv = reinterpret_cast<SpdyDataFrame*>(data_frame.release());
 
   if (flags & DATA_FLAG_FIN) {
     CleanupCompressorForStream(stream_id);
@@ skipping 462 matching lines @@
 
 void SpdyFramer::set_validate_control_frame_sizes(bool value) {
   validate_control_frame_sizes_ = value;
 }
 
 void SpdyFramer::set_enable_compression_default(bool value) {
   g_enable_compression_default = value;
 }
 
 }  // namespace net