diff --git a/quiche/quic/masque/masque_client_bin.cc b/quiche/quic/masque/masque_client_bin.cc
index 8fd5e52..f973227 100644
--- a/quiche/quic/masque/masque_client_bin.cc
+++ b/quiche/quic/masque/masque_client_bin.cc
@@ -29,9 +29,9 @@
     bool, disable_certificate_verification, false,
     "If true, don't verify the server certificate.");
 
-DEFINE_QUICHE_COMMAND_LINE_FLAG(std::string, masque_mode, "",
-                                "Allows setting MASQUE mode, valid values are "
-                                "open and legacy. Defaults to open.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, masque_mode, "",
+    "Allows setting MASQUE mode, currently only valid value is \"open\".");
 
 namespace quic {
 
@@ -83,9 +83,7 @@
   }
   MasqueMode masque_mode = MasqueMode::kOpen;
   std::string mode_string = GetQuicFlag(FLAGS_masque_mode);
-  if (mode_string == "legacy") {
-    masque_mode = MasqueMode::kLegacy;
-  } else if (!mode_string.empty() && mode_string != "open") {
+  if (!mode_string.empty() && mode_string != "open") {
     std::cerr << "Invalid masque_mode \"" << mode_string << "\"" << std::endl;
     return 1;
   }
diff --git a/quiche/quic/masque/masque_client_session.cc b/quiche/quic/masque/masque_client_session.cc
index 9a69dad..b053659 100644
--- a/quiche/quic/masque/masque_client_session.cc
+++ b/quiche/quic/masque/masque_client_session.cc
@@ -30,42 +30,7 @@
                             crypto_config, push_promise_index),
       masque_mode_(masque_mode),
       uri_template_(uri_template),
-      owner_(owner),
-      compression_engine_(this) {}
-
-void MasqueClientSession::OnMessageReceived(absl::string_view message) {
-  if (masque_mode_ == MasqueMode::kLegacy) {
-    QUIC_DVLOG(1) << "Received DATAGRAM frame of length " << message.length();
-    QuicConnectionId client_connection_id, server_connection_id;
-    QuicSocketAddress target_server_address;
-    std::vector<char> packet;
-    bool version_present;
-    if (!compression_engine_.DecompressDatagram(
-            message, &client_connection_id, &server_connection_id,
-            &target_server_address, &packet, &version_present)) {
-      return;
-    }
-
-    auto connection_id_registration =
-        client_connection_id_registrations_.find(client_connection_id);
-    if (connection_id_registration ==
-        client_connection_id_registrations_.end()) {
-      QUIC_DLOG(ERROR) << "MasqueClientSession failed to dispatch "
-                       << client_connection_id;
-      return;
-    }
-    EncapsulatedClientSession* encapsulated_client_session =
-        connection_id_registration->second;
-    encapsulated_client_session->ProcessPacket(
-        absl::string_view(packet.data(), packet.size()), target_server_address);
-
-    QUIC_DVLOG(1) << "Sent " << packet.size() << " bytes to connection for "
-                  << client_connection_id;
-    return;
-  }
-  QUICHE_DCHECK_EQ(masque_mode_, MasqueMode::kOpen);
-  QuicSpdySession::OnMessageReceived(message);
-}
+      owner_(owner) {}
 
 void MasqueClientSession::OnMessageAcked(QuicMessageId message_id,
                                          QuicTime /*receive_timestamp*/) {
@@ -174,16 +139,8 @@
 }
 
 void MasqueClientSession::SendPacket(
-    QuicConnectionId client_connection_id,
-    QuicConnectionId server_connection_id, absl::string_view packet,
-    const QuicSocketAddress& target_server_address,
+    absl::string_view packet, const QuicSocketAddress& target_server_address,
     EncapsulatedClientSession* encapsulated_client_session) {
-  if (masque_mode_ == MasqueMode::kLegacy) {
-    compression_engine_.CompressAndSendPacket(packet, client_connection_id,
-                                              server_connection_id,
-                                              target_server_address);
-    return;
-  }
   const ConnectUdpClientState* connect_udp = GetOrCreateConnectUdpClientState(
       target_server_address, encapsulated_client_session);
   if (connect_udp == nullptr) {
@@ -200,34 +157,8 @@
                 << MessageStatusToString(message_status);
 }
 
-void MasqueClientSession::RegisterConnectionId(
-    QuicConnectionId client_connection_id,
+void MasqueClientSession::CloseConnectUdpStream(
     EncapsulatedClientSession* encapsulated_client_session) {
-  QUIC_DLOG(INFO) << "Registering " << client_connection_id
-                  << " to encapsulated client";
-  QUICHE_DCHECK(
-      client_connection_id_registrations_.find(client_connection_id) ==
-          client_connection_id_registrations_.end() ||
-      client_connection_id_registrations_[client_connection_id] ==
-          encapsulated_client_session);
-  client_connection_id_registrations_[client_connection_id] =
-      encapsulated_client_session;
-}
-
-void MasqueClientSession::UnregisterConnectionId(
-    QuicConnectionId client_connection_id,
-    EncapsulatedClientSession* encapsulated_client_session) {
-  QUIC_DLOG(INFO) << "Unregistering " << client_connection_id;
-  if (masque_mode_ == MasqueMode::kLegacy) {
-    if (client_connection_id_registrations_.find(client_connection_id) !=
-        client_connection_id_registrations_.end()) {
-      client_connection_id_registrations_.erase(client_connection_id);
-      owner_->UnregisterClientConnectionId(client_connection_id);
-      compression_engine_.UnregisterClientConnectionId(client_connection_id);
-    }
-    return;
-  }
-
   for (auto it = connect_udp_client_states_.begin();
        it != connect_udp_client_states_.end();) {
     if (it->encapsulated_client_session() == encapsulated_client_session) {
diff --git a/quiche/quic/masque/masque_client_session.h b/quiche/quic/masque/masque_client_session.h
index 6e469b2..05162b5 100644
--- a/quiche/quic/masque/masque_client_session.h
+++ b/quiche/quic/masque/masque_client_session.h
@@ -10,7 +10,6 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/http/quic_spdy_client_session.h"
-#include "quiche/quic/masque/masque_compression_engine.h"
 #include "quiche/quic/masque/masque_utils.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
@@ -30,10 +29,6 @@
    public:
     virtual ~Owner() {}
 
-    // Notifies the owner that the client connection ID is no longer in use.
-    virtual void UnregisterClientConnectionId(
-        QuicConnectionId client_connection_id) = 0;
-
     // Notifies the owner that a settings frame has been received.
     virtual void OnSettingsReceived() = 0;
   };
@@ -70,7 +65,6 @@
   MasqueClientSession& operator=(const MasqueClientSession&) = delete;
 
   // From QuicSession.
-  void OnMessageReceived(absl::string_view message) override;
   void OnMessageAcked(QuicMessageId message_id,
                       QuicTime receive_timestamp) override;
   void OnMessageLost(QuicMessageId message_id) override;
@@ -82,26 +76,12 @@
   bool OnSettingsFrame(const SettingsFrame& frame) override;
 
   // Send encapsulated packet.
-  void SendPacket(QuicConnectionId client_connection_id,
-                  QuicConnectionId server_connection_id,
-                  absl::string_view packet,
+  void SendPacket(absl::string_view packet,
                   const QuicSocketAddress& target_server_address,
                   EncapsulatedClientSession* encapsulated_client_session);
 
-  // Register encapsulated client. This allows clients that are encapsulated
-  // within this MASQUE session to indicate they own a given client connection
-  // ID so incoming packets with that connection ID are routed back to them.
-  // Callers must not register a second different |encapsulated_client_session|
-  // with the same |client_connection_id|. Every call must be matched with a
-  // call to UnregisterConnectionId.
-  void RegisterConnectionId(
-      QuicConnectionId client_connection_id,
-      EncapsulatedClientSession* encapsulated_client_session);
-
-  // Unregister encapsulated client. |client_connection_id| must match a
-  // value previously passed to RegisterConnectionId.
-  void UnregisterConnectionId(
-      QuicConnectionId client_connection_id,
+  // Close CONNECT-UDP stream tied to this encapsulated client session.
+  void CloseConnectUdpStream(
       EncapsulatedClientSession* encapsulated_client_session);
 
  private:
@@ -155,11 +135,7 @@
   MasqueMode masque_mode_;
   std::string uri_template_;
   std::list<ConnectUdpClientState> connect_udp_client_states_;
-  absl::flat_hash_map<QuicConnectionId, EncapsulatedClientSession*,
-                      QuicConnectionIdHash>
-      client_connection_id_registrations_;
   Owner* owner_;  // Unowned;
-  MasqueCompressionEngine compression_engine_;
 };
 
 }  // namespace quic
diff --git a/quiche/quic/masque/masque_compression_engine.cc b/quiche/quic/masque/masque_compression_engine.cc
deleted file mode 100644
index 3d05740..0000000
--- a/quiche/quic/masque/masque_compression_engine.cc
+++ /dev/null
@@ -1,526 +0,0 @@
-// 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 "quiche/quic/masque/masque_compression_engine.h"
-
-#include <cstdint>
-
-#include "absl/strings/string_view.h"
-#include "quiche/quic/core/quic_data_reader.h"
-#include "quiche/quic/core/quic_data_writer.h"
-#include "quiche/quic/core/quic_framer.h"
-#include "quiche/quic/core/quic_session.h"
-#include "quiche/quic/core/quic_types.h"
-#include "quiche/quic/core/quic_versions.h"
-#include "quiche/quic/platform/api/quic_containers.h"
-#include "quiche/common/platform/api/quiche_mem_slice.h"
-#include "quiche/common/quiche_buffer_allocator.h"
-#include "quiche/common/quiche_text_utils.h"
-
-namespace quic {
-
-namespace {
-// |kFlowId0| is used to indicate creation of a new compression context.
-const QuicDatagramStreamId kFlowId0 = 0;
-
-enum MasqueAddressFamily : uint8_t {
-  MasqueAddressFamilyIPv4 = 4,
-  MasqueAddressFamilyIPv6 = 6,
-};
-
-}  // namespace
-
-MasqueCompressionEngine::MasqueCompressionEngine(
-    QuicSpdySession* masque_session)
-    : masque_session_(masque_session),
-      next_available_flow_id_(
-          masque_session_->perspective() == Perspective::IS_CLIENT ? 0 : 1) {}
-
-QuicDatagramStreamId 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) {
-  QuicDatagramStreamId 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;
-    QUICHE_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.
-  next_available_flow_id_ += 2;
-  flow_id = next_available_flow_id_;
-  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, QuicDatagramStreamId flow_id,
-    bool validated, uint8_t first_byte, bool long_header,
-    QuicDataReader* reader, QuicDataWriter* writer) {
-  if (validated) {
-    QUIC_DVLOG(1) << "Compressing using validated flow_id " << flow_id;
-    if (!writer->WriteVarInt62(flow_id)) {
-      QUIC_BUG(quic_bug_10981_1) << "Failed to write flow_id";
-      return false;
-    }
-  } else {
-    QUIC_DVLOG(1) << "Compressing using unvalidated flow_id " << flow_id;
-    if (!writer->WriteVarInt62(kFlowId0)) {
-      QUIC_BUG(quic_bug_10981_2) << "Failed to write kFlowId0";
-      return false;
-    }
-    if (!writer->WriteVarInt62(flow_id)) {
-      QUIC_BUG(quic_bug_10981_3) << "Failed to write flow_id";
-      return false;
-    }
-    if (!writer->WriteLengthPrefixedConnectionId(client_connection_id)) {
-      QUIC_BUG(quic_bug_10981_4) << "Failed to write client_connection_id";
-      return false;
-    }
-    if (!writer->WriteLengthPrefixedConnectionId(server_connection_id)) {
-      QUIC_BUG(quic_bug_10981_5) << "Failed to write server_connection_id";
-      return false;
-    }
-    if (!writer->WriteUInt16(server_address.port())) {
-      QUIC_BUG(quic_bug_10981_6) << "Failed to write port";
-      return false;
-    }
-    QuicIpAddress peer_ip = server_address.host();
-    QUICHE_DCHECK(peer_ip.IsInitialized());
-    std::string peer_ip_bytes = peer_ip.ToPackedString();
-    QUICHE_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(quic_bug_10981_7) << "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(quic_bug_10981_8) << "Bad IPv4 length " << server_address;
-        return false;
-      }
-    } else {
-      QUIC_BUG(quic_bug_10981_9)
-          << "Unexpected server_address " << server_address;
-      return false;
-    }
-    if (!writer->WriteUInt8(address_id)) {
-      QUIC_BUG(quic_bug_10981_10) << "Failed to write address_id";
-      return false;
-    }
-    if (!writer->WriteStringPiece(peer_ip_bytes)) {
-      QUIC_BUG(quic_bug_10981_11) << "Failed to write IP address";
-      return false;
-    }
-  }
-  if (!writer->WriteUInt8(first_byte)) {
-    QUIC_BUG(quic_bug_10981_12) << "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(quic_bug_10981_13) << "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;
-    }
-  }
-  absl::string_view packet_payload = reader->ReadRemainingPayload();
-  if (!writer->WriteStringPiece(packet_payload)) {
-    QUIC_BUG(quic_bug_10981_14) << "Failed to write packet_payload";
-    return false;
-  }
-  return true;
-}
-
-void MasqueCompressionEngine::CompressAndSendPacket(
-    absl::string_view 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"
-                << quiche::QuicheTextUtils::HexDump(packet);
-  QUICHE_DCHECK(server_address.IsInitialized());
-  if (packet.empty()) {
-    QUIC_BUG(quic_bug_10981_15) << "Tried to send empty packet";
-    return;
-  }
-  QuicDataReader reader(packet.data(), packet.length());
-  uint8_t first_byte;
-  if (!reader.ReadUInt8(&first_byte)) {
-    QUIC_BUG(quic_bug_10981_16) << "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;
-  QuicDatagramStreamId 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();
-  }
-  quiche::QuicheBuffer buffer(
-      masque_session_->connection()->helper()->GetStreamSendBufferAllocator(),
-      slice_length);
-  QuicDataWriter writer(buffer.size(), buffer.data());
-
-  if (!WriteCompressedPacketToSlice(
-          client_connection_id, server_connection_id, server_address,
-          destination_connection_id, source_connection_id, flow_id, validated,
-          first_byte, long_header, &reader, &writer)) {
-    return;
-  }
-
-  MessageResult message_result =
-      masque_session_->SendMessage(quiche::QuicheMemSlice(std::move(buffer)));
-
-  QUIC_DVLOG(1) << "Sent packet compressed with flow ID " << flow_id
-                << " and got message result " << message_result;
-}
-
-bool MasqueCompressionEngine::ParseCompressionContext(
-    QuicDataReader* reader, MasqueCompressionContext* context) {
-  QuicDatagramStreamId 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(quic_bug_10981_17) << "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::vector<char>* 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::vector<char>(packet_length);
-  QuicDataWriter writer(packet->size(), packet->data());
-  if (!writer.WriteUInt8(first_byte)) {
-    QUIC_BUG(quic_bug_10981_18) << "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(quic_bug_10981_19) << "Failed to write version";
-      return false;
-    }
-    if (!writer.WriteLengthPrefixedConnectionId(destination_connection_id)) {
-      QUIC_BUG(quic_bug_10981_20)
-          << "Failed to write long header destination_connection_id";
-      return false;
-    }
-    if (!writer.WriteLengthPrefixedConnectionId(source_connection_id)) {
-      QUIC_BUG(quic_bug_10981_21)
-          << "Failed to write long header source_connection_id";
-      return false;
-    }
-  } else {
-    if (!writer.WriteConnectionId(destination_connection_id)) {
-      QUIC_BUG(quic_bug_10981_22)
-          << "Failed to write short header destination_connection_id";
-      return false;
-    }
-  }
-  absl::string_view payload = reader->ReadRemainingPayload();
-  if (!writer.WriteStringPiece(payload)) {
-    QUIC_BUG(quic_bug_10981_23) << "Failed to write payload";
-    return false;
-  }
-  return true;
-}
-
-bool MasqueCompressionEngine::DecompressDatagram(
-    absl::string_view datagram, QuicConnectionId* client_connection_id,
-    QuicConnectionId* server_connection_id, QuicSocketAddress* server_address,
-    std::vector<char>* packet, bool* version_present) {
-  QUIC_DVLOG(1) << "Decompressing DATAGRAM frame of length "
-                << datagram.length();
-  QuicDataReader reader(datagram);
-  QuicDatagramStreamId 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"
-                << quiche::QuicheTextUtils::HexDump(
-                       absl::string_view(packet->data(), packet->size()));
-
-  return true;
-}
-
-void MasqueCompressionEngine::UnregisterClientConnectionId(
-    QuicConnectionId client_connection_id) {
-  std::vector<QuicDatagramStreamId> 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 (QuicDatagramStreamId flow_id : flow_ids_to_remove) {
-    contexts_.erase(flow_id);
-  }
-}
-
-}  // namespace quic
diff --git a/quiche/quic/masque/masque_compression_engine.h b/quiche/quic/masque/masque_compression_engine.h
deleted file mode 100644
index 8c09de2..0000000
--- a/quiche/quic/masque/masque_compression_engine.h
+++ /dev/null
@@ -1,120 +0,0 @@
-// 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_COMPRESSION_ENGINE_H_
-#define QUICHE_QUIC_MASQUE_MASQUE_COMPRESSION_ENGINE_H_
-
-#include "absl/container/flat_hash_map.h"
-#include "absl/strings/string_view.h"
-#include "quiche/quic/core/http/quic_spdy_session.h"
-#include "quiche/quic/core/quic_connection_id.h"
-#include "quiche/quic/core/quic_types.h"
-#include "quiche/quic/platform/api/quic_containers.h"
-#include "quiche/quic/platform/api/quic_export.h"
-#include "quiche/quic/platform/api/quic_socket_address.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(QuicSpdySession* 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(absl::string_view 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(absl::string_view datagram,
-                          QuicConnectionId* client_connection_id,
-                          QuicConnectionId* server_connection_id,
-                          QuicSocketAddress* server_address,
-                          std::vector<char>* 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;
-  };
-
-  // 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.
-  QuicDatagramStreamId 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,
-                                    QuicDatagramStreamId flow_id,
-                                    bool validated, uint8_t first_byte,
-                                    bool long_header, QuicDataReader* reader,
-                                    QuicDataWriter* writer);
-
-  // 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::vector<char>* packet,
-                               bool* version_present);
-
-  QuicSpdySession* masque_session_;  // Unowned.
-  absl::flat_hash_map<QuicDatagramStreamId, MasqueCompressionContext> contexts_;
-  QuicDatagramStreamId next_available_flow_id_;
-};
-
-}  // namespace quic
-
-#endif  // QUICHE_QUIC_MASQUE_MASQUE_COMPRESSION_ENGINE_H_
diff --git a/quiche/quic/masque/masque_dispatcher.cc b/quiche/quic/masque/masque_dispatcher.cc
index 6db6f8c..d0440a6 100644
--- a/quiche/quic/masque/masque_dispatcher.cc
+++ b/quiche/quic/masque/masque_dispatcher.cc
@@ -38,50 +38,11 @@
                          ParsedQuicVersionVector{version});
 
   auto session = std::make_unique<MasqueServerSession>(
-      masque_mode_, config(), GetSupportedVersions(), connection, this, this,
+      masque_mode_, config(), GetSupportedVersions(), connection, this,
       epoll_server_, session_helper(), crypto_config(),
       compressed_certs_cache(), masque_server_backend_);
   session->Initialize();
   return session;
 }
 
-bool MasqueDispatcher::OnFailedToDispatchPacket(
-    const ReceivedPacketInfo& packet_info) {
-  auto connection_id_registration = client_connection_id_registrations_.find(
-      packet_info.destination_connection_id);
-  if (connection_id_registration == client_connection_id_registrations_.end()) {
-    QUIC_DLOG(INFO) << "MasqueDispatcher failed to dispatch " << packet_info;
-    return false;
-  }
-  MasqueServerSession* masque_server_session =
-      connection_id_registration->second;
-  masque_server_session->HandlePacketFromServer(packet_info);
-  return true;
-}
-
-void MasqueDispatcher::RegisterClientConnectionId(
-    QuicConnectionId client_connection_id,
-    MasqueServerSession* masque_server_session) {
-  QUIC_DLOG(INFO) << "Registering encapsulated " << client_connection_id
-                  << " to MASQUE session "
-                  << masque_server_session->connection_id();
-
-  // Make sure we don't try to overwrite an existing registration with a
-  // different session.
-  QUIC_BUG_IF(quic_bug_12013_1,
-              client_connection_id_registrations_.find(client_connection_id) !=
-                      client_connection_id_registrations_.end() &&
-                  client_connection_id_registrations_[client_connection_id] !=
-                      masque_server_session)
-      << "Overwriting existing registration for " << client_connection_id;
-  client_connection_id_registrations_[client_connection_id] =
-      masque_server_session;
-}
-
-void MasqueDispatcher::UnregisterClientConnectionId(
-    QuicConnectionId client_connection_id) {
-  QUIC_DLOG(INFO) << "Unregistering " << client_connection_id;
-  client_connection_id_registrations_.erase(client_connection_id);
-}
-
 }  // namespace quic
diff --git a/quiche/quic/masque/masque_dispatcher.h b/quiche/quic/masque/masque_dispatcher.h
index 90d319c..b5ef5bb 100644
--- a/quiche/quic/masque/masque_dispatcher.h
+++ b/quiche/quic/masque/masque_dispatcher.h
@@ -17,8 +17,7 @@
 
 // QUIC dispatcher that handles new MASQUE connections and can proxy traffic
 // between MASQUE clients and QUIC servers.
-class QUIC_NO_EXPORT MasqueDispatcher : public QuicSimpleDispatcher,
-                                        public MasqueServerSession::Visitor {
+class QUIC_NO_EXPORT MasqueDispatcher : public QuicSimpleDispatcher {
  public:
   explicit MasqueDispatcher(
       MasqueMode masque_mode, const QuicConfig* config,
@@ -41,25 +40,10 @@
       const ParsedQuicVersion& version,
       const quic::ParsedClientHello& parsed_chlo) override;
 
-  bool OnFailedToDispatchPacket(const ReceivedPacketInfo& packet_info) override;
-
-  // From MasqueServerSession::Visitor.
-  void RegisterClientConnectionId(
-      QuicConnectionId client_connection_id,
-      MasqueServerSession* masque_server_session) override;
-
-  void UnregisterClientConnectionId(
-      QuicConnectionId client_connection_id) override;
-
  private:
   MasqueMode masque_mode_;
   QuicEpollServer* epoll_server_;               // Unowned.
   MasqueServerBackend* masque_server_backend_;  // Unowned.
-  // Mapping from client connection IDs to server sessions, allows routing
-  // incoming packets to the right MASQUE connection.
-  absl::flat_hash_map<QuicConnectionId, MasqueServerSession*,
-                      QuicConnectionIdHash>
-      client_connection_id_registrations_;
 };
 
 }  // namespace quic
diff --git a/quiche/quic/masque/masque_encapsulated_client_session.cc b/quiche/quic/masque/masque_encapsulated_client_session.cc
index 988b511..077430f 100644
--- a/quiche/quic/masque/masque_encapsulated_client_session.cc
+++ b/quiche/quic/masque/masque_encapsulated_client_session.cc
@@ -33,8 +33,7 @@
 void MasqueEncapsulatedClientSession::OnConnectionClosed(
     const QuicConnectionCloseFrame& frame, ConnectionCloseSource source) {
   QuicSpdyClientSession::OnConnectionClosed(frame, source);
-  masque_client_session_->UnregisterConnectionId(
-      connection()->client_connection_id(), this);
+  masque_client_session_->CloseConnectUdpStream(this);
 }
 
 }  // namespace quic
diff --git a/quiche/quic/masque/masque_encapsulated_epoll_client.cc b/quiche/quic/masque/masque_encapsulated_epoll_client.cc
index 41dde4e..242d265 100644
--- a/quiche/quic/masque/masque_encapsulated_epoll_client.cc
+++ b/quiche/quic/masque/masque_encapsulated_epoll_client.cc
@@ -29,9 +29,7 @@
                   << " bytes to " << peer_address;
     absl::string_view packet(buffer, buf_len);
     client_->masque_client()->masque_client_session()->SendPacket(
-        client_->session()->connection()->client_connection_id(),
-        client_->session()->connection()->connection_id(), packet, peer_address,
-        client_->masque_encapsulated_client_session());
+        packet, peer_address, client_->masque_encapsulated_client_session());
     return WriteResult(WRITE_STATUS_OK, buf_len);
   }
 
@@ -93,8 +91,8 @@
       masque_client_(masque_client) {}
 
 MasqueEncapsulatedEpollClient::~MasqueEncapsulatedEpollClient() {
-  masque_client_->masque_client_session()->UnregisterConnectionId(
-      client_connection_id_, masque_encapsulated_client_session());
+  masque_client_->masque_client_session()->CloseConnectUdpStream(
+      masque_encapsulated_client_session());
 }
 
 std::unique_ptr<QuicSession>
@@ -113,13 +111,4 @@
   return static_cast<MasqueEncapsulatedClientSession*>(QuicClient::session());
 }
 
-QuicConnectionId MasqueEncapsulatedEpollClient::GetClientConnectionId() {
-  if (client_connection_id_.IsEmpty()) {
-    client_connection_id_ = QuicUtils::CreateRandomConnectionId();
-    masque_client_->masque_client_session()->RegisterConnectionId(
-        client_connection_id_, masque_encapsulated_client_session());
-  }
-  return client_connection_id_;
-}
-
 }  // namespace quic
diff --git a/quiche/quic/masque/masque_encapsulated_epoll_client.h b/quiche/quic/masque/masque_encapsulated_epoll_client.h
index cbe1bcd..2b98652 100644
--- a/quiche/quic/masque/masque_encapsulated_epoll_client.h
+++ b/quiche/quic/masque/masque_encapsulated_epoll_client.h
@@ -32,8 +32,6 @@
       const ParsedQuicVersionVector& supported_versions,
       QuicConnection* connection) override;
 
-  QuicConnectionId GetClientConnectionId() override;
-
   // MASQUE client that this client is encapsulated in.
   MasqueEpollClient* masque_client() { return masque_client_; }
 
@@ -42,7 +40,6 @@
 
  private:
   MasqueEpollClient* masque_client_;  // Unowned.
-  QuicConnectionId client_connection_id_;
 };
 
 }  // namespace quic
diff --git a/quiche/quic/masque/masque_epoll_client.cc b/quiche/quic/masque/masque_epoll_client.cc
index 6d6470b..705ea15 100644
--- a/quiche/quic/masque/masque_epoll_client.cc
+++ b/quiche/quic/masque/masque_epoll_client.cc
@@ -91,36 +91,6 @@
     return nullptr;
   }
 
-  if (masque_client->masque_mode() == MasqueMode::kLegacy) {
-    // Construct the legacy mode init request.
-    spdy::Http2HeaderBlock header_block;
-    header_block[":method"] = "POST";
-    header_block[":scheme"] = "https";
-    header_block[":authority"] = masque_client->authority();
-    header_block[":path"] = "/.well-known/masque/init";
-    std::string body = "foo";
-
-    // Make sure to store the response, for later output.
-    masque_client->set_store_response(true);
-
-    // Send the MASQUE init command.
-    masque_client->SendRequestAndWaitForResponse(header_block, body,
-                                                 /*fin=*/true);
-
-    if (!masque_client->connected()) {
-      QUIC_LOG(ERROR)
-          << "MASQUE init request caused connection failure. Error: "
-          << QuicErrorCodeToString(masque_client->session()->error());
-      return nullptr;
-    }
-
-    const int response_code = masque_client->latest_response_code();
-    if (response_code != 200) {
-      QUIC_LOG(ERROR) << "MASQUE init request failed with HTTP response code "
-                      << response_code;
-      return nullptr;
-    }
-  }
   return masque_client;
 }
 
@@ -133,22 +103,4 @@
   return connected() && settings_received_;
 }
 
-void MasqueEpollClient::UnregisterClientConnectionId(
-    QuicConnectionId client_connection_id) {
-  std::string body(client_connection_id.data(), client_connection_id.length());
-
-  // Construct a GET or POST request for supplied URL.
-  spdy::Http2HeaderBlock header_block;
-  header_block[":method"] = "POST";
-  header_block[":scheme"] = "https";
-  header_block[":authority"] = authority();
-  header_block[":path"] = "/.well-known/masque/unregister";
-
-  // Make sure to store the response, for later output.
-  set_store_response(true);
-
-  // Send the MASQUE unregister command.
-  SendRequest(header_block, body, /*fin=*/true);
-}
-
 }  // namespace quic
diff --git a/quiche/quic/masque/masque_epoll_client.h b/quiche/quic/masque/masque_epoll_client.h
index 7b36bf6..7eff270 100644
--- a/quiche/quic/masque/masque_epoll_client.h
+++ b/quiche/quic/masque/masque_epoll_client.h
@@ -38,9 +38,6 @@
 
   // From MasqueClientSession::Owner.
   void OnSettingsReceived() override;
-  // Send a MASQUE client connection ID unregister command to the server.
-  void UnregisterClientConnectionId(
-      QuicConnectionId client_connection_id) override;
 
   MasqueMode masque_mode() const { return masque_mode_; }
 
diff --git a/quiche/quic/masque/masque_server_backend.cc b/quiche/quic/masque/masque_server_backend.cc
index 8dfe8b8..8e74e16 100644
--- a/quiche/quic/masque/masque_server_backend.cc
+++ b/quiche/quic/masque/masque_server_backend.cc
@@ -20,7 +20,6 @@
 
 bool MasqueServerBackend::MaybeHandleMasqueRequest(
     const spdy::Http2HeaderBlock& request_headers,
-    const std::string& request_body,
     QuicSimpleServerBackend::RequestHandler* request_handler) {
   auto method_pair = request_headers.find(":method");
   if (method_pair == request_headers.end()) {
@@ -29,34 +28,11 @@
   }
   absl::string_view method = method_pair->second;
   std::string masque_path = "";
-  if (masque_mode_ == MasqueMode::kLegacy) {
-    auto path_pair = request_headers.find(":path");
-    auto scheme_pair = request_headers.find(":scheme");
-    if (path_pair == request_headers.end() ||
-        scheme_pair == request_headers.end()) {
-      // This request is missing required headers.
-      return false;
-    }
-    absl::string_view path = path_pair->second;
-    absl::string_view scheme = scheme_pair->second;
-    if (scheme != "https" || method != "POST" || request_body.empty()) {
-      // MASQUE requests MUST be a non-empty https POST.
-      return false;
-    }
-
-    if (path.rfind("/.well-known/masque/", 0) != 0) {
-      // This request is not a MASQUE path.
-      return false;
-    }
-    masque_path = std::string(path.substr(sizeof("/.well-known/masque/") - 1));
-  } else {
-    QUICHE_DCHECK_EQ(masque_mode_, MasqueMode::kOpen);
-    auto protocol_pair = request_headers.find(":protocol");
-    if (method != "CONNECT" || protocol_pair == request_headers.end() ||
-        protocol_pair->second != "connect-udp") {
-      // This is not a MASQUE request.
-      return false;
-    }
+  auto protocol_pair = request_headers.find(":protocol");
+  if (method != "CONNECT" || protocol_pair == request_headers.end() ||
+      protocol_pair->second != "connect-udp") {
+    // This is not a MASQUE request.
+    return false;
   }
 
   if (!server_authority_.empty()) {
@@ -82,8 +58,7 @@
   BackendClient* backend_client = it->second.backend_client;
 
   std::unique_ptr<QuicBackendResponse> response =
-      backend_client->HandleMasqueRequest(masque_path, request_headers,
-                                          request_body, request_handler);
+      backend_client->HandleMasqueRequest(request_headers, request_handler);
   if (response == nullptr) {
     QUIC_LOG(ERROR) << "Backend client did not process request for "
                     << masque_path << request_headers.DebugString();
@@ -103,8 +78,7 @@
     const spdy::Http2HeaderBlock& request_headers,
     const std::string& request_body,
     QuicSimpleServerBackend::RequestHandler* request_handler) {
-  if (MaybeHandleMasqueRequest(request_headers, request_body,
-                               request_handler)) {
+  if (MaybeHandleMasqueRequest(request_headers, request_handler)) {
     // Request was handled as a MASQUE request.
     return;
   }
diff --git a/quiche/quic/masque/masque_server_backend.h b/quiche/quic/masque/masque_server_backend.h
index 7480a86..8f35c3b 100644
--- a/quiche/quic/masque/masque_server_backend.h
+++ b/quiche/quic/masque/masque_server_backend.h
@@ -21,9 +21,7 @@
   class QUIC_NO_EXPORT BackendClient {
    public:
     virtual std::unique_ptr<QuicBackendResponse> HandleMasqueRequest(
-        const std::string& masque_path,
         const spdy::Http2HeaderBlock& request_headers,
-        const std::string& request_body,
         QuicSimpleServerBackend::RequestHandler* request_handler) = 0;
     virtual ~BackendClient() = default;
   };
@@ -56,7 +54,6 @@
   // Handle MASQUE request.
   bool MaybeHandleMasqueRequest(
       const spdy::Http2HeaderBlock& request_headers,
-      const std::string& request_body,
       QuicSimpleServerBackend::RequestHandler* request_handler);
 
   MasqueMode masque_mode_;
diff --git a/quiche/quic/masque/masque_server_bin.cc b/quiche/quic/masque/masque_server_bin.cc
index ac1c189..bae882f 100644
--- a/quiche/quic/masque/masque_server_bin.cc
+++ b/quiche/quic/masque/masque_server_bin.cc
@@ -31,9 +31,9 @@
     "Specifies the authority over which the server will accept MASQUE "
     "requests. Defaults to empty which allows all authorities.");
 
-DEFINE_QUICHE_COMMAND_LINE_FLAG(std::string, masque_mode, "",
-                                "Allows setting MASQUE mode, valid values are "
-                                "open and legacy. Defaults to open.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, masque_mode, "",
+    "Allows setting MASQUE mode, currently only valid value is \"open\".");
 
 int main(int argc, char* argv[]) {
   quiche::QuicheSystemEventLoop event_loop("masque_server");
@@ -47,9 +47,7 @@
 
   quic::MasqueMode masque_mode = quic::MasqueMode::kOpen;
   std::string mode_string = GetQuicFlag(FLAGS_masque_mode);
-  if (mode_string == "legacy") {
-    masque_mode = quic::MasqueMode::kLegacy;
-  } else if (!mode_string.empty() && mode_string != "open") {
+  if (!mode_string.empty() && mode_string != "open") {
     std::cerr << "Invalid masque_mode \"" << mode_string << "\"" << std::endl;
     return 1;
   }
diff --git a/quiche/quic/masque/masque_server_session.cc b/quiche/quic/masque/masque_server_session.cc
index 268421f..3a81caa 100644
--- a/quiche/quic/masque/masque_server_session.cc
+++ b/quiche/quic/masque/masque_server_session.cc
@@ -78,7 +78,7 @@
 MasqueServerSession::MasqueServerSession(
     MasqueMode masque_mode, const QuicConfig& config,
     const ParsedQuicVersionVector& supported_versions,
-    QuicConnection* connection, QuicSession::Visitor* visitor, Visitor* owner,
+    QuicConnection* connection, QuicSession::Visitor* visitor,
     QuicEpollServer* epoll_server, QuicCryptoServerStreamBase::Helper* helper,
     const QuicCryptoServerConfig* crypto_config,
     QuicCompressedCertsCache* compressed_certs_cache,
@@ -87,9 +87,7 @@
                               helper, crypto_config, compressed_certs_cache,
                               masque_server_backend),
       masque_server_backend_(masque_server_backend),
-      owner_(owner),
       epoll_server_(epoll_server),
-      compression_engine_(this),
       masque_mode_(masque_mode) {
   // Artificially increase the max packet length to 1350 to ensure we can fit
   // QUIC packets inside DATAGRAM frames.
@@ -100,44 +98,6 @@
   QUICHE_DCHECK_NE(epoll_server_, nullptr);
 }
 
-void MasqueServerSession::OnMessageReceived(absl::string_view message) {
-  if (masque_mode_ == MasqueMode::kLegacy) {
-    QUIC_DVLOG(1) << "Received DATAGRAM frame of length " << message.length();
-    QuicConnectionId client_connection_id, server_connection_id;
-    QuicSocketAddress target_server_address;
-    std::vector<char> packet;
-    bool version_present;
-    if (!compression_engine_.DecompressDatagram(
-            message, &client_connection_id, &server_connection_id,
-            &target_server_address, &packet, &version_present)) {
-      return;
-    }
-
-    QUIC_DVLOG(1) << "Received packet of length " << packet.size() << " for "
-                  << target_server_address << " client "
-                  << client_connection_id;
-
-    if (version_present) {
-      if (client_connection_id.length() != kQuicDefaultConnectionIdLength) {
-        QUIC_DLOG(ERROR)
-            << "Dropping long header with invalid client_connection_id "
-            << client_connection_id;
-        return;
-      }
-      owner_->RegisterClientConnectionId(client_connection_id, this);
-    }
-
-    WriteResult write_result = connection()->writer()->WritePacket(
-        packet.data(), packet.size(), connection()->self_address().host(),
-        target_server_address, nullptr);
-    QUIC_DVLOG(1) << "Got " << write_result << " for " << packet.size()
-                  << " bytes to " << target_server_address;
-    return;
-  }
-  QUICHE_DCHECK_EQ(masque_mode_, MasqueMode::kOpen);
-  QuicSpdySession::OnMessageReceived(message);
-}
-
 void MasqueServerSession::OnMessageAcked(QuicMessageId message_id,
                                          QuicTime /*receive_timestamp*/) {
   QUIC_DVLOG(1) << "Received ack for DATAGRAM frame " << message_id;
@@ -166,206 +126,155 @@
 }
 
 std::unique_ptr<QuicBackendResponse> MasqueServerSession::HandleMasqueRequest(
-    const std::string& masque_path,
     const spdy::Http2HeaderBlock& request_headers,
-    const std::string& request_body,
     QuicSimpleServerBackend::RequestHandler* request_handler) {
-  if (masque_mode_ != MasqueMode::kLegacy) {
-    auto path_pair = request_headers.find(":path");
-    auto scheme_pair = request_headers.find(":scheme");
-    auto method_pair = request_headers.find(":method");
-    auto protocol_pair = request_headers.find(":protocol");
-    auto authority_pair = request_headers.find(":authority");
-    if (path_pair == request_headers.end()) {
-      QUIC_DLOG(ERROR) << "MASQUE request is missing :path";
-      return CreateBackendErrorResponse("400", "Missing :path");
-    }
-    if (scheme_pair == request_headers.end()) {
-      QUIC_DLOG(ERROR) << "MASQUE request is missing :scheme";
-      return CreateBackendErrorResponse("400", "Missing :scheme");
-    }
-    if (method_pair == request_headers.end()) {
-      QUIC_DLOG(ERROR) << "MASQUE request is missing :method";
-      return CreateBackendErrorResponse("400", "Missing :method");
-    }
-    if (protocol_pair == request_headers.end()) {
-      QUIC_DLOG(ERROR) << "MASQUE request is missing :protocol";
-      return CreateBackendErrorResponse("400", "Missing :protocol");
-    }
-    if (authority_pair == request_headers.end()) {
-      QUIC_DLOG(ERROR) << "MASQUE request is missing :authority";
-      return CreateBackendErrorResponse("400", "Missing :authority");
-    }
-    absl::string_view path = path_pair->second;
-    absl::string_view scheme = scheme_pair->second;
-    absl::string_view method = method_pair->second;
-    absl::string_view protocol = protocol_pair->second;
-    absl::string_view authority = authority_pair->second;
-    if (path.empty()) {
-      QUIC_DLOG(ERROR) << "MASQUE request with empty path";
-      return CreateBackendErrorResponse("400", "Empty path");
-    }
-    if (scheme.empty()) {
-      return CreateBackendErrorResponse("400", "Empty scheme");
-    }
-    if (method != "CONNECT") {
-      QUIC_DLOG(ERROR) << "MASQUE request with bad method \"" << method << "\"";
-      return CreateBackendErrorResponse("400", "Bad method");
-    }
-    if (protocol != "connect-udp") {
-      QUIC_DLOG(ERROR) << "MASQUE request with bad protocol \"" << protocol
-                       << "\"";
-      return CreateBackendErrorResponse("400", "Bad protocol");
-    }
-    absl::optional<QuicDatagramStreamId> flow_id;
-    if (http_datagram_support() == HttpDatagramSupport::kDraft00) {
-      flow_id = SpdyUtils::ParseDatagramFlowIdHeader(request_headers);
-      if (!flow_id.has_value()) {
-        QUIC_DLOG(ERROR)
-            << "MASQUE request with bad or missing DatagramFlowId header";
-        return CreateBackendErrorResponse(
-            "400", "Bad or missing DatagramFlowId header");
-      }
-    }
-    // Extract target host and port from path using default template.
-    std::vector<absl::string_view> path_split = absl::StrSplit(path, '/');
-    if (path_split.size() != 4 || !path_split[0].empty() ||
-        path_split[1].empty() || path_split[2].empty() ||
-        !path_split[3].empty()) {
-      QUIC_DLOG(ERROR) << "MASQUE request with bad path \"" << path << "\"";
-      return CreateBackendErrorResponse("400", "Bad path");
-    }
-    absl::optional<std::string> host = quiche::AsciiUrlDecode(path_split[1]);
-    if (!host.has_value()) {
-      QUIC_DLOG(ERROR) << "Failed to decode host \"" << path_split[1] << "\"";
-      return CreateBackendErrorResponse("500", "Failed to decode host");
-    }
-    absl::optional<std::string> port = quiche::AsciiUrlDecode(path_split[2]);
-    if (!port.has_value()) {
-      QUIC_DLOG(ERROR) << "Failed to decode port \"" << path_split[2] << "\"";
-      return CreateBackendErrorResponse("500", "Failed to decode port");
-    }
-
-    // Perform DNS resolution.
-    addrinfo hint = {};
-    hint.ai_protocol = IPPROTO_UDP;
-
-    addrinfo* info_list = nullptr;
-    int result = getaddrinfo(host.value().c_str(), port.value().c_str(), &hint,
-                             &info_list);
-    if (result != 0) {
-      QUIC_DLOG(ERROR) << "Failed to resolve " << authority << ": "
-                       << gai_strerror(result);
-      return CreateBackendErrorResponse("500", "DNS resolution failed");
-    }
-
-    QUICHE_CHECK_NE(info_list, nullptr);
-    std::unique_ptr<addrinfo, void (*)(addrinfo*)> info_list_owned(
-        info_list, freeaddrinfo);
-    QuicSocketAddress target_server_address(info_list->ai_addr,
-                                            info_list->ai_addrlen);
-    QUIC_DLOG(INFO) << "Got CONNECT_UDP request on stream ID "
-                    << request_handler->stream_id() << " flow_id="
-                    << (flow_id.has_value() ? absl::StrCat(*flow_id) : "none")
-                    << " target_server_address=\"" << target_server_address
-                    << "\"";
-
-    FdWrapper fd_wrapper(target_server_address.host().AddressFamilyToInt());
-    if (fd_wrapper.fd() == kQuicInvalidSocketFd) {
-      QUIC_DLOG(ERROR) << "Socket creation failed";
-      return CreateBackendErrorResponse("500", "Socket creation failed");
-    }
-    QuicSocketAddress empty_address(QuicIpAddress::Any6(), 0);
-    if (target_server_address.host().IsIPv4()) {
-      empty_address = QuicSocketAddress(QuicIpAddress::Any4(), 0);
-    }
-    QuicUdpSocketApi socket_api;
-    if (!socket_api.Bind(fd_wrapper.fd(), empty_address)) {
-      QUIC_DLOG(ERROR) << "Socket bind failed";
-      return CreateBackendErrorResponse("500", "Socket bind failed");
-    }
-    epoll_server_->RegisterFDForRead(fd_wrapper.fd(), this);
-
-    QuicSpdyStream* stream = static_cast<QuicSpdyStream*>(
-        GetActiveStream(request_handler->stream_id()));
-    if (stream == nullptr) {
-      QUIC_BUG(bad masque server stream type)
-          << "Unexpected stream type for stream ID "
-          << request_handler->stream_id();
-      return CreateBackendErrorResponse("500", "Bad stream type");
-    }
-    if (flow_id.has_value()) {
-      stream->RegisterHttp3DatagramFlowId(*flow_id);
-    }
-    connect_udp_server_states_.push_back(ConnectUdpServerState(
-        stream, target_server_address, fd_wrapper.extract_fd(), this));
-
-    if (http_datagram_support() == HttpDatagramSupport::kDraft00) {
-      // TODO(b/181256914) remove this when we drop support for
-      // draft-ietf-masque-h3-datagram-00 in favor of later drafts.
-      stream->RegisterHttp3DatagramVisitor(&connect_udp_server_states_.back());
-    }
-
-    spdy::Http2HeaderBlock response_headers;
-    response_headers[":status"] = "200";
-    if (flow_id.has_value()) {
-      SpdyUtils::AddDatagramFlowIdHeader(&response_headers, *flow_id);
-    }
-    auto response = std::make_unique<QuicBackendResponse>();
-    response->set_response_type(QuicBackendResponse::INCOMPLETE_RESPONSE);
-    response->set_headers(std::move(response_headers));
-    response->set_body("");
-
-    return response;
+  auto path_pair = request_headers.find(":path");
+  auto scheme_pair = request_headers.find(":scheme");
+  auto method_pair = request_headers.find(":method");
+  auto protocol_pair = request_headers.find(":protocol");
+  auto authority_pair = request_headers.find(":authority");
+  if (path_pair == request_headers.end()) {
+    QUIC_DLOG(ERROR) << "MASQUE request is missing :path";
+    return CreateBackendErrorResponse("400", "Missing :path");
   }
-
-  QUIC_DLOG(INFO) << "MasqueServerSession handling MASQUE request";
-
-  if (masque_path == "init") {
-    if (masque_initialized_) {
-      QUIC_DLOG(ERROR) << "Got second MASQUE init request";
-      return nullptr;
-    }
-    masque_initialized_ = true;
-  } else if (masque_path == "unregister") {
-    QuicConnectionId connection_id(request_body.data(), request_body.length());
-    QUIC_DLOG(INFO) << "Received MASQUE request to unregister "
-                    << connection_id;
-    owner_->UnregisterClientConnectionId(connection_id);
-    compression_engine_.UnregisterClientConnectionId(connection_id);
-  } else {
-    if (!masque_initialized_) {
-      QUIC_DLOG(ERROR) << "Got MASQUE request before init";
-      return nullptr;
+  if (scheme_pair == request_headers.end()) {
+    QUIC_DLOG(ERROR) << "MASQUE request is missing :scheme";
+    return CreateBackendErrorResponse("400", "Missing :scheme");
+  }
+  if (method_pair == request_headers.end()) {
+    QUIC_DLOG(ERROR) << "MASQUE request is missing :method";
+    return CreateBackendErrorResponse("400", "Missing :method");
+  }
+  if (protocol_pair == request_headers.end()) {
+    QUIC_DLOG(ERROR) << "MASQUE request is missing :protocol";
+    return CreateBackendErrorResponse("400", "Missing :protocol");
+  }
+  if (authority_pair == request_headers.end()) {
+    QUIC_DLOG(ERROR) << "MASQUE request is missing :authority";
+    return CreateBackendErrorResponse("400", "Missing :authority");
+  }
+  absl::string_view path = path_pair->second;
+  absl::string_view scheme = scheme_pair->second;
+  absl::string_view method = method_pair->second;
+  absl::string_view protocol = protocol_pair->second;
+  absl::string_view authority = authority_pair->second;
+  if (path.empty()) {
+    QUIC_DLOG(ERROR) << "MASQUE request with empty path";
+    return CreateBackendErrorResponse("400", "Empty path");
+  }
+  if (scheme.empty()) {
+    return CreateBackendErrorResponse("400", "Empty scheme");
+  }
+  if (method != "CONNECT") {
+    QUIC_DLOG(ERROR) << "MASQUE request with bad method \"" << method << "\"";
+    return CreateBackendErrorResponse("400", "Bad method");
+  }
+  if (protocol != "connect-udp") {
+    QUIC_DLOG(ERROR) << "MASQUE request with bad protocol \"" << protocol
+                     << "\"";
+    return CreateBackendErrorResponse("400", "Bad protocol");
+  }
+  absl::optional<QuicDatagramStreamId> flow_id;
+  if (http_datagram_support() == HttpDatagramSupport::kDraft00) {
+    flow_id = SpdyUtils::ParseDatagramFlowIdHeader(request_headers);
+    if (!flow_id.has_value()) {
+      QUIC_DLOG(ERROR)
+          << "MASQUE request with bad or missing DatagramFlowId header";
+      return CreateBackendErrorResponse("400",
+                                        "Bad or missing DatagramFlowId header");
     }
   }
+  // Extract target host and port from path using default template.
+  std::vector<absl::string_view> path_split = absl::StrSplit(path, '/');
+  if (path_split.size() != 4 || !path_split[0].empty() ||
+      path_split[1].empty() || path_split[2].empty() ||
+      !path_split[3].empty()) {
+    QUIC_DLOG(ERROR) << "MASQUE request with bad path \"" << path << "\"";
+    return CreateBackendErrorResponse("400", "Bad path");
+  }
+  absl::optional<std::string> host = quiche::AsciiUrlDecode(path_split[1]);
+  if (!host.has_value()) {
+    QUIC_DLOG(ERROR) << "Failed to decode host \"" << path_split[1] << "\"";
+    return CreateBackendErrorResponse("500", "Failed to decode host");
+  }
+  absl::optional<std::string> port = quiche::AsciiUrlDecode(path_split[2]);
+  if (!port.has_value()) {
+    QUIC_DLOG(ERROR) << "Failed to decode port \"" << path_split[2] << "\"";
+    return CreateBackendErrorResponse("500", "Failed to decode port");
+  }
 
-  // TODO(dschinazi) implement binary protocol sent in response body.
-  const std::string response_body = "";
+  // Perform DNS resolution.
+  addrinfo hint = {};
+  hint.ai_protocol = IPPROTO_UDP;
+
+  addrinfo* info_list = nullptr;
+  int result = getaddrinfo(host.value().c_str(), port.value().c_str(), &hint,
+                           &info_list);
+  if (result != 0 || info_list == nullptr) {
+    QUIC_DLOG(ERROR) << "Failed to resolve " << authority << ": "
+                     << gai_strerror(result);
+    return CreateBackendErrorResponse("500", "DNS resolution failed");
+  }
+
+  std::unique_ptr<addrinfo, void (*)(addrinfo*)> info_list_owned(info_list,
+                                                                 freeaddrinfo);
+  QuicSocketAddress target_server_address(info_list->ai_addr,
+                                          info_list->ai_addrlen);
+  QUIC_DLOG(INFO) << "Got CONNECT_UDP request on stream ID "
+                  << request_handler->stream_id() << " flow_id="
+                  << (flow_id.has_value() ? absl::StrCat(*flow_id) : "none")
+                  << " target_server_address=\"" << target_server_address
+                  << "\"";
+
+  FdWrapper fd_wrapper(target_server_address.host().AddressFamilyToInt());
+  if (fd_wrapper.fd() == kQuicInvalidSocketFd) {
+    QUIC_DLOG(ERROR) << "Socket creation failed";
+    return CreateBackendErrorResponse("500", "Socket creation failed");
+  }
+  QuicSocketAddress empty_address(QuicIpAddress::Any6(), 0);
+  if (target_server_address.host().IsIPv4()) {
+    empty_address = QuicSocketAddress(QuicIpAddress::Any4(), 0);
+  }
+  QuicUdpSocketApi socket_api;
+  if (!socket_api.Bind(fd_wrapper.fd(), empty_address)) {
+    QUIC_DLOG(ERROR) << "Socket bind failed";
+    return CreateBackendErrorResponse("500", "Socket bind failed");
+  }
+  epoll_server_->RegisterFDForRead(fd_wrapper.fd(), this);
+
+  QuicSpdyStream* stream =
+      static_cast<QuicSpdyStream*>(GetActiveStream(request_handler->stream_id()));
+  if (stream == nullptr) {
+    QUIC_BUG(bad masque server stream type)
+        << "Unexpected stream type for stream ID "
+        << request_handler->stream_id();
+    return CreateBackendErrorResponse("500", "Bad stream type");
+  }
+  if (flow_id.has_value()) {
+    stream->RegisterHttp3DatagramFlowId(*flow_id);
+  }
+  connect_udp_server_states_.push_back(ConnectUdpServerState(
+      stream, target_server_address, fd_wrapper.extract_fd(), this));
+
+  if (http_datagram_support() == HttpDatagramSupport::kDraft00) {
+    // TODO(b/181256914) remove this when we drop support for
+    // draft-ietf-masque-h3-datagram-00 in favor of later drafts.
+    stream->RegisterHttp3DatagramVisitor(&connect_udp_server_states_.back());
+  }
+
   spdy::Http2HeaderBlock response_headers;
   response_headers[":status"] = "200";
+  if (flow_id.has_value()) {
+    SpdyUtils::AddDatagramFlowIdHeader(&response_headers, *flow_id);
+  }
   auto response = std::make_unique<QuicBackendResponse>();
-  response->set_response_type(QuicBackendResponse::REGULAR_RESPONSE);
+  response->set_response_type(QuicBackendResponse::INCOMPLETE_RESPONSE);
   response->set_headers(std::move(response_headers));
-  response->set_body(response_body);
+  response->set_body("");
 
   return response;
 }
 
-void MasqueServerSession::HandlePacketFromServer(
-    const ReceivedPacketInfo& packet_info) {
-  QUIC_DVLOG(1) << "MasqueServerSession received " << packet_info;
-  if (masque_mode_ == MasqueMode::kLegacy) {
-    compression_engine_.CompressAndSendPacket(
-        packet_info.packet.AsStringPiece(),
-        packet_info.destination_connection_id, packet_info.source_connection_id,
-        packet_info.peer_address);
-    return;
-  }
-  QUIC_LOG(ERROR) << "Ignoring packet from server in " << masque_mode_
-                  << " mode";
-}
-
 void MasqueServerSession::OnRegistration(QuicEpollServer* /*eps*/,
                                          QuicUdpSocketFd fd, int event_mask) {
   QUIC_DVLOG(1) << "OnRegistration " << fd << " event_mask " << event_mask;
diff --git a/quiche/quic/masque/masque_server_session.h b/quiche/quic/masque/masque_server_session.h
index 09aedb9..a2ae75d 100644
--- a/quiche/quic/masque/masque_server_session.h
+++ b/quiche/quic/masque/masque_server_session.h
@@ -7,7 +7,6 @@
 
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/quic_udp_socket.h"
-#include "quiche/quic/masque/masque_compression_engine.h"
 #include "quiche/quic/masque/masque_server_backend.h"
 #include "quiche/quic/masque/masque_utils.h"
 #include "quiche/quic/platform/api/quic_epoll.h"
@@ -22,25 +21,10 @@
       public MasqueServerBackend::BackendClient,
       public QuicEpollCallbackInterface {
  public:
-  // Interface meant to be implemented by owner of this MasqueServerSession
-  // instance.
-  class QUIC_NO_EXPORT Visitor {
-   public:
-    virtual ~Visitor() {}
-    // Register a client connection ID as being handled by this session.
-    virtual void RegisterClientConnectionId(
-        QuicConnectionId client_connection_id,
-        MasqueServerSession* masque_server_session) = 0;
-
-    // Unregister a client connection ID.
-    virtual void UnregisterClientConnectionId(
-        QuicConnectionId client_connection_id) = 0;
-  };
-
   explicit MasqueServerSession(
       MasqueMode masque_mode, const QuicConfig& config,
       const ParsedQuicVersionVector& supported_versions,
-      QuicConnection* connection, QuicSession::Visitor* visitor, Visitor* owner,
+      QuicConnection* connection, QuicSession::Visitor* visitor,
       QuicEpollServer* epoll_server, QuicCryptoServerStreamBase::Helper* helper,
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache,
@@ -51,7 +35,6 @@
   MasqueServerSession& operator=(const MasqueServerSession&) = delete;
 
   // From QuicSession.
-  void OnMessageReceived(absl::string_view message) override;
   void OnMessageAcked(QuicMessageId message_id,
                       QuicTime receive_timestamp) override;
   void OnMessageLost(QuicMessageId message_id) override;
@@ -61,9 +44,7 @@
 
   // From MasqueServerBackend::BackendClient.
   std::unique_ptr<QuicBackendResponse> HandleMasqueRequest(
-      const std::string& masque_path,
       const spdy::Http2HeaderBlock& request_headers,
-      const std::string& request_body,
       QuicSimpleServerBackend::RequestHandler* request_handler) override;
 
   // From QuicEpollCallbackInterface.
@@ -75,9 +56,6 @@
   void OnShutdown(QuicEpollServer* eps, QuicUdpSocketFd fd) override;
   std::string Name() const override;
 
-  // Handle packet for client, meant to be called by MasqueDispatcher.
-  void HandlePacketFromServer(const ReceivedPacketInfo& packet_info);
-
   QuicEpollServer* epoll_server() const { return epoll_server_; }
 
  private:
@@ -124,9 +102,7 @@
   }
 
   MasqueServerBackend* masque_server_backend_;  // Unowned.
-  Visitor* owner_;                              // Unowned.
   QuicEpollServer* epoll_server_;               // Unowned.
-  MasqueCompressionEngine compression_engine_;
   MasqueMode masque_mode_;
   std::list<ConnectUdpServerState> connect_udp_server_states_;
   bool masque_initialized_ = false;
diff --git a/quiche/quic/masque/masque_utils.cc b/quiche/quic/masque/masque_utils.cc
index b440bd1..d09fc49 100644
--- a/quiche/quic/masque/masque_utils.cc
+++ b/quiche/quic/masque/masque_utils.cc
@@ -30,8 +30,6 @@
   switch (masque_mode) {
     case MasqueMode::kInvalid:
       return "Invalid";
-    case MasqueMode::kLegacy:
-      return "Legacy";
     case MasqueMode::kOpen:
       return "Open";
   }
diff --git a/quiche/quic/masque/masque_utils.h b/quiche/quic/masque/masque_utils.h
index 652bf35..12faae0 100644
--- a/quiche/quic/masque/masque_utils.h
+++ b/quiche/quic/masque/masque_utils.h
@@ -26,10 +26,6 @@
 // Mode that MASQUE is operating in.
 enum class MasqueMode : uint8_t {
   kInvalid = 0,  // Should never be used.
-  kLegacy = 1,   // Legacy mode uses the legacy MASQUE protocol as documented in
-  // <https://tools.ietf.org/html/draft-schinazi-masque-protocol>. That version
-  // of MASQUE uses a custom application-protocol over HTTP/3, and also allows
-  // unauthenticated clients.
   kOpen = 2,  // Open mode uses the MASQUE HTTP CONNECT-UDP method as documented
   // in <https://tools.ietf.org/html/draft-ietf-masque-connect-udp>. This mode
   // allows unauthenticated clients (a more restricted mode will be added to