diff --git a/http2/adapter/data_source.h b/http2/adapter/data_source.h
index 6b1a8ce..d867141 100644
--- a/http2/adapter/data_source.h
+++ b/http2/adapter/data_source.h
@@ -32,6 +32,18 @@
   virtual bool send_fin() const = 0;
 };
 
+// Represents a source of metadata frames for transmission to the peer.
+class QUICHE_EXPORT_PRIVATE MetadataSource {
+ public:
+  virtual ~MetadataSource() {}
+
+  // This method is called with a destination buffer and length. It should
+  // return the number of payload bytes copied to |dest|, or a negative integer
+  // to indicate an error, as well as a boolean indicating whether the metadata
+  // has been completely copied.
+  virtual std::pair<ssize_t, bool> Pack(uint8_t* dest, size_t dest_len) = 0;
+};
+
 }  // namespace adapter
 }  // namespace http2
 
diff --git a/http2/adapter/http2_adapter.h b/http2/adapter/http2_adapter.h
index 75eb138..789be98 100644
--- a/http2/adapter/http2_adapter.h
+++ b/http2/adapter/http2_adapter.h
@@ -62,10 +62,10 @@
   virtual void SubmitRst(Http2StreamId stream_id,
                          Http2ErrorCode error_code) = 0;
 
-  // Submits a METADATA frame for the given stream (a |stream_id| of 0 indicates
-  // connection-level METADATA). If |fin|, the frame will also have the
-  // END_METADATA flag set.
-  virtual void SubmitMetadata(Http2StreamId stream_id, bool fin) = 0;
+  // Submits a sequence of METADATA frames for the given stream. A |stream_id|
+  // of 0 indicates connection-level METADATA.
+  virtual void SubmitMetadata(Http2StreamId stream_id,
+                              std::unique_ptr<MetadataSource> source) = 0;
 
   // Invokes the visitor's OnReadyToSend() method for serialized frame data.
   // Returns 0 on success.
diff --git a/http2/adapter/nghttp2_adapter.cc b/http2/adapter/nghttp2_adapter.cc
index b786daa..9b444a3 100644
--- a/http2/adapter/nghttp2_adapter.cc
+++ b/http2/adapter/nghttp2_adapter.cc
@@ -90,8 +90,8 @@
                                stream_id, window_increment);
 }
 
-void NgHttp2Adapter::SubmitMetadata(Http2StreamId /*stream_id*/,
-                                    bool /*end_metadata*/) {
+void NgHttp2Adapter::SubmitMetadata(
+    Http2StreamId /*stream_id*/, std::unique_ptr<MetadataSource> /*source*/) {
   QUICHE_LOG(DFATAL) << "Not implemented";
 }
 
diff --git a/http2/adapter/nghttp2_adapter.h b/http2/adapter/nghttp2_adapter.h
index 2f2cbad..151f9a7 100644
--- a/http2/adapter/nghttp2_adapter.h
+++ b/http2/adapter/nghttp2_adapter.h
@@ -49,7 +49,8 @@
 
   void SubmitRst(Http2StreamId stream_id, Http2ErrorCode error_code) override;
 
-  void SubmitMetadata(Http2StreamId stream_id, bool end_metadata) override;
+  void SubmitMetadata(Http2StreamId stream_id,
+                      std::unique_ptr<MetadataSource> source) override;
 
   int Send() override;
 
diff --git a/http2/adapter/oghttp2_adapter.cc b/http2/adapter/oghttp2_adapter.cc
index f695696..27f011e 100644
--- a/http2/adapter/oghttp2_adapter.cc
+++ b/http2/adapter/oghttp2_adapter.cc
@@ -75,8 +75,9 @@
       absl::make_unique<SpdyWindowUpdateIR>(stream_id, window_increment));
 }
 
-void OgHttp2Adapter::SubmitMetadata(Http2StreamId /*stream_id*/, bool /*fin*/) {
-  QUICHE_BUG(oghttp2_submit_metadata) << "Not implemented";
+void OgHttp2Adapter::SubmitMetadata(Http2StreamId stream_id,
+                                    std::unique_ptr<MetadataSource> source) {
+  session_->SubmitMetadata(stream_id, std::move(source));
 }
 
 int OgHttp2Adapter::Send() { return session_->Send(); }
diff --git a/http2/adapter/oghttp2_adapter.h b/http2/adapter/oghttp2_adapter.h
index ace8ea9..9c7bad3 100644
--- a/http2/adapter/oghttp2_adapter.h
+++ b/http2/adapter/oghttp2_adapter.h
@@ -34,7 +34,8 @@
                     absl::string_view opaque_data) override;
   void SubmitWindowUpdate(Http2StreamId stream_id,
                           int window_increment) override;
-  void SubmitMetadata(Http2StreamId stream_id, bool fin) override;
+  void SubmitMetadata(Http2StreamId stream_id,
+                      std::unique_ptr<MetadataSource> source) override;
   int Send() override;
   int GetSendWindowSize() const override;
   int GetStreamSendWindowSize(Http2StreamId stream_id) const override;
diff --git a/http2/adapter/oghttp2_adapter_test.cc b/http2/adapter/oghttp2_adapter_test.cc
index 401fda4..9cc960f 100644
--- a/http2/adapter/oghttp2_adapter_test.cc
+++ b/http2/adapter/oghttp2_adapter_test.cc
@@ -1,6 +1,7 @@
 #include "http2/adapter/oghttp2_adapter.h"
 
 #include "http2/adapter/mock_http2_visitor.h"
+#include "http2/adapter/oghttp2_util.h"
 #include "http2/adapter/test_frame_sequence.h"
 #include "http2/adapter/test_utils.h"
 #include "common/platform/api/quiche_test.h"
@@ -531,7 +532,43 @@
 }
 
 TEST_F(OgHttp2AdapterTest, SubmitMetadata) {
-  EXPECT_QUICHE_BUG(adapter_->SubmitMetadata(3, true), "Not implemented");
+  auto source = absl::make_unique<TestMetadataSource>(ToHeaderBlock(ToHeaders(
+      {{"query-cost", "is too darn high"}, {"secret-sauce", "hollandaise"}})));
+  adapter_->SubmitMetadata(1, std::move(source));
+  EXPECT_TRUE(adapter_->session().want_write());
+
+  EXPECT_CALL(http2_visitor_, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+  EXPECT_CALL(http2_visitor_, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+  EXPECT_CALL(http2_visitor_, OnBeforeFrameSent(kMetadataFrameType, 1, _, 0x4));
+  EXPECT_CALL(http2_visitor_, OnFrameSent(kMetadataFrameType, 1, _, 0x4, 0));
+
+  int result = adapter_->Send();
+  EXPECT_EQ(0, result);
+  EXPECT_THAT(
+      http2_visitor_.data(),
+      EqualsFrames({spdy::SpdyFrameType::SETTINGS,
+                    static_cast<spdy::SpdyFrameType>(kMetadataFrameType)}));
+  EXPECT_FALSE(adapter_->session().want_write());
+}
+
+TEST_F(OgHttp2AdapterTest, SubmitConnectionMetadata) {
+  auto source = absl::make_unique<TestMetadataSource>(ToHeaderBlock(ToHeaders(
+      {{"query-cost", "is too darn high"}, {"secret-sauce", "hollandaise"}})));
+  adapter_->SubmitMetadata(0, std::move(source));
+  EXPECT_TRUE(adapter_->session().want_write());
+
+  EXPECT_CALL(http2_visitor_, OnBeforeFrameSent(SETTINGS, 0, _, 0x0));
+  EXPECT_CALL(http2_visitor_, OnFrameSent(SETTINGS, 0, _, 0x0, 0));
+  EXPECT_CALL(http2_visitor_, OnBeforeFrameSent(kMetadataFrameType, 0, _, 0x4));
+  EXPECT_CALL(http2_visitor_, OnFrameSent(kMetadataFrameType, 0, _, 0x4, 0));
+
+  int result = adapter_->Send();
+  EXPECT_EQ(0, result);
+  EXPECT_THAT(
+      http2_visitor_.data(),
+      EqualsFrames({spdy::SpdyFrameType::SETTINGS,
+                    static_cast<spdy::SpdyFrameType>(kMetadataFrameType)}));
+  EXPECT_FALSE(adapter_->session().want_write());
 }
 
 TEST_F(OgHttp2AdapterTest, GetSendWindowSize) {
diff --git a/http2/adapter/oghttp2_session.cc b/http2/adapter/oghttp2_session.cc
index 6aa98b8..b43e4a8 100644
--- a/http2/adapter/oghttp2_session.cc
+++ b/http2/adapter/oghttp2_session.cc
@@ -10,6 +10,8 @@
 
 namespace {
 
+const size_t kMaxMetadataFrameSize = 16384;
+
 // TODO(birenroy): Consider incorporating spdy::FlagsSerializionVisitor here.
 class FrameAttributeCollector : public spdy::SpdyFrameVisitor {
  public:
@@ -80,6 +82,12 @@
     flags_ = continuation.end_headers() ? 0x4 : 0;
     length_ = continuation.size() - spdy::kFrameHeaderSize;
   }
+  void VisitUnknown(const spdy::SpdyUnknownIR& unknown) override {
+    frame_type_ = static_cast<uint8_t>(unknown.frame_type());
+    stream_id_ = unknown.stream_id();
+    flags_ = unknown.flags();
+    length_ = unknown.size() - spdy::kFrameHeaderSize;
+  }
   void VisitAltSvc(const spdy::SpdyAltSvcIR& /*altsvc*/) override {}
   void VisitPriorityUpdate(
       const spdy::SpdyPriorityUpdateIR& /*priority_update*/) override {}
@@ -287,6 +295,9 @@
     return result < 0 ? result : 0;
   }
   bool continue_writing = SendQueuedFrames();
+  while (continue_writing && !connection_metadata_.empty()) {
+    continue_writing = SendMetadata(0, connection_metadata_);
+  }
   // Wake streams for writes.
   while (continue_writing && write_scheduler_.HasReadyStreams() &&
          connection_send_window_ > 0) {
@@ -346,6 +357,11 @@
     return true;
   }
   StreamState& state = it->second;
+  bool connection_can_write = true;
+  if (!state.outbound_metadata.empty()) {
+    connection_can_write = SendMetadata(stream_id, state.outbound_metadata);
+  }
+
   if (state.outbound_body == nullptr) {
     // No data to send, but there might be trailers.
     if (state.trailers != nullptr) {
@@ -360,10 +376,10 @@
     return true;
   }
   bool source_can_produce = true;
-  bool connection_can_write = true;
   int32_t available_window = std::min(
       std::min(connection_send_window_, state.send_window), max_frame_payload_);
-  while (available_window > 0 && state.outbound_body != nullptr) {
+  while (connection_can_write && available_window > 0 &&
+         state.outbound_body != nullptr) {
     ssize_t length;
     bool end_data;
     std::tie(length, end_data) =
@@ -382,6 +398,7 @@
     data.SetDataShallow(length);
     spdy::SpdySerializedFrame header =
         spdy::SpdyFramer::SerializeDataFrameHeaderWithPaddingLengthField(data);
+    QUICHE_DCHECK(serialized_prefix_.empty() && frames_.empty());
     const bool success =
         state.outbound_body->Send(absl::string_view(header), length);
     if (!success) {
@@ -422,6 +439,33 @@
   return connection_can_write && available_window > 0;
 }
 
+bool OgHttp2Session::SendMetadata(Http2StreamId stream_id,
+                                  OgHttp2Session::MetadataSequence& sequence) {
+  auto payload_buffer = absl::make_unique<uint8_t[]>(kMaxMetadataFrameSize);
+  while (!sequence.empty()) {
+    MetadataSource& source = *sequence.front();
+
+    ssize_t written;
+    bool end_metadata;
+    std::tie(written, end_metadata) =
+        source.Pack(payload_buffer.get(), kMaxMetadataFrameSize);
+    if (written < 0) {
+      // Did not touch the connection, so perhaps writes are still possible.
+      return true;
+    }
+    QUICHE_DCHECK_LE(static_cast<size_t>(written), kMaxMetadataFrameSize);
+    auto payload = absl::string_view(
+        reinterpret_cast<const char*>(payload_buffer.get()), written);
+    EnqueueFrame(absl::make_unique<spdy::SpdyUnknownIR>(
+        stream_id, kMetadataFrameType, end_metadata ? kMetadataEndFlag : 0u,
+        std::string(payload)));
+    if (end_metadata) {
+      sequence.erase(sequence.begin());
+    }
+  }
+  return SendQueuedFrames();
+}
+
 int32_t OgHttp2Session::SubmitRequest(
     absl::Span<const Header> headers,
     std::unique_ptr<DataFrameSource> data_source, void* user_data) {
@@ -507,6 +551,17 @@
   return 0;
 }
 
+void OgHttp2Session::SubmitMetadata(Http2StreamId stream_id,
+                                    std::unique_ptr<MetadataSource> source) {
+  if (stream_id == 0) {
+    connection_metadata_.push_back(std::move(source));
+  } else {
+    auto iter = CreateStream(stream_id);
+    iter->second.outbound_metadata.push_back(std::move(source));
+    write_scheduler_.MarkStreamReady(stream_id, false);
+  }
+}
+
 void OgHttp2Session::OnError(http2::Http2DecoderAdapter::SpdyFramerError error,
                              std::string detailed_error) {
   QUICHE_VLOG(1) << "Error: "
diff --git a/http2/adapter/oghttp2_session.h b/http2/adapter/oghttp2_session.h
index 6bec0ca..5188828 100644
--- a/http2/adapter/oghttp2_session.h
+++ b/http2/adapter/oghttp2_session.h
@@ -45,6 +45,8 @@
   int SubmitResponse(Http2StreamId stream_id, absl::Span<const Header> headers,
                      std::unique_ptr<DataFrameSource> data_source);
   int SubmitTrailer(Http2StreamId stream_id, absl::Span<const Header> trailers);
+  void SubmitMetadata(Http2StreamId stream_id,
+                      std::unique_ptr<MetadataSource> source);
 
   bool IsServerSession() const {
     return options_.perspective == Perspective::kServer;
@@ -86,7 +88,7 @@
   bool want_read() const override { return !received_goaway_; }
   bool want_write() const override {
     return !frames_.empty() || !serialized_prefix_.empty() ||
-           write_scheduler_.HasReadyStreams();
+           write_scheduler_.HasReadyStreams() || !connection_metadata_.empty();
   }
   int GetRemoteWindowSize() const override { return connection_send_window_; }
 
@@ -151,6 +153,7 @@
                       Http2VisitorInterface::OnHeaderResult result);
 
  private:
+  using MetadataSequence = std::vector<std::unique_ptr<MetadataSource>>;
   struct QUICHE_EXPORT_PRIVATE StreamState {
     StreamState(int32_t stream_receive_window,
                 WindowManager::WindowUpdateListener listener)
@@ -158,6 +161,7 @@
 
     WindowManager window_manager;
     std::unique_ptr<DataFrameSource> outbound_body;
+    MetadataSequence outbound_metadata;
     std::unique_ptr<spdy::SpdyHeaderBlock> trailers;
     void* user_data = nullptr;
     int32_t send_window = kInitialFlowControlWindowSize;
@@ -202,6 +206,8 @@
   // some other reason).
   bool WriteForStream(Http2StreamId stream_id);
 
+  bool SendMetadata(Http2StreamId stream_id, MetadataSequence& sequence);
+
   void SendTrailers(Http2StreamId stream_id, spdy::SpdyHeaderBlock trailers);
 
   // Encapsulates the RST_STREAM NO_ERROR behavior described in RFC 7540
@@ -246,6 +252,8 @@
 
   absl::flat_hash_set<Http2StreamId> streams_reset_;
 
+  MetadataSequence connection_metadata_;
+
   Http2StreamId next_stream_id_ = 1;
   Http2StreamId highest_received_stream_id_ = 0;
   int connection_send_window_ = kInitialFlowControlWindowSize;
diff --git a/http2/adapter/test_utils.cc b/http2/adapter/test_utils.cc
index 8b3f4d6..9281215 100644
--- a/http2/adapter/test_utils.cc
+++ b/http2/adapter/test_utils.cc
@@ -1,6 +1,7 @@
 #include "http2/adapter/test_utils.h"
 
 #include "common/quiche_endian.h"
+#include "spdy/core/hpack/hpack_encoder.h"
 #include "spdy/core/spdy_frame_reader.h"
 
 namespace http2 {
@@ -85,6 +86,27 @@
   return true;
 }
 
+std::string EncodeHeaders(const spdy::SpdyHeaderBlock& entries) {
+  spdy::HpackEncoder encoder;
+  encoder.DisableCompression();
+  std::string result;
+  QUICHE_CHECK(encoder.EncodeHeaderSet(entries, &result));
+  return result;
+}
+
+TestMetadataSource::TestMetadataSource(const spdy::SpdyHeaderBlock& entries)
+    : encoded_entries_(EncodeHeaders(entries)) {
+  remaining_ = encoded_entries_;
+}
+
+std::pair<ssize_t, bool> TestMetadataSource::Pack(uint8_t* dest,
+                                                  size_t dest_len) {
+  const size_t copied = std::min(dest_len, remaining_.size());
+  std::memcpy(dest, remaining_.data(), copied);
+  remaining_.remove_prefix(copied);
+  return std::make_pair(copied, remaining_.empty());
+}
+
 namespace {
 
 using TypeAndOptionalLength =
@@ -103,6 +125,14 @@
   return out;
 }
 
+std::string FrameTypeToString(uint8_t frame_type) {
+  if (spdy::IsDefinedFrameType(frame_type)) {
+    return spdy::FrameTypeToString(spdy::ParseFrameType(frame_type));
+  } else {
+    return absl::StrFormat("0x%x", static_cast<int>(frame_type));
+  }
+}
+
 // Custom gMock matcher, used to implement EqualsFrames().
 class SpdyControlFrameMatcher
     : public testing::MatcherInterface<absl::string_view> {
@@ -153,16 +183,8 @@
       return false;
     }
 
-    if (!spdy::IsDefinedFrameType(raw_type)) {
-      *listener << "; expected type " << FrameTypeToString(expected_type)
-                << " but raw type " << static_cast<int>(raw_type)
-                << " is not a defined frame type!";
-      return false;
-    }
-
-    spdy::SpdyFrameType actual_type = spdy::ParseFrameType(raw_type);
-    if (actual_type != expected_type) {
-      *listener << "; actual type: " << FrameTypeToString(actual_type)
+    if (raw_type != static_cast<uint8_t>(expected_type)) {
+      *listener << "; actual type: " << FrameTypeToString(raw_type)
                 << " but expected type: " << FrameTypeToString(expected_type);
       return false;
     }
diff --git a/http2/adapter/test_utils.h b/http2/adapter/test_utils.h
index bec3fc3..ff52eee 100644
--- a/http2/adapter/test_utils.h
+++ b/http2/adapter/test_utils.h
@@ -10,6 +10,7 @@
 #include "http2/adapter/mock_http2_visitor.h"
 #include "common/platform/api/quiche_export.h"
 #include "common/platform/api/quiche_test.h"
+#include "spdy/core/spdy_header_block.h"
 #include "spdy/core/spdy_protocol.h"
 
 namespace http2 {
@@ -71,6 +72,17 @@
   bool is_data_available_ = true;
 };
 
+class QUICHE_NO_EXPORT TestMetadataSource : public MetadataSource {
+ public:
+  explicit TestMetadataSource(const spdy::SpdyHeaderBlock& entries);
+
+  std::pair<ssize_t, bool> Pack(uint8_t* dest, size_t dest_len) override;
+
+ private:
+  const std::string encoded_entries_;
+  absl::string_view remaining_;
+};
+
 // These matchers check whether a string consists entirely of HTTP/2 frames of
 // the specified ordered sequence. This is useful in tests where we want to show
 // that one or more particular frame types are serialized for sending to the