diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 0b296df..95589ca 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -3158,7 +3158,7 @@
         }
         case IETF_DATA_BLOCKED: {
           QuicBlockedFrame frame;
-          if (!ProcessIetfBlockedFrame(reader, &frame)) {
+          if (!ProcessDataBlockedFrame(reader, &frame)) {
             return RaiseError(QUIC_INVALID_BLOCKED_DATA);
           }
           QUIC_DVLOG(2) << ENDPOINT << "Processing IETF blocked frame "
@@ -3172,7 +3172,7 @@
         }
         case IETF_STREAM_DATA_BLOCKED: {
           QuicBlockedFrame frame;
-          if (!ProcessStreamBlockedFrame(reader, &frame)) {
+          if (!ProcessStreamDataBlockedFrame(reader, &frame)) {
             return RaiseError(QUIC_INVALID_STREAM_BLOCKED_DATA);
           }
           QUIC_DVLOG(2) << ENDPOINT << "Processing IETF stream blocked frame "
@@ -5549,9 +5549,9 @@
                                     QuicDataWriter* writer) {
   if (VersionHasIetfQuicFrames(version_.transport_version)) {
     if (frame.stream_id == QuicUtils::GetInvalidStreamId(transport_version())) {
-      return AppendIetfBlockedFrame(frame, writer);
+      return AppendDataBlockedFrame(frame, writer);
     }
-    return AppendStreamBlockedFrame(frame, writer);
+    return AppendStreamDataBlockedFrame(frame, writer);
   }
   uint32_t stream_id = static_cast<uint32_t>(frame.stream_id);
   if (!writer->WriteUInt32(stream_id)) {
@@ -5908,7 +5908,7 @@
   return true;
 }
 
-bool QuicFramer::AppendIetfBlockedFrame(const QuicBlockedFrame& frame,
+bool QuicFramer::AppendDataBlockedFrame(const QuicBlockedFrame& frame,
                                         QuicDataWriter* writer) {
   if (!writer->WriteVarInt62(frame.offset)) {
     set_detailed_error("Can not write blocked offset.");
@@ -5917,7 +5917,7 @@
   return true;
 }
 
-bool QuicFramer::ProcessIetfBlockedFrame(QuicDataReader* reader,
+bool QuicFramer::ProcessDataBlockedFrame(QuicDataReader* reader,
                                          QuicBlockedFrame* frame) {
   // Indicates that it is a BLOCKED frame (as opposed to STREAM_BLOCKED).
   frame->stream_id = QuicUtils::GetInvalidStreamId(transport_version());
@@ -5928,8 +5928,8 @@
   return true;
 }
 
-bool QuicFramer::AppendStreamBlockedFrame(const QuicBlockedFrame& frame,
-                                          QuicDataWriter* writer) {
+bool QuicFramer::AppendStreamDataBlockedFrame(const QuicBlockedFrame& frame,
+                                              QuicDataWriter* writer) {
   if (!writer->WriteVarInt62(frame.stream_id)) {
     set_detailed_error("Can not write stream blocked stream id.");
     return false;
@@ -5941,8 +5941,8 @@
   return true;
 }
 
-bool QuicFramer::ProcessStreamBlockedFrame(QuicDataReader* reader,
-                                           QuicBlockedFrame* frame) {
+bool QuicFramer::ProcessStreamDataBlockedFrame(QuicDataReader* reader,
+                                               QuicBlockedFrame* frame) {
   if (!reader->ReadVarIntU32(&frame->stream_id)) {
     set_detailed_error("Can not read stream blocked stream id.");
     return false;
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index 85cc7fb..a6d480b 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -951,14 +951,14 @@
                               QuicMaxStreamsFrame* frame,
                               uint64_t frame_type);
 
-  bool AppendIetfBlockedFrame(const QuicBlockedFrame& frame,
+  bool AppendDataBlockedFrame(const QuicBlockedFrame& frame,
                               QuicDataWriter* writer);
-  bool ProcessIetfBlockedFrame(QuicDataReader* reader, QuicBlockedFrame* frame);
+  bool ProcessDataBlockedFrame(QuicDataReader* reader, QuicBlockedFrame* frame);
 
-  bool AppendStreamBlockedFrame(const QuicBlockedFrame& frame,
-                                QuicDataWriter* writer);
-  bool ProcessStreamBlockedFrame(QuicDataReader* reader,
-                                 QuicBlockedFrame* frame);
+  bool AppendStreamDataBlockedFrame(const QuicBlockedFrame& frame,
+                                    QuicDataWriter* writer);
+  bool ProcessStreamDataBlockedFrame(QuicDataReader* reader,
+                                     QuicBlockedFrame* frame);
 
   bool AppendStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame,
                                  QuicDataWriter* writer);
diff --git a/quic/test_tools/quic_framer_peer.cc b/quic/test_tools/quic_framer_peer.cc
index 1cb8edf..cc94232 100644
--- a/quic/test_tools/quic_framer_peer.cc
+++ b/quic/test_tools/quic_framer_peer.cc
@@ -57,245 +57,6 @@
 }
 
 // static
-bool QuicFramerPeer::ProcessIetfStreamFrame(QuicFramer* framer,
-                                            QuicDataReader* reader,
-                                            uint8_t frame_type,
-                                            QuicStreamFrame* frame) {
-  return framer->ProcessIetfStreamFrame(reader, frame_type, frame);
-}
-
-// static
-bool QuicFramerPeer::AppendIetfStreamFrame(QuicFramer* framer,
-                                           const QuicStreamFrame& frame,
-                                           bool last_frame_in_packet,
-                                           QuicDataWriter* writer) {
-  return framer->AppendIetfStreamFrame(frame, last_frame_in_packet, writer);
-}
-
-// static
-bool QuicFramerPeer::AppendCryptoFrame(QuicFramer* framer,
-                                       const QuicCryptoFrame& frame,
-                                       QuicDataWriter* writer) {
-  return framer->AppendCryptoFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessIetfAckFrame(QuicFramer* framer,
-                                         QuicDataReader* reader,
-                                         uint64_t frame_type,
-                                         QuicAckFrame* ack_frame) {
-  return framer->ProcessIetfAckFrame(reader, frame_type, ack_frame);
-}
-
-// static
-bool QuicFramerPeer::AppendIetfAckFrameAndTypeByte(QuicFramer* framer,
-                                        const QuicAckFrame& frame,
-                                        QuicDataWriter* writer) {
-  return framer->AppendIetfAckFrameAndTypeByte(frame, writer);
-}
-// static
-size_t QuicFramerPeer::GetIetfAckFrameSize(QuicFramer* framer,
-                                           const QuicAckFrame& frame) {
-  return framer->GetIetfAckFrameSize(frame);
-}
-
-// static
-bool QuicFramerPeer::AppendIetfConnectionCloseFrame(
-    QuicFramer* framer,
-    const QuicConnectionCloseFrame& frame,
-    QuicDataWriter* writer) {
-  return framer->AppendIetfConnectionCloseFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessIetfConnectionCloseFrame(
-    QuicFramer* framer,
-    QuicDataReader* reader,
-    QuicConnectionCloseType type,
-    QuicConnectionCloseFrame* frame) {
-  return framer->ProcessIetfConnectionCloseFrame(reader, type, frame);
-}
-
-// static
-bool QuicFramerPeer::ProcessPathChallengeFrame(QuicFramer* framer,
-                                               QuicDataReader* reader,
-                                               QuicPathChallengeFrame* frame) {
-  return framer->ProcessPathChallengeFrame(reader, frame);
-}
-
-// static
-bool QuicFramerPeer::ProcessPathResponseFrame(QuicFramer* framer,
-                                              QuicDataReader* reader,
-                                              QuicPathResponseFrame* frame) {
-  return framer->ProcessPathResponseFrame(reader, frame);
-}
-
-// static
-bool QuicFramerPeer::AppendPathChallengeFrame(
-    QuicFramer* framer,
-    const QuicPathChallengeFrame& frame,
-    QuicDataWriter* writer) {
-  return framer->AppendPathChallengeFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::AppendPathResponseFrame(QuicFramer* framer,
-                                             const QuicPathResponseFrame& frame,
-                                             QuicDataWriter* writer) {
-  return framer->AppendPathResponseFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::AppendIetfResetStreamFrame(QuicFramer* framer,
-                                                const QuicRstStreamFrame& frame,
-                                                QuicDataWriter* writer) {
-  return framer->AppendIetfResetStreamFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessIetfResetStreamFrame(QuicFramer* framer,
-                                                 QuicDataReader* reader,
-                                                 QuicRstStreamFrame* frame) {
-  return framer->ProcessIetfResetStreamFrame(reader, frame);
-}
-
-// static
-bool QuicFramerPeer::ProcessStopSendingFrame(
-    QuicFramer* framer,
-    QuicDataReader* reader,
-    QuicStopSendingFrame* stop_sending_frame) {
-  return framer->ProcessStopSendingFrame(reader, stop_sending_frame);
-}
-
-// static
-bool QuicFramerPeer::AppendStopSendingFrame(
-    QuicFramer* framer,
-    const QuicStopSendingFrame& stop_sending_frame,
-    QuicDataWriter* writer) {
-  return framer->AppendStopSendingFrame(stop_sending_frame, writer);
-}
-
-// static
-bool QuicFramerPeer::AppendMaxDataFrame(QuicFramer* framer,
-                                        const QuicWindowUpdateFrame& frame,
-                                        QuicDataWriter* writer) {
-  return framer->AppendMaxDataFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::AppendMaxStreamDataFrame(
-    QuicFramer* framer,
-    const QuicWindowUpdateFrame& frame,
-    QuicDataWriter* writer) {
-  return framer->AppendMaxStreamDataFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessMaxDataFrame(QuicFramer* framer,
-                                         QuicDataReader* reader,
-                                         QuicWindowUpdateFrame* frame) {
-  return framer->ProcessMaxDataFrame(reader, frame);
-}
-
-// static
-bool QuicFramerPeer::ProcessMaxStreamDataFrame(QuicFramer* framer,
-                                               QuicDataReader* reader,
-                                               QuicWindowUpdateFrame* frame) {
-  return framer->ProcessMaxStreamDataFrame(reader, frame);
-}
-
-// static
-bool QuicFramerPeer::AppendMaxStreamsFrame(QuicFramer* framer,
-                                           const QuicMaxStreamsFrame& frame,
-                                           QuicDataWriter* writer) {
-  return framer->AppendMaxStreamsFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessMaxStreamsFrame(QuicFramer* framer,
-                                            QuicDataReader* reader,
-                                            QuicMaxStreamsFrame* frame,
-                                            uint64_t frame_type) {
-  return framer->ProcessMaxStreamsFrame(reader, frame, frame_type);
-}
-
-// static
-bool QuicFramerPeer::AppendIetfBlockedFrame(QuicFramer* framer,
-                                            const QuicBlockedFrame& frame,
-                                            QuicDataWriter* writer) {
-  return framer->AppendIetfBlockedFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessIetfBlockedFrame(QuicFramer* framer,
-                                             QuicDataReader* reader,
-                                             QuicBlockedFrame* frame) {
-  return framer->ProcessIetfBlockedFrame(reader, frame);
-}
-
-// static
-bool QuicFramerPeer::AppendStreamBlockedFrame(QuicFramer* framer,
-                                              const QuicBlockedFrame& frame,
-                                              QuicDataWriter* writer) {
-  return framer->AppendStreamBlockedFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessStreamBlockedFrame(QuicFramer* framer,
-                                               QuicDataReader* reader,
-                                               QuicBlockedFrame* frame) {
-  return framer->ProcessStreamBlockedFrame(reader, frame);
-}
-
-// static
-bool QuicFramerPeer::AppendStreamsBlockedFrame(
-    QuicFramer* framer,
-    const QuicStreamsBlockedFrame& frame,
-    QuicDataWriter* writer) {
-  return framer->AppendStreamsBlockedFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessStreamsBlockedFrame(QuicFramer* framer,
-                                                QuicDataReader* reader,
-                                                QuicStreamsBlockedFrame* frame,
-                                                uint64_t frame_type) {
-  return framer->ProcessStreamsBlockedFrame(reader, frame, frame_type);
-}
-
-// static
-bool QuicFramerPeer::AppendNewConnectionIdFrame(
-    QuicFramer* framer,
-    const QuicNewConnectionIdFrame& frame,
-    QuicDataWriter* writer) {
-  return framer->AppendNewConnectionIdFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessNewConnectionIdFrame(
-    QuicFramer* framer,
-    QuicDataReader* reader,
-    QuicNewConnectionIdFrame* frame) {
-  return framer->ProcessNewConnectionIdFrame(reader, frame);
-}
-
-// static
-bool QuicFramerPeer::AppendRetireConnectionIdFrame(
-    QuicFramer* framer,
-    const QuicRetireConnectionIdFrame& frame,
-    QuicDataWriter* writer) {
-  return framer->AppendRetireConnectionIdFrame(frame, writer);
-}
-
-// static
-bool QuicFramerPeer::ProcessRetireConnectionIdFrame(
-    QuicFramer* framer,
-    QuicDataReader* reader,
-    QuicRetireConnectionIdFrame* frame) {
-  return framer->ProcessRetireConnectionIdFrame(reader, frame);
-}
-
-// static
 void QuicFramerPeer::SwapCrypters(QuicFramer* framer1, QuicFramer* framer2) {
   for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; i++) {
     framer1->encrypter_[i].swap(framer2->encrypter_[i]);
@@ -327,16 +88,6 @@
 }
 
 // static
-size_t QuicFramerPeer::ComputeFrameLength(
-    QuicFramer* framer,
-    const QuicFrame& frame,
-    bool last_frame_in_packet,
-    QuicPacketNumberLength packet_number_length) {
-  return framer->ComputeFrameLength(frame, last_frame_in_packet,
-                                    packet_number_length);
-}
-
-// static
 void QuicFramerPeer::SetFirstSendingPacketNumber(QuicFramer* framer,
                                                  uint64_t packet_number) {
   *const_cast<QuicPacketNumber*>(&framer->first_sending_packet_number_) =
diff --git a/quic/test_tools/quic_framer_peer.h b/quic/test_tools/quic_framer_peer.h
index 5dbdf82..fdfa0df 100644
--- a/quic/test_tools/quic_framer_peer.h
+++ b/quic/test_tools/quic_framer_peer.h
@@ -41,125 +41,6 @@
   static QuicEncrypter* GetEncrypter(QuicFramer* framer, EncryptionLevel level);
   static QuicDecrypter* GetDecrypter(QuicFramer* framer, EncryptionLevel level);
 
-  // IETF defined frame append/process methods.
-  static bool ProcessIetfStreamFrame(QuicFramer* framer,
-                                     QuicDataReader* reader,
-                                     uint8_t frame_type,
-                                     QuicStreamFrame* frame);
-  static bool AppendIetfStreamFrame(QuicFramer* framer,
-                                    const QuicStreamFrame& frame,
-                                    bool last_frame_in_packet,
-                                    QuicDataWriter* writer);
-  static bool AppendCryptoFrame(QuicFramer* framer,
-                                const QuicCryptoFrame& frame,
-                                QuicDataWriter* writer);
-
-  static bool AppendIetfConnectionCloseFrame(
-      QuicFramer* framer,
-      const QuicConnectionCloseFrame& frame,
-      QuicDataWriter* writer);
-  static bool ProcessIetfConnectionCloseFrame(QuicFramer* framer,
-                                              QuicDataReader* reader,
-                                              QuicConnectionCloseType type,
-                                              QuicConnectionCloseFrame* frame);
-  static bool ProcessIetfAckFrame(QuicFramer* framer,
-                                  QuicDataReader* reader,
-                                  uint64_t frame_type,
-                                  QuicAckFrame* ack_frame);
-  static bool AppendIetfAckFrameAndTypeByte(QuicFramer* framer,
-                                            const QuicAckFrame& frame,
-                                            QuicDataWriter* writer);
-  static size_t GetIetfAckFrameSize(QuicFramer* framer,
-                                    const QuicAckFrame& frame);
-  static bool AppendIetfResetStreamFrame(QuicFramer* framer,
-                                         const QuicRstStreamFrame& frame,
-                                         QuicDataWriter* writer);
-  static bool ProcessIetfResetStreamFrame(QuicFramer* framer,
-                                          QuicDataReader* reader,
-                                          QuicRstStreamFrame* frame);
-
-  static bool ProcessPathChallengeFrame(QuicFramer* framer,
-                                        QuicDataReader* reader,
-                                        QuicPathChallengeFrame* frame);
-  static bool ProcessPathResponseFrame(QuicFramer* framer,
-                                       QuicDataReader* reader,
-                                       QuicPathResponseFrame* frame);
-
-  static bool AppendPathChallengeFrame(QuicFramer* framer,
-                                       const QuicPathChallengeFrame& frame,
-                                       QuicDataWriter* writer);
-  static bool AppendPathResponseFrame(QuicFramer* framer,
-                                      const QuicPathResponseFrame& frame,
-                                      QuicDataWriter* writer);
-
-  static bool ProcessStopSendingFrame(QuicFramer* framer,
-                                      QuicDataReader* reader,
-                                      QuicStopSendingFrame* stop_sending_frame);
-  static bool AppendStopSendingFrame(
-      QuicFramer* framer,
-      const QuicStopSendingFrame& stop_sending_frame,
-      QuicDataWriter* writer);
-
-  // Append/consume IETF-Format MAX_DATA and MAX_STREAM_DATA frames
-  static bool AppendMaxDataFrame(QuicFramer* framer,
-                                 const QuicWindowUpdateFrame& frame,
-                                 QuicDataWriter* writer);
-  static bool AppendMaxStreamDataFrame(QuicFramer* framer,
-                                       const QuicWindowUpdateFrame& frame,
-                                       QuicDataWriter* writer);
-  static bool ProcessMaxDataFrame(QuicFramer* framer,
-                                  QuicDataReader* reader,
-                                  QuicWindowUpdateFrame* frame);
-  static bool ProcessMaxStreamDataFrame(QuicFramer* framer,
-                                        QuicDataReader* reader,
-                                        QuicWindowUpdateFrame* frame);
-  static bool AppendMaxStreamsFrame(QuicFramer* framer,
-                                    const QuicMaxStreamsFrame& frame,
-                                    QuicDataWriter* writer);
-  static bool ProcessMaxStreamsFrame(QuicFramer* framer,
-                                     QuicDataReader* reader,
-                                     QuicMaxStreamsFrame* frame,
-                                     uint64_t frame_type);
-  static bool AppendIetfBlockedFrame(QuicFramer* framer,
-                                     const QuicBlockedFrame& frame,
-                                     QuicDataWriter* writer);
-  static bool ProcessIetfBlockedFrame(QuicFramer* framer,
-                                      QuicDataReader* reader,
-                                      QuicBlockedFrame* frame);
-
-  static bool AppendStreamBlockedFrame(QuicFramer* framer,
-                                       const QuicBlockedFrame& frame,
-                                       QuicDataWriter* writer);
-  static bool ProcessStreamBlockedFrame(QuicFramer* framer,
-                                        QuicDataReader* reader,
-                                        QuicBlockedFrame* frame);
-
-  static bool AppendStreamsBlockedFrame(QuicFramer* framer,
-                                        const QuicStreamsBlockedFrame& frame,
-                                        QuicDataWriter* writer);
-  static bool ProcessStreamsBlockedFrame(QuicFramer* framer,
-                                         QuicDataReader* reader,
-                                         QuicStreamsBlockedFrame* frame,
-                                         uint64_t frame_type);
-
-  static bool AppendNewConnectionIdFrame(QuicFramer* framer,
-                                         const QuicNewConnectionIdFrame& frame,
-                                         QuicDataWriter* writer);
-  static bool ProcessNewConnectionIdFrame(QuicFramer* framer,
-                                          QuicDataReader* reader,
-                                          QuicNewConnectionIdFrame* frame);
-  static bool AppendRetireConnectionIdFrame(
-      QuicFramer* framer,
-      const QuicRetireConnectionIdFrame& frame,
-      QuicDataWriter* writer);
-  static bool ProcessRetireConnectionIdFrame(
-      QuicFramer* framer,
-      QuicDataReader* reader,
-      QuicRetireConnectionIdFrame* frame);
-  static size_t ComputeFrameLength(QuicFramer* framer,
-                                   const QuicFrame& frame,
-                                   bool last_frame_in_packet,
-                                   QuicPacketNumberLength packet_number_length);
   static void SetFirstSendingPacketNumber(QuicFramer* framer,
                                           uint64_t packet_number);
   static void SetExpectedServerConnectionIDLength(