diff --git a/quic/masque/README.md b/quic/masque/README.md
new file mode 100644
index 0000000..6bfc08e
--- /dev/null
+++ b/quic/masque/README.md
@@ -0,0 +1,4 @@
+# MASQUE
+
+The files in this directory implement MASQUE as described in
+<https://tools.ietf.org/html/draft-schinazi-masque>.
diff --git a/quic/masque/masque_compression_engine.cc b/quic/masque/masque_compression_engine.cc
new file mode 100644
index 0000000..fc8957b
--- /dev/null
+++ b/quic/masque/masque_compression_engine.cc
@@ -0,0 +1,540 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/third_party/quiche/src/quic/masque/masque_compression_engine.h"
+
+#include <cstdint>
+
+#include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
+#include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
+#include "net/third_party/quiche/src/quic/core/quic_framer.h"
+#include "net/third_party/quiche/src/quic/core/quic_session.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
+
+namespace quic {
+
+namespace {
+// |kFlowId0| is used to indicate creation of a new compression context.
+const QuicDatagramFlowId kFlowId0 = 0;
+
+enum MasqueAddressFamily : uint8_t {
+  MasqueAddressFamilyIPv4 = 4,
+  MasqueAddressFamilyIPv6 = 6,
+};
+
+}  // namespace
+
+MasqueCompressionEngine::MasqueCompressionEngine(QuicSession* masque_session)
+    : masque_session_(masque_session) {
+  if (masque_session_->perspective() == Perspective::IS_SERVER) {
+    next_flow_id_ = 1;
+  } else {
+    next_flow_id_ = 2;
+  }
+}
+
+QuicDatagramFlowId MasqueCompressionEngine::FindOrCreateCompressionContext(
+    QuicConnectionId client_connection_id,
+    QuicConnectionId server_connection_id,
+    const QuicSocketAddress& server_address,
+    bool client_connection_id_present,
+    bool server_connection_id_present,
+    bool* validated) {
+  QuicDatagramFlowId flow_id = kFlowId0;
+  *validated = false;
+  for (const auto& kv : contexts_) {
+    const MasqueCompressionContext& context = kv.second;
+    if (context.server_address != server_address) {
+      continue;
+    }
+    if (client_connection_id_present &&
+        context.client_connection_id != client_connection_id) {
+      continue;
+    }
+    if (server_connection_id_present &&
+        context.server_connection_id != server_connection_id) {
+      continue;
+    }
+
+    flow_id = kv.first;
+    DCHECK_NE(flow_id, kFlowId0);
+    *validated = context.validated;
+    QUIC_DVLOG(1) << "Compressing using " << (*validated ? "" : "un")
+                  << "validated flow_id " << flow_id << " to "
+                  << context.server_address << " client "
+                  << context.client_connection_id << " server "
+                  << context.server_connection_id;
+    break;
+  }
+
+  if (flow_id != kFlowId0) {
+    // Found a compression context, use it.
+    return flow_id;
+  }
+
+  // Create new compression context.
+  flow_id = GetNextFlowId();
+  QUIC_DVLOG(1) << "Compression assigning new flow_id " << flow_id << " to "
+                << server_address << " client " << client_connection_id
+                << " server " << server_connection_id;
+  MasqueCompressionContext context;
+  context.client_connection_id = client_connection_id;
+  context.server_connection_id = server_connection_id;
+  context.server_address = server_address;
+  contexts_[flow_id] = context;
+
+  return flow_id;
+}
+
+bool MasqueCompressionEngine::WriteCompressedPacketToSlice(
+    QuicConnectionId client_connection_id,
+    QuicConnectionId server_connection_id,
+    const QuicSocketAddress& server_address,
+    QuicConnectionId destination_connection_id,
+    QuicConnectionId source_connection_id,
+    QuicDatagramFlowId flow_id,
+    bool validated,
+    uint8_t first_byte,
+    bool long_header,
+    QuicDataReader* reader,
+    QuicMemSlice* slice) {
+  QuicDataWriter writer(slice->length(), const_cast<char*>(slice->data()));
+  if (validated) {
+    QUIC_DVLOG(1) << "Compressing using validated flow_id " << flow_id;
+    if (!writer.WriteVarInt62(flow_id)) {
+      QUIC_BUG << "Failed to write flow_id";
+      return false;
+    }
+  } else {
+    QUIC_DVLOG(1) << "Compressing using unvalidated flow_id " << flow_id;
+    if (!writer.WriteVarInt62(kFlowId0)) {
+      QUIC_BUG << "Failed to write kFlowId0";
+      return false;
+    }
+    if (!writer.WriteVarInt62(flow_id)) {
+      QUIC_BUG << "Failed to write flow_id";
+      return false;
+    }
+    if (!writer.WriteLengthPrefixedConnectionId(client_connection_id)) {
+      QUIC_BUG << "Failed to write client_connection_id";
+      return false;
+    }
+    if (!writer.WriteLengthPrefixedConnectionId(server_connection_id)) {
+      QUIC_BUG << "Failed to write server_connection_id";
+      return false;
+    }
+    if (!writer.WriteUInt16(server_address.port())) {
+      QUIC_BUG << "Failed to write port";
+      return false;
+    }
+    QuicIpAddress peer_ip = server_address.host();
+    DCHECK(peer_ip.IsInitialized());
+    std::string peer_ip_bytes = peer_ip.ToPackedString();
+    DCHECK(!peer_ip_bytes.empty());
+    uint8_t address_id;
+    if (peer_ip.address_family() == IpAddressFamily::IP_V6) {
+      address_id = MasqueAddressFamilyIPv6;
+      if (peer_ip_bytes.length() != QuicIpAddress::kIPv6AddressSize) {
+        QUIC_BUG << "Bad IPv6 length " << server_address;
+        return false;
+      }
+    } else if (peer_ip.address_family() == IpAddressFamily::IP_V4) {
+      address_id = MasqueAddressFamilyIPv4;
+      if (peer_ip_bytes.length() != QuicIpAddress::kIPv4AddressSize) {
+        QUIC_BUG << "Bad IPv4 length " << server_address;
+        return false;
+      }
+    } else {
+      QUIC_BUG << "Unexpected server_address " << server_address;
+      return false;
+    }
+    if (!writer.WriteUInt8(address_id)) {
+      QUIC_BUG << "Failed to write address_id";
+      return false;
+    }
+    if (!writer.WriteStringPiece(peer_ip_bytes)) {
+      QUIC_BUG << "Failed to write IP address";
+      return false;
+    }
+  }
+  if (!writer.WriteUInt8(first_byte)) {
+    QUIC_BUG << "Failed to write first_byte";
+    return false;
+  }
+  if (long_header) {
+    QuicVersionLabel version_label;
+    if (!reader->ReadUInt32(&version_label)) {
+      QUIC_DLOG(ERROR) << "Failed to read version";
+      return false;
+    }
+    if (!writer.WriteUInt32(version_label)) {
+      QUIC_BUG << "Failed to write version";
+      return false;
+    }
+    QuicConnectionId packet_destination_connection_id,
+        packet_source_connection_id;
+    if (!reader->ReadLengthPrefixedConnectionId(
+            &packet_destination_connection_id) ||
+        !reader->ReadLengthPrefixedConnectionId(&packet_source_connection_id)) {
+      QUIC_DLOG(ERROR) << "Failed to parse long header connection IDs";
+      return false;
+    }
+    if (packet_destination_connection_id != destination_connection_id) {
+      QUIC_DLOG(ERROR) << "Long header packet's destination_connection_id "
+                       << packet_destination_connection_id
+                       << " does not match expected "
+                       << destination_connection_id;
+      return false;
+    }
+    if (packet_source_connection_id != source_connection_id) {
+      QUIC_DLOG(ERROR) << "Long header packet's source_connection_id "
+                       << packet_source_connection_id
+                       << " does not match expected " << source_connection_id;
+      return false;
+    }
+  } else {
+    QuicConnectionId packet_destination_connection_id;
+    if (!reader->ReadConnectionId(&packet_destination_connection_id,
+                                  destination_connection_id.length())) {
+      QUIC_DLOG(ERROR)
+          << "Failed to read short header packet's destination_connection_id";
+      return false;
+    }
+    if (packet_destination_connection_id != destination_connection_id) {
+      QUIC_DLOG(ERROR) << "Short header packet's destination_connection_id "
+                       << packet_destination_connection_id
+                       << " does not match expected "
+                       << destination_connection_id;
+      return false;
+    }
+  }
+  QuicStringPiece packet_payload = reader->ReadRemainingPayload();
+  if (!writer.WriteStringPiece(packet_payload)) {
+    QUIC_BUG << "Failed to write packet_payload";
+    return false;
+  }
+  return true;
+}
+
+void MasqueCompressionEngine::CompressAndSendPacket(
+    QuicStringPiece packet,
+    QuicConnectionId client_connection_id,
+    QuicConnectionId server_connection_id,
+    const QuicSocketAddress& server_address) {
+  QUIC_DVLOG(2) << "Compressing client " << client_connection_id << " server "
+                << server_connection_id << "\n"
+                << QuicTextUtils::HexDump(packet);
+  DCHECK(server_address.IsInitialized());
+  if (packet.empty()) {
+    QUIC_BUG << "Tried to send empty packet";
+    return;
+  }
+  QuicDataReader reader(packet.data(), packet.length());
+  uint8_t first_byte;
+  if (!reader.ReadUInt8(&first_byte)) {
+    QUIC_BUG << "Failed to read first_byte";
+    return;
+  }
+  const bool long_header = (first_byte & FLAGS_LONG_HEADER) != 0;
+  bool client_connection_id_present = true, server_connection_id_present = true;
+  QuicConnectionId destination_connection_id, source_connection_id;
+  if (masque_session_->perspective() == Perspective::IS_SERVER) {
+    destination_connection_id = client_connection_id;
+    source_connection_id = server_connection_id;
+    if (!long_header) {
+      server_connection_id_present = false;
+    }
+  } else {
+    destination_connection_id = server_connection_id;
+    source_connection_id = client_connection_id;
+    if (!long_header) {
+      client_connection_id_present = false;
+    }
+  }
+
+  bool validated = false;
+  QuicDatagramFlowId flow_id = FindOrCreateCompressionContext(
+      client_connection_id, server_connection_id, server_address,
+      client_connection_id_present, server_connection_id_present, &validated);
+
+  size_t slice_length = packet.length() - destination_connection_id.length();
+  if (long_header) {
+    slice_length -= sizeof(uint8_t) * 2 + source_connection_id.length();
+  }
+  if (validated) {
+    slice_length += QuicDataWriter::GetVarInt62Len(flow_id);
+  } else {
+    slice_length += QuicDataWriter::GetVarInt62Len(kFlowId0) +
+                    QuicDataWriter::GetVarInt62Len(flow_id) + sizeof(uint8_t) +
+                    client_connection_id.length() + sizeof(uint8_t) +
+                    server_connection_id.length() +
+                    sizeof(server_address.port()) + sizeof(uint8_t) +
+                    server_address.host().ToPackedString().length();
+  }
+  QuicMemSlice slice(
+      masque_session_->connection()->helper()->GetStreamSendBufferAllocator(),
+      slice_length);
+
+  if (!WriteCompressedPacketToSlice(client_connection_id, server_connection_id,
+                                    server_address, destination_connection_id,
+                                    source_connection_id, flow_id, validated,
+                                    first_byte, long_header, &reader, &slice)) {
+    return;
+  }
+
+  MessageResult message_result =
+      masque_session_->SendMessage(QuicMemSliceSpan(&slice));
+
+  QUIC_DVLOG(1) << "Sent packet compressed with flow ID " << flow_id
+                << " and got message result " << message_result;
+}
+
+bool MasqueCompressionEngine::ParseCompressionContext(
+    QuicDataReader* reader,
+    MasqueCompressionContext* context) {
+  QuicDatagramFlowId new_flow_id;
+  if (!reader->ReadVarInt62(&new_flow_id)) {
+    QUIC_DLOG(ERROR) << "Could not read new_flow_id";
+    return false;
+  }
+  QuicConnectionId new_client_connection_id;
+  if (!reader->ReadLengthPrefixedConnectionId(&new_client_connection_id)) {
+    QUIC_DLOG(ERROR) << "Could not read new_client_connection_id";
+    return false;
+  }
+  QuicConnectionId new_server_connection_id;
+  if (!reader->ReadLengthPrefixedConnectionId(&new_server_connection_id)) {
+    QUIC_DLOG(ERROR) << "Could not read new_server_connection_id";
+    return false;
+  }
+  uint16_t port;
+  if (!reader->ReadUInt16(&port)) {
+    QUIC_DLOG(ERROR) << "Could not read port";
+    return false;
+  }
+  uint8_t address_id;
+  if (!reader->ReadUInt8(&address_id)) {
+    QUIC_DLOG(ERROR) << "Could not read address_id";
+    return false;
+  }
+  size_t ip_bytes_length;
+  if (address_id == MasqueAddressFamilyIPv6) {
+    ip_bytes_length = QuicIpAddress::kIPv6AddressSize;
+  } else if (address_id == MasqueAddressFamilyIPv4) {
+    ip_bytes_length = QuicIpAddress::kIPv4AddressSize;
+  } else {
+    QUIC_DLOG(ERROR) << "Unknown address_id " << static_cast<int>(address_id);
+    return false;
+  }
+  char ip_bytes[QuicIpAddress::kMaxAddressSize];
+  if (!reader->ReadBytes(ip_bytes, ip_bytes_length)) {
+    QUIC_DLOG(ERROR) << "Could not read IP address";
+    return false;
+  }
+  QuicIpAddress ip_address;
+  ip_address.FromPackedString(ip_bytes, ip_bytes_length);
+  if (!ip_address.IsInitialized()) {
+    QUIC_BUG << "Failed to parse IP address";
+    return false;
+  }
+  QuicSocketAddress new_server_address = QuicSocketAddress(ip_address, port);
+  auto context_pair = contexts_.find(new_flow_id);
+  if (context_pair == contexts_.end()) {
+    context->client_connection_id = new_client_connection_id;
+    context->server_connection_id = new_server_connection_id;
+    context->server_address = new_server_address;
+    context->validated = true;
+    contexts_[new_flow_id] = *context;
+    QUIC_DVLOG(1) << "Registered new flow_id " << new_flow_id << " to "
+                  << new_server_address << " client "
+                  << new_client_connection_id << " server "
+                  << new_server_connection_id;
+  } else {
+    *context = context_pair->second;
+    if (context->client_connection_id != new_client_connection_id) {
+      QUIC_LOG(ERROR)
+          << "Received incorrect context registration for existing flow_id "
+          << new_flow_id << " mismatched client "
+          << context->client_connection_id << " " << new_client_connection_id;
+      return false;
+    }
+    if (context->server_connection_id != new_server_connection_id) {
+      QUIC_LOG(ERROR)
+          << "Received incorrect context registration for existing flow_id "
+          << new_flow_id << " mismatched server "
+          << context->server_connection_id << " " << new_server_connection_id;
+      return false;
+    }
+    if (context->server_address != new_server_address) {
+      QUIC_LOG(ERROR)
+          << "Received incorrect context registration for existing flow_id "
+          << new_flow_id << " mismatched server " << context->server_address
+          << " " << new_server_address;
+      return false;
+    }
+    if (!context->validated) {
+      context->validated = true;
+      contexts_[new_flow_id] = *context;
+      QUIC_DLOG(INFO) << "Successfully validated remotely-unvalidated flow_id "
+                      << new_flow_id << " to " << new_server_address
+                      << " client " << new_client_connection_id << " server "
+                      << new_server_connection_id;
+    } else {
+      QUIC_DVLOG(1) << "Decompressing using incoming locally-validated "
+                       "remotely-unvalidated flow_id "
+                    << new_flow_id << " to " << new_server_address << " client "
+                    << new_client_connection_id << " server "
+                    << new_server_connection_id;
+    }
+  }
+  return true;
+}
+
+bool MasqueCompressionEngine::WriteDecompressedPacket(
+    QuicDataReader* reader,
+    const MasqueCompressionContext& context,
+    std::string* packet,
+    bool* version_present) {
+  QuicConnectionId destination_connection_id, source_connection_id;
+  if (masque_session_->perspective() == Perspective::IS_SERVER) {
+    destination_connection_id = context.server_connection_id;
+    source_connection_id = context.client_connection_id;
+  } else {
+    destination_connection_id = context.client_connection_id;
+    source_connection_id = context.server_connection_id;
+  }
+
+  size_t packet_length =
+      reader->BytesRemaining() + destination_connection_id.length();
+  uint8_t first_byte;
+  if (!reader->ReadUInt8(&first_byte)) {
+    QUIC_DLOG(ERROR) << "Failed to read first_byte";
+    return false;
+  }
+  *version_present = (first_byte & FLAGS_LONG_HEADER) != 0;
+  if (*version_present) {
+    packet_length += sizeof(uint8_t) * 2 + source_connection_id.length();
+  }
+  *packet = std::string(packet_length, 0);
+  QuicDataWriter writer(packet->length(), packet->data());
+  if (!writer.WriteUInt8(first_byte)) {
+    QUIC_BUG << "Failed to write first_byte";
+    return false;
+  }
+  if (*version_present) {
+    QuicVersionLabel version_label;
+    if (!reader->ReadUInt32(&version_label)) {
+      QUIC_DLOG(ERROR) << "Failed to read version";
+      return false;
+    }
+    if (!writer.WriteUInt32(version_label)) {
+      QUIC_BUG << "Failed to write version";
+      return false;
+    }
+    if (!writer.WriteLengthPrefixedConnectionId(destination_connection_id)) {
+      QUIC_BUG << "Failed to write long header destination_connection_id";
+      return false;
+    }
+    if (!writer.WriteLengthPrefixedConnectionId(source_connection_id)) {
+      QUIC_BUG << "Failed to write long header source_connection_id";
+      return false;
+    }
+  } else {
+    if (!writer.WriteConnectionId(destination_connection_id)) {
+      QUIC_BUG << "Failed to write short header destination_connection_id";
+      return false;
+    }
+  }
+  QuicStringPiece payload = reader->ReadRemainingPayload();
+  if (!writer.WriteStringPiece(payload)) {
+    QUIC_BUG << "Failed to write payload";
+    return false;
+  }
+  return true;
+}
+
+bool MasqueCompressionEngine::DecompressDatagram(
+    QuicStringPiece datagram,
+    QuicConnectionId* client_connection_id,
+    QuicConnectionId* server_connection_id,
+    QuicSocketAddress* server_address,
+    std::string* packet,
+    bool* version_present) {
+  QUIC_DVLOG(1) << "Decompressing DATAGRAM frame of length "
+                << datagram.length();
+  QuicDataReader reader(datagram);
+  QuicDatagramFlowId flow_id;
+  if (!reader.ReadVarInt62(&flow_id)) {
+    QUIC_DLOG(ERROR) << "Could not read flow_id";
+    return false;
+  }
+  MasqueCompressionContext context;
+  if (flow_id == kFlowId0) {
+    if (!ParseCompressionContext(&reader, &context)) {
+      return false;
+    }
+  } else {
+    auto context_pair = contexts_.find(flow_id);
+    if (context_pair == contexts_.end()) {
+      QUIC_DLOG(ERROR) << "Received unknown flow_id " << flow_id;
+      return false;
+    }
+    context = context_pair->second;
+
+    if (!context.validated) {
+      context.validated = true;
+      contexts_[flow_id] = context;
+      QUIC_DLOG(INFO) << "Successfully validated remotely-validated flow_id "
+                      << flow_id << " to " << context.server_address
+                      << " client " << context.client_connection_id
+                      << " server " << context.server_connection_id;
+    } else {
+      QUIC_DVLOG(1) << "Decompressing using incoming locally-validated "
+                       "remotely-validated flow_id "
+                    << flow_id << " to " << context.server_address << " client "
+                    << context.client_connection_id << " server "
+                    << context.server_connection_id;
+    }
+  }
+
+  if (!WriteDecompressedPacket(&reader, context, packet, version_present)) {
+    return false;
+  }
+
+  *server_address = context.server_address;
+  *client_connection_id = context.client_connection_id;
+  *server_connection_id = context.server_connection_id;
+
+  QUIC_DVLOG(2) << "Decompressed client " << context.client_connection_id
+                << " server " << context.server_connection_id << "\n"
+                << QuicTextUtils::HexDump(*packet);
+
+  return true;
+}
+
+QuicDatagramFlowId MasqueCompressionEngine::GetNextFlowId() {
+  const QuicDatagramFlowId next_flow_id = next_flow_id_;
+  next_flow_id_ += 2;
+  return next_flow_id;
+}
+
+void MasqueCompressionEngine::UnregisterClientConnectionId(
+    QuicConnectionId client_connection_id) {
+  std::vector<QuicDatagramFlowId> flow_ids_to_remove;
+  for (const auto& kv : contexts_) {
+    const MasqueCompressionContext& context = kv.second;
+    if (context.client_connection_id == client_connection_id) {
+      flow_ids_to_remove.push_back(kv.first);
+    }
+  }
+  for (QuicDatagramFlowId flow_id : flow_ids_to_remove) {
+    contexts_.erase(flow_id);
+  }
+}
+
+}  // namespace quic
diff --git a/quic/masque/masque_compression_engine.h b/quic/masque/masque_compression_engine.h
new file mode 100644
index 0000000..09c49a6
--- /dev/null
+++ b/quic/masque/masque_compression_engine.h
@@ -0,0 +1,126 @@
+// Copyright 2019 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_QUIC_MASQUE_MASQUE_PROTOCOL_H_
+#define QUICHE_QUIC_MASQUE_MASQUE_PROTOCOL_H_
+
+#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
+#include "net/third_party/quiche/src/quic/core/quic_session.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+
+namespace quic {
+
+// MASQUE compression engine used by client and servers.
+// This class allows converting QUIC packets into a compressed form suitable
+// for sending over QUIC DATAGRAM frames. It leverages a flow identifier at the
+// start of each datagram to indicate which compression context was used to
+// compress this packet, or to create new compression contexts.
+// Compression contexts contain client and server connection IDs and the
+// server's IP and port. This allows compressing that information in most
+// packets without requiring access to the cryptographic keys of the end-to-end
+// encapsulated session. When the flow identifier is 0, the DATAGRAM contains
+// all the contents of the compression context. When the flow identifier is
+// non-zero, those fields are removed so the encapsulated QUIC packet is
+// transmitted without connection IDs and reassembled by the peer on
+// decompression. This only needs to contain the HTTP server's IP address since
+// the client's IP address is not visible to the HTTP server.
+
+class QUIC_NO_EXPORT MasqueCompressionEngine {
+ public:
+  // Caller must ensure that |masque_session| has a lifetime longer than the
+  // newly constructed MasqueCompressionEngine.
+  explicit MasqueCompressionEngine(QuicSession* masque_session);
+
+  // Disallow copy and assign.
+  MasqueCompressionEngine(const MasqueCompressionEngine&) = delete;
+  MasqueCompressionEngine& operator=(const MasqueCompressionEngine&) = delete;
+
+  // Compresses packet and sends it in a DATAGRAM frame over a MASQUE session.
+  // When used from MASQUE client to MASQUE server, the MASQUE server will then
+  // send the packet to the provided |server_address|.
+  // When used from MASQUE server to MASQUE client, the MASQUE client will then
+  // hand off the uncompressed packet to an encapsulated session that will treat
+  // it as having come from the provided |server_address|.
+  // The connection IDs are the one used by the encapsulated |packet|.
+  void CompressAndSendPacket(QuicStringPiece packet,
+                             QuicConnectionId client_connection_id,
+                             QuicConnectionId server_connection_id,
+                             const QuicSocketAddress& server_address);
+
+  // Decompresses received DATAGRAM frame contents from |datagram| and places
+  // them in |packet|. Reverses the transformation from CompressAndSendPacket.
+  // The connection IDs are the one used by the encapsulated |packet|.
+  // |server_address| will be filled with the |server_address| passed to
+  // CompressAndSendPacket. |version_present| will contain whether the
+  // encapsulated |packet| contains a Version field.
+  bool DecompressDatagram(QuicStringPiece datagram,
+                          QuicConnectionId* client_connection_id,
+                          QuicConnectionId* server_connection_id,
+                          QuicSocketAddress* server_address,
+                          std::string* packet,
+                          bool* version_present);
+
+  // Clears all entries referencing |client_connection_id| from the
+  // compression table.
+  void UnregisterClientConnectionId(QuicConnectionId client_connection_id);
+
+ private:
+  struct QUIC_NO_EXPORT MasqueCompressionContext {
+    QuicConnectionId client_connection_id;
+    QuicConnectionId server_connection_id;
+    QuicSocketAddress server_address;
+    bool validated = false;
+  };
+
+  // Generates a new datagram flow ID.
+  QuicDatagramFlowId GetNextFlowId();
+
+  // Finds or creates a new compression context to use during compression.
+  // |client_connection_id_present| and |server_connection_id_present| indicate
+  // whether the corresponding connection ID is present in the current packet.
+  // |validated| will contain whether the compression context that matches
+  // these arguments is currently validated or not.
+  QuicDatagramFlowId FindOrCreateCompressionContext(
+      QuicConnectionId client_connection_id,
+      QuicConnectionId server_connection_id,
+      const QuicSocketAddress& server_address,
+      bool client_connection_id_present,
+      bool server_connection_id_present,
+      bool* validated);
+
+  // Writes compressed packet to |slice| during compression.
+  bool WriteCompressedPacketToSlice(QuicConnectionId client_connection_id,
+                                    QuicConnectionId server_connection_id,
+                                    const QuicSocketAddress& server_address,
+                                    QuicConnectionId destination_connection_id,
+                                    QuicConnectionId source_connection_id,
+                                    QuicDatagramFlowId flow_id,
+                                    bool validated,
+                                    uint8_t first_byte,
+                                    bool long_header,
+                                    QuicDataReader* reader,
+                                    QuicMemSlice* slice);
+
+  // Parses compression context from flow ID 0 during decompression.
+  bool ParseCompressionContext(QuicDataReader* reader,
+                               MasqueCompressionContext* context);
+
+  // Writes decompressed packet to |packet| during decompression.
+  bool WriteDecompressedPacket(QuicDataReader* reader,
+                               const MasqueCompressionContext& context,
+                               std::string* packet,
+                               bool* version_present);
+
+  QuicSession* masque_session_;  // Unowned.
+  QuicUnorderedMap<QuicDatagramFlowId, MasqueCompressionContext> contexts_;
+  QuicDatagramFlowId next_flow_id_;
+};
+
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_MASQUE_MASQUE_PROTOCOL_H_
diff --git a/quic/masque/masque_utils.cc b/quic/masque/masque_utils.cc
new file mode 100644
index 0000000..6ef88ae
--- /dev/null
+++ b/quic/masque/masque_utils.cc
@@ -0,0 +1,22 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/third_party/quiche/src/quic/masque/masque_utils.h"
+
+namespace quic {
+
+ParsedQuicVersionVector MasqueSupportedVersions() {
+  QuicVersionInitializeSupportForIetfDraft();
+  ParsedQuicVersion version(PROTOCOL_TLS1_3, QUIC_VERSION_99);
+  QuicEnableVersion(version);
+  return {version};
+}
+
+QuicConfig MasqueEncapsulatedConfig() {
+  QuicConfig config;
+  config.SetMaxPacketSizeToSend(kMasqueMaxEncapsulatedPacketSize);
+  return config;
+}
+
+}  // namespace quic
diff --git a/quic/masque/masque_utils.h b/quic/masque/masque_utils.h
new file mode 100644
index 0000000..d8f9d0f
--- /dev/null
+++ b/quic/masque/masque_utils.h
@@ -0,0 +1,25 @@
+// Copyright 2019 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_QUIC_MASQUE_MASQUE_UTILS_H_
+#define QUICHE_QUIC_MASQUE_MASQUE_UTILS_H_
+
+#include "net/third_party/quiche/src/quic/core/quic_config.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
+
+namespace quic {
+
+// List of QUIC versions that support MASQUE. Currently restricted to IETF QUIC.
+QUIC_NO_EXPORT ParsedQuicVersionVector MasqueSupportedVersions();
+
+// Default QuicConfig for use with MASQUE. Sets a custom max_packet_size.
+QUIC_NO_EXPORT QuicConfig MasqueEncapsulatedConfig();
+
+// Maximum packet size for encapsulated connections.
+const QuicByteCount kMasqueMaxEncapsulatedPacketSize = 1300;
+
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_MASQUE_MASQUE_UTILS_H_