Add a SpdyFramer extension API implementation.

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 <cctype>
@@ skipping 1796 matching lines @@
   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,
+    builder.BeginNewFrame(*this, SerializeFrameType(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();
 }
@@ skipping 152 matching lines @@
   size_t length_field = 0;
   SerializeHeadersBuilderHelper(headers, &flags, &size, &hpack_encoding,
                                 &weight, &length_field);
 
   SpdyFrameBuilder builder(size);
 
   if (!skip_rewritelength_) {
     builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
                           headers.stream_id());
   } else {
-    builder.BeginNewFrame(*this, SpdyFrameType::HEADERS, flags,
-                          headers.stream_id(), length_field);
+    builder.BeginNewFrame(*this, SerializeFrameType(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(),
@@ skipping 69 matching lines @@
   string 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);
+    builder.BeginNewFrame(*this,
+                          SerializeFrameType(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 {
@@ skipping 294 matching lines @@
   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());
+    ok = ok &&
+         builder.BeginNewFrame(*this, SerializeFrameType(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 {
@@ skipping 83 matching lines @@
   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,
+                                     SerializeFrameType(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 &&
@@ skipping 44 matching lines @@
   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);
+    ok = builder.BeginNewFrame(*this,
+                               SerializeFrameType(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();
@@ skipping 211 matching lines @@
     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, SerializeFrameType(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;
 }
 
@@ skipping 64 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