diff --git a/build/source_list.bzl b/build/source_list.bzl
index bb7da0b..d65346b 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -77,13 +77,19 @@
     "http2/adapter/window_manager.h",
     "http2/core/array_output_buffer.h",
     "http2/core/header_byte_listener_interface.h",
+    "http2/core/http2_frame_decoder_adapter.h",
     "http2/core/http2_header_block_hpack_listener.h",
     "http2/core/http2_trace_logging.h",
     "http2/core/no_op_headers_handler.h",
     "http2/core/priority_write_scheduler.h",
     "http2/core/recording_headers_handler.h",
+    "http2/core/spdy_alt_svc_wire_format.h",
+    "http2/core/spdy_bitmasks.h",
+    "http2/core/spdy_frame_builder.h",
+    "http2/core/spdy_framer.h",
     "http2/core/spdy_headers_handler_interface.h",
     "http2/core/spdy_no_op_visitor.h",
+    "http2/core/spdy_protocol.h",
     "http2/core/zero_copy_output_buffer.h",
     "http2/decoder/decode_buffer.h",
     "http2/decoder/decode_http2_structures.h",
@@ -434,9 +440,14 @@
     "http2/adapter/oghttp2_util.cc",
     "http2/adapter/window_manager.cc",
     "http2/core/array_output_buffer.cc",
+    "http2/core/http2_frame_decoder_adapter.cc",
     "http2/core/http2_trace_logging.cc",
     "http2/core/recording_headers_handler.cc",
+    "http2/core/spdy_alt_svc_wire_format.cc",
+    "http2/core/spdy_frame_builder.cc",
+    "http2/core/spdy_framer.cc",
     "http2/core/spdy_no_op_visitor.cc",
+    "http2/core/spdy_protocol.cc",
     "http2/decoder/decode_buffer.cc",
     "http2/decoder/decode_http2_structures.cc",
     "http2/decoder/decode_status.cc",
@@ -688,11 +699,6 @@
     "quic/core/web_transport_write_blocked_list.cc",
     "quic/platform/api/quic_socket_address.cc",
     "spdy/core/hpack/hpack_decoder_adapter.cc",
-    "spdy/core/http2_frame_decoder_adapter.cc",
-    "spdy/core/spdy_alt_svc_wire_format.cc",
-    "spdy/core/spdy_frame_builder.cc",
-    "spdy/core/spdy_framer.cc",
-    "spdy/core/spdy_protocol.cc",
     "web_transport/complete_buffer_visitor.cc",
     "web_transport/encapsulated/encapsulated_web_transport.cc",
     "web_transport/web_transport_headers.cc",
@@ -1113,6 +1119,10 @@
     "http2/adapter/window_manager_test.cc",
     "http2/core/array_output_buffer_test.cc",
     "http2/core/priority_write_scheduler_test.cc",
+    "http2/core/spdy_alt_svc_wire_format_test.cc",
+    "http2/core/spdy_frame_builder_test.cc",
+    "http2/core/spdy_framer_test.cc",
+    "http2/core/spdy_protocol_test.cc",
     "http2/decoder/decode_buffer_test.cc",
     "http2/decoder/decode_http2_structures_test.cc",
     "http2/decoder/http2_frame_decoder_test.cc",
@@ -1326,10 +1336,6 @@
     "quic/tools/simple_ticket_crypter_test.cc",
     "spdy/core/hpack/hpack_decoder_adapter_test.cc",
     "spdy/core/hpack/hpack_round_trip_test.cc",
-    "spdy/core/spdy_alt_svc_wire_format_test.cc",
-    "spdy/core/spdy_frame_builder_test.cc",
-    "spdy/core/spdy_framer_test.cc",
-    "spdy/core/spdy_protocol_test.cc",
     "web_transport/encapsulated/encapsulated_web_transport_test.cc",
     "web_transport/web_transport_headers_test.cc",
     "web_transport/web_transport_priority_scheduler_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 23aaaaa..1692b9a 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -77,13 +77,19 @@
     "src/quiche/http2/adapter/window_manager.h",
     "src/quiche/http2/core/array_output_buffer.h",
     "src/quiche/http2/core/header_byte_listener_interface.h",
+    "src/quiche/http2/core/http2_frame_decoder_adapter.h",
     "src/quiche/http2/core/http2_header_block_hpack_listener.h",
     "src/quiche/http2/core/http2_trace_logging.h",
     "src/quiche/http2/core/no_op_headers_handler.h",
     "src/quiche/http2/core/priority_write_scheduler.h",
     "src/quiche/http2/core/recording_headers_handler.h",
+    "src/quiche/http2/core/spdy_alt_svc_wire_format.h",
+    "src/quiche/http2/core/spdy_bitmasks.h",
+    "src/quiche/http2/core/spdy_frame_builder.h",
+    "src/quiche/http2/core/spdy_framer.h",
     "src/quiche/http2/core/spdy_headers_handler_interface.h",
     "src/quiche/http2/core/spdy_no_op_visitor.h",
+    "src/quiche/http2/core/spdy_protocol.h",
     "src/quiche/http2/core/zero_copy_output_buffer.h",
     "src/quiche/http2/decoder/decode_buffer.h",
     "src/quiche/http2/decoder/decode_http2_structures.h",
@@ -434,9 +440,14 @@
     "src/quiche/http2/adapter/oghttp2_util.cc",
     "src/quiche/http2/adapter/window_manager.cc",
     "src/quiche/http2/core/array_output_buffer.cc",
+    "src/quiche/http2/core/http2_frame_decoder_adapter.cc",
     "src/quiche/http2/core/http2_trace_logging.cc",
     "src/quiche/http2/core/recording_headers_handler.cc",
+    "src/quiche/http2/core/spdy_alt_svc_wire_format.cc",
+    "src/quiche/http2/core/spdy_frame_builder.cc",
+    "src/quiche/http2/core/spdy_framer.cc",
     "src/quiche/http2/core/spdy_no_op_visitor.cc",
+    "src/quiche/http2/core/spdy_protocol.cc",
     "src/quiche/http2/decoder/decode_buffer.cc",
     "src/quiche/http2/decoder/decode_http2_structures.cc",
     "src/quiche/http2/decoder/decode_status.cc",
@@ -688,11 +699,6 @@
     "src/quiche/quic/core/web_transport_write_blocked_list.cc",
     "src/quiche/quic/platform/api/quic_socket_address.cc",
     "src/quiche/spdy/core/hpack/hpack_decoder_adapter.cc",
-    "src/quiche/spdy/core/http2_frame_decoder_adapter.cc",
-    "src/quiche/spdy/core/spdy_alt_svc_wire_format.cc",
-    "src/quiche/spdy/core/spdy_frame_builder.cc",
-    "src/quiche/spdy/core/spdy_framer.cc",
-    "src/quiche/spdy/core/spdy_protocol.cc",
     "src/quiche/web_transport/complete_buffer_visitor.cc",
     "src/quiche/web_transport/encapsulated/encapsulated_web_transport.cc",
     "src/quiche/web_transport/web_transport_headers.cc",
@@ -1114,6 +1120,10 @@
     "src/quiche/http2/adapter/window_manager_test.cc",
     "src/quiche/http2/core/array_output_buffer_test.cc",
     "src/quiche/http2/core/priority_write_scheduler_test.cc",
+    "src/quiche/http2/core/spdy_alt_svc_wire_format_test.cc",
+    "src/quiche/http2/core/spdy_frame_builder_test.cc",
+    "src/quiche/http2/core/spdy_framer_test.cc",
+    "src/quiche/http2/core/spdy_protocol_test.cc",
     "src/quiche/http2/decoder/decode_buffer_test.cc",
     "src/quiche/http2/decoder/decode_http2_structures_test.cc",
     "src/quiche/http2/decoder/http2_frame_decoder_test.cc",
@@ -1327,10 +1337,6 @@
     "src/quiche/quic/tools/simple_ticket_crypter_test.cc",
     "src/quiche/spdy/core/hpack/hpack_decoder_adapter_test.cc",
     "src/quiche/spdy/core/hpack/hpack_round_trip_test.cc",
-    "src/quiche/spdy/core/spdy_alt_svc_wire_format_test.cc",
-    "src/quiche/spdy/core/spdy_frame_builder_test.cc",
-    "src/quiche/spdy/core/spdy_framer_test.cc",
-    "src/quiche/spdy/core/spdy_protocol_test.cc",
     "src/quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc",
     "src/quiche/web_transport/web_transport_headers_test.cc",
     "src/quiche/web_transport/web_transport_priority_scheduler_test.cc",
diff --git a/build/source_list.json b/build/source_list.json
index 33422d0..9bb5d09 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -76,13 +76,19 @@
     "quiche/http2/adapter/window_manager.h",
     "quiche/http2/core/array_output_buffer.h",
     "quiche/http2/core/header_byte_listener_interface.h",
+    "quiche/http2/core/http2_frame_decoder_adapter.h",
     "quiche/http2/core/http2_header_block_hpack_listener.h",
     "quiche/http2/core/http2_trace_logging.h",
     "quiche/http2/core/no_op_headers_handler.h",
     "quiche/http2/core/priority_write_scheduler.h",
     "quiche/http2/core/recording_headers_handler.h",
+    "quiche/http2/core/spdy_alt_svc_wire_format.h",
+    "quiche/http2/core/spdy_bitmasks.h",
+    "quiche/http2/core/spdy_frame_builder.h",
+    "quiche/http2/core/spdy_framer.h",
     "quiche/http2/core/spdy_headers_handler_interface.h",
     "quiche/http2/core/spdy_no_op_visitor.h",
+    "quiche/http2/core/spdy_protocol.h",
     "quiche/http2/core/zero_copy_output_buffer.h",
     "quiche/http2/decoder/decode_buffer.h",
     "quiche/http2/decoder/decode_http2_structures.h",
@@ -433,9 +439,14 @@
     "quiche/http2/adapter/oghttp2_util.cc",
     "quiche/http2/adapter/window_manager.cc",
     "quiche/http2/core/array_output_buffer.cc",
+    "quiche/http2/core/http2_frame_decoder_adapter.cc",
     "quiche/http2/core/http2_trace_logging.cc",
     "quiche/http2/core/recording_headers_handler.cc",
+    "quiche/http2/core/spdy_alt_svc_wire_format.cc",
+    "quiche/http2/core/spdy_frame_builder.cc",
+    "quiche/http2/core/spdy_framer.cc",
     "quiche/http2/core/spdy_no_op_visitor.cc",
+    "quiche/http2/core/spdy_protocol.cc",
     "quiche/http2/decoder/decode_buffer.cc",
     "quiche/http2/decoder/decode_http2_structures.cc",
     "quiche/http2/decoder/decode_status.cc",
@@ -687,11 +698,6 @@
     "quiche/quic/core/web_transport_write_blocked_list.cc",
     "quiche/quic/platform/api/quic_socket_address.cc",
     "quiche/spdy/core/hpack/hpack_decoder_adapter.cc",
-    "quiche/spdy/core/http2_frame_decoder_adapter.cc",
-    "quiche/spdy/core/spdy_alt_svc_wire_format.cc",
-    "quiche/spdy/core/spdy_frame_builder.cc",
-    "quiche/spdy/core/spdy_framer.cc",
-    "quiche/spdy/core/spdy_protocol.cc",
     "quiche/web_transport/complete_buffer_visitor.cc",
     "quiche/web_transport/encapsulated/encapsulated_web_transport.cc",
     "quiche/web_transport/web_transport_headers.cc",
@@ -1113,6 +1119,10 @@
     "quiche/http2/adapter/window_manager_test.cc",
     "quiche/http2/core/array_output_buffer_test.cc",
     "quiche/http2/core/priority_write_scheduler_test.cc",
+    "quiche/http2/core/spdy_alt_svc_wire_format_test.cc",
+    "quiche/http2/core/spdy_frame_builder_test.cc",
+    "quiche/http2/core/spdy_framer_test.cc",
+    "quiche/http2/core/spdy_protocol_test.cc",
     "quiche/http2/decoder/decode_buffer_test.cc",
     "quiche/http2/decoder/decode_http2_structures_test.cc",
     "quiche/http2/decoder/http2_frame_decoder_test.cc",
@@ -1326,10 +1336,6 @@
     "quiche/quic/tools/simple_ticket_crypter_test.cc",
     "quiche/spdy/core/hpack/hpack_decoder_adapter_test.cc",
     "quiche/spdy/core/hpack/hpack_round_trip_test.cc",
-    "quiche/spdy/core/spdy_alt_svc_wire_format_test.cc",
-    "quiche/spdy/core/spdy_frame_builder_test.cc",
-    "quiche/spdy/core/spdy_framer_test.cc",
-    "quiche/spdy/core/spdy_protocol_test.cc",
     "quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc",
     "quiche/web_transport/web_transport_headers_test.cc",
     "quiche/web_transport/web_transport_priority_scheduler_test.cc"
diff --git a/quiche/spdy/core/http2_frame_decoder_adapter.cc b/quiche/http2/core/http2_frame_decoder_adapter.cc
similarity index 99%
rename from quiche/spdy/core/http2_frame_decoder_adapter.cc
rename to quiche/http2/core/http2_frame_decoder_adapter.cc
index 8eb9370..64362d1 100644
--- a/quiche/spdy/core/http2_frame_decoder_adapter.cc
+++ b/quiche/http2/core/http2_frame_decoder_adapter.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/spdy/core/http2_frame_decoder_adapter.h"
+#include "quiche/http2/core/http2_frame_decoder_adapter.h"
 
 // Logging policy: If an error in the input is detected, QUICHE_VLOG(n) is used
 // so that the option exists to debug the situation. Otherwise, this code mostly
@@ -17,7 +17,9 @@
 #include <string>
 
 #include "absl/strings/string_view.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
 #include "quiche/http2/core/spdy_headers_handler_interface.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/http2/decoder/decode_buffer.h"
 #include "quiche/http2/decoder/decode_status.h"
 #include "quiche/http2/decoder/http2_frame_decoder.h"
@@ -29,8 +31,6 @@
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_endian.h"
 #include "quiche/spdy/core/hpack/hpack_decoder_adapter.h"
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 using ::spdy::ExtensionVisitorInterface;
 using ::spdy::HpackDecoderAdapter;
@@ -69,7 +69,7 @@
 
 // Overwrites the fields of the header with invalid values, for the purpose
 // of identifying reading of unset fields. Only takes effect for debug builds.
-// In Address Sanatizer builds, it also marks the fields as un-readable.
+// In Address Sanitizer builds, it also marks the fields as un-readable.
 #ifndef NDEBUG
 void CorruptFrameHeader(Http2FrameHeader* header) {
   // Beyond a valid payload length, which is 2^24 - 1.
diff --git a/quiche/http2/core/http2_frame_decoder_adapter.h b/quiche/http2/core/http2_frame_decoder_adapter.h
new file mode 100644
index 0000000..2fde705
--- /dev/null
+++ b/quiche/http2/core/http2_frame_decoder_adapter.h
@@ -0,0 +1,566 @@
+// Copyright 2016 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.
+
+#ifndef QUICHE_HTTP2_CORE_HTTP2_FRAME_DECODER_ADAPTER_H_
+#define QUICHE_HTTP2_CORE_HTTP2_FRAME_DECODER_ADAPTER_H_
+
+#include <stddef.h>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
+#include "quiche/http2/core/spdy_headers_handler_interface.h"
+#include "quiche/http2/core/spdy_protocol.h"
+#include "quiche/http2/decoder/decode_status.h"
+#include "quiche/http2/decoder/http2_frame_decoder.h"
+#include "quiche/http2/decoder/http2_frame_decoder_listener.h"
+#include "quiche/http2/http2_constants.h"
+#include "quiche/http2/http2_structures.h"
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/spdy/core/hpack/hpack_decoder_adapter.h"
+
+namespace spdy {
+
+class SpdyFramerVisitorInterface;
+class ExtensionVisitorInterface;
+
+}  // namespace spdy
+
+// TODO(dahollings): Perform various renames/moves suggested in cl/164660364.
+
+namespace http2 {
+
+// Adapts SpdyFramer interface to use Http2FrameDecoder.
+class QUICHE_EXPORT Http2DecoderAdapter
+    : public http2::Http2FrameDecoderListener {
+ public:
+  // HTTP2 states.
+  enum SpdyState {
+    SPDY_ERROR,
+    SPDY_READY_FOR_FRAME,  // Framer is ready for reading the next frame.
+    SPDY_FRAME_COMPLETE,  // Framer has finished reading a frame, need to reset.
+    SPDY_READING_COMMON_HEADER,
+    SPDY_CONTROL_FRAME_PAYLOAD,
+    SPDY_READ_DATA_FRAME_PADDING_LENGTH,
+    SPDY_CONSUME_PADDING,
+    SPDY_IGNORE_REMAINING_PAYLOAD,
+    SPDY_FORWARD_STREAM_FRAME,
+    SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK,
+    SPDY_CONTROL_FRAME_HEADER_BLOCK,
+    SPDY_GOAWAY_FRAME_PAYLOAD,
+    SPDY_SETTINGS_FRAME_HEADER,
+    SPDY_SETTINGS_FRAME_PAYLOAD,
+    SPDY_ALTSVC_FRAME_PAYLOAD,
+    SPDY_EXTENSION_FRAME_PAYLOAD,
+  };
+
+  // Framer error codes.
+  enum SpdyFramerError {
+    SPDY_NO_ERROR,
+    SPDY_INVALID_STREAM_ID,           // Stream ID is invalid
+    SPDY_INVALID_CONTROL_FRAME,       // Control frame is mal-formatted.
+    SPDY_CONTROL_PAYLOAD_TOO_LARGE,   // Control frame payload was too large.
+    SPDY_DECOMPRESS_FAILURE,          // There was an error decompressing.
+    SPDY_INVALID_PADDING,             // HEADERS or DATA frame padding invalid
+    SPDY_INVALID_DATA_FRAME_FLAGS,    // Data frame has invalid flags.
+    SPDY_UNEXPECTED_FRAME,            // Frame received out of order.
+    SPDY_INTERNAL_FRAMER_ERROR,       // SpdyFramer was used incorrectly.
+    SPDY_INVALID_CONTROL_FRAME_SIZE,  // Control frame not sized to spec
+    SPDY_OVERSIZED_PAYLOAD,           // Payload size was too large
+
+    // HttpDecoder or HttpDecoderAdapter error.
+    // See HpackDecodingError for description of each error code.
+    SPDY_HPACK_INDEX_VARINT_ERROR,
+    SPDY_HPACK_NAME_LENGTH_VARINT_ERROR,
+    SPDY_HPACK_VALUE_LENGTH_VARINT_ERROR,
+    SPDY_HPACK_NAME_TOO_LONG,
+    SPDY_HPACK_VALUE_TOO_LONG,
+    SPDY_HPACK_NAME_HUFFMAN_ERROR,
+    SPDY_HPACK_VALUE_HUFFMAN_ERROR,
+    SPDY_HPACK_MISSING_DYNAMIC_TABLE_SIZE_UPDATE,
+    SPDY_HPACK_INVALID_INDEX,
+    SPDY_HPACK_INVALID_NAME_INDEX,
+    SPDY_HPACK_DYNAMIC_TABLE_SIZE_UPDATE_NOT_ALLOWED,
+    SPDY_HPACK_INITIAL_DYNAMIC_TABLE_SIZE_UPDATE_IS_ABOVE_LOW_WATER_MARK,
+    SPDY_HPACK_DYNAMIC_TABLE_SIZE_UPDATE_IS_ABOVE_ACKNOWLEDGED_SETTING,
+    SPDY_HPACK_TRUNCATED_BLOCK,
+    SPDY_HPACK_FRAGMENT_TOO_LONG,
+    SPDY_HPACK_COMPRESSED_HEADER_SIZE_EXCEEDS_LIMIT,
+
+    // Set if the visitor no longer wishes to receive events for this
+    // connection.
+    SPDY_STOP_PROCESSING,
+
+    LAST_ERROR,  // Must be the last entry in the enum.
+  };
+
+  // For debugging.
+  static const char* StateToString(int state);
+  static const char* SpdyFramerErrorToString(SpdyFramerError spdy_framer_error);
+
+  Http2DecoderAdapter();
+  ~Http2DecoderAdapter() override;
+
+  Http2DecoderAdapter(const Http2DecoderAdapter&) = delete;
+  Http2DecoderAdapter& operator=(const Http2DecoderAdapter&) = delete;
+
+  // Set callbacks to be called from the framer.  A visitor must be set, or
+  // else the framer will likely crash.  It is acceptable for the visitor
+  // to do nothing.  If this is called multiple times, only the last visitor
+  // will be used.
+  void set_visitor(spdy::SpdyFramerVisitorInterface* visitor);
+  spdy::SpdyFramerVisitorInterface* visitor() const { return visitor_; }
+
+  // Set extension callbacks to be called from the framer or decoder. Optional.
+  // If called multiple times, only the last visitor will be used.
+  void set_extension_visitor(spdy::ExtensionVisitorInterface* visitor);
+  spdy::ExtensionVisitorInterface* extension_visitor() const {
+    return extension_;
+  }
+
+  // Set debug callbacks to be called from the framer. The debug visitor is
+  // completely optional and need not be set in order for normal operation.
+  // If this is called multiple times, only the last visitor will be used.
+  void set_debug_visitor(spdy::SpdyFramerDebugVisitorInterface* debug_visitor);
+  spdy::SpdyFramerDebugVisitorInterface* debug_visitor() const {
+    return debug_visitor_;
+  }
+
+  // Decode the |len| bytes of encoded HTTP/2 starting at |*data|. Returns
+  // the number of bytes consumed. It is safe to pass more bytes in than
+  // may be consumed. Should process (or otherwise buffer) as much as
+  // available.
+  //
+  // If the input contains the entirety of a DATA frame payload, GOAWAY frame
+  // Additional Debug Data field, or unknown frame payload, then the
+  // corresponding SpdyFramerVisitorInterface::OnStreamFrameData(),
+  // OnGoAwayFrameData(), or ExtensionVisitorInterface::OnFramePayload() method
+  // is guaranteed to be called exactly once, with the entire payload or field.
+  size_t ProcessInput(const char* data, size_t len);
+
+  // Current state of the decoder.
+  SpdyState state() const;
+
+  // Current error code (NO_ERROR if state != ERROR).
+  SpdyFramerError spdy_framer_error() const;
+
+  // Has any frame header looked like the start of an HTTP/1.1 (or earlier)
+  // response? Used to detect if a backend/server that we sent a request to
+  // has responded with an HTTP/1.1 (or earlier) response.
+  bool probable_http_response() const;
+
+  spdy::HpackDecoderAdapter& GetHpackDecoder() { return hpack_decoder_; }
+  const spdy::HpackDecoderAdapter& GetHpackDecoder() const {
+    return hpack_decoder_;
+  }
+
+  bool HasError() const;
+
+  // A visitor may call this method to indicate it no longer wishes to receive
+  // events for this connection.
+  void StopProcessing();
+
+  // Sets the limit on the size of received HTTP/2 frame payloads. Corresponds
+  // to SETTINGS_MAX_FRAME_SIZE as advertised to the peer.
+  void SetMaxFrameSize(size_t max_frame_size);
+
+ private:
+  bool OnFrameHeader(const Http2FrameHeader& header) override;
+  void OnDataStart(const Http2FrameHeader& header) override;
+  void OnDataPayload(const char* data, size_t len) override;
+  void OnDataEnd() override;
+  void OnHeadersStart(const Http2FrameHeader& header) override;
+  void OnHeadersPriority(const Http2PriorityFields& priority) override;
+  void OnHpackFragment(const char* data, size_t len) override;
+  void OnHeadersEnd() override;
+  void OnPriorityFrame(const Http2FrameHeader& header,
+                       const Http2PriorityFields& priority) override;
+  void OnContinuationStart(const Http2FrameHeader& header) override;
+  void OnContinuationEnd() override;
+  void OnPadLength(size_t trailing_length) override;
+  void OnPadding(const char* padding, size_t skipped_length) override;
+  void OnRstStream(const Http2FrameHeader& header,
+                   Http2ErrorCode http2_error_code) override;
+  void OnSettingsStart(const Http2FrameHeader& header) override;
+  void OnSetting(const Http2SettingFields& setting_fields) override;
+  void OnSettingsEnd() override;
+  void OnSettingsAck(const Http2FrameHeader& header) override;
+  void OnPushPromiseStart(const Http2FrameHeader& header,
+                          const Http2PushPromiseFields& promise,
+                          size_t total_padding_length) override;
+  void OnPushPromiseEnd() override;
+  void OnPing(const Http2FrameHeader& header,
+              const Http2PingFields& ping) override;
+  void OnPingAck(const Http2FrameHeader& header,
+                 const Http2PingFields& ping) override;
+  void OnGoAwayStart(const Http2FrameHeader& header,
+                     const Http2GoAwayFields& goaway) override;
+  void OnGoAwayOpaqueData(const char* data, size_t len) override;
+  void OnGoAwayEnd() override;
+  void OnWindowUpdate(const Http2FrameHeader& header,
+                      uint32_t increment) override;
+  void OnAltSvcStart(const Http2FrameHeader& header, size_t origin_length,
+                     size_t value_length) override;
+  void OnAltSvcOriginData(const char* data, size_t len) override;
+  void OnAltSvcValueData(const char* data, size_t len) override;
+  void OnAltSvcEnd() override;
+  void OnPriorityUpdateStart(
+      const Http2FrameHeader& header,
+      const Http2PriorityUpdateFields& priority_update) override;
+  void OnPriorityUpdatePayload(const char* data, size_t len) override;
+  void OnPriorityUpdateEnd() override;
+  void OnUnknownStart(const Http2FrameHeader& header) override;
+  void OnUnknownPayload(const char* data, size_t len) override;
+  void OnUnknownEnd() override;
+  void OnPaddingTooLong(const Http2FrameHeader& header,
+                        size_t missing_length) override;
+  void OnFrameSizeError(const Http2FrameHeader& header) override;
+
+  size_t ProcessInputFrame(const char* data, size_t len);
+
+  void DetermineSpdyState(DecodeStatus status);
+  void ResetBetweenFrames();
+
+  void set_spdy_state(SpdyState v);
+
+  void SetSpdyErrorAndNotify(SpdyFramerError error, std::string detailed_error);
+
+  const Http2FrameHeader& frame_header() const;
+
+  uint32_t stream_id() const;
+  Http2FrameType frame_type() const;
+
+  size_t remaining_total_payload() const;
+
+  bool IsReadingPaddingLength();
+  bool IsSkippingPadding();
+  bool IsDiscardingPayload();
+  // Called from OnXyz or OnXyzStart methods to decide whether it is OK to
+  // handle the callback.
+  bool IsOkToStartFrame(const Http2FrameHeader& header);
+  bool HasRequiredStreamId(uint32_t stream_id);
+
+  bool HasRequiredStreamId(const Http2FrameHeader& header);
+
+  bool HasRequiredStreamIdZero(uint32_t stream_id);
+
+  bool HasRequiredStreamIdZero(const Http2FrameHeader& header);
+
+  void ReportReceiveCompressedFrame(const Http2FrameHeader& header);
+
+  void CommonStartHpackBlock();
+
+  // SpdyFramer calls HandleControlFrameHeadersData even if there are zero
+  // fragment bytes in the first frame, so do the same.
+  void MaybeAnnounceEmptyFirstHpackFragment();
+  void CommonHpackFragmentEnd();
+
+  // The most recently decoded frame header; invalid after we reached the end
+  // of that frame.
+  Http2FrameHeader frame_header_;
+
+  // If decoding an HPACK block that is split across multiple frames, this holds
+  // the frame header of the HEADERS or PUSH_PROMISE that started the block.
+  Http2FrameHeader hpack_first_frame_header_;
+
+  // Amount of trailing padding. Currently used just as an indicator of whether
+  // OnPadLength has been called.
+  std::optional<size_t> opt_pad_length_;
+
+  // Temporary buffers for the AltSvc fields.
+  std::string alt_svc_origin_;
+  std::string alt_svc_value_;
+
+  // Temporary buffers for PRIORITY_UPDATE fields.
+  uint32_t prioritized_stream_id_ = 0;
+  std::string priority_field_value_;
+
+  // Listener used if we transition to an error state; the listener ignores all
+  // the callbacks.
+  Http2FrameDecoderNoOpListener no_op_listener_;
+
+  spdy::SpdyFramerVisitorInterface* visitor_ = nullptr;
+  spdy::SpdyFramerDebugVisitorInterface* debug_visitor_ = nullptr;
+
+  // If non-null, unknown frames and settings are passed to the extension.
+  spdy::ExtensionVisitorInterface* extension_ = nullptr;
+
+  // The HPACK decoder to be used for this adapter.
+  spdy::HpackDecoderAdapter hpack_decoder_;
+
+  // The HTTP/2 frame decoder.
+  Http2FrameDecoder frame_decoder_;
+
+  // Next frame type expected. Currently only used for CONTINUATION frames,
+  // but could be used for detecting whether the first frame is a SETTINGS
+  // frame.
+  // TODO(jamessynge): Provide means to indicate that decoder should require
+  // SETTINGS frame as the first frame.
+  Http2FrameType expected_frame_type_;
+
+  // Attempt to duplicate the SpdyState and SpdyFramerError values that
+  // SpdyFramer sets. Values determined by getting tests to pass.
+  SpdyState spdy_state_ = SpdyState::SPDY_READY_FOR_FRAME;
+  SpdyFramerError spdy_framer_error_ = SpdyFramerError::SPDY_NO_ERROR;
+
+  // The limit on the size of received HTTP/2 payloads as specified in the
+  // SETTINGS_MAX_FRAME_SIZE advertised to peer.
+  size_t max_frame_size_ = spdy::kHttp2DefaultFramePayloadLimit;
+
+  // Has OnFrameHeader been called?
+  bool decoded_frame_header_ = false;
+
+  // Have we recorded an Http2FrameHeader for the current frame?
+  // We only do so if the decoder will make multiple callbacks for
+  // the frame; for example, for PING frames we don't make record
+  // the frame header, but for ALTSVC we do.
+  bool has_frame_header_ = false;
+
+  // Have we recorded an Http2FrameHeader for the current HPACK block?
+  // True only for multi-frame HPACK blocks.
+  bool has_hpack_first_frame_header_ = false;
+
+  // Has OnHeaders() already been called for current HEADERS block? Only
+  // meaningful between OnHeadersStart and OnHeadersPriority.
+  bool on_headers_called_ = false;
+
+  // Has OnHpackFragment() already been called for current HPACK block?
+  // SpdyFramer will pass an empty buffer to the HPACK decoder if a HEADERS
+  // or PUSH_PROMISE has no HPACK data in it (e.g. a HEADERS frame with only
+  // padding). Detect that condition and replicate the behavior using this
+  // field.
+  bool on_hpack_fragment_called_ = false;
+
+  // Have we seen a frame header that appears to be an HTTP/1 response?
+  bool latched_probable_http_response_ = false;
+
+  // Is expected_frame_type_ set?
+  bool has_expected_frame_type_ = false;
+
+  // Is the current frame payload destined for |extension_|?
+  bool handling_extension_payload_ = false;
+};
+
+}  // namespace http2
+
+namespace spdy {
+
+// Http2DecoderAdapter will use the given visitor implementing this
+// interface to deliver event callbacks as frames are decoded.
+//
+// Control frames that contain HTTP2 header blocks (HEADER, and PUSH_PROMISE)
+// are processed in fashion that allows the decompressed header block to be
+// delivered in chunks to the visitor.
+// The following steps are followed:
+//   1. OnHeaders, or OnPushPromise is called.
+//   2. OnHeaderFrameStart is called; visitor is expected to return an instance
+//      of SpdyHeadersHandlerInterface that will receive the header key-value
+//      pairs.
+//   3. OnHeaderFrameEnd is called, indicating that the full header block has
+//      been delivered for the control frame.
+// During step 2, if the visitor is not interested in accepting the header data,
+// it should return a no-op implementation of SpdyHeadersHandlerInterface.
+class QUICHE_EXPORT SpdyFramerVisitorInterface {
+ public:
+  virtual ~SpdyFramerVisitorInterface() {}
+
+  // Called if an error is detected in the SpdyFrame protocol.
+  virtual void OnError(http2::Http2DecoderAdapter::SpdyFramerError error,
+                       std::string detailed_error) = 0;
+
+  // Called when the common header for a frame is received. Validating the
+  // common header occurs in later processing.
+  virtual void OnCommonHeader(SpdyStreamId /*stream_id*/, size_t /*length*/,
+                              uint8_t /*type*/, uint8_t /*flags*/) {}
+
+  // Called when a data frame header is received. The frame's data payload will
+  // be provided via subsequent calls to OnStreamFrameData().
+  // |stream_id| The stream receiving data.
+  // |length| The length of the payload in this DATA frame. Includes the length
+  //     of the data itself and potential padding.
+  // |fin| Whether the END_STREAM flag is set in the frame header.
+  virtual void OnDataFrameHeader(SpdyStreamId stream_id, size_t length,
+                                 bool fin) = 0;
+
+  // Called when data is received.
+  // |stream_id| The stream receiving data.
+  // |data| A buffer containing the data received.
+  // |len| The length of the data buffer.
+  virtual void OnStreamFrameData(SpdyStreamId stream_id, const char* data,
+                                 size_t len) = 0;
+
+  // Called when the other side has finished sending data on this stream.
+  // |stream_id| The stream that was receiving data.
+  virtual void OnStreamEnd(SpdyStreamId stream_id) = 0;
+
+  // Called when padding length field is received on a DATA frame.
+  // |stream_id| The stream receiving data.
+  // |value| The value of the padding length field.
+  virtual void OnStreamPadLength(SpdyStreamId /*stream_id*/, size_t /*value*/) {
+  }
+
+  // Called when padding is received (the trailing octets, not pad_len field) on
+  // a DATA frame.
+  // |stream_id| The stream receiving data.
+  // |len| The number of padding octets.
+  virtual void OnStreamPadding(SpdyStreamId stream_id, size_t len) = 0;
+
+  // Called just before processing the payload of a frame containing header
+  // data. Should return an implementation of SpdyHeadersHandlerInterface that
+  // will receive headers for stream |stream_id|. The caller will not take
+  // ownership of the headers handler. The same instance should remain live
+  // and be returned for all header frames comprising a logical header block
+  // (i.e. until OnHeaderFrameEnd() is called).
+  virtual SpdyHeadersHandlerInterface* OnHeaderFrameStart(
+      SpdyStreamId stream_id) = 0;
+
+  // Called after processing the payload of a frame containing header data.
+  virtual void OnHeaderFrameEnd(SpdyStreamId stream_id) = 0;
+
+  // Called when a RST_STREAM frame has been parsed.
+  virtual void OnRstStream(SpdyStreamId stream_id,
+                           SpdyErrorCode error_code) = 0;
+
+  // Called when a SETTINGS frame is received.
+  virtual void OnSettings() {}
+
+  // Called when a complete setting within a SETTINGS frame has been parsed.
+  // Note that |id| may or may not be a SETTINGS ID defined in the HTTP/2 spec.
+  virtual void OnSetting(SpdySettingsId id, uint32_t value) = 0;
+
+  // Called when a SETTINGS frame is received with the ACK flag set.
+  virtual void OnSettingsAck() {}
+
+  // Called before and after parsing SETTINGS id and value tuples.
+  virtual void OnSettingsEnd() = 0;
+
+  // Called when a PING frame has been parsed.
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) = 0;
+
+  // Called when a GOAWAY frame has been parsed.
+  virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
+                        SpdyErrorCode error_code) = 0;
+
+  // Called when a HEADERS frame is received.
+  // Note that header block data is not included. See OnHeaderFrameStart().
+  // |stream_id| The stream receiving the header.
+  // |payload_length| The length of the payload in this HEADERS frame. Includes
+  //     the length of the encoded header block and potential padding.
+  // |has_priority| Whether or not the headers frame included a priority value,
+  //     and stream dependency info.
+  // |weight| If |has_priority| is true, then weight (in the range [1, 256])
+  //     for the receiving stream, otherwise 0.
+  // |parent_stream_id| If |has_priority| is true the parent stream of the
+  //     receiving stream, else 0.
+  // |exclusive| If |has_priority| is true the exclusivity of dependence on the
+  //     parent stream, else false.
+  // |fin| Whether the END_STREAM flag is set in the frame header.
+  // |end| False if HEADERs frame is to be followed by a CONTINUATION frame,
+  //     or true if not.
+  virtual void OnHeaders(SpdyStreamId stream_id, size_t payload_length,
+                         bool has_priority, int weight,
+                         SpdyStreamId parent_stream_id, bool exclusive,
+                         bool fin, bool end) = 0;
+
+  // Called when a WINDOW_UPDATE frame has been parsed.
+  virtual void OnWindowUpdate(SpdyStreamId stream_id,
+                              int delta_window_size) = 0;
+
+  // Called when a goaway frame opaque data is available.
+  // |goaway_data| A buffer containing the opaque GOAWAY data chunk received.
+  // |len| The length of the header data buffer. A length of zero indicates
+  //       that the header data block has been completely sent.
+  // When this function returns true the visitor indicates that it accepted
+  // all of the data. Returning false indicates that that an error has
+  // occurred while processing the data. Default implementation returns true.
+  virtual bool OnGoAwayFrameData(const char* goaway_data, size_t len);
+
+  // Called when a PUSH_PROMISE frame is received.
+  // Note that header block data is not included. See OnHeaderFrameStart().
+  virtual void OnPushPromise(SpdyStreamId stream_id,
+                             SpdyStreamId promised_stream_id, bool end) = 0;
+
+  // Called when a CONTINUATION frame is received.
+  // Note that header block data is not included. See OnHeaderFrameStart().
+  // |stream_id| The stream receiving the CONTINUATION.
+  // |payload_length| The length of the payload in this CONTINUATION frame.
+  // |end| True if this CONTINUATION frame will not be followed by another
+  //     CONTINUATION frame.
+  virtual void OnContinuation(SpdyStreamId stream_id, size_t payload_length,
+                              bool end) = 0;
+
+  // Called when an ALTSVC frame has been parsed.
+  virtual void OnAltSvc(
+      SpdyStreamId /*stream_id*/, absl::string_view /*origin*/,
+      const SpdyAltSvcWireFormat::AlternativeServiceVector& /*altsvc_vector*/) {
+  }
+
+  // Called when a PRIORITY frame is received.
+  // |stream_id| The stream to update the priority of.
+  // |parent_stream_id| The parent stream of |stream_id|.
+  // |weight| Stream weight, in the range [1, 256].
+  // |exclusive| Whether |stream_id| should be an only child of
+  //     |parent_stream_id|.
+  virtual void OnPriority(SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
+                          int weight, bool exclusive) = 0;
+
+  // Called when a PRIORITY_UPDATE frame is received on stream 0.
+  // |prioritized_stream_id| is the Prioritized Stream ID and
+  // |priority_field_value| is the Priority Field Value
+  // parsed from the frame payload.
+  virtual void OnPriorityUpdate(SpdyStreamId prioritized_stream_id,
+                                absl::string_view priority_field_value) = 0;
+
+  // Called when a frame type we don't recognize is received.
+  // Return true if this appears to be a valid extension frame, false otherwise.
+  // We distinguish between extension frames and nonsense by checking
+  // whether the stream id is valid.
+  // TODO(b/239060116): Remove this callback altogether.
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, uint8_t frame_type) = 0;
+
+  // Called when the common header for a non-standard frame is received. If the
+  // `length` is nonzero, the frame's payload will be provided via subsequent
+  // calls to OnUnknownFramePayload().
+  // |stream_id| The stream receiving the non-standard frame.
+  // |length| The length of the payload of the frame.
+  // |type| The type of the frame. This type is non-standard.
+  // |flags| The flags of the frame.
+  virtual void OnUnknownFrameStart(SpdyStreamId stream_id, size_t length,
+                                   uint8_t type, uint8_t flags) = 0;
+
+  // Called when a non-empty payload chunk for a non-standard frame is received.
+  // The payload for a single frame may be delivered as multiple calls to
+  // OnUnknownFramePayload(). Since the length field is passed in
+  // OnUnknownFrameStart(), there is no explicit indication of the end of the
+  // frame payload.
+  // |stream_id| The stream receiving the non-standard frame.
+  // |payload| The payload chunk, which will be non-empty.
+  virtual void OnUnknownFramePayload(SpdyStreamId stream_id,
+                                     absl::string_view payload) = 0;
+};
+
+class QUICHE_EXPORT ExtensionVisitorInterface {
+ public:
+  virtual ~ExtensionVisitorInterface() {}
+
+  // Called when non-standard SETTINGS are received.
+  virtual void OnSetting(SpdySettingsId id, uint32_t value) = 0;
+
+  // Called when non-standard frames are received.
+  virtual bool OnFrameHeader(SpdyStreamId stream_id, size_t length,
+                             uint8_t type, uint8_t flags) = 0;
+
+  // The payload for a single frame may be delivered as multiple calls to
+  // OnFramePayload. Since the length field is passed in OnFrameHeader, there is
+  // no explicit indication of the end of the frame payload.
+  virtual void OnFramePayload(const char* data, size_t len) = 0;
+};
+
+}  // namespace spdy
+
+#endif  // QUICHE_HTTP2_CORE_HTTP2_FRAME_DECODER_ADAPTER_H_
diff --git a/quiche/http2/core/http2_trace_logging.cc b/quiche/http2/core/http2_trace_logging.cc
index 30988a9..7ae1fa1 100644
--- a/quiche/http2/core/http2_trace_logging.cc
+++ b/quiche/http2/core/http2_trace_logging.cc
@@ -8,11 +8,11 @@
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_callbacks.h"
 #include "quiche/spdy/core/http2_header_block.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 // Convenience macros for printing function arguments in log lines in the
 // format arg_name=value.
diff --git a/quiche/http2/core/http2_trace_logging.h b/quiche/http2/core/http2_trace_logging.h
index 84f7898..1d11ac3 100644
--- a/quiche/http2/core/http2_trace_logging.h
+++ b/quiche/http2/core/http2_trace_logging.h
@@ -8,13 +8,13 @@
 #include <cstdint>
 
 #include "absl/strings/string_view.h"
+#include "quiche/http2/core/http2_frame_decoder_adapter.h"
 #include "quiche/http2/core/recording_headers_handler.h"
 #include "quiche/http2/core/spdy_headers_handler_interface.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_callbacks.h"
-#include "quiche/spdy/core/http2_frame_decoder_adapter.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 // Logging macro to use for all HTTP/2 trace logging. Iff trace logging is
 // enabled, logs at level INFO with a common prefix prepended (to facilitate
diff --git a/quiche/http2/core/priority_write_scheduler.h b/quiche/http2/core/priority_write_scheduler.h
index 0e33111..7cab893 100644
--- a/quiche/http2/core/priority_write_scheduler.h
+++ b/quiche/http2/core/priority_write_scheduler.h
@@ -18,11 +18,11 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "absl/time/time.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_circular_deque.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 namespace http2 {
 
diff --git a/quiche/http2/core/priority_write_scheduler_test.cc b/quiche/http2/core/priority_write_scheduler_test.cc
index 4ac72bc..e290c42 100644
--- a/quiche/http2/core/priority_write_scheduler_test.cc
+++ b/quiche/http2/core/priority_write_scheduler_test.cc
@@ -4,15 +4,14 @@
 
 #include "quiche/http2/core/priority_write_scheduler.h"
 
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/http2/test_tools/spdy_test_utils.h"
 #include "quiche/common/platform/api/quiche_expect_bug.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 namespace http2 {
 namespace test {
 
-using ::spdy::kHttp2RootStreamId;
 using ::spdy::SpdyPriority;
 using ::spdy::SpdyStreamId;
 using ::testing::Eq;
diff --git a/quiche/spdy/core/spdy_alt_svc_wire_format.cc b/quiche/http2/core/spdy_alt_svc_wire_format.cc
similarity index 99%
rename from quiche/spdy/core/spdy_alt_svc_wire_format.cc
rename to quiche/http2/core/spdy_alt_svc_wire_format.cc
index 7981975..422e1ab 100644
--- a/quiche/spdy/core/spdy_alt_svc_wire_format.cc
+++ b/quiche/http2/core/spdy_alt_svc_wire_format.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
 
 #include <algorithm>
 #include <cctype>
diff --git a/quiche/http2/core/spdy_alt_svc_wire_format.h b/quiche/http2/core/spdy_alt_svc_wire_format.h
new file mode 100644
index 0000000..3d57b50
--- /dev/null
+++ b/quiche/http2/core/spdy_alt_svc_wire_format.h
@@ -0,0 +1,104 @@
+// Copyright (c) 2015 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.
+
+// This file contains data structures and utility functions used for serializing
+// and parsing alternative service header values, common to HTTP/1.1 header
+// fields and HTTP/2 and QUIC ALTSVC frames.  See specification at
+// https://httpwg.github.io/http-extensions/alt-svc.html.
+
+#ifndef QUICHE_HTTP2_CORE_SPDY_ALT_SVC_WIRE_FORMAT_H_
+#define QUICHE_HTTP2_CORE_SPDY_ALT_SVC_WIRE_FORMAT_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace spdy {
+
+namespace test {
+class SpdyAltSvcWireFormatPeer;
+}  // namespace test
+
+class QUICHE_EXPORT SpdyAltSvcWireFormat {
+ public:
+  using VersionVector = absl::InlinedVector<uint32_t, 8>;
+
+  struct QUICHE_EXPORT AlternativeService {
+    std::string protocol_id;
+    std::string host;
+
+    // Default is 0: invalid port.
+    uint16_t port = 0;
+    // Default is one day.
+    uint32_t max_age_seconds = 86400;
+    // Default is empty: unspecified version.
+    VersionVector version;
+
+    AlternativeService();
+    AlternativeService(const std::string& protocol_id, const std::string& host,
+                       uint16_t port, uint32_t max_age_seconds,
+                       VersionVector version);
+    AlternativeService(const AlternativeService& other);
+    ~AlternativeService();
+
+    bool operator==(const AlternativeService& other) const {
+      return protocol_id == other.protocol_id && host == other.host &&
+             port == other.port && version == other.version &&
+             max_age_seconds == other.max_age_seconds;
+    }
+  };
+  // An empty vector means alternative services should be cleared for given
+  // origin.  Note that the wire format for this is the string "clear", not an
+  // empty value (which is invalid).
+  typedef std::vector<AlternativeService> AlternativeServiceVector;
+
+  friend class test::SpdyAltSvcWireFormatPeer;
+  static bool ParseHeaderFieldValue(absl::string_view value,
+                                    AlternativeServiceVector* altsvc_vector);
+  static std::string SerializeHeaderFieldValue(
+      const AlternativeServiceVector& altsvc_vector);
+
+ private:
+  // Forward |*c| over space and tab or until |end| is reached.
+  static void SkipWhiteSpace(absl::string_view::const_iterator* c,
+                             absl::string_view::const_iterator end);
+  // Decode percent-decoded string between |c| and |end| into |*output|.
+  // Return true on success, false if input is invalid.
+  static bool PercentDecode(absl::string_view::const_iterator c,
+                            absl::string_view::const_iterator end,
+                            std::string* output);
+  // Parse the authority part of Alt-Svc between |c| and |end| into |*host| and
+  // |*port|.  Return true on success, false if input is invalid.
+  static bool ParseAltAuthority(absl::string_view::const_iterator c,
+                                absl::string_view::const_iterator end,
+                                std::string* host, uint16_t* port);
+  // Parse a positive integer between |c| and |end| into |*value|.
+  // Return true on success, false if input is not a positive integer or it
+  // cannot be represented on uint16_t.
+  static bool ParsePositiveInteger16(absl::string_view::const_iterator c,
+                                     absl::string_view::const_iterator end,
+                                     uint16_t* value);
+  // Parse a positive integer between |c| and |end| into |*value|.
+  // Return true on success, false if input is not a positive integer or it
+  // cannot be represented on uint32_t.
+  static bool ParsePositiveInteger32(absl::string_view::const_iterator c,
+                                     absl::string_view::const_iterator end,
+                                     uint32_t* value);
+  // Parse |c| as hexadecimal digit, case insensitive.  |c| must be [0-9a-fA-F].
+  // Output is between 0 and 15.
+  static char HexDigitToInt(char c);
+  // Parse |data| as hexadecimal number into |*value|.  |data| must only contain
+  // hexadecimal digits, no "0x" prefix.
+  // Return true on success, false if input is empty, not valid hexadecimal
+  // number, or cannot be represented on uint32_t.
+  static bool HexDecodeToUInt32(absl::string_view data, uint32_t* value);
+};
+
+}  // namespace spdy
+
+#endif  // QUICHE_HTTP2_CORE_SPDY_ALT_SVC_WIRE_FORMAT_H_
diff --git a/quiche/spdy/core/spdy_alt_svc_wire_format_test.cc b/quiche/http2/core/spdy_alt_svc_wire_format_test.cc
similarity index 99%
rename from quiche/spdy/core/spdy_alt_svc_wire_format_test.cc
rename to quiche/http2/core/spdy_alt_svc_wire_format_test.cc
index 0b1b2e6..fc57dc2 100644
--- a/quiche/spdy/core/spdy_alt_svc_wire_format_test.cc
+++ b/quiche/http2/core/spdy_alt_svc_wire_format_test.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
 
 #include <cstddef>
 #include <cstdint>
diff --git a/quiche/http2/core/spdy_bitmasks.h b/quiche/http2/core/spdy_bitmasks.h
new file mode 100644
index 0000000..8da227c
--- /dev/null
+++ b/quiche/http2/core/spdy_bitmasks.h
@@ -0,0 +1,18 @@
+// 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.
+
+#ifndef QUICHE_HTTP2_CORE_SPDY_BITMASKS_H_
+#define QUICHE_HTTP2_CORE_SPDY_BITMASKS_H_
+
+namespace spdy {
+
+// StreamId mask from the SpdyHeader
+inline constexpr unsigned int kStreamIdMask = 0x7fffffff;
+
+// Mask the lower 24 bits.
+inline constexpr unsigned int kLengthMask = 0xffffff;
+
+}  // namespace spdy
+
+#endif  // QUICHE_HTTP2_CORE_SPDY_BITMASKS_H_
diff --git a/quiche/spdy/core/spdy_frame_builder.cc b/quiche/http2/core/spdy_frame_builder.cc
similarity index 97%
rename from quiche/spdy/core/spdy_frame_builder.cc
rename to quiche/http2/core/spdy_frame_builder.cc
index 783fd03..cec9f4d 100644
--- a/quiche/spdy/core/spdy_frame_builder.cc
+++ b/quiche/http2/core/spdy_frame_builder.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/spdy/core/spdy_frame_builder.h"
+#include "quiche/http2/core/spdy_frame_builder.h"
 
 #include <algorithm>
 #include <cstddef>
@@ -10,11 +10,11 @@
 #include <cstring>
 
 #include "absl/strings/string_view.h"
+#include "quiche/http2/core/spdy_bitmasks.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/http2/core/zero_copy_output_buffer.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_logging.h"
-#include "quiche/spdy/core/spdy_bitmasks.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 namespace spdy {
 
diff --git a/quiche/http2/core/spdy_frame_builder.h b/quiche/http2/core/spdy_frame_builder.h
new file mode 100644
index 0000000..ee879a4
--- /dev/null
+++ b/quiche/http2/core/spdy_frame_builder.h
@@ -0,0 +1,140 @@
+// 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.
+
+#ifndef QUICHE_HTTP2_CORE_SPDY_FRAME_BUILDER_H_
+#define QUICHE_HTTP2_CORE_SPDY_FRAME_BUILDER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+#include "absl/strings/string_view.h"
+#include "quiche/http2/core/spdy_protocol.h"
+#include "quiche/http2/core/zero_copy_output_buffer.h"
+#include "quiche/common/platform/api/quiche_bug_tracker.h"
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/quiche_endian.h"
+
+namespace spdy {
+
+namespace test {
+class SpdyFrameBuilderPeer;
+}  // namespace test
+
+// This class provides facilities for basic binary value packing
+// into Spdy frames.
+//
+// The SpdyFrameBuilder supports appending primitive values (int, string, etc)
+// to a frame instance.  The SpdyFrameBuilder grows its internal memory buffer
+// dynamically to hold the sequence of primitive values.   The internal memory
+// buffer is exposed as the "data" of the SpdyFrameBuilder.
+class QUICHE_EXPORT SpdyFrameBuilder {
+ public:
+  // Initializes a SpdyFrameBuilder with a buffer of given size
+  explicit SpdyFrameBuilder(size_t size);
+  // Doesn't take ownership of output.
+  SpdyFrameBuilder(size_t size, ZeroCopyOutputBuffer* output);
+
+  ~SpdyFrameBuilder();
+
+  // Returns the total size of the SpdyFrameBuilder's data, which may include
+  // multiple frames.
+  size_t length() const { return offset_ + length_; }
+
+  // Seeks forward by the given number of bytes. Useful in conjunction with
+  // GetWriteableBuffer() above.
+  bool Seek(size_t length);
+
+  // Populates this frame with a HTTP2 frame prefix using length information
+  // from |capacity_|. The given type must be a control frame type.
+  bool BeginNewFrame(SpdyFrameType type, uint8_t flags, SpdyStreamId stream_id);
+
+  // Populates this frame with a HTTP2 frame prefix with type and length
+  // information.  |type| must be a defined frame type.
+  bool BeginNewFrame(SpdyFrameType type, uint8_t flags, SpdyStreamId stream_id,
+                     size_t length);
+
+  // Populates this frame with a HTTP2 frame prefix with type and length
+  // information.  |raw_frame_type| may be a defined or undefined frame type.
+  bool BeginNewUncheckedFrame(uint8_t raw_frame_type, uint8_t flags,
+                              SpdyStreamId stream_id, size_t length);
+
+  // Takes the buffer from the SpdyFrameBuilder.
+  SpdySerializedFrame take() {
+    QUICHE_BUG_IF(spdy_bug_39_1, output_ != nullptr)
+        << "ZeroCopyOutputBuffer is used to build "
+        << "frames. take() shouldn't be called";
+    QUICHE_BUG_IF(spdy_bug_39_2, kMaxFrameSizeLimit < length_)
+        << "Frame length " << length_
+        << " is longer than the maximum possible allowed length.";
+    SpdySerializedFrame rv(std::move(buffer_), length());
+    capacity_ = 0;
+    length_ = 0;
+    offset_ = 0;
+    return rv;
+  }
+
+  // Methods for adding to the payload.  These values are appended to the end
+  // of the SpdyFrameBuilder payload. Note - binary integers are converted from
+  // host to network form.
+  bool WriteUInt8(uint8_t value) { return WriteBytes(&value, sizeof(value)); }
+  bool WriteUInt16(uint16_t value) {
+    value = quiche::QuicheEndian::HostToNet16(value);
+    return WriteBytes(&value, sizeof(value));
+  }
+  bool WriteUInt24(uint32_t value) {
+    value = quiche::QuicheEndian::HostToNet32(value);
+    return WriteBytes(reinterpret_cast<char*>(&value) + 1, sizeof(value) - 1);
+  }
+  bool WriteUInt32(uint32_t value) {
+    value = quiche::QuicheEndian::HostToNet32(value);
+    return WriteBytes(&value, sizeof(value));
+  }
+  bool WriteUInt64(uint64_t value) {
+    uint32_t upper =
+        quiche::QuicheEndian::HostToNet32(static_cast<uint32_t>(value >> 32));
+    uint32_t lower =
+        quiche::QuicheEndian::HostToNet32(static_cast<uint32_t>(value));
+    return (WriteBytes(&upper, sizeof(upper)) &&
+            WriteBytes(&lower, sizeof(lower)));
+  }
+  bool WriteStringPiece32(const absl::string_view value);
+  bool WriteBytes(const void* data, uint32_t data_len);
+
+ private:
+  friend class test::SpdyFrameBuilderPeer;
+
+  // Populates this frame with a HTTP2 frame prefix with type and length
+  // information.
+  bool BeginNewFrameInternal(uint8_t raw_frame_type, uint8_t flags,
+                             SpdyStreamId stream_id, size_t length);
+
+  // Returns a writeable buffer of given size in bytes, to be appended to the
+  // currently written frame. Does bounds checking on length but does not
+  // increment the underlying iterator. To do so, consumers should subsequently
+  // call Seek().
+  // In general, consumers should use Write*() calls instead of this.
+  // Returns NULL on failure.
+  char* GetWritableBuffer(size_t length);
+  char* GetWritableOutput(size_t desired_length, size_t* actual_length);
+
+  // Checks to make sure that there is an appropriate amount of space for a
+  // write of given size, in bytes.
+  bool CanWrite(size_t length) const;
+
+  // A buffer to be created whenever a new frame needs to be written. Used only
+  // if |output_| is nullptr.
+  std::unique_ptr<char[]> buffer_;
+  // A pre-allocated buffer. If not-null, serialized frame data is written to
+  // this buffer.
+  ZeroCopyOutputBuffer* output_ = nullptr;  // Does not own.
+
+  size_t capacity_;  // Allocation size of payload, set by constructor.
+  size_t length_;    // Length of the latest frame in the buffer.
+  size_t offset_;    // Position at which the latest frame begins.
+};
+
+}  // namespace spdy
+
+#endif  // QUICHE_HTTP2_CORE_SPDY_FRAME_BUILDER_H_
diff --git a/quiche/spdy/core/spdy_frame_builder_test.cc b/quiche/http2/core/spdy_frame_builder_test.cc
similarity index 96%
rename from quiche/spdy/core/spdy_frame_builder_test.cc
rename to quiche/http2/core/spdy_frame_builder_test.cc
index 4992ead..3fe48ca 100644
--- a/quiche/spdy/core/spdy_frame_builder_test.cc
+++ b/quiche/http2/core/spdy_frame_builder_test.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/spdy/core/spdy_frame_builder.h"
+#include "quiche/http2/core/spdy_frame_builder.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -10,10 +10,10 @@
 
 #include "absl/strings/string_view.h"
 #include "quiche/http2/core/array_output_buffer.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/http2/test_tools/spdy_test_utils.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 namespace spdy {
 
diff --git a/quiche/spdy/core/spdy_framer.cc b/quiche/http2/core/spdy_framer.cc
similarity index 99%
rename from quiche/spdy/core/spdy_framer.cc
rename to quiche/http2/core/spdy_framer.cc
index 2e30a95..3539082 100644
--- a/quiche/spdy/core/spdy_framer.cc
+++ b/quiche/http2/core/spdy_framer.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/spdy/core/spdy_framer.h"
+#include "quiche/http2/core/spdy_framer.h"
 
 #include <algorithm>
 #include <cstddef>
@@ -13,15 +13,15 @@
 
 #include "absl/base/attributes.h"
 #include "absl/memory/memory.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
+#include "quiche/http2/core/spdy_frame_builder.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/http2/core/zero_copy_output_buffer.h"
 #include "quiche/http2/hpack/hpack_constants.h"
 #include "quiche/http2/hpack/hpack_encoder.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/spdy/core/http2_header_block.h"
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
-#include "quiche/spdy/core/spdy_frame_builder.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 namespace spdy {
 
diff --git a/quiche/http2/core/spdy_framer.h b/quiche/http2/core/spdy_framer.h
new file mode 100644
index 0000000..b656893
--- /dev/null
+++ b/quiche/http2/core/spdy_framer.h
@@ -0,0 +1,371 @@
+// 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.
+
+#ifndef QUICHE_HTTP2_CORE_SPDY_FRAMER_H_
+#define QUICHE_HTTP2_CORE_SPDY_FRAMER_H_
+
+#include <stddef.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "quiche/http2/core/spdy_protocol.h"
+#include "quiche/http2/core/zero_copy_output_buffer.h"
+#include "quiche/http2/hpack/hpack_encoder.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace spdy {
+
+namespace test {
+
+class SpdyFramerPeer;
+class SpdyFramerTest_MultipleContinuationFramesWithIterator_Test;
+class SpdyFramerTest_PushPromiseFramesWithIterator_Test;
+
+}  // namespace test
+
+class QUICHE_EXPORT SpdyFrameSequence {
+ public:
+  virtual ~SpdyFrameSequence() {}
+
+  // Serializes the next frame in the sequence to |output|. Returns the number
+  // of bytes written to |output|.
+  virtual size_t NextFrame(ZeroCopyOutputBuffer* output) = 0;
+
+  // Returns true iff there is at least one more frame in the sequence.
+  virtual bool HasNextFrame() const = 0;
+
+  // Get SpdyFrameIR of the frame to be serialized.
+  virtual const SpdyFrameIR& GetIR() const = 0;
+};
+
+class QUICHE_EXPORT SpdyFramer {
+ public:
+  enum CompressionOption {
+    ENABLE_COMPRESSION,
+    DISABLE_COMPRESSION,
+  };
+
+  // Create a SpdyFrameSequence to serialize |frame_ir|.
+  static std::unique_ptr<SpdyFrameSequence> CreateIterator(
+      SpdyFramer* framer, std::unique_ptr<const SpdyFrameIR> frame_ir);
+
+  // Gets the serialized flags for the given |frame|.
+  static uint8_t GetSerializedFlags(const SpdyFrameIR& frame);
+
+  // Serialize a data frame.
+  static SpdySerializedFrame SerializeData(const SpdyDataIR& data_ir);
+  // Serializes the data frame header and optionally padding length fields,
+  // excluding actual data payload and padding.
+  static SpdySerializedFrame SerializeDataFrameHeaderWithPaddingLengthField(
+      const SpdyDataIR& data_ir);
+
+  // Serializes a WINDOW_UPDATE frame. The WINDOW_UPDATE
+  // frame is used to implement per stream flow control.
+  static SpdySerializedFrame SerializeWindowUpdate(
+      const SpdyWindowUpdateIR& window_update);
+
+  explicit SpdyFramer(CompressionOption option);
+
+  virtual ~SpdyFramer();
+
+  // Set debug callbacks to be called from the framer. The debug visitor is
+  // completely optional and need not be set in order for normal operation.
+  // If this is called multiple times, only the last visitor will be used.
+  void set_debug_visitor(SpdyFramerDebugVisitorInterface* debug_visitor);
+
+  SpdySerializedFrame SerializeRstStream(
+      const SpdyRstStreamIR& rst_stream) const;
+
+  // Serializes a SETTINGS frame. The SETTINGS frame is
+  // used to communicate name/value pairs relevant to the communication channel.
+  SpdySerializedFrame SerializeSettings(const SpdySettingsIR& settings) const;
+
+  // Serializes a PING frame. The unique_id is used to
+  // identify the ping request/response.
+  SpdySerializedFrame SerializePing(const SpdyPingIR& ping) const;
+
+  // Serializes a GOAWAY frame. The GOAWAY frame is used
+  // prior to the shutting down of the TCP connection, and includes the
+  // stream_id of the last stream the sender of the frame is willing to process
+  // to completion.
+  SpdySerializedFrame SerializeGoAway(const SpdyGoAwayIR& goaway) const;
+
+  // Serializes a HEADERS frame. The HEADERS frame is used
+  // for sending headers.
+  SpdySerializedFrame SerializeHeaders(const SpdyHeadersIR& headers);
+
+  // Serializes a PUSH_PROMISE frame. The PUSH_PROMISE frame is used
+  // to inform the client that it will be receiving an additional stream
+  // in response to the original request. The frame includes synthesized
+  // headers to explain the upcoming data.
+  SpdySerializedFrame SerializePushPromise(
+      const SpdyPushPromiseIR& push_promise);
+
+  // Serializes a CONTINUATION frame. The CONTINUATION frame is used
+  // to continue a sequence of header block fragments.
+  SpdySerializedFrame SerializeContinuation(
+      const SpdyContinuationIR& continuation) const;
+
+  // Serializes an ALTSVC frame. The ALTSVC frame advertises the
+  // availability of an alternative service to the client.
+  SpdySerializedFrame SerializeAltSvc(const SpdyAltSvcIR& altsvc);
+
+  // Serializes a PRIORITY frame. The PRIORITY frame advises a change in
+  // the relative priority of the given stream.
+  SpdySerializedFrame SerializePriority(const SpdyPriorityIR& priority) const;
+
+  // Serializes a PRIORITY_UPDATE frame.
+  // See https://httpwg.org/http-extensions/draft-ietf-httpbis-priority.html.
+  SpdySerializedFrame SerializePriorityUpdate(
+      const SpdyPriorityUpdateIR& priority_update) const;
+
+  // Serializes an ACCEPT_CH frame.  See
+  // https://tools.ietf.org/html/draft-davidben-http-client-hint-reliability-02.
+  SpdySerializedFrame SerializeAcceptCh(const SpdyAcceptChIR& accept_ch) const;
+
+  // Serializes an unknown frame given a frame header and payload.
+  SpdySerializedFrame SerializeUnknown(const SpdyUnknownIR& unknown) const;
+
+  // Serialize a frame of unknown type.
+  SpdySerializedFrame SerializeFrame(const SpdyFrameIR& frame);
+
+  // Serialize a data frame.
+  bool SerializeData(const SpdyDataIR& data,
+                     ZeroCopyOutputBuffer* output) const;
+
+  // Serializes the data frame header and optionally padding length fields,
+  // excluding actual data payload and padding.
+  bool SerializeDataFrameHeaderWithPaddingLengthField(
+      const SpdyDataIR& data, ZeroCopyOutputBuffer* output) const;
+
+  bool SerializeRstStream(const SpdyRstStreamIR& rst_stream,
+                          ZeroCopyOutputBuffer* output) const;
+
+  // Serializes a SETTINGS frame. The SETTINGS frame is
+  // used to communicate name/value pairs relevant to the communication channel.
+  bool SerializeSettings(const SpdySettingsIR& settings,
+                         ZeroCopyOutputBuffer* output) const;
+
+  // Serializes a PING frame. The unique_id is used to
+  // identify the ping request/response.
+  bool SerializePing(const SpdyPingIR& ping,
+                     ZeroCopyOutputBuffer* output) const;
+
+  // Serializes a GOAWAY frame. The GOAWAY frame is used
+  // prior to the shutting down of the TCP connection, and includes the
+  // stream_id of the last stream the sender of the frame is willing to process
+  // to completion.
+  bool SerializeGoAway(const SpdyGoAwayIR& goaway,
+                       ZeroCopyOutputBuffer* output) const;
+
+  // Serializes a HEADERS frame. The HEADERS frame is used
+  // for sending headers.
+  bool SerializeHeaders(const SpdyHeadersIR& headers,
+                        ZeroCopyOutputBuffer* output);
+
+  // Serializes a WINDOW_UPDATE frame. The WINDOW_UPDATE
+  // frame is used to implement per stream flow control.
+  bool SerializeWindowUpdate(const SpdyWindowUpdateIR& window_update,
+                             ZeroCopyOutputBuffer* output) const;
+
+  // Serializes a PUSH_PROMISE frame. The PUSH_PROMISE frame is used
+  // to inform the client that it will be receiving an additional stream
+  // in response to the original request. The frame includes synthesized
+  // headers to explain the upcoming data.
+  bool SerializePushPromise(const SpdyPushPromiseIR& push_promise,
+                            ZeroCopyOutputBuffer* output);
+
+  // Serializes a CONTINUATION frame. The CONTINUATION frame is used
+  // to continue a sequence of header block fragments.
+  bool SerializeContinuation(const SpdyContinuationIR& continuation,
+                             ZeroCopyOutputBuffer* output) const;
+
+  // Serializes an ALTSVC frame. The ALTSVC frame advertises the
+  // availability of an alternative service to the client.
+  bool SerializeAltSvc(const SpdyAltSvcIR& altsvc,
+                       ZeroCopyOutputBuffer* output);
+
+  // Serializes a PRIORITY frame. The PRIORITY frame advises a change in
+  // the relative priority of the given stream.
+  bool SerializePriority(const SpdyPriorityIR& priority,
+                         ZeroCopyOutputBuffer* output) const;
+
+  // Serializes a PRIORITY_UPDATE frame.
+  // See https://httpwg.org/http-extensions/draft-ietf-httpbis-priority.html.
+  bool SerializePriorityUpdate(const SpdyPriorityUpdateIR& priority_update,
+                               ZeroCopyOutputBuffer* output) const;
+
+  // Serializes an ACCEPT_CH frame.  See
+  // https://tools.ietf.org/html/draft-davidben-http-client-hint-reliability-02.
+  bool SerializeAcceptCh(const SpdyAcceptChIR& accept_ch,
+                         ZeroCopyOutputBuffer* output) const;
+
+  // Serializes an unknown frame given a frame header and payload.
+  bool SerializeUnknown(const SpdyUnknownIR& unknown,
+                        ZeroCopyOutputBuffer* output) const;
+
+  // Serialize a frame of unknown type.
+  size_t SerializeFrame(const SpdyFrameIR& frame, ZeroCopyOutputBuffer* output);
+
+  // Returns whether this SpdyFramer will compress header blocks using HPACK.
+  bool compression_enabled() const {
+    return compression_option_ == ENABLE_COMPRESSION;
+  }
+
+  void SetHpackIndexingPolicy(HpackEncoder::IndexingPolicy policy) {
+    GetHpackEncoder()->SetIndexingPolicy(std::move(policy));
+  }
+
+  // Updates the maximum size of the header encoder compression table.
+  void UpdateHeaderEncoderTableSize(uint32_t value);
+
+  // Returns the maximum size of the header encoder compression table.
+  size_t header_encoder_table_size() const;
+
+  // Get (and lazily initialize) the HPACK encoder state.
+  HpackEncoder* GetHpackEncoder();
+
+  // Gets the HPACK encoder state. Returns nullptr if the encoder has not been
+  // initialized.
+  const HpackEncoder* GetHpackEncoder() const { return hpack_encoder_.get(); }
+
+ protected:
+  friend class test::SpdyFramerPeer;
+  friend class test::SpdyFramerTest_MultipleContinuationFramesWithIterator_Test;
+  friend class test::SpdyFramerTest_PushPromiseFramesWithIterator_Test;
+
+  // Iteratively converts a SpdyFrameIR into an appropriate sequence of Spdy
+  // frames.
+  // Example usage:
+  // std::unique_ptr<SpdyFrameSequence> it = CreateIterator(framer, frame_ir);
+  // while (it->HasNextFrame()) {
+  //   if(it->NextFrame(output) == 0) {
+  //     // Write failed;
+  //   }
+  // }
+  class QUICHE_EXPORT SpdyFrameIterator : public SpdyFrameSequence {
+   public:
+    // Creates an iterator with the provided framer.
+    // Does not take ownership of |framer|.
+    // |framer| must outlive this instance.
+    explicit SpdyFrameIterator(SpdyFramer* framer);
+    ~SpdyFrameIterator() override;
+
+    // Serializes the next frame in the sequence to |output|. Returns the number
+    // of bytes written to |output|.
+    size_t NextFrame(ZeroCopyOutputBuffer* output) override;
+
+    // Returns true iff there is at least one more frame in the sequence.
+    bool HasNextFrame() const override;
+
+    // SpdyFrameIterator is neither copyable nor movable.
+    SpdyFrameIterator(const SpdyFrameIterator&) = delete;
+    SpdyFrameIterator& operator=(const SpdyFrameIterator&) = delete;
+
+   protected:
+    virtual size_t GetFrameSizeSansBlock() const = 0;
+    virtual bool SerializeGivenEncoding(const std::string& encoding,
+                                        ZeroCopyOutputBuffer* output) const = 0;
+
+    SpdyFramer* GetFramer() const { return framer_; }
+
+    void SetEncoder(const SpdyFrameWithHeaderBlockIR* ir) {
+      encoder_ =
+          framer_->GetHpackEncoder()->EncodeHeaderSet(ir->header_block());
+    }
+
+    bool has_next_frame() const { return has_next_frame_; }
+
+   private:
+    SpdyFramer* const framer_;
+    std::unique_ptr<HpackEncoder::ProgressiveEncoder> encoder_;
+    bool is_first_frame_;
+    bool has_next_frame_;
+  };
+
+  // Iteratively converts a SpdyHeadersIR (with a possibly huge
+  // Http2HeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
+  // write to the output.
+  class QUICHE_EXPORT SpdyHeaderFrameIterator : public SpdyFrameIterator {
+   public:
+    // Does not take ownership of |framer|. Take ownership of |headers_ir|.
+    SpdyHeaderFrameIterator(SpdyFramer* framer,
+                            std::unique_ptr<const SpdyHeadersIR> headers_ir);
+
+    ~SpdyHeaderFrameIterator() override;
+
+   private:
+    const SpdyFrameIR& GetIR() const override;
+    size_t GetFrameSizeSansBlock() const override;
+    bool SerializeGivenEncoding(const std::string& encoding,
+                                ZeroCopyOutputBuffer* output) const override;
+
+    const std::unique_ptr<const SpdyHeadersIR> headers_ir_;
+  };
+
+  // Iteratively converts a SpdyPushPromiseIR (with a possibly huge
+  // Http2HeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
+  // write to the output.
+  class QUICHE_EXPORT SpdyPushPromiseFrameIterator : public SpdyFrameIterator {
+   public:
+    // Does not take ownership of |framer|. Take ownership of |push_promise_ir|.
+    SpdyPushPromiseFrameIterator(
+        SpdyFramer* framer,
+        std::unique_ptr<const SpdyPushPromiseIR> push_promise_ir);
+
+    ~SpdyPushPromiseFrameIterator() override;
+
+   private:
+    const SpdyFrameIR& GetIR() const override;
+    size_t GetFrameSizeSansBlock() const override;
+    bool SerializeGivenEncoding(const std::string& encoding,
+                                ZeroCopyOutputBuffer* output) const override;
+
+    const std::unique_ptr<const SpdyPushPromiseIR> push_promise_ir_;
+  };
+
+  // Converts a SpdyFrameIR into one Spdy frame (a sequence of length 1), and
+  // write it to the output.
+  class QUICHE_EXPORT SpdyControlFrameIterator : public SpdyFrameSequence {
+   public:
+    SpdyControlFrameIterator(SpdyFramer* framer,
+                             std::unique_ptr<const SpdyFrameIR> frame_ir);
+    ~SpdyControlFrameIterator() override;
+
+    size_t NextFrame(ZeroCopyOutputBuffer* output) override;
+
+    bool HasNextFrame() const override;
+
+    const SpdyFrameIR& GetIR() const override;
+
+   private:
+    SpdyFramer* const framer_;
+    std::unique_ptr<const SpdyFrameIR> frame_ir_;
+    bool has_next_frame_ = true;
+  };
+
+ private:
+  void SerializeHeadersBuilderHelper(const SpdyHeadersIR& headers,
+                                     uint8_t* flags, size_t* size,
+                                     std::string* hpack_encoding, int* weight,
+                                     size_t* length_field);
+  void SerializePushPromiseBuilderHelper(const SpdyPushPromiseIR& push_promise,
+                                         uint8_t* flags,
+                                         std::string* hpack_encoding,
+                                         size_t* size);
+
+  std::unique_ptr<HpackEncoder> hpack_encoder_;
+
+  SpdyFramerDebugVisitorInterface* debug_visitor_;
+
+  // Determines whether HPACK compression is used.
+  const CompressionOption compression_option_;
+};
+
+}  // namespace spdy
+
+#endif  // QUICHE_HTTP2_CORE_SPDY_FRAMER_H_
diff --git a/quiche/spdy/core/spdy_framer_test.cc b/quiche/http2/core/spdy_framer_test.cc
similarity index 99%
rename from quiche/spdy/core/spdy_framer_test.cc
rename to quiche/http2/core/spdy_framer_test.cc
index 8b0ae57..aa0b205 100644
--- a/quiche/spdy/core/spdy_framer_test.cc
+++ b/quiche/http2/core/spdy_framer_test.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/spdy/core/spdy_framer.h"
+#include "quiche/http2/core/spdy_framer.h"
 
 #include <stdlib.h>
 
@@ -19,20 +19,20 @@
 #include "absl/base/macros.h"
 #include "absl/strings/string_view.h"
 #include "quiche/http2/core/array_output_buffer.h"
+#include "quiche/http2/core/http2_frame_decoder_adapter.h"
 #include "quiche/http2/core/recording_headers_handler.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
+#include "quiche/http2/core/spdy_bitmasks.h"
+#include "quiche/http2/core/spdy_frame_builder.h"
 #include "quiche/http2/core/spdy_headers_handler_interface.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/http2/hpack/hpack_encoder.h"
 #include "quiche/http2/test_tools/mock_spdy_framer_visitor.h"
 #include "quiche/http2/test_tools/spdy_test_utils.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/quiche_text_utils.h"
-#include "quiche/spdy/core/http2_frame_decoder_adapter.h"
 #include "quiche/spdy/core/http2_header_block.h"
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
-#include "quiche/spdy/core/spdy_bitmasks.h"
-#include "quiche/spdy/core/spdy_frame_builder.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 using ::http2::Http2DecoderAdapter;
 using ::testing::_;
diff --git a/quiche/http2/core/spdy_no_op_visitor.cc b/quiche/http2/core/spdy_no_op_visitor.cc
index 8361524..f3d04a9 100644
--- a/quiche/http2/core/spdy_no_op_visitor.cc
+++ b/quiche/http2/core/spdy_no_op_visitor.cc
@@ -8,7 +8,7 @@
 #include <type_traits>
 
 #include "quiche/http2/core/spdy_headers_handler_interface.h"
-#include "quiche/spdy/core/spdy_protocol.h"
+#include "quiche/http2/core/spdy_protocol.h"
 
 namespace spdy {
 
diff --git a/quiche/http2/core/spdy_no_op_visitor.h b/quiche/http2/core/spdy_no_op_visitor.h
index fc822bf..4f4ff53 100644
--- a/quiche/http2/core/spdy_no_op_visitor.h
+++ b/quiche/http2/core/spdy_no_op_visitor.h
@@ -14,11 +14,11 @@
 #include <string>
 
 #include "absl/strings/string_view.h"
+#include "quiche/http2/core/http2_frame_decoder_adapter.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
 #include "quiche/http2/core/spdy_headers_handler_interface.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/common/platform/api/quiche_export.h"
-#include "quiche/spdy/core/http2_frame_decoder_adapter.h"
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 namespace spdy {
 
diff --git a/quiche/spdy/core/spdy_protocol.cc b/quiche/http2/core/spdy_protocol.cc
similarity index 99%
rename from quiche/spdy/core/spdy_protocol.cc
rename to quiche/http2/core/spdy_protocol.cc
index fc3b971..ae3f662 100644
--- a/quiche/spdy/core/spdy_protocol.cc
+++ b/quiche/http2/core/spdy_protocol.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/spdy/core/spdy_protocol.h"
+#include "quiche/http2/core/spdy_protocol.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -14,11 +14,11 @@
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_flag_utils.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/spdy/core/http2_header_block.h"
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
 
 namespace spdy {
 
diff --git a/quiche/http2/core/spdy_protocol.h b/quiche/http2/core/spdy_protocol.h
new file mode 100644
index 0000000..24bb9d5
--- /dev/null
+++ b/quiche/http2/core/spdy_protocol.h
@@ -0,0 +1,1101 @@
+// 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.
+
+// This file contains some protocol structures for use with SPDY 3 and HTTP 2
+// The SPDY 3 spec can be found at:
+// http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
+
+#ifndef QUICHE_HTTP2_CORE_SPDY_PROTOCOL_H_
+#define QUICHE_HTTP2_CORE_SPDY_PROTOCOL_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
+#include "quiche/http2/core/spdy_bitmasks.h"
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/platform/api/quiche_flags.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/spdy/core/http2_header_block.h"
+
+namespace spdy {
+
+// A stream ID is a 31-bit entity.
+using SpdyStreamId = uint32_t;
+
+// A SETTINGS ID is a 16-bit entity.
+using SpdySettingsId = uint16_t;
+
+// Specifies the stream ID used to denote the current session (for
+// flow control).
+inline constexpr SpdyStreamId kSessionFlowControlStreamId = 0;
+
+// 0 is not a valid stream ID for any other purpose than flow control.
+inline constexpr SpdyStreamId kInvalidStreamId = 0;
+
+// Max stream id.
+inline constexpr SpdyStreamId kMaxStreamId = 0x7fffffff;
+
+// The maximum possible frame payload size allowed by the spec.
+inline constexpr uint32_t kSpdyMaxFrameSizeLimit = (1 << 24) - 1;
+
+// The initial value for the maximum frame payload size as per the spec. This is
+// the maximum control frame size we accept.
+inline constexpr uint32_t kHttp2DefaultFramePayloadLimit = 1 << 14;
+
+// The maximum size of the control frames that we send, including the size of
+// the header. This limit is arbitrary. We can enforce it here or at the
+// application layer. We chose the framing layer, but this can be changed (or
+// removed) if necessary later down the line.
+inline constexpr size_t kHttp2MaxControlFrameSendSize =
+    kHttp2DefaultFramePayloadLimit - 1;
+
+// Number of octets in the frame header.
+inline constexpr size_t kFrameHeaderSize = 9;
+
+// The initial value for the maximum frame payload size as per the spec. This is
+// the maximum control frame size we accept.
+inline constexpr uint32_t kHttp2DefaultFrameSizeLimit =
+    kHttp2DefaultFramePayloadLimit + kFrameHeaderSize;
+
+// The initial value for the maximum size of the header list, "unlimited" (max
+// unsigned 32-bit int) as per the spec.
+inline constexpr uint32_t kSpdyInitialHeaderListSizeLimit = 0xFFFFFFFF;
+
+// Maximum window size for a Spdy stream or session.
+inline constexpr int32_t kSpdyMaximumWindowSize =
+    0x7FFFFFFF;  // Max signed 32bit int
+
+// Maximum padding size in octets for one DATA or HEADERS or PUSH_PROMISE frame.
+inline constexpr int32_t kPaddingSizePerFrame = 256;
+
+// The HTTP/2 connection preface, which must be the first bytes sent by the
+// client upon starting an HTTP/2 connection, and which must be followed by a
+// SETTINGS frame.  Note that even though |kHttp2ConnectionHeaderPrefix| is
+// defined as a string literal with a null terminator, the actual connection
+// preface is only the first |kHttp2ConnectionHeaderPrefixSize| bytes, which
+// excludes the null terminator.
+QUICHE_EXPORT extern const char* const kHttp2ConnectionHeaderPrefix;
+inline constexpr int kHttp2ConnectionHeaderPrefixSize = 24;
+
+// Wire values for HTTP2 frame types.
+enum class SpdyFrameType : uint8_t {
+  DATA = 0x00,
+  HEADERS = 0x01,
+  PRIORITY = 0x02,
+  RST_STREAM = 0x03,
+  SETTINGS = 0x04,
+  PUSH_PROMISE = 0x05,
+  PING = 0x06,
+  GOAWAY = 0x07,
+  WINDOW_UPDATE = 0x08,
+  CONTINUATION = 0x09,
+  // ALTSVC is a public extension.
+  ALTSVC = 0x0a,
+  PRIORITY_UPDATE = 0x10,
+  ACCEPT_CH = 0x89,
+};
+
+// Flags on data packets.
+enum SpdyDataFlags {
+  DATA_FLAG_NONE = 0x00,
+  DATA_FLAG_FIN = 0x01,
+  DATA_FLAG_PADDED = 0x08,
+};
+
+// Flags on control packets
+enum SpdyControlFlags {
+  CONTROL_FLAG_NONE = 0x00,
+  CONTROL_FLAG_FIN = 0x01,
+};
+
+enum SpdyPingFlags {
+  PING_FLAG_ACK = 0x01,
+};
+
+// Used by HEADERS, PUSH_PROMISE, and CONTINUATION.
+enum SpdyHeadersFlags {
+  HEADERS_FLAG_END_HEADERS = 0x04,
+  HEADERS_FLAG_PADDED = 0x08,
+  HEADERS_FLAG_PRIORITY = 0x20,
+};
+
+enum SpdyPushPromiseFlags {
+  PUSH_PROMISE_FLAG_END_PUSH_PROMISE = 0x04,
+  PUSH_PROMISE_FLAG_PADDED = 0x08,
+};
+
+enum Http2SettingsControlFlags {
+  SETTINGS_FLAG_ACK = 0x01,
+};
+
+// Wire values of HTTP/2 setting identifiers.
+enum SpdyKnownSettingsId : SpdySettingsId {
+  // HPACK header table maximum size.
+  SETTINGS_HEADER_TABLE_SIZE = 0x1,
+  SETTINGS_MIN = SETTINGS_HEADER_TABLE_SIZE,
+  // Whether or not server push (PUSH_PROMISE) is enabled.
+  SETTINGS_ENABLE_PUSH = 0x2,
+  // The maximum number of simultaneous live streams in each direction.
+  SETTINGS_MAX_CONCURRENT_STREAMS = 0x3,
+  // Initial window size in bytes
+  SETTINGS_INITIAL_WINDOW_SIZE = 0x4,
+  // The size of the largest frame payload that a receiver is willing to accept.
+  SETTINGS_MAX_FRAME_SIZE = 0x5,
+  // The maximum size of header list that the sender is prepared to accept.
+  SETTINGS_MAX_HEADER_LIST_SIZE = 0x6,
+  // Enable Websockets over HTTP/2, see
+  // https://httpwg.org/specs/rfc8441.html
+  SETTINGS_ENABLE_CONNECT_PROTOCOL = 0x8,
+  // Disable HTTP/2 priorities, see
+  // https://tools.ietf.org/html/draft-ietf-httpbis-priority-02.
+  SETTINGS_DEPRECATE_HTTP2_PRIORITIES = 0x9,
+  SETTINGS_MAX = SETTINGS_DEPRECATE_HTTP2_PRIORITIES,
+  // Experimental setting used to configure an alternative write scheduler.
+  SETTINGS_EXPERIMENT_SCHEDULER = 0xFF45,
+};
+
+// This explicit operator is needed, otherwise compiler finds
+// overloaded operator to be ambiguous.
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       SpdyKnownSettingsId id);
+
+// This operator is needed, because SpdyFrameType is an enum class,
+// therefore implicit conversion to underlying integer type is not allowed.
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                       SpdyFrameType frame_type);
+
+using SettingsMap = std::map<SpdySettingsId, uint32_t>;
+
+// HTTP/2 error codes, RFC 7540 Section 7.
+enum SpdyErrorCode : uint32_t {
+  ERROR_CODE_NO_ERROR = 0x0,
+  ERROR_CODE_PROTOCOL_ERROR = 0x1,
+  ERROR_CODE_INTERNAL_ERROR = 0x2,
+  ERROR_CODE_FLOW_CONTROL_ERROR = 0x3,
+  ERROR_CODE_SETTINGS_TIMEOUT = 0x4,
+  ERROR_CODE_STREAM_CLOSED = 0x5,
+  ERROR_CODE_FRAME_SIZE_ERROR = 0x6,
+  ERROR_CODE_REFUSED_STREAM = 0x7,
+  ERROR_CODE_CANCEL = 0x8,
+  ERROR_CODE_COMPRESSION_ERROR = 0x9,
+  ERROR_CODE_CONNECT_ERROR = 0xa,
+  ERROR_CODE_ENHANCE_YOUR_CALM = 0xb,
+  ERROR_CODE_INADEQUATE_SECURITY = 0xc,
+  ERROR_CODE_HTTP_1_1_REQUIRED = 0xd,
+  ERROR_CODE_MAX = ERROR_CODE_HTTP_1_1_REQUIRED
+};
+
+// Type of priority write scheduler.
+enum class WriteSchedulerType {
+  LIFO,  // Last added stream has the highest priority.
+  SPDY,  // Uses SPDY priorities described in
+         // https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority.
+  HTTP2,  // Uses HTTP2 (tree-style) priority described in
+          // https://tools.ietf.org/html/rfc7540#section-5.3.
+  FIFO,   // Stream with the smallest stream ID has the highest priority.
+};
+
+// A SPDY priority is a number between 0 and 7 (inclusive).
+typedef uint8_t SpdyPriority;
+
+// Lowest and Highest here refer to SPDY priorities as described in
+// https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority
+inline constexpr SpdyPriority kV3HighestPriority = 0;
+inline constexpr SpdyPriority kV3LowestPriority = 7;
+
+// Returns SPDY 3.x priority value clamped to the valid range of [0, 7].
+QUICHE_EXPORT SpdyPriority ClampSpdy3Priority(SpdyPriority priority);
+
+// HTTP/2 stream weights are integers in range [1, 256], as specified in RFC
+// 7540 section 5.3.2. Default stream weight is defined in section 5.3.5.
+inline constexpr int kHttp2MinStreamWeight = 1;
+inline constexpr int kHttp2MaxStreamWeight = 256;
+inline constexpr int kHttp2DefaultStreamWeight = 16;
+
+// Returns HTTP/2 weight clamped to the valid range of [1, 256].
+QUICHE_EXPORT int ClampHttp2Weight(int weight);
+
+// Maps SPDY 3.x priority value in range [0, 7] to HTTP/2 weight value in range
+// [1, 256], where priority 0 (i.e. highest precedence) corresponds to maximum
+// weight 256 and priority 7 (lowest precedence) corresponds to minimum weight
+// 1.
+QUICHE_EXPORT int Spdy3PriorityToHttp2Weight(SpdyPriority priority);
+
+// Maps HTTP/2 weight value in range [1, 256] to SPDY 3.x priority value in
+// range [0, 7], where minimum weight 1 corresponds to priority 7 (lowest
+// precedence) and maximum weight 256 corresponds to priority 0 (highest
+// precedence).
+QUICHE_EXPORT SpdyPriority Http2WeightToSpdy3Priority(int weight);
+
+// Reserved ID for root stream of HTTP/2 stream dependency tree, as specified
+// in RFC 7540 section 5.3.1.
+const unsigned int kHttp2RootStreamId = 0;
+
+typedef uint64_t SpdyPingId;
+
+// Returns true if a given on-the-wire enumeration of a frame type is defined
+// in a standardized HTTP/2 specification, false otherwise.
+QUICHE_EXPORT bool IsDefinedFrameType(uint8_t frame_type_field);
+
+// Parses a frame type from an on-the-wire enumeration.
+// Behavior is undefined for invalid frame type fields; consumers should first
+// use IsValidFrameType() to verify validity of frame type fields.
+QUICHE_EXPORT SpdyFrameType ParseFrameType(uint8_t frame_type_field);
+
+// Serializes a frame type to the on-the-wire value.
+QUICHE_EXPORT uint8_t SerializeFrameType(SpdyFrameType frame_type);
+
+// (HTTP/2) All standard frame types except WINDOW_UPDATE are
+// (stream-specific xor connection-level). Returns false iff we know
+// the given frame type does not align with the given streamID.
+QUICHE_EXPORT bool IsValidHTTP2FrameStreamId(
+    SpdyStreamId current_frame_stream_id, SpdyFrameType frame_type_field);
+
+// Serialize |frame_type| to string for logging/debugging.
+QUICHE_EXPORT const char* FrameTypeToString(SpdyFrameType frame_type);
+
+// If |wire_setting_id| is the on-the-wire representation of a defined SETTINGS
+// parameter, parse it to |*setting_id| and return true.
+QUICHE_EXPORT bool ParseSettingsId(SpdySettingsId wire_setting_id,
+                                   SpdyKnownSettingsId* setting_id);
+
+// Returns a string representation of the |id| for logging/debugging. Returns
+// the |id| prefixed with "SETTINGS_UNKNOWN_" for unknown SETTINGS IDs. To parse
+// the |id| into a SpdyKnownSettingsId (if applicable), use ParseSettingsId().
+QUICHE_EXPORT std::string SettingsIdToString(SpdySettingsId id);
+
+// Parse |wire_error_code| to a SpdyErrorCode.
+// Treat unrecognized error codes as INTERNAL_ERROR
+// as recommended by the HTTP/2 specification.
+QUICHE_EXPORT SpdyErrorCode ParseErrorCode(uint32_t wire_error_code);
+
+// Serialize RST_STREAM or GOAWAY frame error code to string
+// for logging/debugging.
+QUICHE_EXPORT const char* ErrorCodeToString(SpdyErrorCode error_code);
+
+// Serialize |type| to string for logging/debugging.
+QUICHE_EXPORT const char* WriteSchedulerTypeToString(WriteSchedulerType type);
+
+// Minimum size of a frame, in octets.
+inline constexpr size_t kFrameMinimumSize = kFrameHeaderSize;
+
+// Minimum frame size for variable size frame types (includes mandatory fields),
+// frame size for fixed size frames, in octets.
+
+inline constexpr size_t kDataFrameMinimumSize = kFrameHeaderSize;
+inline constexpr size_t kHeadersFrameMinimumSize = kFrameHeaderSize;
+// PRIORITY frame has stream_dependency (4 octets) and weight (1 octet) fields.
+inline constexpr size_t kPriorityFrameSize = kFrameHeaderSize + 5;
+// RST_STREAM frame has error_code (4 octets) field.
+inline constexpr size_t kRstStreamFrameSize = kFrameHeaderSize + 4;
+inline constexpr size_t kSettingsFrameMinimumSize = kFrameHeaderSize;
+inline constexpr size_t kSettingsOneSettingSize =
+    sizeof(uint32_t) + sizeof(SpdySettingsId);
+// PUSH_PROMISE frame has promised_stream_id (4 octet) field.
+inline constexpr size_t kPushPromiseFrameMinimumSize = kFrameHeaderSize + 4;
+// PING frame has opaque_bytes (8 octet) field.
+inline constexpr size_t kPingFrameSize = kFrameHeaderSize + 8;
+// GOAWAY frame has last_stream_id (4 octet) and error_code (4 octet) fields.
+inline constexpr size_t kGoawayFrameMinimumSize = kFrameHeaderSize + 8;
+// WINDOW_UPDATE frame has window_size_increment (4 octet) field.
+inline constexpr size_t kWindowUpdateFrameSize = kFrameHeaderSize + 4;
+inline constexpr size_t kContinuationFrameMinimumSize = kFrameHeaderSize;
+// ALTSVC frame has origin_len (2 octets) field.
+inline constexpr size_t kGetAltSvcFrameMinimumSize = kFrameHeaderSize + 2;
+// PRIORITY_UPDATE frame has prioritized_stream_id (4 octets) field.
+inline constexpr size_t kPriorityUpdateFrameMinimumSize = kFrameHeaderSize + 4;
+// ACCEPT_CH frame may have empty payload.
+inline constexpr size_t kAcceptChFrameMinimumSize = kFrameHeaderSize;
+// Each ACCEPT_CH frame entry has a 16-bit origin length and a 16-bit value
+// length.
+inline constexpr size_t kAcceptChFramePerEntryOverhead = 4;
+
+// Maximum possible configurable size of a frame in octets.
+inline constexpr size_t kMaxFrameSizeLimit =
+    kSpdyMaxFrameSizeLimit + kFrameHeaderSize;
+// Size of a header block size field.
+inline constexpr size_t kSizeOfSizeField = sizeof(uint32_t);
+// Initial window size for a stream in bytes.
+inline constexpr int32_t kInitialStreamWindowSize = 64 * 1024 - 1;
+// Initial window size for a session in bytes.
+inline constexpr int32_t kInitialSessionWindowSize = 64 * 1024 - 1;
+// The NPN string for HTTP2, "h2".
+QUICHE_EXPORT extern const char* const kHttp2Npn;
+// An estimate of the HPACK overhead for each header field in bytes, intended to
+// be no smaller than actual overhead, based on the literal header field
+// representation in RFC 7541 Section 6.2 (with or without indexing):
+//   - 1 byte for the opcode.
+//   - 2 bytes for the name length (assuming new name).
+//   - 3 bytes for the value length.
+// TODO(b/322146543): Remove the `New` suffix with deprecation of
+// --gfe2_reloadable_flag_http2_add_hpack_overhead_bytes2.
+inline constexpr size_t kPerHeaderHpackOverheadNew = 6;
+// An estimate size of the HPACK overhead for each header field. 1 bytes for
+// indexed literal, 1 bytes for key literal and length encoding, and 2 bytes for
+// value literal and length encoding.
+// TODO(b/322146543): Remove with deprecation of
+// --gfe2_reloadable_flag_http2_add_hpack_overhead_bytes2.
+inline constexpr size_t kPerHeaderHpackOverheadOld = 4;
+
+// Names of pseudo-headers defined for HTTP/2 requests.
+QUICHE_EXPORT extern const char* const kHttp2AuthorityHeader;
+QUICHE_EXPORT extern const char* const kHttp2MethodHeader;
+QUICHE_EXPORT extern const char* const kHttp2PathHeader;
+QUICHE_EXPORT extern const char* const kHttp2SchemeHeader;
+QUICHE_EXPORT extern const char* const kHttp2ProtocolHeader;
+
+// Name of pseudo-header defined for HTTP/2 responses.
+QUICHE_EXPORT extern const char* const kHttp2StatusHeader;
+
+QUICHE_EXPORT size_t GetNumberRequiredContinuationFrames(size_t size);
+
+// Variant type that is either a SPDY 3.x priority value, or else an HTTP/2
+// stream dependency tuple {parent stream ID, weight, exclusive bit}. Templated
+// to allow for use by QUIC code; SPDY and HTTP/2 code should use the concrete
+// type instantiation SpdyStreamPrecedence.
+template <typename StreamIdType>
+class QUICHE_EXPORT StreamPrecedence {
+ public:
+  // Constructs instance that is a SPDY 3.x priority. Clamps priority value to
+  // the valid range [0, 7].
+  explicit StreamPrecedence(SpdyPriority priority)
+      : precedence_(ClampSpdy3Priority(priority)) {}
+
+  // Constructs instance that is an HTTP/2 stream weight, parent stream ID, and
+  // exclusive bit. Clamps stream weight to the valid range [1, 256].
+  StreamPrecedence(StreamIdType parent_id, int weight, bool is_exclusive)
+      : precedence_(Http2StreamDependency{parent_id, ClampHttp2Weight(weight),
+                                          is_exclusive}) {}
+
+  // Intentionally copyable, to support pass by value.
+  StreamPrecedence(const StreamPrecedence& other) = default;
+  StreamPrecedence& operator=(const StreamPrecedence& other) = default;
+
+  // Returns true if this instance is a SPDY 3.x priority, or false if this
+  // instance is an HTTP/2 stream dependency.
+  bool is_spdy3_priority() const {
+    return absl::holds_alternative<SpdyPriority>(precedence_);
+  }
+
+  // Returns SPDY 3.x priority value. If |is_spdy3_priority()| is true, this is
+  // the value provided at construction, clamped to the legal priority
+  // range. Otherwise, it is the HTTP/2 stream weight mapped to a SPDY 3.x
+  // priority value, where minimum weight 1 corresponds to priority 7 (lowest
+  // precedence) and maximum weight 256 corresponds to priority 0 (highest
+  // precedence).
+  SpdyPriority spdy3_priority() const {
+    return is_spdy3_priority()
+               ? absl::get<SpdyPriority>(precedence_)
+               : Http2WeightToSpdy3Priority(
+                     absl::get<Http2StreamDependency>(precedence_).weight);
+  }
+
+  // Returns HTTP/2 parent stream ID. If |is_spdy3_priority()| is false, this is
+  // the value provided at construction, otherwise it is |kHttp2RootStreamId|.
+  StreamIdType parent_id() const {
+    return is_spdy3_priority()
+               ? kHttp2RootStreamId
+               : absl::get<Http2StreamDependency>(precedence_).parent_id;
+  }
+
+  // Returns HTTP/2 stream weight. If |is_spdy3_priority()| is false, this is
+  // the value provided at construction, clamped to the legal weight
+  // range. Otherwise, it is the SPDY 3.x priority value mapped to an HTTP/2
+  // stream weight, where priority 0 (i.e. highest precedence) corresponds to
+  // maximum weight 256 and priority 7 (lowest precedence) corresponds to
+  // minimum weight 1.
+  int weight() const {
+    return is_spdy3_priority()
+               ? Spdy3PriorityToHttp2Weight(
+                     absl::get<SpdyPriority>(precedence_))
+               : absl::get<Http2StreamDependency>(precedence_).weight;
+  }
+
+  // Returns HTTP/2 parent stream exclusivity. If |is_spdy3_priority()| is
+  // false, this is the value provided at construction, otherwise it is false.
+  bool is_exclusive() const {
+    return absl::holds_alternative<Http2StreamDependency>(precedence_) &&
+           absl::get<Http2StreamDependency>(precedence_).is_exclusive;
+  }
+
+  // Facilitates test assertions.
+  bool operator==(const StreamPrecedence& other) const {
+    return precedence_ == other.precedence_;
+  }
+
+  bool operator!=(const StreamPrecedence& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  struct QUICHE_EXPORT Http2StreamDependency {
+    StreamIdType parent_id;
+    int weight;
+    bool is_exclusive;
+
+    bool operator==(const Http2StreamDependency& other) const {
+      return parent_id == other.parent_id && weight == other.weight &&
+             is_exclusive == other.is_exclusive;
+    }
+  };
+
+  absl::variant<SpdyPriority, Http2StreamDependency> precedence_;
+};
+
+typedef StreamPrecedence<SpdyStreamId> SpdyStreamPrecedence;
+
+class SpdyFrameVisitor;
+
+// Intermediate representation for HTTP2 frames.
+class QUICHE_EXPORT SpdyFrameIR {
+ public:
+  virtual ~SpdyFrameIR() {}
+
+  virtual void Visit(SpdyFrameVisitor* visitor) const = 0;
+  virtual SpdyFrameType frame_type() const = 0;
+  SpdyStreamId stream_id() const { return stream_id_; }
+  virtual bool fin() const;
+  // Returns an estimate of the size of the serialized frame, without applying
+  // compression. May not be exact, but implementations should return the same
+  // value for a const frame.
+  virtual size_t size() const = 0;
+
+  // Returns the number of bytes of flow control window that would be consumed
+  // by this frame if written to the wire.
+  virtual int flow_control_window_consumed() const;
+
+ protected:
+  SpdyFrameIR() : stream_id_(0) {}
+  explicit SpdyFrameIR(SpdyStreamId stream_id) : stream_id_(stream_id) {}
+  SpdyFrameIR(const SpdyFrameIR&) = delete;
+  SpdyFrameIR& operator=(const SpdyFrameIR&) = delete;
+
+ private:
+  SpdyStreamId stream_id_;
+};
+
+// Abstract class intended to be inherited by IRs that have the option of a FIN
+// flag.
+class QUICHE_EXPORT SpdyFrameWithFinIR : public SpdyFrameIR {
+ public:
+  ~SpdyFrameWithFinIR() override {}
+  bool fin() const override;
+  void set_fin(bool fin) { fin_ = fin; }
+
+ protected:
+  explicit SpdyFrameWithFinIR(SpdyStreamId stream_id)
+      : SpdyFrameIR(stream_id), fin_(false) {}
+  SpdyFrameWithFinIR(const SpdyFrameWithFinIR&) = delete;
+  SpdyFrameWithFinIR& operator=(const SpdyFrameWithFinIR&) = delete;
+
+ private:
+  bool fin_;
+};
+
+// Abstract class intended to be inherited by IRs that contain a header
+// block. Implies SpdyFrameWithFinIR.
+class QUICHE_EXPORT SpdyFrameWithHeaderBlockIR : public SpdyFrameWithFinIR {
+ public:
+  ~SpdyFrameWithHeaderBlockIR() override;
+
+  const Http2HeaderBlock& header_block() const { return header_block_; }
+  void set_header_block(Http2HeaderBlock header_block) {
+    // Deep copy.
+    header_block_ = std::move(header_block);
+  }
+  void SetHeader(absl::string_view name, absl::string_view value) {
+    header_block_[name] = value;
+  }
+
+ protected:
+  SpdyFrameWithHeaderBlockIR(SpdyStreamId stream_id,
+                             Http2HeaderBlock header_block);
+  SpdyFrameWithHeaderBlockIR(const SpdyFrameWithHeaderBlockIR&) = delete;
+  SpdyFrameWithHeaderBlockIR& operator=(const SpdyFrameWithHeaderBlockIR&) =
+      delete;
+
+ private:
+  Http2HeaderBlock header_block_;
+};
+
+class QUICHE_EXPORT SpdyDataIR : public SpdyFrameWithFinIR {
+ public:
+  // Performs a deep copy on data.
+  SpdyDataIR(SpdyStreamId stream_id, absl::string_view data);
+
+  // Performs a deep copy on data.
+  SpdyDataIR(SpdyStreamId stream_id, const char* data);
+
+  // Moves data into data_store_. Makes a copy if passed a non-movable string.
+  SpdyDataIR(SpdyStreamId stream_id, std::string data);
+
+  // Use in conjunction with SetDataShallow() for shallow-copy on data.
+  explicit SpdyDataIR(SpdyStreamId stream_id);
+  SpdyDataIR(const SpdyDataIR&) = delete;
+  SpdyDataIR& operator=(const SpdyDataIR&) = delete;
+
+  ~SpdyDataIR() override;
+
+  const char* data() const { return data_; }
+  size_t data_len() const { return data_len_; }
+
+  bool padded() const { return padded_; }
+
+  int padding_payload_len() const { return padding_payload_len_; }
+
+  void set_padding_len(int padding_len) {
+    QUICHE_DCHECK_GT(padding_len, 0);
+    QUICHE_DCHECK_LE(padding_len, kPaddingSizePerFrame);
+    padded_ = true;
+    // The pad field takes one octet on the wire.
+    padding_payload_len_ = padding_len - 1;
+  }
+
+  // Deep-copy of data (keep private copy).
+  void SetDataDeep(absl::string_view data) {
+    data_store_ = std::make_unique<std::string>(data.data(), data.size());
+    data_ = data_store_->data();
+    data_len_ = data.size();
+  }
+
+  // Shallow-copy of data (do not keep private copy).
+  void SetDataShallow(absl::string_view data) {
+    data_store_.reset();
+    data_ = data.data();
+    data_len_ = data.size();
+  }
+
+  // Use this method if we don't have a contiguous buffer and only
+  // need a length.
+  void SetDataShallow(size_t len) {
+    data_store_.reset();
+    data_ = nullptr;
+    data_len_ = len;
+  }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  int flow_control_window_consumed() const override;
+
+  size_t size() const override;
+
+ private:
+  // Used to store data that this SpdyDataIR should own.
+  std::unique_ptr<std::string> data_store_;
+  const char* data_;
+  size_t data_len_;
+
+  bool padded_;
+  // padding_payload_len_ = desired padding length - len(padding length field).
+  int padding_payload_len_;
+};
+
+class QUICHE_EXPORT SpdyRstStreamIR : public SpdyFrameIR {
+ public:
+  SpdyRstStreamIR(SpdyStreamId stream_id, SpdyErrorCode error_code);
+  SpdyRstStreamIR(const SpdyRstStreamIR&) = delete;
+  SpdyRstStreamIR& operator=(const SpdyRstStreamIR&) = delete;
+
+  ~SpdyRstStreamIR() override;
+
+  SpdyErrorCode error_code() const { return error_code_; }
+  void set_error_code(SpdyErrorCode error_code) { error_code_ = error_code; }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+ private:
+  SpdyErrorCode error_code_;
+};
+
+class QUICHE_EXPORT SpdySettingsIR : public SpdyFrameIR {
+ public:
+  SpdySettingsIR();
+  SpdySettingsIR(const SpdySettingsIR&) = delete;
+  SpdySettingsIR& operator=(const SpdySettingsIR&) = delete;
+  ~SpdySettingsIR() override;
+
+  // Overwrites as appropriate.
+  const SettingsMap& values() const { return values_; }
+  void AddSetting(SpdySettingsId id, int32_t value) { values_[id] = value; }
+
+  bool is_ack() const { return is_ack_; }
+  void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+ private:
+  SettingsMap values_;
+  bool is_ack_;
+};
+
+class QUICHE_EXPORT SpdyPingIR : public SpdyFrameIR {
+ public:
+  explicit SpdyPingIR(SpdyPingId id) : id_(id), is_ack_(false) {}
+  SpdyPingIR(const SpdyPingIR&) = delete;
+  SpdyPingIR& operator=(const SpdyPingIR&) = delete;
+  SpdyPingId id() const { return id_; }
+
+  bool is_ack() const { return is_ack_; }
+  void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+ private:
+  SpdyPingId id_;
+  bool is_ack_;
+};
+
+class QUICHE_EXPORT SpdyGoAwayIR : public SpdyFrameIR {
+ public:
+  // References description, doesn't copy it, so description must outlast
+  // this SpdyGoAwayIR.
+  SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyErrorCode error_code,
+               absl::string_view description);
+
+  // References description, doesn't copy it, so description must outlast
+  // this SpdyGoAwayIR.
+  SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyErrorCode error_code,
+               const char* description);
+
+  // Moves description into description_store_, so caller doesn't need to
+  // keep description live after constructing this SpdyGoAwayIR.
+  SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyErrorCode error_code,
+               std::string description);
+  SpdyGoAwayIR(const SpdyGoAwayIR&) = delete;
+  SpdyGoAwayIR& operator=(const SpdyGoAwayIR&) = delete;
+
+  ~SpdyGoAwayIR() override;
+
+  SpdyStreamId last_good_stream_id() const { return last_good_stream_id_; }
+  void set_last_good_stream_id(SpdyStreamId last_good_stream_id) {
+    QUICHE_DCHECK_EQ(0u, last_good_stream_id & ~kStreamIdMask);
+    last_good_stream_id_ = last_good_stream_id;
+  }
+  SpdyErrorCode error_code() const { return error_code_; }
+  void set_error_code(SpdyErrorCode error_code) {
+    // TODO(hkhalil): Check valid ranges of error_code?
+    error_code_ = error_code;
+  }
+
+  const absl::string_view& description() const { return description_; }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+ private:
+  SpdyStreamId last_good_stream_id_;
+  SpdyErrorCode error_code_;
+  const std::string description_store_;
+  const absl::string_view description_;
+};
+
+class QUICHE_EXPORT SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
+ public:
+  explicit SpdyHeadersIR(SpdyStreamId stream_id)
+      : SpdyHeadersIR(stream_id, Http2HeaderBlock()) {}
+  SpdyHeadersIR(SpdyStreamId stream_id, Http2HeaderBlock header_block)
+      : SpdyFrameWithHeaderBlockIR(stream_id, std::move(header_block)) {}
+  SpdyHeadersIR(const SpdyHeadersIR&) = delete;
+  SpdyHeadersIR& operator=(const SpdyHeadersIR&) = delete;
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+  bool has_priority() const { return has_priority_; }
+  void set_has_priority(bool has_priority) { has_priority_ = has_priority; }
+  int weight() const { return weight_; }
+  void set_weight(int weight) { weight_ = weight; }
+  SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
+  void set_parent_stream_id(SpdyStreamId id) { parent_stream_id_ = id; }
+  bool exclusive() const { return exclusive_; }
+  void set_exclusive(bool exclusive) { exclusive_ = exclusive; }
+  bool padded() const { return padded_; }
+  int padding_payload_len() const { return padding_payload_len_; }
+  void set_padding_len(int padding_len) {
+    QUICHE_DCHECK_GT(padding_len, 0);
+    QUICHE_DCHECK_LE(padding_len, kPaddingSizePerFrame);
+    padded_ = true;
+    // The pad field takes one octet on the wire.
+    padding_payload_len_ = padding_len - 1;
+  }
+
+ private:
+  bool has_priority_ = false;
+  int weight_ = kHttp2DefaultStreamWeight;
+  SpdyStreamId parent_stream_id_ = 0;
+  bool exclusive_ = false;
+  bool padded_ = false;
+  int padding_payload_len_ = 0;
+  const bool add_hpack_overhead_bytes_ =
+      GetQuicheReloadableFlag(http2_add_hpack_overhead_bytes2);
+};
+
+class QUICHE_EXPORT SpdyWindowUpdateIR : public SpdyFrameIR {
+ public:
+  SpdyWindowUpdateIR(SpdyStreamId stream_id, int32_t delta)
+      : SpdyFrameIR(stream_id) {
+    set_delta(delta);
+  }
+  SpdyWindowUpdateIR(const SpdyWindowUpdateIR&) = delete;
+  SpdyWindowUpdateIR& operator=(const SpdyWindowUpdateIR&) = delete;
+
+  int32_t delta() const { return delta_; }
+  void set_delta(int32_t delta) {
+    QUICHE_DCHECK_LE(0, delta);
+    QUICHE_DCHECK_LE(delta, kSpdyMaximumWindowSize);
+    delta_ = delta;
+  }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+ private:
+  int32_t delta_;
+};
+
+class QUICHE_EXPORT SpdyPushPromiseIR : public SpdyFrameWithHeaderBlockIR {
+ public:
+  SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id)
+      : SpdyPushPromiseIR(stream_id, promised_stream_id, Http2HeaderBlock()) {}
+  SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
+                    Http2HeaderBlock header_block)
+      : SpdyFrameWithHeaderBlockIR(stream_id, std::move(header_block)),
+        promised_stream_id_(promised_stream_id),
+        padded_(false),
+        padding_payload_len_(0) {}
+  SpdyPushPromiseIR(const SpdyPushPromiseIR&) = delete;
+  SpdyPushPromiseIR& operator=(const SpdyPushPromiseIR&) = delete;
+  SpdyStreamId promised_stream_id() const { return promised_stream_id_; }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+  bool padded() const { return padded_; }
+  int padding_payload_len() const { return padding_payload_len_; }
+  void set_padding_len(int padding_len) {
+    QUICHE_DCHECK_GT(padding_len, 0);
+    QUICHE_DCHECK_LE(padding_len, kPaddingSizePerFrame);
+    padded_ = true;
+    // The pad field takes one octet on the wire.
+    padding_payload_len_ = padding_len - 1;
+  }
+
+ private:
+  SpdyStreamId promised_stream_id_;
+
+  bool padded_;
+  int padding_payload_len_;
+};
+
+class QUICHE_EXPORT SpdyContinuationIR : public SpdyFrameIR {
+ public:
+  explicit SpdyContinuationIR(SpdyStreamId stream_id);
+  SpdyContinuationIR(const SpdyContinuationIR&) = delete;
+  SpdyContinuationIR& operator=(const SpdyContinuationIR&) = delete;
+  ~SpdyContinuationIR() override;
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  bool end_headers() const { return end_headers_; }
+  void set_end_headers(bool end_headers) { end_headers_ = end_headers; }
+  const std::string& encoding() const { return encoding_; }
+  void take_encoding(std::string encoding) { encoding_ = std::move(encoding); }
+  size_t size() const override;
+
+ private:
+  std::string encoding_;
+  bool end_headers_;
+};
+
+class QUICHE_EXPORT SpdyAltSvcIR : public SpdyFrameIR {
+ public:
+  explicit SpdyAltSvcIR(SpdyStreamId stream_id);
+  SpdyAltSvcIR(const SpdyAltSvcIR&) = delete;
+  SpdyAltSvcIR& operator=(const SpdyAltSvcIR&) = delete;
+  ~SpdyAltSvcIR() override;
+
+  std::string origin() const { return origin_; }
+  const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector() const {
+    return altsvc_vector_;
+  }
+
+  void set_origin(std::string origin) { origin_ = std::move(origin); }
+  void add_altsvc(const SpdyAltSvcWireFormat::AlternativeService& altsvc) {
+    altsvc_vector_.push_back(altsvc);
+  }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+ private:
+  std::string origin_;
+  SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector_;
+};
+
+class QUICHE_EXPORT SpdyPriorityIR : public SpdyFrameIR {
+ public:
+  SpdyPriorityIR(SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
+                 int weight, bool exclusive)
+      : SpdyFrameIR(stream_id),
+        parent_stream_id_(parent_stream_id),
+        weight_(weight),
+        exclusive_(exclusive) {}
+  SpdyPriorityIR(const SpdyPriorityIR&) = delete;
+  SpdyPriorityIR& operator=(const SpdyPriorityIR&) = delete;
+  SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
+  int weight() const { return weight_; }
+  bool exclusive() const { return exclusive_; }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+ private:
+  SpdyStreamId parent_stream_id_;
+  int weight_;
+  bool exclusive_;
+};
+
+class QUICHE_EXPORT SpdyPriorityUpdateIR : public SpdyFrameIR {
+ public:
+  SpdyPriorityUpdateIR(SpdyStreamId stream_id,
+                       SpdyStreamId prioritized_stream_id,
+                       std::string priority_field_value)
+      : SpdyFrameIR(stream_id),
+        prioritized_stream_id_(prioritized_stream_id),
+        priority_field_value_(std::move(priority_field_value)) {}
+  SpdyPriorityUpdateIR(const SpdyPriorityUpdateIR&) = delete;
+  SpdyPriorityUpdateIR& operator=(const SpdyPriorityUpdateIR&) = delete;
+  SpdyStreamId prioritized_stream_id() const { return prioritized_stream_id_; }
+  const std::string& priority_field_value() const {
+    return priority_field_value_;
+  }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+ private:
+  SpdyStreamId prioritized_stream_id_;
+  std::string priority_field_value_;
+};
+
+struct QUICHE_EXPORT AcceptChOriginValuePair {
+  std::string origin;
+  std::string value;
+  bool operator==(const AcceptChOriginValuePair& rhs) const {
+    return origin == rhs.origin && value == rhs.value;
+  }
+};
+
+class QUICHE_EXPORT SpdyAcceptChIR : public SpdyFrameIR {
+ public:
+  SpdyAcceptChIR(std::vector<AcceptChOriginValuePair> entries)
+      : entries_(std::move(entries)) {}
+  SpdyAcceptChIR(const SpdyAcceptChIR&) = delete;
+  SpdyAcceptChIR& operator=(const SpdyAcceptChIR&) = delete;
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  size_t size() const override;
+
+  const std::vector<AcceptChOriginValuePair>& entries() const {
+    return entries_;
+  }
+
+ private:
+  std::vector<AcceptChOriginValuePair> entries_;
+};
+
+// Represents a frame of unrecognized type.
+class QUICHE_EXPORT SpdyUnknownIR : public SpdyFrameIR {
+ public:
+  SpdyUnknownIR(SpdyStreamId stream_id, uint8_t type, uint8_t flags,
+                std::string payload)
+      : SpdyFrameIR(stream_id),
+        type_(type),
+        flags_(flags),
+        length_(payload.size()),
+        payload_(std::move(payload)) {}
+  SpdyUnknownIR(const SpdyUnknownIR&) = delete;
+  SpdyUnknownIR& operator=(const SpdyUnknownIR&) = delete;
+  uint8_t type() const { return type_; }
+  uint8_t flags() const { return flags_; }
+  size_t length() const { return length_; }
+  const std::string& payload() const { return payload_; }
+
+  void Visit(SpdyFrameVisitor* visitor) const override;
+
+  SpdyFrameType frame_type() const override;
+
+  int flow_control_window_consumed() const override;
+
+  size_t size() const override;
+
+ protected:
+  // Allows subclasses to overwrite the default payload length.
+  void set_length(size_t length) { length_ = length; }
+
+ private:
+  uint8_t type_;
+  uint8_t flags_;
+  size_t length_;
+  const std::string payload_;
+};
+
+class QUICHE_EXPORT SpdySerializedFrame {
+ public:
+  SpdySerializedFrame() : size_(0) {}
+
+  // Creates a valid SpdySerializedFrame using a pre-created buffer.
+  SpdySerializedFrame(std::unique_ptr<char[]> data, size_t size)
+      : frame_(std::move(data)), size_(size) {}
+
+  SpdySerializedFrame(SpdySerializedFrame&& other)
+      : frame_(std::move(other.frame_)), size_(other.size_) {}
+
+  SpdySerializedFrame(const SpdySerializedFrame&) = delete;
+  SpdySerializedFrame& operator=(const SpdySerializedFrame&) = delete;
+
+  SpdySerializedFrame& operator=(SpdySerializedFrame&& other) {
+    // Take over |other|.
+    frame_ = std::move(other.frame_);
+    size_ = other.size_;
+    return *this;
+  }
+
+  ~SpdySerializedFrame() = default;
+
+  // Provides access to the frame bytes, which is a buffer containing the frame
+  // packed as expected for sending over the wire.
+  char* data() const { return frame_.get(); }
+
+  // Returns the actual size of the underlying buffer.
+  size_t size() const { return size_; }
+
+  operator absl::string_view() const {
+    return absl::string_view{frame_.get(), size_};
+  }
+
+ private:
+  std::unique_ptr<char[]> frame_;
+  size_t size_;
+};
+
+// This interface is for classes that want to process SpdyFrameIRs without
+// having to know what type they are.  An instance of this interface can be
+// passed to a SpdyFrameIR's Visit method, and the appropriate type-specific
+// method of this class will be called.
+class QUICHE_EXPORT SpdyFrameVisitor {
+ public:
+  SpdyFrameVisitor() {}
+  SpdyFrameVisitor(const SpdyFrameVisitor&) = delete;
+  SpdyFrameVisitor& operator=(const SpdyFrameVisitor&) = delete;
+  virtual ~SpdyFrameVisitor() {}
+
+  virtual void VisitRstStream(const SpdyRstStreamIR& rst_stream) = 0;
+  virtual void VisitSettings(const SpdySettingsIR& settings) = 0;
+  virtual void VisitPing(const SpdyPingIR& ping) = 0;
+  virtual void VisitGoAway(const SpdyGoAwayIR& goaway) = 0;
+  virtual void VisitHeaders(const SpdyHeadersIR& headers) = 0;
+  virtual void VisitWindowUpdate(const SpdyWindowUpdateIR& window_update) = 0;
+  virtual void VisitPushPromise(const SpdyPushPromiseIR& push_promise) = 0;
+  virtual void VisitContinuation(const SpdyContinuationIR& continuation) = 0;
+  virtual void VisitAltSvc(const SpdyAltSvcIR& altsvc) = 0;
+  virtual void VisitPriority(const SpdyPriorityIR& priority) = 0;
+  virtual void VisitData(const SpdyDataIR& data) = 0;
+  virtual void VisitPriorityUpdate(
+      const SpdyPriorityUpdateIR& priority_update) = 0;
+  virtual void VisitAcceptCh(const SpdyAcceptChIR& accept_ch) = 0;
+  virtual void VisitUnknown(const SpdyUnknownIR& /*unknown*/) {
+    // TODO(birenroy): make abstract.
+  }
+};
+
+// Optionally, and in addition to SpdyFramerVisitorInterface, a class supporting
+// SpdyFramerDebugVisitorInterface may be used in conjunction with SpdyFramer in
+// order to extract debug/internal information about the SpdyFramer as it
+// operates.
+//
+// Most HTTP2 implementations need not bother with this interface at all.
+class QUICHE_EXPORT SpdyFramerDebugVisitorInterface {
+ public:
+  virtual ~SpdyFramerDebugVisitorInterface() {}
+
+  // Called after compressing a frame with a payload of
+  // a list of name-value pairs.
+  // |payload_len| is the uncompressed payload size.
+  // |frame_len| is the compressed frame size.
+  virtual void OnSendCompressedFrame(SpdyStreamId /*stream_id*/,
+                                     SpdyFrameType /*type*/,
+                                     size_t /*payload_len*/,
+                                     size_t /*frame_len*/) {}
+
+  // Called when a frame containing a compressed payload of
+  // name-value pairs is received.
+  // |frame_len| is the compressed frame size.
+  virtual void OnReceiveCompressedFrame(SpdyStreamId /*stream_id*/,
+                                        SpdyFrameType /*type*/,
+                                        size_t /*frame_len*/) {}
+};
+
+// Calculates the number of bytes required to serialize a SpdyHeadersIR, not
+// including the bytes to be used for the encoded header set.
+size_t GetHeaderFrameSizeSansBlock(const SpdyHeadersIR& header_ir);
+
+// Calculates the number of bytes required to serialize a SpdyPushPromiseIR,
+// not including the bytes to be used for the encoded header set.
+size_t GetPushPromiseFrameSizeSansBlock(
+    const SpdyPushPromiseIR& push_promise_ir);
+
+}  // namespace spdy
+
+#endif  // QUICHE_HTTP2_CORE_SPDY_PROTOCOL_H_
diff --git a/quiche/spdy/core/spdy_protocol_test.cc b/quiche/http2/core/spdy_protocol_test.cc
similarity index 99%
rename from quiche/spdy/core/spdy_protocol_test.cc
rename to quiche/http2/core/spdy_protocol_test.cc
index 5a22bb2..7dbbe02 100644
--- a/quiche/spdy/core/spdy_protocol_test.cc
+++ b/quiche/http2/core/spdy_protocol_test.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/spdy/core/spdy_protocol.h"
+#include "quiche/http2/core/spdy_protocol.h"
 
 #include <iostream>
 #include <string>
diff --git a/quiche/http2/test_tools/http2_trace_printer.cc b/quiche/http2/test_tools/http2_trace_printer.cc
index 682f91b..cc04ce0 100644
--- a/quiche/http2/test_tools/http2_trace_printer.cc
+++ b/quiche/http2/test_tools/http2_trace_printer.cc
@@ -7,7 +7,7 @@
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
 #include "quiche/http2/core/http2_trace_logging.h"
-#include "quiche/spdy/core/spdy_protocol.h"
+#include "quiche/http2/core/spdy_protocol.h"
 
 namespace http2 {
 namespace test {
diff --git a/quiche/http2/test_tools/http2_trace_printer.h b/quiche/http2/test_tools/http2_trace_printer.h
index 6f27db1..3dc92af 100644
--- a/quiche/http2/test_tools/http2_trace_printer.h
+++ b/quiche/http2/test_tools/http2_trace_printer.h
@@ -4,10 +4,10 @@
 #include <cstddef>
 
 #include "absl/strings/string_view.h"
+#include "quiche/http2/core/http2_frame_decoder_adapter.h"
 #include "quiche/http2/core/http2_trace_logging.h"
 #include "quiche/http2/core/spdy_no_op_visitor.h"
 #include "quiche/common/platform/api/quiche_export.h"
-#include "quiche/spdy/core/http2_frame_decoder_adapter.h"
 
 namespace http2 {
 namespace test {
diff --git a/quiche/http2/test_tools/mock_spdy_framer_visitor.h b/quiche/http2/test_tools/mock_spdy_framer_visitor.h
index efec274..a66764d 100644
--- a/quiche/http2/test_tools/mock_spdy_framer_visitor.h
+++ b/quiche/http2/test_tools/mock_spdy_framer_visitor.h
@@ -11,13 +11,13 @@
 #include <string>
 
 #include "absl/strings/string_view.h"
+#include "quiche/http2/core/http2_frame_decoder_adapter.h"
 #include "quiche/http2/core/recording_headers_handler.h"
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
 #include "quiche/http2/core/spdy_headers_handler_interface.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/platform/api/quiche_test.h"
-#include "quiche/spdy/core/http2_frame_decoder_adapter.h"
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 // TODO(b/318698478): fix namespace and class name
 namespace spdy {
diff --git a/quiche/http2/test_tools/spdy_test_utils.cc b/quiche/http2/test_tools/spdy_test_utils.cc
index 70f30c8..766acce 100644
--- a/quiche/http2/test_tools/spdy_test_utils.cc
+++ b/quiche/http2/test_tools/spdy_test_utils.cc
@@ -10,10 +10,10 @@
 #include <memory>
 #include <string>
 
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/quiche_endian.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 namespace spdy {
 namespace test {
diff --git a/quiche/http2/test_tools/spdy_test_utils.h b/quiche/http2/test_tools/spdy_test_utils.h
index 1db9439..e59924f 100644
--- a/quiche/http2/test_tools/spdy_test_utils.h
+++ b/quiche/http2/test_tools/spdy_test_utils.h
@@ -10,8 +10,8 @@
 #include <string>
 
 #include "absl/strings/string_view.h"
+#include "quiche/http2/core/spdy_protocol.h"
 #include "quiche/spdy/core/http2_header_block.h"
-#include "quiche/spdy/core/spdy_protocol.h"
 
 // TODO(b/318698478): update the namespace and file name
 namespace spdy {
diff --git a/quiche/spdy/core/http2_frame_decoder_adapter.h b/quiche/spdy/core/http2_frame_decoder_adapter.h
index 33249a3..dd78809 100644
--- a/quiche/spdy/core/http2_frame_decoder_adapter.h
+++ b/quiche/spdy/core/http2_frame_decoder_adapter.h
@@ -5,562 +5,6 @@
 #ifndef QUICHE_SPDY_CORE_HTTP2_FRAME_DECODER_ADAPTER_H_
 #define QUICHE_SPDY_CORE_HTTP2_FRAME_DECODER_ADAPTER_H_
 
-#include <stddef.h>
-
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <string>
-
-#include "absl/strings/string_view.h"
-#include "quiche/http2/core/spdy_headers_handler_interface.h"
-#include "quiche/http2/decoder/decode_status.h"
-#include "quiche/http2/decoder/http2_frame_decoder.h"
-#include "quiche/http2/decoder/http2_frame_decoder_listener.h"
-#include "quiche/http2/http2_constants.h"
-#include "quiche/http2/http2_structures.h"
-#include "quiche/common/platform/api/quiche_export.h"
-#include "quiche/spdy/core/hpack/hpack_decoder_adapter.h"
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
-#include "quiche/spdy/core/spdy_protocol.h"
-
-namespace spdy {
-
-class SpdyFramerVisitorInterface;
-class ExtensionVisitorInterface;
-
-}  // namespace spdy
-
-// TODO(dahollings): Perform various renames/moves suggested in cl/164660364.
-
-namespace http2 {
-
-// Adapts SpdyFramer interface to use Http2FrameDecoder.
-class QUICHE_EXPORT Http2DecoderAdapter
-    : public http2::Http2FrameDecoderListener {
- public:
-  // HTTP2 states.
-  enum SpdyState {
-    SPDY_ERROR,
-    SPDY_READY_FOR_FRAME,  // Framer is ready for reading the next frame.
-    SPDY_FRAME_COMPLETE,  // Framer has finished reading a frame, need to reset.
-    SPDY_READING_COMMON_HEADER,
-    SPDY_CONTROL_FRAME_PAYLOAD,
-    SPDY_READ_DATA_FRAME_PADDING_LENGTH,
-    SPDY_CONSUME_PADDING,
-    SPDY_IGNORE_REMAINING_PAYLOAD,
-    SPDY_FORWARD_STREAM_FRAME,
-    SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK,
-    SPDY_CONTROL_FRAME_HEADER_BLOCK,
-    SPDY_GOAWAY_FRAME_PAYLOAD,
-    SPDY_SETTINGS_FRAME_HEADER,
-    SPDY_SETTINGS_FRAME_PAYLOAD,
-    SPDY_ALTSVC_FRAME_PAYLOAD,
-    SPDY_EXTENSION_FRAME_PAYLOAD,
-  };
-
-  // Framer error codes.
-  enum SpdyFramerError {
-    SPDY_NO_ERROR,
-    SPDY_INVALID_STREAM_ID,           // Stream ID is invalid
-    SPDY_INVALID_CONTROL_FRAME,       // Control frame is mal-formatted.
-    SPDY_CONTROL_PAYLOAD_TOO_LARGE,   // Control frame payload was too large.
-    SPDY_DECOMPRESS_FAILURE,          // There was an error decompressing.
-    SPDY_INVALID_PADDING,             // HEADERS or DATA frame padding invalid
-    SPDY_INVALID_DATA_FRAME_FLAGS,    // Data frame has invalid flags.
-    SPDY_UNEXPECTED_FRAME,            // Frame received out of order.
-    SPDY_INTERNAL_FRAMER_ERROR,       // SpdyFramer was used incorrectly.
-    SPDY_INVALID_CONTROL_FRAME_SIZE,  // Control frame not sized to spec
-    SPDY_OVERSIZED_PAYLOAD,           // Payload size was too large
-
-    // HttpDecoder or HttpDecoderAdapter error.
-    // See HpackDecodingError for description of each error code.
-    SPDY_HPACK_INDEX_VARINT_ERROR,
-    SPDY_HPACK_NAME_LENGTH_VARINT_ERROR,
-    SPDY_HPACK_VALUE_LENGTH_VARINT_ERROR,
-    SPDY_HPACK_NAME_TOO_LONG,
-    SPDY_HPACK_VALUE_TOO_LONG,
-    SPDY_HPACK_NAME_HUFFMAN_ERROR,
-    SPDY_HPACK_VALUE_HUFFMAN_ERROR,
-    SPDY_HPACK_MISSING_DYNAMIC_TABLE_SIZE_UPDATE,
-    SPDY_HPACK_INVALID_INDEX,
-    SPDY_HPACK_INVALID_NAME_INDEX,
-    SPDY_HPACK_DYNAMIC_TABLE_SIZE_UPDATE_NOT_ALLOWED,
-    SPDY_HPACK_INITIAL_DYNAMIC_TABLE_SIZE_UPDATE_IS_ABOVE_LOW_WATER_MARK,
-    SPDY_HPACK_DYNAMIC_TABLE_SIZE_UPDATE_IS_ABOVE_ACKNOWLEDGED_SETTING,
-    SPDY_HPACK_TRUNCATED_BLOCK,
-    SPDY_HPACK_FRAGMENT_TOO_LONG,
-    SPDY_HPACK_COMPRESSED_HEADER_SIZE_EXCEEDS_LIMIT,
-
-    // Set if the visitor no longer wishes to receive events for this
-    // connection.
-    SPDY_STOP_PROCESSING,
-
-    LAST_ERROR,  // Must be the last entry in the enum.
-  };
-
-  // For debugging.
-  static const char* StateToString(int state);
-  static const char* SpdyFramerErrorToString(SpdyFramerError spdy_framer_error);
-
-  Http2DecoderAdapter();
-  ~Http2DecoderAdapter() override;
-
-  Http2DecoderAdapter(const Http2DecoderAdapter&) = delete;
-  Http2DecoderAdapter& operator=(const Http2DecoderAdapter&) = delete;
-
-  // Set callbacks to be called from the framer.  A visitor must be set, or
-  // else the framer will likely crash.  It is acceptable for the visitor
-  // to do nothing.  If this is called multiple times, only the last visitor
-  // will be used.
-  void set_visitor(spdy::SpdyFramerVisitorInterface* visitor);
-  spdy::SpdyFramerVisitorInterface* visitor() const { return visitor_; }
-
-  // Set extension callbacks to be called from the framer or decoder. Optional.
-  // If called multiple times, only the last visitor will be used.
-  void set_extension_visitor(spdy::ExtensionVisitorInterface* visitor);
-  spdy::ExtensionVisitorInterface* extension_visitor() const {
-    return extension_;
-  }
-
-  // Set debug callbacks to be called from the framer. The debug visitor is
-  // completely optional and need not be set in order for normal operation.
-  // If this is called multiple times, only the last visitor will be used.
-  void set_debug_visitor(spdy::SpdyFramerDebugVisitorInterface* debug_visitor);
-  spdy::SpdyFramerDebugVisitorInterface* debug_visitor() const {
-    return debug_visitor_;
-  }
-
-  // Decode the |len| bytes of encoded HTTP/2 starting at |*data|. Returns
-  // the number of bytes consumed. It is safe to pass more bytes in than
-  // may be consumed. Should process (or otherwise buffer) as much as
-  // available.
-  //
-  // If the input contains the entirety of a DATA frame payload, GOAWAY frame
-  // Additional Debug Data field, or unknown frame payload, then the
-  // corresponding SpdyFramerVisitorInterface::OnStreamFrameData(),
-  // OnGoAwayFrameData(), or ExtensionVisitorInterface::OnFramePayload() method
-  // is guaranteed to be called exactly once, with the entire payload or field.
-  size_t ProcessInput(const char* data, size_t len);
-
-  // Current state of the decoder.
-  SpdyState state() const;
-
-  // Current error code (NO_ERROR if state != ERROR).
-  SpdyFramerError spdy_framer_error() const;
-
-  // Has any frame header looked like the start of an HTTP/1.1 (or earlier)
-  // response? Used to detect if a backend/server that we sent a request to
-  // has responded with an HTTP/1.1 (or earlier) response.
-  bool probable_http_response() const;
-
-  spdy::HpackDecoderAdapter& GetHpackDecoder() { return hpack_decoder_; }
-  const spdy::HpackDecoderAdapter& GetHpackDecoder() const {
-    return hpack_decoder_;
-  }
-
-  bool HasError() const;
-
-  // A visitor may call this method to indicate it no longer wishes to receive
-  // events for this connection.
-  void StopProcessing();
-
-  // Sets the limit on the size of received HTTP/2 frame payloads. Corresponds
-  // to SETTINGS_MAX_FRAME_SIZE as advertised to the peer.
-  void SetMaxFrameSize(size_t max_frame_size);
-
- private:
-  bool OnFrameHeader(const Http2FrameHeader& header) override;
-  void OnDataStart(const Http2FrameHeader& header) override;
-  void OnDataPayload(const char* data, size_t len) override;
-  void OnDataEnd() override;
-  void OnHeadersStart(const Http2FrameHeader& header) override;
-  void OnHeadersPriority(const Http2PriorityFields& priority) override;
-  void OnHpackFragment(const char* data, size_t len) override;
-  void OnHeadersEnd() override;
-  void OnPriorityFrame(const Http2FrameHeader& header,
-                       const Http2PriorityFields& priority) override;
-  void OnContinuationStart(const Http2FrameHeader& header) override;
-  void OnContinuationEnd() override;
-  void OnPadLength(size_t trailing_length) override;
-  void OnPadding(const char* padding, size_t skipped_length) override;
-  void OnRstStream(const Http2FrameHeader& header,
-                   Http2ErrorCode http2_error_code) override;
-  void OnSettingsStart(const Http2FrameHeader& header) override;
-  void OnSetting(const Http2SettingFields& setting_fields) override;
-  void OnSettingsEnd() override;
-  void OnSettingsAck(const Http2FrameHeader& header) override;
-  void OnPushPromiseStart(const Http2FrameHeader& header,
-                          const Http2PushPromiseFields& promise,
-                          size_t total_padding_length) override;
-  void OnPushPromiseEnd() override;
-  void OnPing(const Http2FrameHeader& header,
-              const Http2PingFields& ping) override;
-  void OnPingAck(const Http2FrameHeader& header,
-                 const Http2PingFields& ping) override;
-  void OnGoAwayStart(const Http2FrameHeader& header,
-                     const Http2GoAwayFields& goaway) override;
-  void OnGoAwayOpaqueData(const char* data, size_t len) override;
-  void OnGoAwayEnd() override;
-  void OnWindowUpdate(const Http2FrameHeader& header,
-                      uint32_t increment) override;
-  void OnAltSvcStart(const Http2FrameHeader& header, size_t origin_length,
-                     size_t value_length) override;
-  void OnAltSvcOriginData(const char* data, size_t len) override;
-  void OnAltSvcValueData(const char* data, size_t len) override;
-  void OnAltSvcEnd() override;
-  void OnPriorityUpdateStart(
-      const Http2FrameHeader& header,
-      const Http2PriorityUpdateFields& priority_update) override;
-  void OnPriorityUpdatePayload(const char* data, size_t len) override;
-  void OnPriorityUpdateEnd() override;
-  void OnUnknownStart(const Http2FrameHeader& header) override;
-  void OnUnknownPayload(const char* data, size_t len) override;
-  void OnUnknownEnd() override;
-  void OnPaddingTooLong(const Http2FrameHeader& header,
-                        size_t missing_length) override;
-  void OnFrameSizeError(const Http2FrameHeader& header) override;
-
-  size_t ProcessInputFrame(const char* data, size_t len);
-
-  void DetermineSpdyState(DecodeStatus status);
-  void ResetBetweenFrames();
-
-  void set_spdy_state(SpdyState v);
-
-  void SetSpdyErrorAndNotify(SpdyFramerError error, std::string detailed_error);
-
-  const Http2FrameHeader& frame_header() const;
-
-  uint32_t stream_id() const;
-  Http2FrameType frame_type() const;
-
-  size_t remaining_total_payload() const;
-
-  bool IsReadingPaddingLength();
-  bool IsSkippingPadding();
-  bool IsDiscardingPayload();
-  // Called from OnXyz or OnXyzStart methods to decide whether it is OK to
-  // handle the callback.
-  bool IsOkToStartFrame(const Http2FrameHeader& header);
-  bool HasRequiredStreamId(uint32_t stream_id);
-
-  bool HasRequiredStreamId(const Http2FrameHeader& header);
-
-  bool HasRequiredStreamIdZero(uint32_t stream_id);
-
-  bool HasRequiredStreamIdZero(const Http2FrameHeader& header);
-
-  void ReportReceiveCompressedFrame(const Http2FrameHeader& header);
-
-  void CommonStartHpackBlock();
-
-  // SpdyFramer calls HandleControlFrameHeadersData even if there are zero
-  // fragment bytes in the first frame, so do the same.
-  void MaybeAnnounceEmptyFirstHpackFragment();
-  void CommonHpackFragmentEnd();
-
-  // The most recently decoded frame header; invalid after we reached the end
-  // of that frame.
-  Http2FrameHeader frame_header_;
-
-  // If decoding an HPACK block that is split across multiple frames, this holds
-  // the frame header of the HEADERS or PUSH_PROMISE that started the block.
-  Http2FrameHeader hpack_first_frame_header_;
-
-  // Amount of trailing padding. Currently used just as an indicator of whether
-  // OnPadLength has been called.
-  std::optional<size_t> opt_pad_length_;
-
-  // Temporary buffers for the AltSvc fields.
-  std::string alt_svc_origin_;
-  std::string alt_svc_value_;
-
-  // Temporary buffers for PRIORITY_UPDATE fields.
-  uint32_t prioritized_stream_id_ = 0;
-  std::string priority_field_value_;
-
-  // Listener used if we transition to an error state; the listener ignores all
-  // the callbacks.
-  Http2FrameDecoderNoOpListener no_op_listener_;
-
-  spdy::SpdyFramerVisitorInterface* visitor_ = nullptr;
-  spdy::SpdyFramerDebugVisitorInterface* debug_visitor_ = nullptr;
-
-  // If non-null, unknown frames and settings are passed to the extension.
-  spdy::ExtensionVisitorInterface* extension_ = nullptr;
-
-  // The HPACK decoder to be used for this adapter.
-  spdy::HpackDecoderAdapter hpack_decoder_;
-
-  // The HTTP/2 frame decoder.
-  Http2FrameDecoder frame_decoder_;
-
-  // Next frame type expected. Currently only used for CONTINUATION frames,
-  // but could be used for detecting whether the first frame is a SETTINGS
-  // frame.
-  // TODO(jamessynge): Provide means to indicate that decoder should require
-  // SETTINGS frame as the first frame.
-  Http2FrameType expected_frame_type_;
-
-  // Attempt to duplicate the SpdyState and SpdyFramerError values that
-  // SpdyFramer sets. Values determined by getting tests to pass.
-  SpdyState spdy_state_ = SpdyState::SPDY_READY_FOR_FRAME;
-  SpdyFramerError spdy_framer_error_ = SpdyFramerError::SPDY_NO_ERROR;
-
-  // The limit on the size of received HTTP/2 payloads as specified in the
-  // SETTINGS_MAX_FRAME_SIZE advertised to peer.
-  size_t max_frame_size_ = spdy::kHttp2DefaultFramePayloadLimit;
-
-  // Has OnFrameHeader been called?
-  bool decoded_frame_header_ = false;
-
-  // Have we recorded an Http2FrameHeader for the current frame?
-  // We only do so if the decoder will make multiple callbacks for
-  // the frame; for example, for PING frames we don't make record
-  // the frame header, but for ALTSVC we do.
-  bool has_frame_header_ = false;
-
-  // Have we recorded an Http2FrameHeader for the current HPACK block?
-  // True only for multi-frame HPACK blocks.
-  bool has_hpack_first_frame_header_ = false;
-
-  // Has OnHeaders() already been called for current HEADERS block? Only
-  // meaningful between OnHeadersStart and OnHeadersPriority.
-  bool on_headers_called_ = false;
-
-  // Has OnHpackFragment() already been called for current HPACK block?
-  // SpdyFramer will pass an empty buffer to the HPACK decoder if a HEADERS
-  // or PUSH_PROMISE has no HPACK data in it (e.g. a HEADERS frame with only
-  // padding). Detect that condition and replicate the behavior using this
-  // field.
-  bool on_hpack_fragment_called_ = false;
-
-  // Have we seen a frame header that appears to be an HTTP/1 response?
-  bool latched_probable_http_response_ = false;
-
-  // Is expected_frame_type_ set?
-  bool has_expected_frame_type_ = false;
-
-  // Is the current frame payload destined for |extension_|?
-  bool handling_extension_payload_ = false;
-};
-
-}  // namespace http2
-
-namespace spdy {
-
-// Http2DecoderAdapter will use the given visitor implementing this
-// interface to deliver event callbacks as frames are decoded.
-//
-// Control frames that contain HTTP2 header blocks (HEADER, and PUSH_PROMISE)
-// are processed in fashion that allows the decompressed header block to be
-// delivered in chunks to the visitor.
-// The following steps are followed:
-//   1. OnHeaders, or OnPushPromise is called.
-//   2. OnHeaderFrameStart is called; visitor is expected to return an instance
-//      of SpdyHeadersHandlerInterface that will receive the header key-value
-//      pairs.
-//   3. OnHeaderFrameEnd is called, indicating that the full header block has
-//      been delivered for the control frame.
-// During step 2, if the visitor is not interested in accepting the header data,
-// it should return a no-op implementation of SpdyHeadersHandlerInterface.
-class QUICHE_EXPORT SpdyFramerVisitorInterface {
- public:
-  virtual ~SpdyFramerVisitorInterface() {}
-
-  // Called if an error is detected in the SpdyFrame protocol.
-  virtual void OnError(http2::Http2DecoderAdapter::SpdyFramerError error,
-                       std::string detailed_error) = 0;
-
-  // Called when the common header for a frame is received. Validating the
-  // common header occurs in later processing.
-  virtual void OnCommonHeader(SpdyStreamId /*stream_id*/, size_t /*length*/,
-                              uint8_t /*type*/, uint8_t /*flags*/) {}
-
-  // Called when a data frame header is received. The frame's data payload will
-  // be provided via subsequent calls to OnStreamFrameData().
-  // |stream_id| The stream receiving data.
-  // |length| The length of the payload in this DATA frame. Includes the length
-  //     of the data itself and potential padding.
-  // |fin| Whether the END_STREAM flag is set in the frame header.
-  virtual void OnDataFrameHeader(SpdyStreamId stream_id, size_t length,
-                                 bool fin) = 0;
-
-  // Called when data is received.
-  // |stream_id| The stream receiving data.
-  // |data| A buffer containing the data received.
-  // |len| The length of the data buffer.
-  virtual void OnStreamFrameData(SpdyStreamId stream_id, const char* data,
-                                 size_t len) = 0;
-
-  // Called when the other side has finished sending data on this stream.
-  // |stream_id| The stream that was receiving data.
-  virtual void OnStreamEnd(SpdyStreamId stream_id) = 0;
-
-  // Called when padding length field is received on a DATA frame.
-  // |stream_id| The stream receiving data.
-  // |value| The value of the padding length field.
-  virtual void OnStreamPadLength(SpdyStreamId /*stream_id*/, size_t /*value*/) {
-  }
-
-  // Called when padding is received (the trailing octets, not pad_len field) on
-  // a DATA frame.
-  // |stream_id| The stream receiving data.
-  // |len| The number of padding octets.
-  virtual void OnStreamPadding(SpdyStreamId stream_id, size_t len) = 0;
-
-  // Called just before processing the payload of a frame containing header
-  // data. Should return an implementation of SpdyHeadersHandlerInterface that
-  // will receive headers for stream |stream_id|. The caller will not take
-  // ownership of the headers handler. The same instance should remain live
-  // and be returned for all header frames comprising a logical header block
-  // (i.e. until OnHeaderFrameEnd() is called).
-  virtual SpdyHeadersHandlerInterface* OnHeaderFrameStart(
-      SpdyStreamId stream_id) = 0;
-
-  // Called after processing the payload of a frame containing header data.
-  virtual void OnHeaderFrameEnd(SpdyStreamId stream_id) = 0;
-
-  // Called when a RST_STREAM frame has been parsed.
-  virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyErrorCode error_code) = 0;
-
-  // Called when a SETTINGS frame is received.
-  virtual void OnSettings() {}
-
-  // Called when a complete setting within a SETTINGS frame has been parsed.
-  // Note that |id| may or may not be a SETTINGS ID defined in the HTTP/2 spec.
-  virtual void OnSetting(SpdySettingsId id, uint32_t value) = 0;
-
-  // Called when a SETTINGS frame is received with the ACK flag set.
-  virtual void OnSettingsAck() {}
-
-  // Called before and after parsing SETTINGS id and value tuples.
-  virtual void OnSettingsEnd() = 0;
-
-  // Called when a PING frame has been parsed.
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) = 0;
-
-  // Called when a GOAWAY frame has been parsed.
-  virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyErrorCode error_code) = 0;
-
-  // Called when a HEADERS frame is received.
-  // Note that header block data is not included. See OnHeaderFrameStart().
-  // |stream_id| The stream receiving the header.
-  // |payload_length| The length of the payload in this HEADERS frame. Includes
-  //     the length of the encoded header block and potential padding.
-  // |has_priority| Whether or not the headers frame included a priority value,
-  //     and stream dependency info.
-  // |weight| If |has_priority| is true, then weight (in the range [1, 256])
-  //     for the receiving stream, otherwise 0.
-  // |parent_stream_id| If |has_priority| is true the parent stream of the
-  //     receiving stream, else 0.
-  // |exclusive| If |has_priority| is true the exclusivity of dependence on the
-  //     parent stream, else false.
-  // |fin| Whether the END_STREAM flag is set in the frame header.
-  // |end| False if HEADERs frame is to be followed by a CONTINUATION frame,
-  //     or true if not.
-  virtual void OnHeaders(SpdyStreamId stream_id, size_t payload_length,
-                         bool has_priority, int weight,
-                         SpdyStreamId parent_stream_id, bool exclusive,
-                         bool fin, bool end) = 0;
-
-  // Called when a WINDOW_UPDATE frame has been parsed.
-  virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              int delta_window_size) = 0;
-
-  // Called when a goaway frame opaque data is available.
-  // |goaway_data| A buffer containing the opaque GOAWAY data chunk received.
-  // |len| The length of the header data buffer. A length of zero indicates
-  //       that the header data block has been completely sent.
-  // When this function returns true the visitor indicates that it accepted
-  // all of the data. Returning false indicates that that an error has
-  // occurred while processing the data. Default implementation returns true.
-  virtual bool OnGoAwayFrameData(const char* goaway_data, size_t len);
-
-  // Called when a PUSH_PROMISE frame is received.
-  // Note that header block data is not included. See OnHeaderFrameStart().
-  virtual void OnPushPromise(SpdyStreamId stream_id,
-                             SpdyStreamId promised_stream_id, bool end) = 0;
-
-  // Called when a CONTINUATION frame is received.
-  // Note that header block data is not included. See OnHeaderFrameStart().
-  // |stream_id| The stream receiving the CONTINUATION.
-  // |payload_length| The length of the payload in this CONTINUATION frame.
-  // |end| True if this CONTINUATION frame will not be followed by another
-  //     CONTINUATION frame.
-  virtual void OnContinuation(SpdyStreamId stream_id, size_t payload_length,
-                              bool end) = 0;
-
-  // Called when an ALTSVC frame has been parsed.
-  virtual void OnAltSvc(
-      SpdyStreamId /*stream_id*/, absl::string_view /*origin*/,
-      const SpdyAltSvcWireFormat::AlternativeServiceVector& /*altsvc_vector*/) {
-  }
-
-  // Called when a PRIORITY frame is received.
-  // |stream_id| The stream to update the priority of.
-  // |parent_stream_id| The parent stream of |stream_id|.
-  // |weight| Stream weight, in the range [1, 256].
-  // |exclusive| Whether |stream_id| should be an only child of
-  //     |parent_stream_id|.
-  virtual void OnPriority(SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
-                          int weight, bool exclusive) = 0;
-
-  // Called when a PRIORITY_UPDATE frame is received on stream 0.
-  // |prioritized_stream_id| is the Prioritized Stream ID and
-  // |priority_field_value| is the Priority Field Value
-  // parsed from the frame payload.
-  virtual void OnPriorityUpdate(SpdyStreamId prioritized_stream_id,
-                                absl::string_view priority_field_value) = 0;
-
-  // Called when a frame type we don't recognize is received.
-  // Return true if this appears to be a valid extension frame, false otherwise.
-  // We distinguish between extension frames and nonsense by checking
-  // whether the stream id is valid.
-  // TODO(b/239060116): Remove this callback altogether.
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, uint8_t frame_type) = 0;
-
-  // Called when the common header for a non-standard frame is received. If the
-  // `length` is nonzero, the frame's payload will be provided via subsequent
-  // calls to OnUnknownFramePayload().
-  // |stream_id| The stream receiving the non-standard frame.
-  // |length| The length of the payload of the frame.
-  // |type| The type of the frame. This type is non-standard.
-  // |flags| The flags of the frame.
-  virtual void OnUnknownFrameStart(SpdyStreamId stream_id, size_t length,
-                                   uint8_t type, uint8_t flags) = 0;
-
-  // Called when a non-empty payload chunk for a non-standard frame is received.
-  // The payload for a single frame may be delivered as multiple calls to
-  // OnUnknownFramePayload(). Since the length field is passed in
-  // OnUnknownFrameStart(), there is no explicit indication of the end of the
-  // frame payload.
-  // |stream_id| The stream receiving the non-standard frame.
-  // |payload| The payload chunk, which will be non-empty.
-  virtual void OnUnknownFramePayload(SpdyStreamId stream_id,
-                                     absl::string_view payload) = 0;
-};
-
-class QUICHE_EXPORT ExtensionVisitorInterface {
- public:
-  virtual ~ExtensionVisitorInterface() {}
-
-  // Called when non-standard SETTINGS are received.
-  virtual void OnSetting(SpdySettingsId id, uint32_t value) = 0;
-
-  // Called when non-standard frames are received.
-  virtual bool OnFrameHeader(SpdyStreamId stream_id, size_t length,
-                             uint8_t type, uint8_t flags) = 0;
-
-  // The payload for a single frame may be delivered as multiple calls to
-  // OnFramePayload. Since the length field is passed in OnFrameHeader, there is
-  // no explicit indication of the end of the frame payload.
-  virtual void OnFramePayload(const char* data, size_t len) = 0;
-};
-
-}  // namespace spdy
+#include "quiche/http2/core/http2_frame_decoder_adapter.h"
 
 #endif  // QUICHE_SPDY_CORE_HTTP2_FRAME_DECODER_ADAPTER_H_
diff --git a/quiche/spdy/core/http2_frame_decoder_adapter_fuzzer.cc b/quiche/spdy/core/http2_frame_decoder_adapter_fuzzer.cc
index 188b46f..9073a75 100644
--- a/quiche/spdy/core/http2_frame_decoder_adapter_fuzzer.cc
+++ b/quiche/spdy/core/http2_frame_decoder_adapter_fuzzer.cc
@@ -1,8 +1,8 @@
 #include <cstddef>
 #include <cstdint>
 
+#include "quiche/http2/core/http2_frame_decoder_adapter.h"
 #include "quiche/http2/core/spdy_no_op_visitor.h"
-#include "quiche/spdy/core/http2_frame_decoder_adapter.h"
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   spdy::SpdyNoOpVisitor visitor;
diff --git a/quiche/spdy/core/spdy_alt_svc_wire_format.h b/quiche/spdy/core/spdy_alt_svc_wire_format.h
index ec0c124..e8ab491 100644
--- a/quiche/spdy/core/spdy_alt_svc_wire_format.h
+++ b/quiche/spdy/core/spdy_alt_svc_wire_format.h
@@ -2,103 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// This file contains data structures and utility functions used for serializing
-// and parsing alternative service header values, common to HTTP/1.1 header
-// fields and HTTP/2 and QUIC ALTSVC frames.  See specification at
-// https://httpwg.github.io/http-extensions/alt-svc.html.
-
 #ifndef QUICHE_SPDY_CORE_SPDY_ALT_SVC_WIRE_FORMAT_H_
 #define QUICHE_SPDY_CORE_SPDY_ALT_SVC_WIRE_FORMAT_H_
 
-#include <cstdint>
-#include <string>
-#include <vector>
-
-#include "absl/container/inlined_vector.h"
-#include "absl/strings/string_view.h"
-#include "quiche/common/platform/api/quiche_export.h"
-
-namespace spdy {
-
-namespace test {
-class SpdyAltSvcWireFormatPeer;
-}  // namespace test
-
-class QUICHE_EXPORT SpdyAltSvcWireFormat {
- public:
-  using VersionVector = absl::InlinedVector<uint32_t, 8>;
-
-  struct QUICHE_EXPORT AlternativeService {
-    std::string protocol_id;
-    std::string host;
-
-    // Default is 0: invalid port.
-    uint16_t port = 0;
-    // Default is one day.
-    uint32_t max_age_seconds = 86400;
-    // Default is empty: unspecified version.
-    VersionVector version;
-
-    AlternativeService();
-    AlternativeService(const std::string& protocol_id, const std::string& host,
-                       uint16_t port, uint32_t max_age_seconds,
-                       VersionVector version);
-    AlternativeService(const AlternativeService& other);
-    ~AlternativeService();
-
-    bool operator==(const AlternativeService& other) const {
-      return protocol_id == other.protocol_id && host == other.host &&
-             port == other.port && version == other.version &&
-             max_age_seconds == other.max_age_seconds;
-    }
-  };
-  // An empty vector means alternative services should be cleared for given
-  // origin.  Note that the wire format for this is the string "clear", not an
-  // empty value (which is invalid).
-  typedef std::vector<AlternativeService> AlternativeServiceVector;
-
-  friend class test::SpdyAltSvcWireFormatPeer;
-  static bool ParseHeaderFieldValue(absl::string_view value,
-                                    AlternativeServiceVector* altsvc_vector);
-  static std::string SerializeHeaderFieldValue(
-      const AlternativeServiceVector& altsvc_vector);
-
- private:
-  // Forward |*c| over space and tab or until |end| is reached.
-  static void SkipWhiteSpace(absl::string_view::const_iterator* c,
-                             absl::string_view::const_iterator end);
-  // Decode percent-decoded string between |c| and |end| into |*output|.
-  // Return true on success, false if input is invalid.
-  static bool PercentDecode(absl::string_view::const_iterator c,
-                            absl::string_view::const_iterator end,
-                            std::string* output);
-  // Parse the authority part of Alt-Svc between |c| and |end| into |*host| and
-  // |*port|.  Return true on success, false if input is invalid.
-  static bool ParseAltAuthority(absl::string_view::const_iterator c,
-                                absl::string_view::const_iterator end,
-                                std::string* host, uint16_t* port);
-  // Parse a positive integer between |c| and |end| into |*value|.
-  // Return true on success, false if input is not a positive integer or it
-  // cannot be represented on uint16_t.
-  static bool ParsePositiveInteger16(absl::string_view::const_iterator c,
-                                     absl::string_view::const_iterator end,
-                                     uint16_t* value);
-  // Parse a positive integer between |c| and |end| into |*value|.
-  // Return true on success, false if input is not a positive integer or it
-  // cannot be represented on uint32_t.
-  static bool ParsePositiveInteger32(absl::string_view::const_iterator c,
-                                     absl::string_view::const_iterator end,
-                                     uint32_t* value);
-  // Parse |c| as hexadecimal digit, case insensitive.  |c| must be [0-9a-fA-F].
-  // Output is between 0 and 15.
-  static char HexDigitToInt(char c);
-  // Parse |data| as hexadecimal number into |*value|.  |data| must only contain
-  // hexadecimal digits, no "0x" prefix.
-  // Return true on success, false if input is empty, not valid hexadecimal
-  // number, or cannot be represented on uint32_t.
-  static bool HexDecodeToUInt32(absl::string_view data, uint32_t* value);
-};
-
-}  // namespace spdy
+#include "quiche/http2/core/spdy_alt_svc_wire_format.h"
 
 #endif  // QUICHE_SPDY_CORE_SPDY_ALT_SVC_WIRE_FORMAT_H_
diff --git a/quiche/spdy/core/spdy_bitmasks.h b/quiche/spdy/core/spdy_bitmasks.h
index 989e013..ae12b55 100644
--- a/quiche/spdy/core/spdy_bitmasks.h
+++ b/quiche/spdy/core/spdy_bitmasks.h
@@ -5,14 +5,6 @@
 #ifndef QUICHE_SPDY_CORE_SPDY_BITMASKS_H_
 #define QUICHE_SPDY_CORE_SPDY_BITMASKS_H_
 
-namespace spdy {
-
-// StreamId mask from the SpdyHeader
-inline constexpr unsigned int kStreamIdMask = 0x7fffffff;
-
-// Mask the lower 24 bits.
-inline constexpr unsigned int kLengthMask = 0xffffff;
-
-}  // namespace spdy
+#include "quiche/http2/core/spdy_bitmasks.h"
 
 #endif  // QUICHE_SPDY_CORE_SPDY_BITMASKS_H_
diff --git a/quiche/spdy/core/spdy_frame_builder.h b/quiche/spdy/core/spdy_frame_builder.h
index 829c878..f8f749b 100644
--- a/quiche/spdy/core/spdy_frame_builder.h
+++ b/quiche/spdy/core/spdy_frame_builder.h
@@ -5,136 +5,6 @@
 #ifndef QUICHE_SPDY_CORE_SPDY_FRAME_BUILDER_H_
 #define QUICHE_SPDY_CORE_SPDY_FRAME_BUILDER_H_
 
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-
-#include "absl/strings/string_view.h"
-#include "quiche/http2/core/zero_copy_output_buffer.h"
-#include "quiche/common/platform/api/quiche_bug_tracker.h"
-#include "quiche/common/platform/api/quiche_export.h"
-#include "quiche/common/quiche_endian.h"
-#include "quiche/spdy/core/spdy_protocol.h"
-
-namespace spdy {
-
-namespace test {
-class SpdyFrameBuilderPeer;
-}  // namespace test
-
-// This class provides facilities for basic binary value packing
-// into Spdy frames.
-//
-// The SpdyFrameBuilder supports appending primitive values (int, string, etc)
-// to a frame instance.  The SpdyFrameBuilder grows its internal memory buffer
-// dynamically to hold the sequence of primitive values.   The internal memory
-// buffer is exposed as the "data" of the SpdyFrameBuilder.
-class QUICHE_EXPORT SpdyFrameBuilder {
- public:
-  // Initializes a SpdyFrameBuilder with a buffer of given size
-  explicit SpdyFrameBuilder(size_t size);
-  // Doesn't take ownership of output.
-  SpdyFrameBuilder(size_t size, ZeroCopyOutputBuffer* output);
-
-  ~SpdyFrameBuilder();
-
-  // Returns the total size of the SpdyFrameBuilder's data, which may include
-  // multiple frames.
-  size_t length() const { return offset_ + length_; }
-
-  // Seeks forward by the given number of bytes. Useful in conjunction with
-  // GetWriteableBuffer() above.
-  bool Seek(size_t length);
-
-  // Populates this frame with a HTTP2 frame prefix using length information
-  // from |capacity_|. The given type must be a control frame type.
-  bool BeginNewFrame(SpdyFrameType type, uint8_t flags, SpdyStreamId stream_id);
-
-  // Populates this frame with a HTTP2 frame prefix with type and length
-  // information.  |type| must be a defined frame type.
-  bool BeginNewFrame(SpdyFrameType type, uint8_t flags, SpdyStreamId stream_id,
-                     size_t length);
-
-  // Populates this frame with a HTTP2 frame prefix with type and length
-  // information.  |raw_frame_type| may be a defined or undefined frame type.
-  bool BeginNewUncheckedFrame(uint8_t raw_frame_type, uint8_t flags,
-                              SpdyStreamId stream_id, size_t length);
-
-  // Takes the buffer from the SpdyFrameBuilder.
-  SpdySerializedFrame take() {
-    QUICHE_BUG_IF(spdy_bug_39_1, output_ != nullptr)
-        << "ZeroCopyOutputBuffer is used to build "
-        << "frames. take() shouldn't be called";
-    QUICHE_BUG_IF(spdy_bug_39_2, kMaxFrameSizeLimit < length_)
-        << "Frame length " << length_
-        << " is longer than the maximum possible allowed length.";
-    SpdySerializedFrame rv(std::move(buffer_), length());
-    capacity_ = 0;
-    length_ = 0;
-    offset_ = 0;
-    return rv;
-  }
-
-  // Methods for adding to the payload.  These values are appended to the end
-  // of the SpdyFrameBuilder payload. Note - binary integers are converted from
-  // host to network form.
-  bool WriteUInt8(uint8_t value) { return WriteBytes(&value, sizeof(value)); }
-  bool WriteUInt16(uint16_t value) {
-    value = quiche::QuicheEndian::HostToNet16(value);
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteUInt24(uint32_t value) {
-    value = quiche::QuicheEndian::HostToNet32(value);
-    return WriteBytes(reinterpret_cast<char*>(&value) + 1, sizeof(value) - 1);
-  }
-  bool WriteUInt32(uint32_t value) {
-    value = quiche::QuicheEndian::HostToNet32(value);
-    return WriteBytes(&value, sizeof(value));
-  }
-  bool WriteUInt64(uint64_t value) {
-    uint32_t upper =
-        quiche::QuicheEndian::HostToNet32(static_cast<uint32_t>(value >> 32));
-    uint32_t lower =
-        quiche::QuicheEndian::HostToNet32(static_cast<uint32_t>(value));
-    return (WriteBytes(&upper, sizeof(upper)) &&
-            WriteBytes(&lower, sizeof(lower)));
-  }
-  bool WriteStringPiece32(const absl::string_view value);
-  bool WriteBytes(const void* data, uint32_t data_len);
-
- private:
-  friend class test::SpdyFrameBuilderPeer;
-
-  // Populates this frame with a HTTP2 frame prefix with type and length
-  // information.
-  bool BeginNewFrameInternal(uint8_t raw_frame_type, uint8_t flags,
-                             SpdyStreamId stream_id, size_t length);
-
-  // Returns a writeable buffer of given size in bytes, to be appended to the
-  // currently written frame. Does bounds checking on length but does not
-  // increment the underlying iterator. To do so, consumers should subsequently
-  // call Seek().
-  // In general, consumers should use Write*() calls instead of this.
-  // Returns NULL on failure.
-  char* GetWritableBuffer(size_t length);
-  char* GetWritableOutput(size_t desired_length, size_t* actual_length);
-
-  // Checks to make sure that there is an appropriate amount of space for a
-  // write of given size, in bytes.
-  bool CanWrite(size_t length) const;
-
-  // A buffer to be created whenever a new frame needs to be written. Used only
-  // if |output_| is nullptr.
-  std::unique_ptr<char[]> buffer_;
-  // A pre-allocated buffer. If not-null, serialized frame data is written to
-  // this buffer.
-  ZeroCopyOutputBuffer* output_ = nullptr;  // Does not own.
-
-  size_t capacity_;  // Allocation size of payload, set by constructor.
-  size_t length_;    // Length of the latest frame in the buffer.
-  size_t offset_;    // Position at which the latest frame begins.
-};
-
-}  // namespace spdy
+#include "quiche/http2/core/spdy_frame_builder.h"
 
 #endif  // QUICHE_SPDY_CORE_SPDY_FRAME_BUILDER_H_
diff --git a/quiche/spdy/core/spdy_framer.h b/quiche/spdy/core/spdy_framer.h
index e660ed5..15fb6e6 100644
--- a/quiche/spdy/core/spdy_framer.h
+++ b/quiche/spdy/core/spdy_framer.h
@@ -5,367 +5,6 @@
 #ifndef QUICHE_SPDY_CORE_SPDY_FRAMER_H_
 #define QUICHE_SPDY_CORE_SPDY_FRAMER_H_
 
-#include <stddef.h>
-
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "quiche/http2/core/zero_copy_output_buffer.h"
-#include "quiche/http2/hpack/hpack_encoder.h"
-#include "quiche/common/platform/api/quiche_export.h"
-#include "quiche/spdy/core/spdy_protocol.h"
-
-namespace spdy {
-
-namespace test {
-
-class SpdyFramerPeer;
-class SpdyFramerTest_MultipleContinuationFramesWithIterator_Test;
-class SpdyFramerTest_PushPromiseFramesWithIterator_Test;
-
-}  // namespace test
-
-class QUICHE_EXPORT SpdyFrameSequence {
- public:
-  virtual ~SpdyFrameSequence() {}
-
-  // Serializes the next frame in the sequence to |output|. Returns the number
-  // of bytes written to |output|.
-  virtual size_t NextFrame(ZeroCopyOutputBuffer* output) = 0;
-
-  // Returns true iff there is at least one more frame in the sequence.
-  virtual bool HasNextFrame() const = 0;
-
-  // Get SpdyFrameIR of the frame to be serialized.
-  virtual const SpdyFrameIR& GetIR() const = 0;
-};
-
-class QUICHE_EXPORT SpdyFramer {
- public:
-  enum CompressionOption {
-    ENABLE_COMPRESSION,
-    DISABLE_COMPRESSION,
-  };
-
-  // Create a SpdyFrameSequence to serialize |frame_ir|.
-  static std::unique_ptr<SpdyFrameSequence> CreateIterator(
-      SpdyFramer* framer, std::unique_ptr<const SpdyFrameIR> frame_ir);
-
-  // Gets the serialized flags for the given |frame|.
-  static uint8_t GetSerializedFlags(const SpdyFrameIR& frame);
-
-  // Serialize a data frame.
-  static SpdySerializedFrame SerializeData(const SpdyDataIR& data_ir);
-  // Serializes the data frame header and optionally padding length fields,
-  // excluding actual data payload and padding.
-  static SpdySerializedFrame SerializeDataFrameHeaderWithPaddingLengthField(
-      const SpdyDataIR& data_ir);
-
-  // Serializes a WINDOW_UPDATE frame. The WINDOW_UPDATE
-  // frame is used to implement per stream flow control.
-  static SpdySerializedFrame SerializeWindowUpdate(
-      const SpdyWindowUpdateIR& window_update);
-
-  explicit SpdyFramer(CompressionOption option);
-
-  virtual ~SpdyFramer();
-
-  // Set debug callbacks to be called from the framer. The debug visitor is
-  // completely optional and need not be set in order for normal operation.
-  // If this is called multiple times, only the last visitor will be used.
-  void set_debug_visitor(SpdyFramerDebugVisitorInterface* debug_visitor);
-
-  SpdySerializedFrame SerializeRstStream(
-      const SpdyRstStreamIR& rst_stream) const;
-
-  // Serializes a SETTINGS frame. The SETTINGS frame is
-  // used to communicate name/value pairs relevant to the communication channel.
-  SpdySerializedFrame SerializeSettings(const SpdySettingsIR& settings) const;
-
-  // Serializes a PING frame. The unique_id is used to
-  // identify the ping request/response.
-  SpdySerializedFrame SerializePing(const SpdyPingIR& ping) const;
-
-  // Serializes a GOAWAY frame. The GOAWAY frame is used
-  // prior to the shutting down of the TCP connection, and includes the
-  // stream_id of the last stream the sender of the frame is willing to process
-  // to completion.
-  SpdySerializedFrame SerializeGoAway(const SpdyGoAwayIR& goaway) const;
-
-  // Serializes a HEADERS frame. The HEADERS frame is used
-  // for sending headers.
-  SpdySerializedFrame SerializeHeaders(const SpdyHeadersIR& headers);
-
-  // Serializes a PUSH_PROMISE frame. The PUSH_PROMISE frame is used
-  // to inform the client that it will be receiving an additional stream
-  // in response to the original request. The frame includes synthesized
-  // headers to explain the upcoming data.
-  SpdySerializedFrame SerializePushPromise(
-      const SpdyPushPromiseIR& push_promise);
-
-  // Serializes a CONTINUATION frame. The CONTINUATION frame is used
-  // to continue a sequence of header block fragments.
-  SpdySerializedFrame SerializeContinuation(
-      const SpdyContinuationIR& continuation) const;
-
-  // Serializes an ALTSVC frame. The ALTSVC frame advertises the
-  // availability of an alternative service to the client.
-  SpdySerializedFrame SerializeAltSvc(const SpdyAltSvcIR& altsvc);
-
-  // Serializes a PRIORITY frame. The PRIORITY frame advises a change in
-  // the relative priority of the given stream.
-  SpdySerializedFrame SerializePriority(const SpdyPriorityIR& priority) const;
-
-  // Serializes a PRIORITY_UPDATE frame.
-  // See https://httpwg.org/http-extensions/draft-ietf-httpbis-priority.html.
-  SpdySerializedFrame SerializePriorityUpdate(
-      const SpdyPriorityUpdateIR& priority_update) const;
-
-  // Serializes an ACCEPT_CH frame.  See
-  // https://tools.ietf.org/html/draft-davidben-http-client-hint-reliability-02.
-  SpdySerializedFrame SerializeAcceptCh(const SpdyAcceptChIR& accept_ch) const;
-
-  // Serializes an unknown frame given a frame header and payload.
-  SpdySerializedFrame SerializeUnknown(const SpdyUnknownIR& unknown) const;
-
-  // Serialize a frame of unknown type.
-  SpdySerializedFrame SerializeFrame(const SpdyFrameIR& frame);
-
-  // Serialize a data frame.
-  bool SerializeData(const SpdyDataIR& data,
-                     ZeroCopyOutputBuffer* output) const;
-
-  // Serializes the data frame header and optionally padding length fields,
-  // excluding actual data payload and padding.
-  bool SerializeDataFrameHeaderWithPaddingLengthField(
-      const SpdyDataIR& data, ZeroCopyOutputBuffer* output) const;
-
-  bool SerializeRstStream(const SpdyRstStreamIR& rst_stream,
-                          ZeroCopyOutputBuffer* output) const;
-
-  // Serializes a SETTINGS frame. The SETTINGS frame is
-  // used to communicate name/value pairs relevant to the communication channel.
-  bool SerializeSettings(const SpdySettingsIR& settings,
-                         ZeroCopyOutputBuffer* output) const;
-
-  // Serializes a PING frame. The unique_id is used to
-  // identify the ping request/response.
-  bool SerializePing(const SpdyPingIR& ping,
-                     ZeroCopyOutputBuffer* output) const;
-
-  // Serializes a GOAWAY frame. The GOAWAY frame is used
-  // prior to the shutting down of the TCP connection, and includes the
-  // stream_id of the last stream the sender of the frame is willing to process
-  // to completion.
-  bool SerializeGoAway(const SpdyGoAwayIR& goaway,
-                       ZeroCopyOutputBuffer* output) const;
-
-  // Serializes a HEADERS frame. The HEADERS frame is used
-  // for sending headers.
-  bool SerializeHeaders(const SpdyHeadersIR& headers,
-                        ZeroCopyOutputBuffer* output);
-
-  // Serializes a WINDOW_UPDATE frame. The WINDOW_UPDATE
-  // frame is used to implement per stream flow control.
-  bool SerializeWindowUpdate(const SpdyWindowUpdateIR& window_update,
-                             ZeroCopyOutputBuffer* output) const;
-
-  // Serializes a PUSH_PROMISE frame. The PUSH_PROMISE frame is used
-  // to inform the client that it will be receiving an additional stream
-  // in response to the original request. The frame includes synthesized
-  // headers to explain the upcoming data.
-  bool SerializePushPromise(const SpdyPushPromiseIR& push_promise,
-                            ZeroCopyOutputBuffer* output);
-
-  // Serializes a CONTINUATION frame. The CONTINUATION frame is used
-  // to continue a sequence of header block fragments.
-  bool SerializeContinuation(const SpdyContinuationIR& continuation,
-                             ZeroCopyOutputBuffer* output) const;
-
-  // Serializes an ALTSVC frame. The ALTSVC frame advertises the
-  // availability of an alternative service to the client.
-  bool SerializeAltSvc(const SpdyAltSvcIR& altsvc,
-                       ZeroCopyOutputBuffer* output);
-
-  // Serializes a PRIORITY frame. The PRIORITY frame advises a change in
-  // the relative priority of the given stream.
-  bool SerializePriority(const SpdyPriorityIR& priority,
-                         ZeroCopyOutputBuffer* output) const;
-
-  // Serializes a PRIORITY_UPDATE frame.
-  // See https://httpwg.org/http-extensions/draft-ietf-httpbis-priority.html.
-  bool SerializePriorityUpdate(const SpdyPriorityUpdateIR& priority_update,
-                               ZeroCopyOutputBuffer* output) const;
-
-  // Serializes an ACCEPT_CH frame.  See
-  // https://tools.ietf.org/html/draft-davidben-http-client-hint-reliability-02.
-  bool SerializeAcceptCh(const SpdyAcceptChIR& accept_ch,
-                         ZeroCopyOutputBuffer* output) const;
-
-  // Serializes an unknown frame given a frame header and payload.
-  bool SerializeUnknown(const SpdyUnknownIR& unknown,
-                        ZeroCopyOutputBuffer* output) const;
-
-  // Serialize a frame of unknown type.
-  size_t SerializeFrame(const SpdyFrameIR& frame, ZeroCopyOutputBuffer* output);
-
-  // Returns whether this SpdyFramer will compress header blocks using HPACK.
-  bool compression_enabled() const {
-    return compression_option_ == ENABLE_COMPRESSION;
-  }
-
-  void SetHpackIndexingPolicy(HpackEncoder::IndexingPolicy policy) {
-    GetHpackEncoder()->SetIndexingPolicy(std::move(policy));
-  }
-
-  // Updates the maximum size of the header encoder compression table.
-  void UpdateHeaderEncoderTableSize(uint32_t value);
-
-  // Returns the maximum size of the header encoder compression table.
-  size_t header_encoder_table_size() const;
-
-  // Get (and lazily initialize) the HPACK encoder state.
-  HpackEncoder* GetHpackEncoder();
-
-  // Gets the HPACK encoder state. Returns nullptr if the encoder has not been
-  // initialized.
-  const HpackEncoder* GetHpackEncoder() const { return hpack_encoder_.get(); }
-
- protected:
-  friend class test::SpdyFramerPeer;
-  friend class test::SpdyFramerTest_MultipleContinuationFramesWithIterator_Test;
-  friend class test::SpdyFramerTest_PushPromiseFramesWithIterator_Test;
-
-  // Iteratively converts a SpdyFrameIR into an appropriate sequence of Spdy
-  // frames.
-  // Example usage:
-  // std::unique_ptr<SpdyFrameSequence> it = CreateIterator(framer, frame_ir);
-  // while (it->HasNextFrame()) {
-  //   if(it->NextFrame(output) == 0) {
-  //     // Write failed;
-  //   }
-  // }
-  class QUICHE_EXPORT SpdyFrameIterator : public SpdyFrameSequence {
-   public:
-    // Creates an iterator with the provided framer.
-    // Does not take ownership of |framer|.
-    // |framer| must outlive this instance.
-    explicit SpdyFrameIterator(SpdyFramer* framer);
-    ~SpdyFrameIterator() override;
-
-    // Serializes the next frame in the sequence to |output|. Returns the number
-    // of bytes written to |output|.
-    size_t NextFrame(ZeroCopyOutputBuffer* output) override;
-
-    // Returns true iff there is at least one more frame in the sequence.
-    bool HasNextFrame() const override;
-
-    // SpdyFrameIterator is neither copyable nor movable.
-    SpdyFrameIterator(const SpdyFrameIterator&) = delete;
-    SpdyFrameIterator& operator=(const SpdyFrameIterator&) = delete;
-
-   protected:
-    virtual size_t GetFrameSizeSansBlock() const = 0;
-    virtual bool SerializeGivenEncoding(const std::string& encoding,
-                                        ZeroCopyOutputBuffer* output) const = 0;
-
-    SpdyFramer* GetFramer() const { return framer_; }
-
-    void SetEncoder(const SpdyFrameWithHeaderBlockIR* ir) {
-      encoder_ =
-          framer_->GetHpackEncoder()->EncodeHeaderSet(ir->header_block());
-    }
-
-    bool has_next_frame() const { return has_next_frame_; }
-
-   private:
-    SpdyFramer* const framer_;
-    std::unique_ptr<HpackEncoder::ProgressiveEncoder> encoder_;
-    bool is_first_frame_;
-    bool has_next_frame_;
-  };
-
-  // Iteratively converts a SpdyHeadersIR (with a possibly huge
-  // Http2HeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
-  // write to the output.
-  class QUICHE_EXPORT SpdyHeaderFrameIterator : public SpdyFrameIterator {
-   public:
-    // Does not take ownership of |framer|. Take ownership of |headers_ir|.
-    SpdyHeaderFrameIterator(SpdyFramer* framer,
-                            std::unique_ptr<const SpdyHeadersIR> headers_ir);
-
-    ~SpdyHeaderFrameIterator() override;
-
-   private:
-    const SpdyFrameIR& GetIR() const override;
-    size_t GetFrameSizeSansBlock() const override;
-    bool SerializeGivenEncoding(const std::string& encoding,
-                                ZeroCopyOutputBuffer* output) const override;
-
-    const std::unique_ptr<const SpdyHeadersIR> headers_ir_;
-  };
-
-  // Iteratively converts a SpdyPushPromiseIR (with a possibly huge
-  // Http2HeaderBlock) into an appropriate sequence of SpdySerializedFrames, and
-  // write to the output.
-  class QUICHE_EXPORT SpdyPushPromiseFrameIterator : public SpdyFrameIterator {
-   public:
-    // Does not take ownership of |framer|. Take ownership of |push_promise_ir|.
-    SpdyPushPromiseFrameIterator(
-        SpdyFramer* framer,
-        std::unique_ptr<const SpdyPushPromiseIR> push_promise_ir);
-
-    ~SpdyPushPromiseFrameIterator() override;
-
-   private:
-    const SpdyFrameIR& GetIR() const override;
-    size_t GetFrameSizeSansBlock() const override;
-    bool SerializeGivenEncoding(const std::string& encoding,
-                                ZeroCopyOutputBuffer* output) const override;
-
-    const std::unique_ptr<const SpdyPushPromiseIR> push_promise_ir_;
-  };
-
-  // Converts a SpdyFrameIR into one Spdy frame (a sequence of length 1), and
-  // write it to the output.
-  class QUICHE_EXPORT SpdyControlFrameIterator : public SpdyFrameSequence {
-   public:
-    SpdyControlFrameIterator(SpdyFramer* framer,
-                             std::unique_ptr<const SpdyFrameIR> frame_ir);
-    ~SpdyControlFrameIterator() override;
-
-    size_t NextFrame(ZeroCopyOutputBuffer* output) override;
-
-    bool HasNextFrame() const override;
-
-    const SpdyFrameIR& GetIR() const override;
-
-   private:
-    SpdyFramer* const framer_;
-    std::unique_ptr<const SpdyFrameIR> frame_ir_;
-    bool has_next_frame_ = true;
-  };
-
- private:
-  void SerializeHeadersBuilderHelper(const SpdyHeadersIR& headers,
-                                     uint8_t* flags, size_t* size,
-                                     std::string* hpack_encoding, int* weight,
-                                     size_t* length_field);
-  void SerializePushPromiseBuilderHelper(const SpdyPushPromiseIR& push_promise,
-                                         uint8_t* flags,
-                                         std::string* hpack_encoding,
-                                         size_t* size);
-
-  std::unique_ptr<HpackEncoder> hpack_encoder_;
-
-  SpdyFramerDebugVisitorInterface* debug_visitor_;
-
-  // Determines whether HPACK compression is used.
-  const CompressionOption compression_option_;
-};
-
-}  // namespace spdy
+#include "quiche/http2/core/spdy_framer.h"
 
 #endif  // QUICHE_SPDY_CORE_SPDY_FRAMER_H_
diff --git a/quiche/spdy/core/spdy_protocol.h b/quiche/spdy/core/spdy_protocol.h
index ec57be2..fbc7499 100644
--- a/quiche/spdy/core/spdy_protocol.h
+++ b/quiche/spdy/core/spdy_protocol.h
@@ -2,1100 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// This file contains some protocol structures for use with SPDY 3 and HTTP 2
-// The SPDY 3 spec can be found at:
-// http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3
-
 #ifndef QUICHE_SPDY_CORE_SPDY_PROTOCOL_H_
 #define QUICHE_SPDY_CORE_SPDY_PROTOCOL_H_
 
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iosfwd>
-#include <map>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
-#include "quiche/common/platform/api/quiche_export.h"
-#include "quiche/common/platform/api/quiche_flags.h"
-#include "quiche/common/platform/api/quiche_logging.h"
-#include "quiche/spdy/core/http2_header_block.h"
-#include "quiche/spdy/core/spdy_alt_svc_wire_format.h"
-#include "quiche/spdy/core/spdy_bitmasks.h"
-
-namespace spdy {
-
-// A stream ID is a 31-bit entity.
-using SpdyStreamId = uint32_t;
-
-// A SETTINGS ID is a 16-bit entity.
-using SpdySettingsId = uint16_t;
-
-// Specifies the stream ID used to denote the current session (for
-// flow control).
-inline constexpr SpdyStreamId kSessionFlowControlStreamId = 0;
-
-// 0 is not a valid stream ID for any other purpose than flow control.
-inline constexpr SpdyStreamId kInvalidStreamId = 0;
-
-// Max stream id.
-inline constexpr SpdyStreamId kMaxStreamId = 0x7fffffff;
-
-// The maximum possible frame payload size allowed by the spec.
-inline constexpr uint32_t kSpdyMaxFrameSizeLimit = (1 << 24) - 1;
-
-// The initial value for the maximum frame payload size as per the spec. This is
-// the maximum control frame size we accept.
-inline constexpr uint32_t kHttp2DefaultFramePayloadLimit = 1 << 14;
-
-// The maximum size of the control frames that we send, including the size of
-// the header. This limit is arbitrary. We can enforce it here or at the
-// application layer. We chose the framing layer, but this can be changed (or
-// removed) if necessary later down the line.
-inline constexpr size_t kHttp2MaxControlFrameSendSize =
-    kHttp2DefaultFramePayloadLimit - 1;
-
-// Number of octets in the frame header.
-inline constexpr size_t kFrameHeaderSize = 9;
-
-// The initial value for the maximum frame payload size as per the spec. This is
-// the maximum control frame size we accept.
-inline constexpr uint32_t kHttp2DefaultFrameSizeLimit =
-    kHttp2DefaultFramePayloadLimit + kFrameHeaderSize;
-
-// The initial value for the maximum size of the header list, "unlimited" (max
-// unsigned 32-bit int) as per the spec.
-inline constexpr uint32_t kSpdyInitialHeaderListSizeLimit = 0xFFFFFFFF;
-
-// Maximum window size for a Spdy stream or session.
-inline constexpr int32_t kSpdyMaximumWindowSize =
-    0x7FFFFFFF;  // Max signed 32bit int
-
-// Maximum padding size in octets for one DATA or HEADERS or PUSH_PROMISE frame.
-inline constexpr int32_t kPaddingSizePerFrame = 256;
-
-// The HTTP/2 connection preface, which must be the first bytes sent by the
-// client upon starting an HTTP/2 connection, and which must be followed by a
-// SETTINGS frame.  Note that even though |kHttp2ConnectionHeaderPrefix| is
-// defined as a string literal with a null terminator, the actual connection
-// preface is only the first |kHttp2ConnectionHeaderPrefixSize| bytes, which
-// excludes the null terminator.
-QUICHE_EXPORT extern const char* const kHttp2ConnectionHeaderPrefix;
-inline constexpr int kHttp2ConnectionHeaderPrefixSize = 24;
-
-// Wire values for HTTP2 frame types.
-enum class SpdyFrameType : uint8_t {
-  DATA = 0x00,
-  HEADERS = 0x01,
-  PRIORITY = 0x02,
-  RST_STREAM = 0x03,
-  SETTINGS = 0x04,
-  PUSH_PROMISE = 0x05,
-  PING = 0x06,
-  GOAWAY = 0x07,
-  WINDOW_UPDATE = 0x08,
-  CONTINUATION = 0x09,
-  // ALTSVC is a public extension.
-  ALTSVC = 0x0a,
-  PRIORITY_UPDATE = 0x10,
-  ACCEPT_CH = 0x89,
-};
-
-// Flags on data packets.
-enum SpdyDataFlags {
-  DATA_FLAG_NONE = 0x00,
-  DATA_FLAG_FIN = 0x01,
-  DATA_FLAG_PADDED = 0x08,
-};
-
-// Flags on control packets
-enum SpdyControlFlags {
-  CONTROL_FLAG_NONE = 0x00,
-  CONTROL_FLAG_FIN = 0x01,
-};
-
-enum SpdyPingFlags {
-  PING_FLAG_ACK = 0x01,
-};
-
-// Used by HEADERS, PUSH_PROMISE, and CONTINUATION.
-enum SpdyHeadersFlags {
-  HEADERS_FLAG_END_HEADERS = 0x04,
-  HEADERS_FLAG_PADDED = 0x08,
-  HEADERS_FLAG_PRIORITY = 0x20,
-};
-
-enum SpdyPushPromiseFlags {
-  PUSH_PROMISE_FLAG_END_PUSH_PROMISE = 0x04,
-  PUSH_PROMISE_FLAG_PADDED = 0x08,
-};
-
-enum Http2SettingsControlFlags {
-  SETTINGS_FLAG_ACK = 0x01,
-};
-
-// Wire values of HTTP/2 setting identifiers.
-enum SpdyKnownSettingsId : SpdySettingsId {
-  // HPACK header table maximum size.
-  SETTINGS_HEADER_TABLE_SIZE = 0x1,
-  SETTINGS_MIN = SETTINGS_HEADER_TABLE_SIZE,
-  // Whether or not server push (PUSH_PROMISE) is enabled.
-  SETTINGS_ENABLE_PUSH = 0x2,
-  // The maximum number of simultaneous live streams in each direction.
-  SETTINGS_MAX_CONCURRENT_STREAMS = 0x3,
-  // Initial window size in bytes
-  SETTINGS_INITIAL_WINDOW_SIZE = 0x4,
-  // The size of the largest frame payload that a receiver is willing to accept.
-  SETTINGS_MAX_FRAME_SIZE = 0x5,
-  // The maximum size of header list that the sender is prepared to accept.
-  SETTINGS_MAX_HEADER_LIST_SIZE = 0x6,
-  // Enable Websockets over HTTP/2, see
-  // https://httpwg.org/specs/rfc8441.html
-  SETTINGS_ENABLE_CONNECT_PROTOCOL = 0x8,
-  // Disable HTTP/2 priorities, see
-  // https://tools.ietf.org/html/draft-ietf-httpbis-priority-02.
-  SETTINGS_DEPRECATE_HTTP2_PRIORITIES = 0x9,
-  SETTINGS_MAX = SETTINGS_DEPRECATE_HTTP2_PRIORITIES,
-  // Experimental setting used to configure an alternative write scheduler.
-  SETTINGS_EXPERIMENT_SCHEDULER = 0xFF45,
-};
-
-// This explicit operator is needed, otherwise compiler finds
-// overloaded operator to be ambiguous.
-QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
-                                       SpdyKnownSettingsId id);
-
-// This operator is needed, because SpdyFrameType is an enum class,
-// therefore implicit conversion to underlying integer type is not allowed.
-QUICHE_EXPORT std::ostream& operator<<(std::ostream& out,
-                                       SpdyFrameType frame_type);
-
-using SettingsMap = std::map<SpdySettingsId, uint32_t>;
-
-// HTTP/2 error codes, RFC 7540 Section 7.
-enum SpdyErrorCode : uint32_t {
-  ERROR_CODE_NO_ERROR = 0x0,
-  ERROR_CODE_PROTOCOL_ERROR = 0x1,
-  ERROR_CODE_INTERNAL_ERROR = 0x2,
-  ERROR_CODE_FLOW_CONTROL_ERROR = 0x3,
-  ERROR_CODE_SETTINGS_TIMEOUT = 0x4,
-  ERROR_CODE_STREAM_CLOSED = 0x5,
-  ERROR_CODE_FRAME_SIZE_ERROR = 0x6,
-  ERROR_CODE_REFUSED_STREAM = 0x7,
-  ERROR_CODE_CANCEL = 0x8,
-  ERROR_CODE_COMPRESSION_ERROR = 0x9,
-  ERROR_CODE_CONNECT_ERROR = 0xa,
-  ERROR_CODE_ENHANCE_YOUR_CALM = 0xb,
-  ERROR_CODE_INADEQUATE_SECURITY = 0xc,
-  ERROR_CODE_HTTP_1_1_REQUIRED = 0xd,
-  ERROR_CODE_MAX = ERROR_CODE_HTTP_1_1_REQUIRED
-};
-
-// Type of priority write scheduler.
-enum class WriteSchedulerType {
-  LIFO,  // Last added stream has the highest priority.
-  SPDY,  // Uses SPDY priorities described in
-         // https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority.
-  HTTP2,  // Uses HTTP2 (tree-style) priority described in
-          // https://tools.ietf.org/html/rfc7540#section-5.3.
-  FIFO,   // Stream with the smallest stream ID has the highest priority.
-};
-
-// A SPDY priority is a number between 0 and 7 (inclusive).
-typedef uint8_t SpdyPriority;
-
-// Lowest and Highest here refer to SPDY priorities as described in
-// https://www.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3-1#TOC-2.3.3-Stream-priority
-inline constexpr SpdyPriority kV3HighestPriority = 0;
-inline constexpr SpdyPriority kV3LowestPriority = 7;
-
-// Returns SPDY 3.x priority value clamped to the valid range of [0, 7].
-QUICHE_EXPORT SpdyPriority ClampSpdy3Priority(SpdyPriority priority);
-
-// HTTP/2 stream weights are integers in range [1, 256], as specified in RFC
-// 7540 section 5.3.2. Default stream weight is defined in section 5.3.5.
-inline constexpr int kHttp2MinStreamWeight = 1;
-inline constexpr int kHttp2MaxStreamWeight = 256;
-inline constexpr int kHttp2DefaultStreamWeight = 16;
-
-// Returns HTTP/2 weight clamped to the valid range of [1, 256].
-QUICHE_EXPORT int ClampHttp2Weight(int weight);
-
-// Maps SPDY 3.x priority value in range [0, 7] to HTTP/2 weight value in range
-// [1, 256], where priority 0 (i.e. highest precedence) corresponds to maximum
-// weight 256 and priority 7 (lowest precedence) corresponds to minimum weight
-// 1.
-QUICHE_EXPORT int Spdy3PriorityToHttp2Weight(SpdyPriority priority);
-
-// Maps HTTP/2 weight value in range [1, 256] to SPDY 3.x priority value in
-// range [0, 7], where minimum weight 1 corresponds to priority 7 (lowest
-// precedence) and maximum weight 256 corresponds to priority 0 (highest
-// precedence).
-QUICHE_EXPORT SpdyPriority Http2WeightToSpdy3Priority(int weight);
-
-// Reserved ID for root stream of HTTP/2 stream dependency tree, as specified
-// in RFC 7540 section 5.3.1.
-const unsigned int kHttp2RootStreamId = 0;
-
-typedef uint64_t SpdyPingId;
-
-// Returns true if a given on-the-wire enumeration of a frame type is defined
-// in a standardized HTTP/2 specification, false otherwise.
-QUICHE_EXPORT bool IsDefinedFrameType(uint8_t frame_type_field);
-
-// Parses a frame type from an on-the-wire enumeration.
-// Behavior is undefined for invalid frame type fields; consumers should first
-// use IsValidFrameType() to verify validity of frame type fields.
-QUICHE_EXPORT SpdyFrameType ParseFrameType(uint8_t frame_type_field);
-
-// Serializes a frame type to the on-the-wire value.
-QUICHE_EXPORT uint8_t SerializeFrameType(SpdyFrameType frame_type);
-
-// (HTTP/2) All standard frame types except WINDOW_UPDATE are
-// (stream-specific xor connection-level). Returns false iff we know
-// the given frame type does not align with the given streamID.
-QUICHE_EXPORT bool IsValidHTTP2FrameStreamId(
-    SpdyStreamId current_frame_stream_id, SpdyFrameType frame_type_field);
-
-// Serialize |frame_type| to string for logging/debugging.
-QUICHE_EXPORT const char* FrameTypeToString(SpdyFrameType frame_type);
-
-// If |wire_setting_id| is the on-the-wire representation of a defined SETTINGS
-// parameter, parse it to |*setting_id| and return true.
-QUICHE_EXPORT bool ParseSettingsId(SpdySettingsId wire_setting_id,
-                                   SpdyKnownSettingsId* setting_id);
-
-// Returns a string representation of the |id| for logging/debugging. Returns
-// the |id| prefixed with "SETTINGS_UNKNOWN_" for unknown SETTINGS IDs. To parse
-// the |id| into a SpdyKnownSettingsId (if applicable), use ParseSettingsId().
-QUICHE_EXPORT std::string SettingsIdToString(SpdySettingsId id);
-
-// Parse |wire_error_code| to a SpdyErrorCode.
-// Treat unrecognized error codes as INTERNAL_ERROR
-// as recommended by the HTTP/2 specification.
-QUICHE_EXPORT SpdyErrorCode ParseErrorCode(uint32_t wire_error_code);
-
-// Serialize RST_STREAM or GOAWAY frame error code to string
-// for logging/debugging.
-QUICHE_EXPORT const char* ErrorCodeToString(SpdyErrorCode error_code);
-
-// Serialize |type| to string for logging/debugging.
-QUICHE_EXPORT const char* WriteSchedulerTypeToString(WriteSchedulerType type);
-
-// Minimum size of a frame, in octets.
-inline constexpr size_t kFrameMinimumSize = kFrameHeaderSize;
-
-// Minimum frame size for variable size frame types (includes mandatory fields),
-// frame size for fixed size frames, in octets.
-
-inline constexpr size_t kDataFrameMinimumSize = kFrameHeaderSize;
-inline constexpr size_t kHeadersFrameMinimumSize = kFrameHeaderSize;
-// PRIORITY frame has stream_dependency (4 octets) and weight (1 octet) fields.
-inline constexpr size_t kPriorityFrameSize = kFrameHeaderSize + 5;
-// RST_STREAM frame has error_code (4 octets) field.
-inline constexpr size_t kRstStreamFrameSize = kFrameHeaderSize + 4;
-inline constexpr size_t kSettingsFrameMinimumSize = kFrameHeaderSize;
-inline constexpr size_t kSettingsOneSettingSize =
-    sizeof(uint32_t) + sizeof(SpdySettingsId);
-// PUSH_PROMISE frame has promised_stream_id (4 octet) field.
-inline constexpr size_t kPushPromiseFrameMinimumSize = kFrameHeaderSize + 4;
-// PING frame has opaque_bytes (8 octet) field.
-inline constexpr size_t kPingFrameSize = kFrameHeaderSize + 8;
-// GOAWAY frame has last_stream_id (4 octet) and error_code (4 octet) fields.
-inline constexpr size_t kGoawayFrameMinimumSize = kFrameHeaderSize + 8;
-// WINDOW_UPDATE frame has window_size_increment (4 octet) field.
-inline constexpr size_t kWindowUpdateFrameSize = kFrameHeaderSize + 4;
-inline constexpr size_t kContinuationFrameMinimumSize = kFrameHeaderSize;
-// ALTSVC frame has origin_len (2 octets) field.
-inline constexpr size_t kGetAltSvcFrameMinimumSize = kFrameHeaderSize + 2;
-// PRIORITY_UPDATE frame has prioritized_stream_id (4 octets) field.
-inline constexpr size_t kPriorityUpdateFrameMinimumSize = kFrameHeaderSize + 4;
-// ACCEPT_CH frame may have empty payload.
-inline constexpr size_t kAcceptChFrameMinimumSize = kFrameHeaderSize;
-// Each ACCEPT_CH frame entry has a 16-bit origin length and a 16-bit value
-// length.
-inline constexpr size_t kAcceptChFramePerEntryOverhead = 4;
-
-// Maximum possible configurable size of a frame in octets.
-inline constexpr size_t kMaxFrameSizeLimit =
-    kSpdyMaxFrameSizeLimit + kFrameHeaderSize;
-// Size of a header block size field.
-inline constexpr size_t kSizeOfSizeField = sizeof(uint32_t);
-// Initial window size for a stream in bytes.
-inline constexpr int32_t kInitialStreamWindowSize = 64 * 1024 - 1;
-// Initial window size for a session in bytes.
-inline constexpr int32_t kInitialSessionWindowSize = 64 * 1024 - 1;
-// The NPN string for HTTP2, "h2".
-QUICHE_EXPORT extern const char* const kHttp2Npn;
-// An estimate of the HPACK overhead for each header field in bytes, intended to
-// be no smaller than actual overhead, based on the literal header field
-// representation in RFC 7541 Section 6.2 (with or without indexing):
-//   - 1 byte for the opcode.
-//   - 2 bytes for the name length (assuming new name).
-//   - 3 bytes for the value length.
-// TODO(b/322146543): Remove the `New` suffix with deprecation of
-// --gfe2_reloadable_flag_http2_add_hpack_overhead_bytes2.
-inline constexpr size_t kPerHeaderHpackOverheadNew = 6;
-// An estimate size of the HPACK overhead for each header field. 1 bytes for
-// indexed literal, 1 bytes for key literal and length encoding, and 2 bytes for
-// value literal and length encoding.
-// TODO(b/322146543): Remove with deprecation of
-// --gfe2_reloadable_flag_http2_add_hpack_overhead_bytes2.
-inline constexpr size_t kPerHeaderHpackOverheadOld = 4;
-
-// Names of pseudo-headers defined for HTTP/2 requests.
-QUICHE_EXPORT extern const char* const kHttp2AuthorityHeader;
-QUICHE_EXPORT extern const char* const kHttp2MethodHeader;
-QUICHE_EXPORT extern const char* const kHttp2PathHeader;
-QUICHE_EXPORT extern const char* const kHttp2SchemeHeader;
-QUICHE_EXPORT extern const char* const kHttp2ProtocolHeader;
-
-// Name of pseudo-header defined for HTTP/2 responses.
-QUICHE_EXPORT extern const char* const kHttp2StatusHeader;
-
-QUICHE_EXPORT size_t GetNumberRequiredContinuationFrames(size_t size);
-
-// Variant type that is either a SPDY 3.x priority value, or else an HTTP/2
-// stream dependency tuple {parent stream ID, weight, exclusive bit}. Templated
-// to allow for use by QUIC code; SPDY and HTTP/2 code should use the concrete
-// type instantiation SpdyStreamPrecedence.
-template <typename StreamIdType>
-class QUICHE_EXPORT StreamPrecedence {
- public:
-  // Constructs instance that is a SPDY 3.x priority. Clamps priority value to
-  // the valid range [0, 7].
-  explicit StreamPrecedence(SpdyPriority priority)
-      : precedence_(ClampSpdy3Priority(priority)) {}
-
-  // Constructs instance that is an HTTP/2 stream weight, parent stream ID, and
-  // exclusive bit. Clamps stream weight to the valid range [1, 256].
-  StreamPrecedence(StreamIdType parent_id, int weight, bool is_exclusive)
-      : precedence_(Http2StreamDependency{parent_id, ClampHttp2Weight(weight),
-                                          is_exclusive}) {}
-
-  // Intentionally copyable, to support pass by value.
-  StreamPrecedence(const StreamPrecedence& other) = default;
-  StreamPrecedence& operator=(const StreamPrecedence& other) = default;
-
-  // Returns true if this instance is a SPDY 3.x priority, or false if this
-  // instance is an HTTP/2 stream dependency.
-  bool is_spdy3_priority() const {
-    return absl::holds_alternative<SpdyPriority>(precedence_);
-  }
-
-  // Returns SPDY 3.x priority value. If |is_spdy3_priority()| is true, this is
-  // the value provided at construction, clamped to the legal priority
-  // range. Otherwise, it is the HTTP/2 stream weight mapped to a SPDY 3.x
-  // priority value, where minimum weight 1 corresponds to priority 7 (lowest
-  // precedence) and maximum weight 256 corresponds to priority 0 (highest
-  // precedence).
-  SpdyPriority spdy3_priority() const {
-    return is_spdy3_priority()
-               ? absl::get<SpdyPriority>(precedence_)
-               : Http2WeightToSpdy3Priority(
-                     absl::get<Http2StreamDependency>(precedence_).weight);
-  }
-
-  // Returns HTTP/2 parent stream ID. If |is_spdy3_priority()| is false, this is
-  // the value provided at construction, otherwise it is |kHttp2RootStreamId|.
-  StreamIdType parent_id() const {
-    return is_spdy3_priority()
-               ? kHttp2RootStreamId
-               : absl::get<Http2StreamDependency>(precedence_).parent_id;
-  }
-
-  // Returns HTTP/2 stream weight. If |is_spdy3_priority()| is false, this is
-  // the value provided at construction, clamped to the legal weight
-  // range. Otherwise, it is the SPDY 3.x priority value mapped to an HTTP/2
-  // stream weight, where priority 0 (i.e. highest precedence) corresponds to
-  // maximum weight 256 and priority 7 (lowest precedence) corresponds to
-  // minimum weight 1.
-  int weight() const {
-    return is_spdy3_priority()
-               ? Spdy3PriorityToHttp2Weight(
-                     absl::get<SpdyPriority>(precedence_))
-               : absl::get<Http2StreamDependency>(precedence_).weight;
-  }
-
-  // Returns HTTP/2 parent stream exclusivity. If |is_spdy3_priority()| is
-  // false, this is the value provided at construction, otherwise it is false.
-  bool is_exclusive() const {
-    return absl::holds_alternative<Http2StreamDependency>(precedence_) &&
-           absl::get<Http2StreamDependency>(precedence_).is_exclusive;
-  }
-
-  // Facilitates test assertions.
-  bool operator==(const StreamPrecedence& other) const {
-    return precedence_ == other.precedence_;
-  }
-
-  bool operator!=(const StreamPrecedence& other) const {
-    return !(*this == other);
-  }
-
- private:
-  struct QUICHE_EXPORT Http2StreamDependency {
-    StreamIdType parent_id;
-    int weight;
-    bool is_exclusive;
-
-    bool operator==(const Http2StreamDependency& other) const {
-      return parent_id == other.parent_id && weight == other.weight &&
-             is_exclusive == other.is_exclusive;
-    }
-  };
-
-  absl::variant<SpdyPriority, Http2StreamDependency> precedence_;
-};
-
-typedef StreamPrecedence<SpdyStreamId> SpdyStreamPrecedence;
-
-class SpdyFrameVisitor;
-
-// Intermediate representation for HTTP2 frames.
-class QUICHE_EXPORT SpdyFrameIR {
- public:
-  virtual ~SpdyFrameIR() {}
-
-  virtual void Visit(SpdyFrameVisitor* visitor) const = 0;
-  virtual SpdyFrameType frame_type() const = 0;
-  SpdyStreamId stream_id() const { return stream_id_; }
-  virtual bool fin() const;
-  // Returns an estimate of the size of the serialized frame, without applying
-  // compression. May not be exact, but implementations should return the same
-  // value for a const frame.
-  virtual size_t size() const = 0;
-
-  // Returns the number of bytes of flow control window that would be consumed
-  // by this frame if written to the wire.
-  virtual int flow_control_window_consumed() const;
-
- protected:
-  SpdyFrameIR() : stream_id_(0) {}
-  explicit SpdyFrameIR(SpdyStreamId stream_id) : stream_id_(stream_id) {}
-  SpdyFrameIR(const SpdyFrameIR&) = delete;
-  SpdyFrameIR& operator=(const SpdyFrameIR&) = delete;
-
- private:
-  SpdyStreamId stream_id_;
-};
-
-// Abstract class intended to be inherited by IRs that have the option of a FIN
-// flag.
-class QUICHE_EXPORT SpdyFrameWithFinIR : public SpdyFrameIR {
- public:
-  ~SpdyFrameWithFinIR() override {}
-  bool fin() const override;
-  void set_fin(bool fin) { fin_ = fin; }
-
- protected:
-  explicit SpdyFrameWithFinIR(SpdyStreamId stream_id)
-      : SpdyFrameIR(stream_id), fin_(false) {}
-  SpdyFrameWithFinIR(const SpdyFrameWithFinIR&) = delete;
-  SpdyFrameWithFinIR& operator=(const SpdyFrameWithFinIR&) = delete;
-
- private:
-  bool fin_;
-};
-
-// Abstract class intended to be inherited by IRs that contain a header
-// block. Implies SpdyFrameWithFinIR.
-class QUICHE_EXPORT SpdyFrameWithHeaderBlockIR : public SpdyFrameWithFinIR {
- public:
-  ~SpdyFrameWithHeaderBlockIR() override;
-
-  const Http2HeaderBlock& header_block() const { return header_block_; }
-  void set_header_block(Http2HeaderBlock header_block) {
-    // Deep copy.
-    header_block_ = std::move(header_block);
-  }
-  void SetHeader(absl::string_view name, absl::string_view value) {
-    header_block_[name] = value;
-  }
-
- protected:
-  SpdyFrameWithHeaderBlockIR(SpdyStreamId stream_id,
-                             Http2HeaderBlock header_block);
-  SpdyFrameWithHeaderBlockIR(const SpdyFrameWithHeaderBlockIR&) = delete;
-  SpdyFrameWithHeaderBlockIR& operator=(const SpdyFrameWithHeaderBlockIR&) =
-      delete;
-
- private:
-  Http2HeaderBlock header_block_;
-};
-
-class QUICHE_EXPORT SpdyDataIR : public SpdyFrameWithFinIR {
- public:
-  // Performs a deep copy on data.
-  SpdyDataIR(SpdyStreamId stream_id, absl::string_view data);
-
-  // Performs a deep copy on data.
-  SpdyDataIR(SpdyStreamId stream_id, const char* data);
-
-  // Moves data into data_store_. Makes a copy if passed a non-movable string.
-  SpdyDataIR(SpdyStreamId stream_id, std::string data);
-
-  // Use in conjunction with SetDataShallow() for shallow-copy on data.
-  explicit SpdyDataIR(SpdyStreamId stream_id);
-  SpdyDataIR(const SpdyDataIR&) = delete;
-  SpdyDataIR& operator=(const SpdyDataIR&) = delete;
-
-  ~SpdyDataIR() override;
-
-  const char* data() const { return data_; }
-  size_t data_len() const { return data_len_; }
-
-  bool padded() const { return padded_; }
-
-  int padding_payload_len() const { return padding_payload_len_; }
-
-  void set_padding_len(int padding_len) {
-    QUICHE_DCHECK_GT(padding_len, 0);
-    QUICHE_DCHECK_LE(padding_len, kPaddingSizePerFrame);
-    padded_ = true;
-    // The pad field takes one octet on the wire.
-    padding_payload_len_ = padding_len - 1;
-  }
-
-  // Deep-copy of data (keep private copy).
-  void SetDataDeep(absl::string_view data) {
-    data_store_ = std::make_unique<std::string>(data.data(), data.size());
-    data_ = data_store_->data();
-    data_len_ = data.size();
-  }
-
-  // Shallow-copy of data (do not keep private copy).
-  void SetDataShallow(absl::string_view data) {
-    data_store_.reset();
-    data_ = data.data();
-    data_len_ = data.size();
-  }
-
-  // Use this method if we don't have a contiguous buffer and only
-  // need a length.
-  void SetDataShallow(size_t len) {
-    data_store_.reset();
-    data_ = nullptr;
-    data_len_ = len;
-  }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  int flow_control_window_consumed() const override;
-
-  size_t size() const override;
-
- private:
-  // Used to store data that this SpdyDataIR should own.
-  std::unique_ptr<std::string> data_store_;
-  const char* data_;
-  size_t data_len_;
-
-  bool padded_;
-  // padding_payload_len_ = desired padding length - len(padding length field).
-  int padding_payload_len_;
-};
-
-class QUICHE_EXPORT SpdyRstStreamIR : public SpdyFrameIR {
- public:
-  SpdyRstStreamIR(SpdyStreamId stream_id, SpdyErrorCode error_code);
-  SpdyRstStreamIR(const SpdyRstStreamIR&) = delete;
-  SpdyRstStreamIR& operator=(const SpdyRstStreamIR&) = delete;
-
-  ~SpdyRstStreamIR() override;
-
-  SpdyErrorCode error_code() const { return error_code_; }
-  void set_error_code(SpdyErrorCode error_code) { error_code_ = error_code; }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
- private:
-  SpdyErrorCode error_code_;
-};
-
-class QUICHE_EXPORT SpdySettingsIR : public SpdyFrameIR {
- public:
-  SpdySettingsIR();
-  SpdySettingsIR(const SpdySettingsIR&) = delete;
-  SpdySettingsIR& operator=(const SpdySettingsIR&) = delete;
-  ~SpdySettingsIR() override;
-
-  // Overwrites as appropriate.
-  const SettingsMap& values() const { return values_; }
-  void AddSetting(SpdySettingsId id, int32_t value) { values_[id] = value; }
-
-  bool is_ack() const { return is_ack_; }
-  void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
- private:
-  SettingsMap values_;
-  bool is_ack_;
-};
-
-class QUICHE_EXPORT SpdyPingIR : public SpdyFrameIR {
- public:
-  explicit SpdyPingIR(SpdyPingId id) : id_(id), is_ack_(false) {}
-  SpdyPingIR(const SpdyPingIR&) = delete;
-  SpdyPingIR& operator=(const SpdyPingIR&) = delete;
-  SpdyPingId id() const { return id_; }
-
-  bool is_ack() const { return is_ack_; }
-  void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
- private:
-  SpdyPingId id_;
-  bool is_ack_;
-};
-
-class QUICHE_EXPORT SpdyGoAwayIR : public SpdyFrameIR {
- public:
-  // References description, doesn't copy it, so description must outlast
-  // this SpdyGoAwayIR.
-  SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyErrorCode error_code,
-               absl::string_view description);
-
-  // References description, doesn't copy it, so description must outlast
-  // this SpdyGoAwayIR.
-  SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyErrorCode error_code,
-               const char* description);
-
-  // Moves description into description_store_, so caller doesn't need to
-  // keep description live after constructing this SpdyGoAwayIR.
-  SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyErrorCode error_code,
-               std::string description);
-  SpdyGoAwayIR(const SpdyGoAwayIR&) = delete;
-  SpdyGoAwayIR& operator=(const SpdyGoAwayIR&) = delete;
-
-  ~SpdyGoAwayIR() override;
-
-  SpdyStreamId last_good_stream_id() const { return last_good_stream_id_; }
-  void set_last_good_stream_id(SpdyStreamId last_good_stream_id) {
-    QUICHE_DCHECK_EQ(0u, last_good_stream_id & ~kStreamIdMask);
-    last_good_stream_id_ = last_good_stream_id;
-  }
-  SpdyErrorCode error_code() const { return error_code_; }
-  void set_error_code(SpdyErrorCode error_code) {
-    // TODO(hkhalil): Check valid ranges of error_code?
-    error_code_ = error_code;
-  }
-
-  const absl::string_view& description() const { return description_; }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
- private:
-  SpdyStreamId last_good_stream_id_;
-  SpdyErrorCode error_code_;
-  const std::string description_store_;
-  const absl::string_view description_;
-};
-
-class QUICHE_EXPORT SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
- public:
-  explicit SpdyHeadersIR(SpdyStreamId stream_id)
-      : SpdyHeadersIR(stream_id, Http2HeaderBlock()) {}
-  SpdyHeadersIR(SpdyStreamId stream_id, Http2HeaderBlock header_block)
-      : SpdyFrameWithHeaderBlockIR(stream_id, std::move(header_block)) {}
-  SpdyHeadersIR(const SpdyHeadersIR&) = delete;
-  SpdyHeadersIR& operator=(const SpdyHeadersIR&) = delete;
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
-  bool has_priority() const { return has_priority_; }
-  void set_has_priority(bool has_priority) { has_priority_ = has_priority; }
-  int weight() const { return weight_; }
-  void set_weight(int weight) { weight_ = weight; }
-  SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
-  void set_parent_stream_id(SpdyStreamId id) { parent_stream_id_ = id; }
-  bool exclusive() const { return exclusive_; }
-  void set_exclusive(bool exclusive) { exclusive_ = exclusive; }
-  bool padded() const { return padded_; }
-  int padding_payload_len() const { return padding_payload_len_; }
-  void set_padding_len(int padding_len) {
-    QUICHE_DCHECK_GT(padding_len, 0);
-    QUICHE_DCHECK_LE(padding_len, kPaddingSizePerFrame);
-    padded_ = true;
-    // The pad field takes one octet on the wire.
-    padding_payload_len_ = padding_len - 1;
-  }
-
- private:
-  bool has_priority_ = false;
-  int weight_ = kHttp2DefaultStreamWeight;
-  SpdyStreamId parent_stream_id_ = 0;
-  bool exclusive_ = false;
-  bool padded_ = false;
-  int padding_payload_len_ = 0;
-  const bool add_hpack_overhead_bytes_ =
-      GetQuicheReloadableFlag(http2_add_hpack_overhead_bytes2);
-};
-
-class QUICHE_EXPORT SpdyWindowUpdateIR : public SpdyFrameIR {
- public:
-  SpdyWindowUpdateIR(SpdyStreamId stream_id, int32_t delta)
-      : SpdyFrameIR(stream_id) {
-    set_delta(delta);
-  }
-  SpdyWindowUpdateIR(const SpdyWindowUpdateIR&) = delete;
-  SpdyWindowUpdateIR& operator=(const SpdyWindowUpdateIR&) = delete;
-
-  int32_t delta() const { return delta_; }
-  void set_delta(int32_t delta) {
-    QUICHE_DCHECK_LE(0, delta);
-    QUICHE_DCHECK_LE(delta, kSpdyMaximumWindowSize);
-    delta_ = delta;
-  }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
- private:
-  int32_t delta_;
-};
-
-class QUICHE_EXPORT SpdyPushPromiseIR : public SpdyFrameWithHeaderBlockIR {
- public:
-  SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id)
-      : SpdyPushPromiseIR(stream_id, promised_stream_id, Http2HeaderBlock()) {}
-  SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id,
-                    Http2HeaderBlock header_block)
-      : SpdyFrameWithHeaderBlockIR(stream_id, std::move(header_block)),
-        promised_stream_id_(promised_stream_id),
-        padded_(false),
-        padding_payload_len_(0) {}
-  SpdyPushPromiseIR(const SpdyPushPromiseIR&) = delete;
-  SpdyPushPromiseIR& operator=(const SpdyPushPromiseIR&) = delete;
-  SpdyStreamId promised_stream_id() const { return promised_stream_id_; }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
-  bool padded() const { return padded_; }
-  int padding_payload_len() const { return padding_payload_len_; }
-  void set_padding_len(int padding_len) {
-    QUICHE_DCHECK_GT(padding_len, 0);
-    QUICHE_DCHECK_LE(padding_len, kPaddingSizePerFrame);
-    padded_ = true;
-    // The pad field takes one octet on the wire.
-    padding_payload_len_ = padding_len - 1;
-  }
-
- private:
-  SpdyStreamId promised_stream_id_;
-
-  bool padded_;
-  int padding_payload_len_;
-};
-
-class QUICHE_EXPORT SpdyContinuationIR : public SpdyFrameIR {
- public:
-  explicit SpdyContinuationIR(SpdyStreamId stream_id);
-  SpdyContinuationIR(const SpdyContinuationIR&) = delete;
-  SpdyContinuationIR& operator=(const SpdyContinuationIR&) = delete;
-  ~SpdyContinuationIR() override;
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  bool end_headers() const { return end_headers_; }
-  void set_end_headers(bool end_headers) { end_headers_ = end_headers; }
-  const std::string& encoding() const { return encoding_; }
-  void take_encoding(std::string encoding) { encoding_ = std::move(encoding); }
-  size_t size() const override;
-
- private:
-  std::string encoding_;
-  bool end_headers_;
-};
-
-class QUICHE_EXPORT SpdyAltSvcIR : public SpdyFrameIR {
- public:
-  explicit SpdyAltSvcIR(SpdyStreamId stream_id);
-  SpdyAltSvcIR(const SpdyAltSvcIR&) = delete;
-  SpdyAltSvcIR& operator=(const SpdyAltSvcIR&) = delete;
-  ~SpdyAltSvcIR() override;
-
-  std::string origin() const { return origin_; }
-  const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector() const {
-    return altsvc_vector_;
-  }
-
-  void set_origin(std::string origin) { origin_ = std::move(origin); }
-  void add_altsvc(const SpdyAltSvcWireFormat::AlternativeService& altsvc) {
-    altsvc_vector_.push_back(altsvc);
-  }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
- private:
-  std::string origin_;
-  SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector_;
-};
-
-class QUICHE_EXPORT SpdyPriorityIR : public SpdyFrameIR {
- public:
-  SpdyPriorityIR(SpdyStreamId stream_id, SpdyStreamId parent_stream_id,
-                 int weight, bool exclusive)
-      : SpdyFrameIR(stream_id),
-        parent_stream_id_(parent_stream_id),
-        weight_(weight),
-        exclusive_(exclusive) {}
-  SpdyPriorityIR(const SpdyPriorityIR&) = delete;
-  SpdyPriorityIR& operator=(const SpdyPriorityIR&) = delete;
-  SpdyStreamId parent_stream_id() const { return parent_stream_id_; }
-  int weight() const { return weight_; }
-  bool exclusive() const { return exclusive_; }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
- private:
-  SpdyStreamId parent_stream_id_;
-  int weight_;
-  bool exclusive_;
-};
-
-class QUICHE_EXPORT SpdyPriorityUpdateIR : public SpdyFrameIR {
- public:
-  SpdyPriorityUpdateIR(SpdyStreamId stream_id,
-                       SpdyStreamId prioritized_stream_id,
-                       std::string priority_field_value)
-      : SpdyFrameIR(stream_id),
-        prioritized_stream_id_(prioritized_stream_id),
-        priority_field_value_(std::move(priority_field_value)) {}
-  SpdyPriorityUpdateIR(const SpdyPriorityUpdateIR&) = delete;
-  SpdyPriorityUpdateIR& operator=(const SpdyPriorityUpdateIR&) = delete;
-  SpdyStreamId prioritized_stream_id() const { return prioritized_stream_id_; }
-  const std::string& priority_field_value() const {
-    return priority_field_value_;
-  }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
- private:
-  SpdyStreamId prioritized_stream_id_;
-  std::string priority_field_value_;
-};
-
-struct QUICHE_EXPORT AcceptChOriginValuePair {
-  std::string origin;
-  std::string value;
-  bool operator==(const AcceptChOriginValuePair& rhs) const {
-    return origin == rhs.origin && value == rhs.value;
-  }
-};
-
-class QUICHE_EXPORT SpdyAcceptChIR : public SpdyFrameIR {
- public:
-  SpdyAcceptChIR(std::vector<AcceptChOriginValuePair> entries)
-      : entries_(std::move(entries)) {}
-  SpdyAcceptChIR(const SpdyAcceptChIR&) = delete;
-  SpdyAcceptChIR& operator=(const SpdyAcceptChIR&) = delete;
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  size_t size() const override;
-
-  const std::vector<AcceptChOriginValuePair>& entries() const {
-    return entries_;
-  }
-
- private:
-  std::vector<AcceptChOriginValuePair> entries_;
-};
-
-// Represents a frame of unrecognized type.
-class QUICHE_EXPORT SpdyUnknownIR : public SpdyFrameIR {
- public:
-  SpdyUnknownIR(SpdyStreamId stream_id, uint8_t type, uint8_t flags,
-                std::string payload)
-      : SpdyFrameIR(stream_id),
-        type_(type),
-        flags_(flags),
-        length_(payload.size()),
-        payload_(std::move(payload)) {}
-  SpdyUnknownIR(const SpdyUnknownIR&) = delete;
-  SpdyUnknownIR& operator=(const SpdyUnknownIR&) = delete;
-  uint8_t type() const { return type_; }
-  uint8_t flags() const { return flags_; }
-  size_t length() const { return length_; }
-  const std::string& payload() const { return payload_; }
-
-  void Visit(SpdyFrameVisitor* visitor) const override;
-
-  SpdyFrameType frame_type() const override;
-
-  int flow_control_window_consumed() const override;
-
-  size_t size() const override;
-
- protected:
-  // Allows subclasses to overwrite the default payload length.
-  void set_length(size_t length) { length_ = length; }
-
- private:
-  uint8_t type_;
-  uint8_t flags_;
-  size_t length_;
-  const std::string payload_;
-};
-
-class QUICHE_EXPORT SpdySerializedFrame {
- public:
-  SpdySerializedFrame() : size_(0) {}
-
-  // Creates a valid SpdySerializedFrame using a pre-created buffer.
-  SpdySerializedFrame(std::unique_ptr<char[]> data, size_t size)
-      : frame_(std::move(data)), size_(size) {}
-
-  SpdySerializedFrame(SpdySerializedFrame&& other)
-      : frame_(std::move(other.frame_)), size_(other.size_) {}
-
-  SpdySerializedFrame(const SpdySerializedFrame&) = delete;
-  SpdySerializedFrame& operator=(const SpdySerializedFrame&) = delete;
-
-  SpdySerializedFrame& operator=(SpdySerializedFrame&& other) {
-    // Take over |other|.
-    frame_ = std::move(other.frame_);
-    size_ = other.size_;
-    return *this;
-  }
-
-  ~SpdySerializedFrame() = default;
-
-  // Provides access to the frame bytes, which is a buffer containing the frame
-  // packed as expected for sending over the wire.
-  char* data() const { return frame_.get(); }
-
-  // Returns the actual size of the underlying buffer.
-  size_t size() const { return size_; }
-
-  operator absl::string_view() const {
-    return absl::string_view{frame_.get(), size_};
-  }
-
- private:
-  std::unique_ptr<char[]> frame_;
-  size_t size_;
-};
-
-// This interface is for classes that want to process SpdyFrameIRs without
-// having to know what type they are.  An instance of this interface can be
-// passed to a SpdyFrameIR's Visit method, and the appropriate type-specific
-// method of this class will be called.
-class QUICHE_EXPORT SpdyFrameVisitor {
- public:
-  SpdyFrameVisitor() {}
-  SpdyFrameVisitor(const SpdyFrameVisitor&) = delete;
-  SpdyFrameVisitor& operator=(const SpdyFrameVisitor&) = delete;
-  virtual ~SpdyFrameVisitor() {}
-
-  virtual void VisitRstStream(const SpdyRstStreamIR& rst_stream) = 0;
-  virtual void VisitSettings(const SpdySettingsIR& settings) = 0;
-  virtual void VisitPing(const SpdyPingIR& ping) = 0;
-  virtual void VisitGoAway(const SpdyGoAwayIR& goaway) = 0;
-  virtual void VisitHeaders(const SpdyHeadersIR& headers) = 0;
-  virtual void VisitWindowUpdate(const SpdyWindowUpdateIR& window_update) = 0;
-  virtual void VisitPushPromise(const SpdyPushPromiseIR& push_promise) = 0;
-  virtual void VisitContinuation(const SpdyContinuationIR& continuation) = 0;
-  virtual void VisitAltSvc(const SpdyAltSvcIR& altsvc) = 0;
-  virtual void VisitPriority(const SpdyPriorityIR& priority) = 0;
-  virtual void VisitData(const SpdyDataIR& data) = 0;
-  virtual void VisitPriorityUpdate(
-      const SpdyPriorityUpdateIR& priority_update) = 0;
-  virtual void VisitAcceptCh(const SpdyAcceptChIR& accept_ch) = 0;
-  virtual void VisitUnknown(const SpdyUnknownIR& /*unknown*/) {
-    // TODO(birenroy): make abstract.
-  }
-};
-
-// Optionally, and in addition to SpdyFramerVisitorInterface, a class supporting
-// SpdyFramerDebugVisitorInterface may be used in conjunction with SpdyFramer in
-// order to extract debug/internal information about the SpdyFramer as it
-// operates.
-//
-// Most HTTP2 implementations need not bother with this interface at all.
-class QUICHE_EXPORT SpdyFramerDebugVisitorInterface {
- public:
-  virtual ~SpdyFramerDebugVisitorInterface() {}
-
-  // Called after compressing a frame with a payload of
-  // a list of name-value pairs.
-  // |payload_len| is the uncompressed payload size.
-  // |frame_len| is the compressed frame size.
-  virtual void OnSendCompressedFrame(SpdyStreamId /*stream_id*/,
-                                     SpdyFrameType /*type*/,
-                                     size_t /*payload_len*/,
-                                     size_t /*frame_len*/) {}
-
-  // Called when a frame containing a compressed payload of
-  // name-value pairs is received.
-  // |frame_len| is the compressed frame size.
-  virtual void OnReceiveCompressedFrame(SpdyStreamId /*stream_id*/,
-                                        SpdyFrameType /*type*/,
-                                        size_t /*frame_len*/) {}
-};
-
-// Calculates the number of bytes required to serialize a SpdyHeadersIR, not
-// including the bytes to be used for the encoded header set.
-size_t GetHeaderFrameSizeSansBlock(const SpdyHeadersIR& header_ir);
-
-// Calculates the number of bytes required to serialize a SpdyPushPromiseIR,
-// not including the bytes to be used for the encoded header set.
-size_t GetPushPromiseFrameSizeSansBlock(
-    const SpdyPushPromiseIR& push_promise_ir);
-
-}  // namespace spdy
+#include "quiche/http2/core/spdy_protocol.h"
 
 #endif  // QUICHE_SPDY_CORE_SPDY_PROTOCOL_H_