Rename MoQT SubscribeAnnounces to SubscribeNamespace.

This completes the update to draft-13.

PiperOrigin-RevId: 792716552
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index fdaac7e..15a00d2 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -598,39 +598,39 @@
       WireStringWithVarInt62Length(message.new_session_uri));
 }
 
-quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnounces(
-    const MoqtSubscribeAnnounces& message) {
+quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespace(
+    const MoqtSubscribeNamespace& message) {
   KeyValuePairList parameters;
   VersionSpecificParametersToKeyValuePairList(message.parameters, parameters);
   if (!ValidateVersionSpecificParameters(
-          parameters, MoqtMessageType::kSubscribeAnnounces)) {
+          parameters, MoqtMessageType::kSubscribeNamespace)) {
     QUICHE_BUG(QUICHE_BUG_invalid_parameters)
         << "Serializing invalid MoQT parameters";
     return quiche::QuicheBuffer();
   }
-  return SerializeControlMessage(MoqtMessageType::kSubscribeAnnounces,
+  return SerializeControlMessage(MoqtMessageType::kSubscribeNamespace,
                                  WireVarInt62(message.request_id),
                                  WireTrackNamespace(message.track_namespace),
                                  WireKeyValuePairList(parameters));
 }
 
-quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnouncesOk(
-    const MoqtSubscribeAnnouncesOk& message) {
-  return SerializeControlMessage(MoqtMessageType::kSubscribeAnnouncesOk,
+quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespaceOk(
+    const MoqtSubscribeNamespaceOk& message) {
+  return SerializeControlMessage(MoqtMessageType::kSubscribeNamespaceOk,
                                  WireVarInt62(message.request_id));
 }
 
-quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnouncesError(
-    const MoqtSubscribeAnnouncesError& message) {
+quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespaceError(
+    const MoqtSubscribeNamespaceError& message) {
   return SerializeControlMessage(
-      MoqtMessageType::kSubscribeAnnouncesError,
+      MoqtMessageType::kSubscribeNamespaceError,
       WireVarInt62(message.request_id), WireVarInt62(message.error_code),
       WireStringWithVarInt62Length(message.error_reason));
 }
 
-quiche::QuicheBuffer MoqtFramer::SerializeUnsubscribeAnnounces(
-    const MoqtUnsubscribeAnnounces& message) {
-  return SerializeControlMessage(MoqtMessageType::kUnsubscribeAnnounces,
+quiche::QuicheBuffer MoqtFramer::SerializeUnsubscribeNamespace(
+    const MoqtUnsubscribeNamespace& message) {
+  return SerializeControlMessage(MoqtMessageType::kUnsubscribeNamespace,
                                  WireTrackNamespace(message.track_namespace));
 }
 
diff --git a/quiche/quic/moqt/moqt_framer.h b/quiche/quic/moqt/moqt_framer.h
index 8310736..b053255 100644
--- a/quiche/quic/moqt/moqt_framer.h
+++ b/quiche/quic/moqt/moqt_framer.h
@@ -57,14 +57,14 @@
       const MoqtTrackStatusRequest& message);
   quiche::QuicheBuffer SerializeTrackStatus(const MoqtTrackStatus& message);
   quiche::QuicheBuffer SerializeGoAway(const MoqtGoAway& message);
-  quiche::QuicheBuffer SerializeSubscribeAnnounces(
-      const MoqtSubscribeAnnounces& message);
-  quiche::QuicheBuffer SerializeSubscribeAnnouncesOk(
-      const MoqtSubscribeAnnouncesOk& message);
-  quiche::QuicheBuffer SerializeSubscribeAnnouncesError(
-      const MoqtSubscribeAnnouncesError& message);
-  quiche::QuicheBuffer SerializeUnsubscribeAnnounces(
-      const MoqtUnsubscribeAnnounces& message);
+  quiche::QuicheBuffer SerializeSubscribeNamespace(
+      const MoqtSubscribeNamespace& message);
+  quiche::QuicheBuffer SerializeSubscribeNamespaceOk(
+      const MoqtSubscribeNamespaceOk& message);
+  quiche::QuicheBuffer SerializeSubscribeNamespaceError(
+      const MoqtSubscribeNamespaceError& message);
+  quiche::QuicheBuffer SerializeUnsubscribeNamespace(
+      const MoqtUnsubscribeNamespace& message);
   quiche::QuicheBuffer SerializeMaxRequestId(const MoqtMaxRequestId& message);
   quiche::QuicheBuffer SerializeFetch(const MoqtFetch& message);
   quiche::QuicheBuffer SerializeFetchCancel(const MoqtFetchCancel& message);
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc
index db3252b..1d9d547 100644
--- a/quiche/quic/moqt/moqt_framer_test.cc
+++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -47,10 +47,10 @@
       MoqtMessageType::kAnnounceError,
       MoqtMessageType::kUnannounce,
       MoqtMessageType::kGoAway,
-      MoqtMessageType::kSubscribeAnnounces,
-      MoqtMessageType::kSubscribeAnnouncesOk,
-      MoqtMessageType::kSubscribeAnnouncesError,
-      MoqtMessageType::kUnsubscribeAnnounces,
+      MoqtMessageType::kSubscribeNamespace,
+      MoqtMessageType::kSubscribeNamespaceOk,
+      MoqtMessageType::kSubscribeNamespaceError,
+      MoqtMessageType::kUnsubscribeNamespace,
       MoqtMessageType::kMaxRequestId,
       MoqtMessageType::kFetch,
       MoqtMessageType::kFetchCancel,
@@ -170,21 +170,21 @@
         auto data = std::get<MoqtGoAway>(structured_data);
         return framer_.SerializeGoAway(data);
       }
-      case moqt::MoqtMessageType::kSubscribeAnnounces: {
-        auto data = std::get<MoqtSubscribeAnnounces>(structured_data);
-        return framer_.SerializeSubscribeAnnounces(data);
+      case moqt::MoqtMessageType::kSubscribeNamespace: {
+        auto data = std::get<MoqtSubscribeNamespace>(structured_data);
+        return framer_.SerializeSubscribeNamespace(data);
       }
-      case moqt::MoqtMessageType::kSubscribeAnnouncesOk: {
-        auto data = std::get<MoqtSubscribeAnnouncesOk>(structured_data);
-        return framer_.SerializeSubscribeAnnouncesOk(data);
+      case moqt::MoqtMessageType::kSubscribeNamespaceOk: {
+        auto data = std::get<MoqtSubscribeNamespaceOk>(structured_data);
+        return framer_.SerializeSubscribeNamespaceOk(data);
       }
-      case moqt::MoqtMessageType::kSubscribeAnnouncesError: {
-        auto data = std::get<MoqtSubscribeAnnouncesError>(structured_data);
-        return framer_.SerializeSubscribeAnnouncesError(data);
+      case moqt::MoqtMessageType::kSubscribeNamespaceError: {
+        auto data = std::get<MoqtSubscribeNamespaceError>(structured_data);
+        return framer_.SerializeSubscribeNamespaceError(data);
       }
-      case moqt::MoqtMessageType::kUnsubscribeAnnounces: {
-        auto data = std::get<MoqtUnsubscribeAnnounces>(structured_data);
-        return framer_.SerializeUnsubscribeAnnounces(data);
+      case moqt::MoqtMessageType::kUnsubscribeNamespace: {
+        auto data = std::get<MoqtUnsubscribeNamespace>(structured_data);
+        return framer_.SerializeUnsubscribeNamespace(data);
       }
       case moqt::MoqtMessageType::kMaxRequestId: {
         auto data = std::get<MoqtMaxRequestId>(structured_data);
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc
index 81f41a5..64e706e 100644
--- a/quiche/quic/moqt/moqt_messages.cc
+++ b/quiche/quic/moqt/moqt_messages.cc
@@ -175,7 +175,7 @@
 
 const std::array<MoqtMessageType, 8> kAllowsAuthorization = {
     MoqtMessageType::kClientSetup, MoqtMessageType::kServerSetup,
-    MoqtMessageType::kSubscribe,   MoqtMessageType::kSubscribeAnnounces,
+    MoqtMessageType::kSubscribe,   MoqtMessageType::kSubscribeNamespace,
     MoqtMessageType::kAnnounce,    MoqtMessageType::kTrackStatusRequest,
     MoqtMessageType::kFetch,       MoqtMessageType::kPublish};
 const std::array<MoqtMessageType, 6> kAllowsDeliveryTimeout = {
@@ -246,13 +246,13 @@
       return "UNANNOUNCE";
     case MoqtMessageType::kGoAway:
       return "GOAWAY";
-    case MoqtMessageType::kSubscribeAnnounces:
+    case MoqtMessageType::kSubscribeNamespace:
       return "SUBSCRIBE_NAMESPACE";
-    case MoqtMessageType::kSubscribeAnnouncesOk:
+    case MoqtMessageType::kSubscribeNamespaceOk:
       return "SUBSCRIBE_NAMESPACE_OK";
-    case MoqtMessageType::kSubscribeAnnouncesError:
+    case MoqtMessageType::kSubscribeNamespaceError:
       return "SUBSCRIBE_NAMESPACE_ERROR";
-    case MoqtMessageType::kUnsubscribeAnnounces:
+    case MoqtMessageType::kUnsubscribeNamespace:
       return "UNSUBSCRIBE_NAMESPACE";
     case MoqtMessageType::kMaxRequestId:
       return "MAX_REQUEST_ID";
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index 175508b..2838975 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -243,10 +243,10 @@
   kTrackStatusRequest = 0x0d,
   kTrackStatus = 0x0e,
   kGoAway = 0x10,
-  kSubscribeAnnounces = 0x11,
-  kSubscribeAnnouncesOk = 0x12,
-  kSubscribeAnnouncesError = 0x13,
-  kUnsubscribeAnnounces = 0x14,
+  kSubscribeNamespace = 0x11,
+  kSubscribeNamespaceOk = 0x12,
+  kSubscribeNamespaceError = 0x13,
+  kUnsubscribeNamespace = 0x14,
   kMaxRequestId = 0x15,
   kFetch = 0x16,
   kFetchCancel = 0x17,
@@ -340,7 +340,7 @@
 };
 
 // Used for SUBSCRIBE_ERROR, ANNOUNCE_ERROR, ANNOUNCE_CANCEL,
-// SUBSCRIBE_ANNOUNCES_ERROR, and FETCH_ERROR.
+// SUBSCRIBE_NAMESPACE_ERROR, and FETCH_ERROR.
 enum class QUICHE_EXPORT RequestErrorCode : uint64_t {
   kInternalError = 0x0,
   kUnauthorized = 0x1,
@@ -348,9 +348,9 @@
   kNotSupported = 0x3,
   kTrackDoesNotExist = 0x4,        // SUBSCRIBE_ERROR and FETCH_ERROR only.
   kUninterested = 0x4,             // ANNOUNCE_ERROR and ANNOUNCE_CANCEL only.
-  kNamespacePrefixUnknown = 0x4,   // SUBSCRIBE_ANNOUNCES_ERROR only.
+  kNamespacePrefixUnknown = 0x4,   // SUBSCRIBE_NAMESPACE_ERROR only.
   kInvalidRange = 0x5,             // SUBSCRIBE_ERROR and FETCH_ERROR only.
-  kNamespacePrefixOverlap = 0x5,   // SUBSCRIBE_ANNOUNCES_ERROR only.
+  kNamespacePrefixOverlap = 0x5,   // SUBSCRIBE_NAMESPACE_ERROR only.
   kNoObjects = 0x6,                // FETCH_ERROR only.
   kInvalidJoiningRequestId = 0x7,  // FETCH_ERROR only.
   kUnknownStatusInRange = 0x8,     // FETCH_ERROR only.
@@ -763,23 +763,23 @@
   std::string new_session_uri;
 };
 
-struct QUICHE_EXPORT MoqtSubscribeAnnounces {
+struct QUICHE_EXPORT MoqtSubscribeNamespace {
   uint64_t request_id;
   TrackNamespace track_namespace;
   VersionSpecificParameters parameters;
 };
 
-struct QUICHE_EXPORT MoqtSubscribeAnnouncesOk {
+struct QUICHE_EXPORT MoqtSubscribeNamespaceOk {
   uint64_t request_id;
 };
 
-struct QUICHE_EXPORT MoqtSubscribeAnnouncesError {
+struct QUICHE_EXPORT MoqtSubscribeNamespaceError {
   uint64_t request_id;
   RequestErrorCode error_code;
   std::string error_reason;
 };
 
-struct QUICHE_EXPORT MoqtUnsubscribeAnnounces {
+struct QUICHE_EXPORT MoqtUnsubscribeNamespace {
   TrackNamespace track_namespace;
 };
 
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index eacc152..e7f4a7d 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -261,17 +261,17 @@
     case MoqtMessageType::kGoAway:
       bytes_read = ProcessGoAway(reader);
       break;
-    case MoqtMessageType::kSubscribeAnnounces:
-      bytes_read = ProcessSubscribeAnnounces(reader);
+    case MoqtMessageType::kSubscribeNamespace:
+      bytes_read = ProcessSubscribeNamespace(reader);
       break;
-    case MoqtMessageType::kSubscribeAnnouncesOk:
-      bytes_read = ProcessSubscribeAnnouncesOk(reader);
+    case MoqtMessageType::kSubscribeNamespaceOk:
+      bytes_read = ProcessSubscribeNamespaceOk(reader);
       break;
-    case MoqtMessageType::kSubscribeAnnouncesError:
-      bytes_read = ProcessSubscribeAnnouncesError(reader);
+    case MoqtMessageType::kSubscribeNamespaceError:
+      bytes_read = ProcessSubscribeNamespaceError(reader);
       break;
-    case MoqtMessageType::kUnsubscribeAnnounces:
-      bytes_read = ProcessUnsubscribeAnnounces(reader);
+    case MoqtMessageType::kUnsubscribeNamespace:
+      bytes_read = ProcessUnsubscribeNamespace(reader);
       break;
     case MoqtMessageType::kMaxRequestId:
       bytes_read = ProcessMaxRequestId(reader);
@@ -691,9 +691,9 @@
   return reader.PreviouslyReadPayload().length();
 }
 
-size_t MoqtControlParser::ProcessSubscribeAnnounces(
+size_t MoqtControlParser::ProcessSubscribeNamespace(
     quic::QuicDataReader& reader) {
-  MoqtSubscribeAnnounces subscribe_announces;
+  MoqtSubscribeNamespace subscribe_announces;
   if (!reader.ReadVarInt62(&subscribe_announces.request_id) ||
       !ReadTrackNamespace(reader, subscribe_announces.track_namespace)) {
     return 0;
@@ -703,31 +703,31 @@
     return 0;
   }
   if (!ValidateVersionSpecificParameters(
-          parameters, MoqtMessageType::kSubscribeAnnounces)) {
-    ParseError("SUBSCRIBE_ANNOUNCES message contains invalid parameters");
+          parameters, MoqtMessageType::kSubscribeNamespace)) {
+    ParseError("SUBSCRIBE_NAMESPACE message contains invalid parameters");
     return 0;
   }
   if (!KeyValuePairListToVersionSpecificParameters(
           parameters, subscribe_announces.parameters)) {
     return 0;
   }
-  visitor_.OnSubscribeAnnouncesMessage(subscribe_announces);
+  visitor_.OnSubscribeNamespaceMessage(subscribe_announces);
   return reader.PreviouslyReadPayload().length();
 }
 
-size_t MoqtControlParser::ProcessSubscribeAnnouncesOk(
+size_t MoqtControlParser::ProcessSubscribeNamespaceOk(
     quic::QuicDataReader& reader) {
-  MoqtSubscribeAnnouncesOk subscribe_namespace_ok;
+  MoqtSubscribeNamespaceOk subscribe_namespace_ok;
   if (!reader.ReadVarInt62(&subscribe_namespace_ok.request_id)) {
     return 0;
   }
-  visitor_.OnSubscribeAnnouncesOkMessage(subscribe_namespace_ok);
+  visitor_.OnSubscribeNamespaceOkMessage(subscribe_namespace_ok);
   return reader.PreviouslyReadPayload().length();
 }
 
-size_t MoqtControlParser::ProcessSubscribeAnnouncesError(
+size_t MoqtControlParser::ProcessSubscribeNamespaceError(
     quic::QuicDataReader& reader) {
-  MoqtSubscribeAnnouncesError subscribe_namespace_error;
+  MoqtSubscribeNamespaceError subscribe_namespace_error;
   uint64_t error_code;
   if (!reader.ReadVarInt62(&subscribe_namespace_error.request_id) ||
       !reader.ReadVarInt62(&error_code) ||
@@ -736,17 +736,17 @@
   }
   subscribe_namespace_error.error_code =
       static_cast<RequestErrorCode>(error_code);
-  visitor_.OnSubscribeAnnouncesErrorMessage(subscribe_namespace_error);
+  visitor_.OnSubscribeNamespaceErrorMessage(subscribe_namespace_error);
   return reader.PreviouslyReadPayload().length();
 }
 
-size_t MoqtControlParser::ProcessUnsubscribeAnnounces(
+size_t MoqtControlParser::ProcessUnsubscribeNamespace(
     quic::QuicDataReader& reader) {
-  MoqtUnsubscribeAnnounces unsubscribe_namespace;
+  MoqtUnsubscribeNamespace unsubscribe_namespace;
   if (!ReadTrackNamespace(reader, unsubscribe_namespace.track_namespace)) {
     return 0;
   }
-  visitor_.OnUnsubscribeAnnouncesMessage(unsubscribe_namespace);
+  visitor_.OnUnsubscribeNamespaceMessage(unsubscribe_namespace);
   return reader.PreviouslyReadPayload().length();
 }
 
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h
index d56c394..f331b9f 100644
--- a/quiche/quic/moqt/moqt_parser.h
+++ b/quiche/quic/moqt/moqt_parser.h
@@ -49,14 +49,14 @@
   virtual void OnUnannounceMessage(const MoqtUnannounce& message) = 0;
   virtual void OnTrackStatusMessage(const MoqtTrackStatus& message) = 0;
   virtual void OnGoAwayMessage(const MoqtGoAway& message) = 0;
-  virtual void OnSubscribeAnnouncesMessage(
-      const MoqtSubscribeAnnounces& message) = 0;
-  virtual void OnSubscribeAnnouncesOkMessage(
-      const MoqtSubscribeAnnouncesOk& message) = 0;
-  virtual void OnSubscribeAnnouncesErrorMessage(
-      const MoqtSubscribeAnnouncesError& message) = 0;
-  virtual void OnUnsubscribeAnnouncesMessage(
-      const MoqtUnsubscribeAnnounces& message) = 0;
+  virtual void OnSubscribeNamespaceMessage(
+      const MoqtSubscribeNamespace& message) = 0;
+  virtual void OnSubscribeNamespaceOkMessage(
+      const MoqtSubscribeNamespaceOk& message) = 0;
+  virtual void OnSubscribeNamespaceErrorMessage(
+      const MoqtSubscribeNamespaceError& message) = 0;
+  virtual void OnUnsubscribeNamespaceMessage(
+      const MoqtUnsubscribeNamespace& message) = 0;
   virtual void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) = 0;
   virtual void OnFetchMessage(const MoqtFetch& message) = 0;
   virtual void OnFetchCancelMessage(const MoqtFetchCancel& message) = 0;
@@ -126,10 +126,10 @@
   size_t ProcessUnannounce(quic::QuicDataReader& reader);
   size_t ProcessTrackStatus(quic::QuicDataReader& reader);
   size_t ProcessGoAway(quic::QuicDataReader& reader);
-  size_t ProcessSubscribeAnnounces(quic::QuicDataReader& reader);
-  size_t ProcessSubscribeAnnouncesOk(quic::QuicDataReader& reader);
-  size_t ProcessSubscribeAnnouncesError(quic::QuicDataReader& reader);
-  size_t ProcessUnsubscribeAnnounces(quic::QuicDataReader& reader);
+  size_t ProcessSubscribeNamespace(quic::QuicDataReader& reader);
+  size_t ProcessSubscribeNamespaceOk(quic::QuicDataReader& reader);
+  size_t ProcessSubscribeNamespaceError(quic::QuicDataReader& reader);
+  size_t ProcessUnsubscribeNamespace(quic::QuicDataReader& reader);
   size_t ProcessMaxRequestId(quic::QuicDataReader& reader);
   size_t ProcessFetch(quic::QuicDataReader& reader);
   size_t ProcessFetchCancel(quic::QuicDataReader& reader);
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc
index dafe27c..1ef7ec5 100644
--- a/quiche/quic/moqt/moqt_parser_test.cc
+++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -48,10 +48,10 @@
     MoqtMessageType::kClientSetup,
     MoqtMessageType::kServerSetup,
     MoqtMessageType::kGoAway,
-    MoqtMessageType::kSubscribeAnnounces,
-    MoqtMessageType::kSubscribeAnnouncesOk,
-    MoqtMessageType::kSubscribeAnnouncesError,
-    MoqtMessageType::kUnsubscribeAnnounces,
+    MoqtMessageType::kSubscribeNamespace,
+    MoqtMessageType::kSubscribeNamespaceOk,
+    MoqtMessageType::kSubscribeNamespaceError,
+    MoqtMessageType::kUnsubscribeNamespace,
     MoqtMessageType::kMaxRequestId,
     MoqtMessageType::kFetch,
     MoqtMessageType::kFetchCancel,
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index b41d74e..dcdee31 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -253,14 +253,14 @@
   std::move(callbacks_.session_terminated_callback)(error);
 }
 
-bool MoqtSession::SubscribeAnnounces(
+bool MoqtSession::SubscribeNamespace(
     TrackNamespace track_namespace,
-    MoqtOutgoingSubscribeAnnouncesCallback callback,
+    MoqtOutgoingSubscribeNamespaceCallback callback,
     VersionSpecificParameters parameters) {
   QUICHE_DCHECK(track_namespace.IsValid());
   if (received_goaway_ || sent_goaway_) {
     QUIC_DLOG(INFO) << ENDPOINT
-                    << "Tried to send SUBSCRIBE_ANNOUNCES after GOAWAY";
+                    << "Tried to send SUBSCRIBE_NAMESPACE after GOAWAY";
     return false;
   }
   if (next_request_id_ >= peer_max_request_id_) {
@@ -271,7 +271,7 @@
       SendControlMessage(framer_.SerializeRequestsBlocked(requests_blocked));
       last_requests_blocked_sent_ = peer_max_request_id_;
     }
-    QUIC_DLOG(INFO) << ENDPOINT << "Tried to send SUBSCRIBE_ANNOUNCES with ID "
+    QUIC_DLOG(INFO) << ENDPOINT << "Tried to send SUBSCRIBE_NAMESPACE with ID "
                     << next_request_id_
                     << " which is greater than the maximum ID "
                     << peer_max_request_id_;
@@ -280,32 +280,32 @@
   if (outgoing_subscribe_announces_.contains(track_namespace)) {
     std::move(callback)(
         track_namespace, RequestErrorCode::kInternalError,
-        "SUBSCRIBE_ANNOUNCES already outstanding for namespace");
+        "SUBSCRIBE_NAMESPACE already outstanding for namespace");
     return false;
   }
-  MoqtSubscribeAnnounces message;
+  MoqtSubscribeNamespace message;
   message.request_id = next_request_id_;
   next_request_id_ += 2;
   message.track_namespace = track_namespace;
   message.parameters = parameters;
-  SendControlMessage(framer_.SerializeSubscribeAnnounces(message));
-  QUIC_DLOG(INFO) << ENDPOINT << "Sent SUBSCRIBE_ANNOUNCES message for "
+  SendControlMessage(framer_.SerializeSubscribeNamespace(message));
+  QUIC_DLOG(INFO) << ENDPOINT << "Sent SUBSCRIBE_NAMESPACE message for "
                   << message.track_namespace;
   pending_outgoing_subscribe_announces_[message.request_id] =
-      PendingSubscribeAnnouncesData{track_namespace, std::move(callback)};
+      PendingSubscribeNamespaceData{track_namespace, std::move(callback)};
   outgoing_subscribe_announces_.emplace(track_namespace);
   return true;
 }
 
-bool MoqtSession::UnsubscribeAnnounces(TrackNamespace track_namespace) {
+bool MoqtSession::UnsubscribeNamespace(TrackNamespace track_namespace) {
   QUICHE_DCHECK(track_namespace.IsValid());
   if (!outgoing_subscribe_announces_.contains(track_namespace)) {
     return false;
   }
-  MoqtUnsubscribeAnnounces message;
+  MoqtUnsubscribeNamespace message;
   message.track_namespace = track_namespace;
-  SendControlMessage(framer_.SerializeUnsubscribeAnnounces(message));
-  QUIC_DLOG(INFO) << ENDPOINT << "Sent UNSUBSCRIBE_ANNOUNCES message for "
+  SendControlMessage(framer_.SerializeUnsubscribeNamespace(message));
+  QUIC_DLOG(INFO) << ENDPOINT << "Sent UNSUBSCRIBE_NAMESPACE message for "
                   << message.track_namespace;
   outgoing_subscribe_announces_.erase(track_namespace);
   return true;
@@ -1334,77 +1334,77 @@
   }
 }
 
-void MoqtSession::ControlStream::OnSubscribeAnnouncesMessage(
-    const MoqtSubscribeAnnounces& message) {
+void MoqtSession::ControlStream::OnSubscribeNamespaceMessage(
+    const MoqtSubscribeNamespace& message) {
   if (!session_->ValidateRequestId(message.request_id)) {
     return;
   }
   // TODO(martinduke): Handle authentication.
   if (session_->sent_goaway_) {
     QUIC_DLOG(INFO) << ENDPOINT
-                    << "Received a SUBSCRIBE_ANNOUNCES after GOAWAY";
-    MoqtSubscribeAnnouncesError error;
+                    << "Received a SUBSCRIBE_NAMESPACE after GOAWAY";
+    MoqtSubscribeNamespaceError error;
     error.request_id = message.request_id;
     error.error_code = RequestErrorCode::kUnauthorized;
-    error.error_reason = "SUBSCRIBE_ANNOUNCES after GOAWAY";
+    error.error_reason = "SUBSCRIBE_NAMESPACE after GOAWAY";
     SendOrBufferMessage(
-        session_->framer_.SerializeSubscribeAnnouncesError(error));
+        session_->framer_.SerializeSubscribeNamespaceError(error));
     return;
   }
   if (!session_->incoming_subscribe_announces_.AddNamespace(
           message.track_namespace)) {
-    QUIC_DLOG(INFO) << ENDPOINT << "Received a SUBSCRIBE_ANNOUNCES for "
+    QUIC_DLOG(INFO) << ENDPOINT << "Received a SUBSCRIBE_NAMESPACE for "
                     << message.track_namespace
                     << " that is already subscribed to";
-    MoqtSubscribeAnnouncesError error;
+    MoqtSubscribeNamespaceError error;
     error.request_id = message.request_id;
     error.error_code = RequestErrorCode::kNamespacePrefixOverlap;
-    error.error_reason = "SUBSCRIBE_ANNOUNCES for similar subscribed namespace";
+    error.error_reason = "SUBSCRIBE_NAMESPACE for similar subscribed namespace";
     SendOrBufferMessage(
-        session_->framer_.SerializeSubscribeAnnouncesError(error));
+        session_->framer_.SerializeSubscribeNamespaceError(error));
     return;
   }
   std::optional<MoqtSubscribeErrorReason> result =
       session_->callbacks_.incoming_subscribe_announces_callback(
           message.track_namespace, message.parameters);
   if (result.has_value()) {
-    MoqtSubscribeAnnouncesError error;
+    MoqtSubscribeNamespaceError error;
     error.request_id = message.request_id;
     error.error_code = result->error_code;
     error.error_reason = result->reason_phrase;
     SendOrBufferMessage(
-        session_->framer_.SerializeSubscribeAnnouncesError(error));
+        session_->framer_.SerializeSubscribeNamespaceError(error));
     session_->incoming_subscribe_announces_.RemoveNamespace(
         message.track_namespace);
     return;
   }
-  MoqtSubscribeAnnouncesOk ok;
+  MoqtSubscribeNamespaceOk ok;
   ok.request_id = message.request_id;
-  SendOrBufferMessage(session_->framer_.SerializeSubscribeAnnouncesOk(ok));
+  SendOrBufferMessage(session_->framer_.SerializeSubscribeNamespaceOk(ok));
 }
 
-void MoqtSession::ControlStream::OnSubscribeAnnouncesOkMessage(
-    const MoqtSubscribeAnnouncesOk& message) {
+void MoqtSession::ControlStream::OnSubscribeNamespaceOkMessage(
+    const MoqtSubscribeNamespaceOk& message) {
   auto it =
       session_->pending_outgoing_subscribe_announces_.find(message.request_id);
   if (it == session_->pending_outgoing_subscribe_announces_.end()) {
     session_->Error(MoqtError::kProtocolViolation,
-                    "Received SUBSCRIBE_ANNOUNCES_OK for unknown request_id");
-    return;  // UNSUBSCRIBE_ANNOUNCES may already have deleted the entry.
+                    "Received SUBSCRIBE_NAMESPACE_OK for unknown request_id");
+    return;  // UNSUBSCRIBE_NAMESPACE may already have deleted the entry.
   }
   std::move(it->second.callback)(it->second.track_namespace, std::nullopt, "");
   session_->pending_outgoing_subscribe_announces_.erase(it);
 }
 
-void MoqtSession::ControlStream::OnSubscribeAnnouncesErrorMessage(
-    const MoqtSubscribeAnnouncesError& message) {
+void MoqtSession::ControlStream::OnSubscribeNamespaceErrorMessage(
+    const MoqtSubscribeNamespaceError& message) {
   auto it =
       session_->pending_outgoing_subscribe_announces_.find(message.request_id);
   if (it == session_->pending_outgoing_subscribe_announces_.end()) {
     session_->Error(
         MoqtError::kProtocolViolation,
-        "Received SUBSCRIBE_ANNOUNCES_ERROR for unknown request_id");
-    return;  // UNSUBSCRIBE_ANNOUNCES may already have deleted the entry.
+        "Received SUBSCRIBE_NAMESPACE_ERROR for unknown request_id");
+    return;  // UNSUBSCRIBE_NAMESPACE may already have deleted the entry.
   }
   std::move(it->second.callback)(it->second.track_namespace, message.error_code,
                                  absl::string_view(message.error_reason));
@@ -1412,8 +1412,8 @@
   session_->pending_outgoing_subscribe_announces_.erase(it);
 }
 
-void MoqtSession::ControlStream::OnUnsubscribeAnnouncesMessage(
-    const MoqtUnsubscribeAnnounces& message) {
+void MoqtSession::ControlStream::OnUnsubscribeNamespaceMessage(
+    const MoqtUnsubscribeNamespace& message) {
   // MoqtSession keeps no state here, so just tell the application.
   std::optional<MoqtSubscribeErrorReason> result =
       session_->callbacks_.incoming_subscribe_announces_callback(
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index 2467d41..252267e 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -98,10 +98,10 @@
   quic::Perspective perspective() const { return parameters_.perspective; }
 
   // Returns true if message was sent.
-  bool SubscribeAnnounces(TrackNamespace track_namespace,
-                          MoqtOutgoingSubscribeAnnouncesCallback callback,
+  bool SubscribeNamespace(TrackNamespace track_namespace,
+                          MoqtOutgoingSubscribeNamespaceCallback callback,
                           VersionSpecificParameters parameters);
-  bool UnsubscribeAnnounces(TrackNamespace track_namespace);
+  bool UnsubscribeNamespace(TrackNamespace track_namespace);
 
   // Send an ANNOUNCE message for |track_namespace|, and call
   // |announce_callback| when the response arrives. Will fail immediately if
@@ -256,14 +256,14 @@
     void OnUnannounceMessage(const MoqtUnannounce& /*message*/) override;
     void OnTrackStatusMessage(const MoqtTrackStatus& message) override {}
     void OnGoAwayMessage(const MoqtGoAway& /*message*/) override;
-    void OnSubscribeAnnouncesMessage(
-        const MoqtSubscribeAnnounces& message) override;
-    void OnSubscribeAnnouncesOkMessage(
-        const MoqtSubscribeAnnouncesOk& message) override;
-    void OnSubscribeAnnouncesErrorMessage(
-        const MoqtSubscribeAnnouncesError& message) override;
-    void OnUnsubscribeAnnouncesMessage(
-        const MoqtUnsubscribeAnnounces& message) override;
+    void OnSubscribeNamespaceMessage(
+        const MoqtSubscribeNamespace& message) override;
+    void OnSubscribeNamespaceOkMessage(
+        const MoqtSubscribeNamespaceOk& message) override;
+    void OnSubscribeNamespaceErrorMessage(
+        const MoqtSubscribeNamespaceError& message) override;
+    void OnUnsubscribeNamespaceMessage(
+        const MoqtUnsubscribeNamespace& message) override;
     void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) override;
     void OnFetchMessage(const MoqtFetch& message) override;
     void OnFetchCancelMessage(const MoqtFetchCancel& message) override {}
@@ -838,14 +838,14 @@
       outgoing_announces_;
 
   // The value is nullptr after OK or ERROR is received. The entry is deleted
-  // when sending UNSUBSCRIBE_ANNOUNCES, to make sure the application doesn't
+  // when sending UNSUBSCRIBE_NAMESPACE, to make sure the application doesn't
   // unsubscribe from something that it isn't subscribed to. ANNOUNCEs that
   // result from this subscription use incoming_announce_callback.
-  struct PendingSubscribeAnnouncesData {
+  struct PendingSubscribeNamespaceData {
     TrackNamespace track_namespace;
-    MoqtOutgoingSubscribeAnnouncesCallback callback;
+    MoqtOutgoingSubscribeNamespaceCallback callback;
   };
-  absl::flat_hash_map<uint64_t, PendingSubscribeAnnouncesData>
+  absl::flat_hash_map<uint64_t, PendingSubscribeNamespaceData>
       pending_outgoing_subscribe_announces_;
   absl::flat_hash_set<TrackNamespace> outgoing_subscribe_announces_;
   // It's an error if the namespaces overlap, so keep track of them.
diff --git a/quiche/quic/moqt/moqt_session_callbacks.h b/quiche/quic/moqt/moqt_session_callbacks.h
index 447bc00..cc0a35c 100644
--- a/quiche/quic/moqt/moqt_session_callbacks.h
+++ b/quiche/quic/moqt/moqt_session_callbacks.h
@@ -36,12 +36,12 @@
         const TrackNamespace& track_namespace,
         const std::optional<VersionSpecificParameters>& parameters)>;
 
-// Called whenever SUBSCRIBE_ANNOUNCES or UNSUBSCRIBE_ANNOUNCES is received from
-// the peer.  For SUBSCRIBE_ANNOUNCES, the return value indicates whether to
-// return an OK or an ERROR; for UNSUBSCRIBE_ANNOUNCES, the return value is
-// ignored. SUBSCRIBE_ANNOUNCES sets a value for |parameters|,
-// UNSUBSCRIBE_ANNOUNCES does not.
-using MoqtIncomingSubscribeAnnouncesCallback =
+// Called whenever SUBSCRIBE_NAMESPACE or UNSUBSCRIBE_NAMESPACE is received from
+// the peer.  For SUBSCRIBE_NAMESPACE, the return value indicates whether to
+// return an OK or an ERROR; for UNSUBSCRIBE_NAMESPACE, the return value is
+// ignored. SUBSCRIBE_NAMESPACE sets a value for |parameters|,
+// UNSUBSCRIBE_NAMESPACE does not.
+using MoqtIncomingSubscribeNamespaceCallback =
     quiche::MultiUseCallback<std::optional<MoqtSubscribeErrorReason>(
         const TrackNamespace& track_namespace,
         std::optional<VersionSpecificParameters> parameters)>;
@@ -55,12 +55,12 @@
 };
 
 inline std::optional<MoqtSubscribeErrorReason>
-DefaultIncomingSubscribeAnnouncesCallback(
+DefaultIncomingSubscribeNamespaceCallback(
     const TrackNamespace& track_namespace,
     std::optional<VersionSpecificParameters> /*parameters*/) {
   return MoqtSubscribeErrorReason{
       RequestErrorCode::kNotSupported,
-      "This endpoint does not support incoming SUBSCRIBE_ANNOUNCES messages"};
+      "This endpoint does not support incoming SUBSCRIBE_NAMESPACE messages"};
 }
 
 // Callbacks for session-level events.
@@ -74,8 +74,8 @@
 
   MoqtIncomingAnnounceCallback incoming_announce_callback =
       DefaultIncomingAnnounceCallback;
-  MoqtIncomingSubscribeAnnouncesCallback incoming_subscribe_announces_callback =
-      DefaultIncomingSubscribeAnnouncesCallback;
+  MoqtIncomingSubscribeNamespaceCallback incoming_subscribe_announces_callback =
+      DefaultIncomingSubscribeNamespaceCallback;
   const quic::QuicClock* clock = quic::QuicDefaultClock::Get();
 };
 
diff --git a/quiche/quic/moqt/moqt_session_interface.h b/quiche/quic/moqt/moqt_session_interface.h
index 6846c96..a6c0c46 100644
--- a/quiche/quic/moqt/moqt_session_interface.h
+++ b/quiche/quic/moqt/moqt_session_interface.h
@@ -26,7 +26,7 @@
     TrackNamespace track_namespace,
     std::optional<MoqtAnnounceErrorReason> error)>;
 
-using MoqtOutgoingSubscribeAnnouncesCallback = quiche::SingleUseCallback<void(
+using MoqtOutgoingSubscribeNamespaceCallback = quiche::SingleUseCallback<void(
     TrackNamespace track_namespace, std::optional<RequestErrorCode> error,
     absl::string_view reason)>;
 
@@ -110,7 +110,7 @@
 
   // TODO(martinduke): Add an API for absolute joining fetch.
 
-  // TODO: Add SubscribeAnnounces, UnsubscribeAnnounces method.
+  // TODO: Add SubscribeNamespace, UnsubscribeNamespace method.
   // TODO: Add Announce, Unannounce method.
   // TODO: Add AnnounceCancel method.
   // TODO: Add TrackStatusRequest method.
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index c290db0..adfb917 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -1009,15 +1009,15 @@
   stream_input->OnAnnounceMessage(announce);
 }
 
-TEST_F(MoqtSessionTest, SubscribeAnnouncesLifeCycle) {
+TEST_F(MoqtSessionTest, SubscribeNamespaceLifeCycle) {
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
   TrackNamespace track_namespace("foo");
   bool got_callback = false;
   EXPECT_CALL(
       mock_stream_,
-      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _));
-  session_.SubscribeAnnounces(
+      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespace), _));
+  session_.SubscribeNamespace(
       track_namespace,
       [&](const TrackNamespace& ns, std::optional<RequestErrorCode> error,
           absl::string_view reason) {
@@ -1027,27 +1027,27 @@
         EXPECT_EQ(reason, "");
       },
       VersionSpecificParameters());
-  MoqtSubscribeAnnouncesOk ok = {
+  MoqtSubscribeNamespaceOk ok = {
       kDefaultLocalRequestId,
   };
-  stream_input->OnSubscribeAnnouncesOkMessage(ok);
+  stream_input->OnSubscribeNamespaceOkMessage(ok);
   EXPECT_TRUE(got_callback);
   EXPECT_CALL(
       mock_stream_,
-      Writev(ControlMessageOfType(MoqtMessageType::kUnsubscribeAnnounces), _));
-  EXPECT_TRUE(session_.UnsubscribeAnnounces(track_namespace));
-  EXPECT_FALSE(session_.UnsubscribeAnnounces(track_namespace));
+      Writev(ControlMessageOfType(MoqtMessageType::kUnsubscribeNamespace), _));
+  EXPECT_TRUE(session_.UnsubscribeNamespace(track_namespace));
+  EXPECT_FALSE(session_.UnsubscribeNamespace(track_namespace));
 }
 
-TEST_F(MoqtSessionTest, SubscribeAnnouncesError) {
+TEST_F(MoqtSessionTest, SubscribeNamespaceError) {
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
   TrackNamespace track_namespace("foo");
   bool got_callback = false;
   EXPECT_CALL(
       mock_stream_,
-      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _));
-  session_.SubscribeAnnounces(
+      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespace), _));
+  session_.SubscribeNamespace(
       track_namespace,
       [&](const TrackNamespace& ns, std::optional<RequestErrorCode> error,
           absl::string_view reason) {
@@ -1058,15 +1058,15 @@
         EXPECT_EQ(reason, "deadbeef");
       },
       VersionSpecificParameters());
-  MoqtSubscribeAnnouncesError error = {
+  MoqtSubscribeNamespaceError error = {
       kDefaultLocalRequestId,
       RequestErrorCode::kInvalidRange,
       /*reason_phrase=*/"deadbeef",
   };
-  stream_input->OnSubscribeAnnouncesErrorMessage(error);
+  stream_input->OnSubscribeNamespaceErrorMessage(error);
   EXPECT_TRUE(got_callback);
   // Entry is immediately gone.
-  EXPECT_FALSE(session_.UnsubscribeAnnounces(track_namespace));
+  EXPECT_FALSE(session_.UnsubscribeNamespace(track_namespace));
 }
 
 TEST_F(MoqtSessionTest, IncomingObject) {
@@ -2711,11 +2711,11 @@
   data_stream.Receive("foo", false);
 }
 
-TEST_F(MoqtSessionTest, IncomingSubscribeAnnounces) {
+TEST_F(MoqtSessionTest, IncomingSubscribeNamespace) {
   TrackNamespace track_namespace = TrackNamespace{"foo"};
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
-  MoqtSubscribeAnnounces announces = {
+  MoqtSubscribeNamespace announces = {
       /*request_id=*/1,
       track_namespace,
       *parameters,
@@ -2728,22 +2728,22 @@
       .WillOnce(Return(std::nullopt));
   EXPECT_CALL(
       control_stream,
-      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesOk), _));
-  stream_input->OnSubscribeAnnouncesMessage(announces);
-  MoqtUnsubscribeAnnounces unsubscribe_announces = {
+      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _));
+  stream_input->OnSubscribeNamespaceMessage(announces);
+  MoqtUnsubscribeNamespace unsubscribe_announces = {
       TrackNamespace{"foo"},
   };
   EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
               Call(track_namespace, std::optional<VersionSpecificParameters>()))
       .WillOnce(Return(std::nullopt));
-  stream_input->OnUnsubscribeAnnouncesMessage(unsubscribe_announces);
+  stream_input->OnUnsubscribeNamespaceMessage(unsubscribe_announces);
 }
 
-TEST_F(MoqtSessionTest, IncomingSubscribeAnnouncesWithError) {
+TEST_F(MoqtSessionTest, IncomingSubscribeNamespaceWithError) {
   TrackNamespace track_namespace{"foo"};
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
-  MoqtSubscribeAnnounces announces = {
+  MoqtSubscribeNamespace announces = {
       /*request_id=*/1,
       track_namespace,
       *parameters,
@@ -2757,9 +2757,9 @@
           MoqtSubscribeErrorReason{RequestErrorCode::kUnauthorized, "foo"}));
   EXPECT_CALL(
       control_stream,
-      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError),
+      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError),
              _));
-  stream_input->OnSubscribeAnnouncesMessage(announces);
+  stream_input->OnSubscribeNamespaceMessage(announces);
 
   // Try again, to verify that it was purged from the tree.
   announces.request_id += 2;
@@ -2768,15 +2768,15 @@
       .WillOnce(Return(std::nullopt));
   EXPECT_CALL(
       control_stream,
-      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesOk), _));
-  stream_input->OnSubscribeAnnouncesMessage(announces);
+      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _));
+  stream_input->OnSubscribeNamespaceMessage(announces);
 }
 
-TEST_F(MoqtSessionTest, IncomingSubscribeAnnouncesWithPrefixOverlap) {
+TEST_F(MoqtSessionTest, IncomingSubscribeNamespaceWithPrefixOverlap) {
   TrackNamespace track_namespace{"foo"};
   auto parameters = std::make_optional<VersionSpecificParameters>(
       AuthTokenType::kOutOfBand, "foo");
-  MoqtSubscribeAnnounces announces = {
+  MoqtSubscribeNamespace announces = {
       /*request_id=*/1,
       track_namespace,
       *parameters,
@@ -2789,26 +2789,26 @@
       .WillOnce(Return(std::nullopt));
   EXPECT_CALL(
       control_stream,
-      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesOk), _));
-  stream_input->OnSubscribeAnnouncesMessage(announces);
+      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _));
+  stream_input->OnSubscribeNamespaceMessage(announces);
 
   // Overlapping request is rejected.
   announces.request_id += 2;
   announces.track_namespace = TrackNamespace{"foo", "bar"};
   EXPECT_CALL(
       control_stream,
-      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError),
+      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError),
              _));
-  stream_input->OnSubscribeAnnouncesMessage(announces);
+  stream_input->OnSubscribeNamespaceMessage(announces);
 
   // Remove the subscription. Now a later one will work.
-  MoqtUnsubscribeAnnounces unsubscribe_announces = {
+  MoqtUnsubscribeNamespace unsubscribe_announces = {
       TrackNamespace{"foo"},
   };
   EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
               Call(track_namespace, std::optional<VersionSpecificParameters>()))
       .WillOnce(Return(std::nullopt));
-  stream_input->OnUnsubscribeAnnouncesMessage(unsubscribe_announces);
+  stream_input->OnUnsubscribeNamespaceMessage(unsubscribe_announces);
 
   // Try again, it will work.
   announces.request_id += 2;
@@ -2817,8 +2817,8 @@
       .WillOnce(Return(std::nullopt));
   EXPECT_CALL(
       control_stream,
-      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesOk), _));
-  stream_input->OnSubscribeAnnouncesMessage(announces);
+      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _));
+  stream_input->OnSubscribeNamespaceMessage(announces);
 }
 
 TEST_F(MoqtSessionTest, FetchThenOkThenCancel) {
@@ -3362,7 +3362,7 @@
   EXPECT_FALSE(session_.SubscribeCurrentObject(FullTrackName("foo", "bar"),
                                                &remote_track_visitor,
                                                VersionSpecificParameters()));
-  EXPECT_FALSE(session_.SubscribeAnnounces(
+  EXPECT_FALSE(session_.SubscribeNamespace(
       TrackNamespace{"foo"},
       +[](TrackNamespace /*track_namespace*/,
           std::optional<RequestErrorCode> /*error*/,
@@ -3413,16 +3413,16 @@
   stream_input->OnFetchMessage(fetch);
   EXPECT_CALL(
       mock_stream_,
-      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError),
+      Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError),
              _));
-  stream_input->OnSubscribeAnnouncesMessage(MoqtSubscribeAnnounces(7));
+  stream_input->OnSubscribeNamespaceMessage(MoqtSubscribeNamespace(7));
   // Block all outgoing SUBSCRIBE, ANNOUNCE, GOAWAY,etc.
   EXPECT_CALL(mock_stream_, Writev).Times(0);
   MockSubscribeRemoteTrackVisitor remote_track_visitor;
   EXPECT_FALSE(session_.SubscribeCurrentObject(
       FullTrackName(TrackNamespace("foo"), "bar"), &remote_track_visitor,
       VersionSpecificParameters()));
-  EXPECT_FALSE(session_.SubscribeAnnounces(
+  EXPECT_FALSE(session_.SubscribeNamespace(
       TrackNamespace{"foo"},
       +[](TrackNamespace /*track_namespace*/,
           std::optional<RequestErrorCode> /*error*/,
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
index bc979d4..f6b14b4 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
@@ -74,17 +74,17 @@
   MoqtMessageType operator()(const MoqtGoAway&) {
     return MoqtMessageType::kGoAway;
   }
-  MoqtMessageType operator()(const MoqtSubscribeAnnounces&) {
-    return MoqtMessageType::kSubscribeAnnounces;
+  MoqtMessageType operator()(const MoqtSubscribeNamespace&) {
+    return MoqtMessageType::kSubscribeNamespace;
   }
-  MoqtMessageType operator()(const MoqtSubscribeAnnouncesOk&) {
-    return MoqtMessageType::kSubscribeAnnouncesOk;
+  MoqtMessageType operator()(const MoqtSubscribeNamespaceOk&) {
+    return MoqtMessageType::kSubscribeNamespaceOk;
   }
-  MoqtMessageType operator()(const MoqtSubscribeAnnouncesError&) {
-    return MoqtMessageType::kSubscribeAnnouncesError;
+  MoqtMessageType operator()(const MoqtSubscribeNamespaceError&) {
+    return MoqtMessageType::kSubscribeNamespaceError;
   }
-  MoqtMessageType operator()(const MoqtUnsubscribeAnnounces&) {
-    return MoqtMessageType::kUnsubscribeAnnounces;
+  MoqtMessageType operator()(const MoqtUnsubscribeNamespace&) {
+    return MoqtMessageType::kUnsubscribeNamespace;
   }
   MoqtMessageType operator()(const MoqtMaxRequestId&) {
     return MoqtMessageType::kMaxRequestId;
@@ -167,17 +167,17 @@
   quiche::QuicheBuffer operator()(const MoqtGoAway& message) {
     return framer.SerializeGoAway(message);
   }
-  quiche::QuicheBuffer operator()(const MoqtSubscribeAnnounces& message) {
-    return framer.SerializeSubscribeAnnounces(message);
+  quiche::QuicheBuffer operator()(const MoqtSubscribeNamespace& message) {
+    return framer.SerializeSubscribeNamespace(message);
   }
-  quiche::QuicheBuffer operator()(const MoqtSubscribeAnnouncesOk& message) {
-    return framer.SerializeSubscribeAnnouncesOk(message);
+  quiche::QuicheBuffer operator()(const MoqtSubscribeNamespaceOk& message) {
+    return framer.SerializeSubscribeNamespaceOk(message);
   }
-  quiche::QuicheBuffer operator()(const MoqtSubscribeAnnouncesError& message) {
-    return framer.SerializeSubscribeAnnouncesError(message);
+  quiche::QuicheBuffer operator()(const MoqtSubscribeNamespaceError& message) {
+    return framer.SerializeSubscribeNamespaceError(message);
   }
-  quiche::QuicheBuffer operator()(const MoqtUnsubscribeAnnounces& message) {
-    return framer.SerializeUnsubscribeAnnounces(message);
+  quiche::QuicheBuffer operator()(const MoqtUnsubscribeNamespace& message) {
+    return framer.SerializeUnsubscribeNamespace(message);
   }
   quiche::QuicheBuffer operator()(const MoqtMaxRequestId& message) {
     return framer.SerializeMaxRequestId(message);
@@ -266,17 +266,17 @@
   void OnGoAwayMessage(const MoqtGoAway& message) {
     frames_.push_back(message);
   }
-  void OnSubscribeAnnouncesMessage(const MoqtSubscribeAnnounces& message) {
+  void OnSubscribeNamespaceMessage(const MoqtSubscribeNamespace& message) {
     frames_.push_back(message);
   }
-  void OnSubscribeAnnouncesOkMessage(const MoqtSubscribeAnnouncesOk& message) {
+  void OnSubscribeNamespaceOkMessage(const MoqtSubscribeNamespaceOk& message) {
     frames_.push_back(message);
   }
-  void OnSubscribeAnnouncesErrorMessage(
-      const MoqtSubscribeAnnouncesError& message) {
+  void OnSubscribeNamespaceErrorMessage(
+      const MoqtSubscribeNamespaceError& message) {
     frames_.push_back(message);
   }
-  void OnUnsubscribeAnnouncesMessage(const MoqtUnsubscribeAnnounces& message) {
+  void OnUnsubscribeNamespaceMessage(const MoqtUnsubscribeNamespace& message) {
     frames_.push_back(message);
   }
   void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) {
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
index 1b6e996..54a704c 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -31,8 +31,8 @@
                  MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce,
                  MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel,
                  MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
-                 MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk,
-                 MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces,
+                 MoqtGoAway, MoqtSubscribeNamespace, MoqtSubscribeNamespaceOk,
+                 MoqtSubscribeNamespaceError, MoqtUnsubscribeNamespace,
                  MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
                  MoqtFetchError, MoqtRequestsBlocked, MoqtPublish,
                  MoqtPublishOk, MoqtPublishError, MoqtObjectAck>;
diff --git a/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h b/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
index 71ff1b3..c29edb6 100644
--- a/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
+++ b/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
@@ -91,20 +91,20 @@
   void OnGoAwayMessage(const MoqtGoAway& message) override {
     OnControlMessage(message);
   }
-  void OnSubscribeAnnouncesMessage(
-      const MoqtSubscribeAnnounces& message) override {
+  void OnSubscribeNamespaceMessage(
+      const MoqtSubscribeNamespace& message) override {
     OnControlMessage(message);
   }
-  void OnSubscribeAnnouncesOkMessage(
-      const MoqtSubscribeAnnouncesOk& message) override {
+  void OnSubscribeNamespaceOkMessage(
+      const MoqtSubscribeNamespaceOk& message) override {
     OnControlMessage(message);
   }
-  void OnSubscribeAnnouncesErrorMessage(
-      const MoqtSubscribeAnnouncesError& message) override {
+  void OnSubscribeNamespaceErrorMessage(
+      const MoqtSubscribeNamespaceError& message) override {
     OnControlMessage(message);
   }
-  void OnUnsubscribeAnnouncesMessage(
-      const MoqtUnsubscribeAnnounces& message) override {
+  void OnUnsubscribeNamespaceMessage(
+      const MoqtUnsubscribeNamespace& message) override {
     OnControlMessage(message);
   }
   void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) override {
diff --git a/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc b/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc
index d954f18..5d17a47 100644
--- a/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc
+++ b/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc
@@ -40,7 +40,7 @@
   return MoqtSessionCallbacks(
       +[] {}, +[](absl::string_view) {}, +[](absl::string_view) {}, +[] {},
       DefaultIncomingAnnounceCallback,
-      DefaultIncomingSubscribeAnnouncesCallback, simulator->GetClock());
+      DefaultIncomingSubscribeNamespaceCallback, simulator->GetClock());
 }
 }  // namespace
 
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index 211b5e0..55edb39 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -67,8 +67,8 @@
                    MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce,
                    MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel,
                    MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
-                   MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk,
-                   MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces,
+                   MoqtGoAway, MoqtSubscribeNamespace, MoqtSubscribeNamespaceOk,
+                   MoqtSubscribeNamespaceError, MoqtUnsubscribeNamespace,
                    MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
                    MoqtFetchError, MoqtRequestsBlocked, MoqtPublish,
                    MoqtPublishOk, MoqtPublishError, MoqtObjectAck>;
@@ -1255,14 +1255,14 @@
   };
 };
 
-class QUICHE_NO_EXPORT SubscribeAnnouncesMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT SubscribeNamespaceMessage : public TestMessageBase {
  public:
-  SubscribeAnnouncesMessage() : TestMessageBase() {
+  SubscribeNamespaceMessage() : TestMessageBase() {
     SetWireImage(raw_packet_, sizeof(raw_packet_));
   }
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
-    auto cast = std::get<MoqtSubscribeAnnounces>(values);
+    auto cast = std::get<MoqtSubscribeNamespace>(values);
     if (cast.request_id != subscribe_namespace_.request_id) {
       QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE request_id mismatch";
       return false;
@@ -1292,21 +1292,21 @@
       0x03, 0x05, 0x03, 0x00, 0x62, 0x61, 0x72,  // authorization_tag = "bar"
   };
 
-  MoqtSubscribeAnnounces subscribe_namespace_ = {
+  MoqtSubscribeNamespace subscribe_namespace_ = {
       /*request_id=*/1,
       TrackNamespace("foo"),
       VersionSpecificParameters(AuthTokenType::kOutOfBand, "bar"),
   };
 };
 
-class QUICHE_NO_EXPORT SubscribeAnnouncesOkMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT SubscribeNamespaceOkMessage : public TestMessageBase {
  public:
-  SubscribeAnnouncesOkMessage() : TestMessageBase() {
+  SubscribeNamespaceOkMessage() : TestMessageBase() {
     SetWireImage(raw_packet_, sizeof(raw_packet_));
   }
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
-    auto cast = std::get<MoqtSubscribeAnnouncesOk>(values);
+    auto cast = std::get<MoqtSubscribeNamespaceOk>(values);
     if (cast.request_id != subscribe_namespace_ok_.request_id) {
       QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_OK request_id mismatch";
       return false;
@@ -1325,19 +1325,19 @@
       0x12, 0x00, 0x01, 0x01,  // request_id = 1
   };
 
-  MoqtSubscribeAnnouncesOk subscribe_namespace_ok_ = {
+  MoqtSubscribeNamespaceOk subscribe_namespace_ok_ = {
       /*request_id=*/1,
   };
 };
 
-class QUICHE_NO_EXPORT SubscribeAnnouncesErrorMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT SubscribeNamespaceErrorMessage : public TestMessageBase {
  public:
-  SubscribeAnnouncesErrorMessage() : TestMessageBase() {
+  SubscribeNamespaceErrorMessage() : TestMessageBase() {
     SetWireImage(raw_packet_, sizeof(raw_packet_));
   }
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
-    auto cast = std::get<MoqtSubscribeAnnouncesError>(values);
+    auto cast = std::get<MoqtSubscribeNamespaceError>(values);
     if (cast.request_id != subscribe_namespace_error_.request_id) {
       QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR request_id mismatch";
       return false;
@@ -1366,21 +1366,21 @@
       0x03, 0x62, 0x61, 0x72,  // error_reason = "bar"
   };
 
-  MoqtSubscribeAnnouncesError subscribe_namespace_error_ = {
+  MoqtSubscribeNamespaceError subscribe_namespace_error_ = {
       /*request_id=*/1,
       /*error_code=*/RequestErrorCode::kUnauthorized,
       /*error_reason=*/"bar",
   };
 };
 
-class QUICHE_NO_EXPORT UnsubscribeAnnouncesMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT UnsubscribeNamespaceMessage : public TestMessageBase {
  public:
-  UnsubscribeAnnouncesMessage() : TestMessageBase() {
+  UnsubscribeNamespaceMessage() : TestMessageBase() {
     SetWireImage(raw_packet_, sizeof(raw_packet_));
   }
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
-    auto cast = std::get<MoqtUnsubscribeAnnounces>(values);
+    auto cast = std::get<MoqtUnsubscribeNamespace>(values);
     if (cast.track_namespace != unsubscribe_namespace_.track_namespace) {
       QUIC_LOG(INFO) << "UNSUBSCRIBE_NAMESPACE track namespace mismatch";
       return false;
@@ -1399,7 +1399,7 @@
       0x14, 0x00, 0x05, 0x01, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace
   };
 
-  MoqtUnsubscribeAnnounces unsubscribe_namespace_ = {
+  MoqtUnsubscribeNamespace unsubscribe_namespace_ = {
       TrackNamespace("foo"),
   };
 };
@@ -2077,14 +2077,14 @@
       return std::make_unique<TrackStatusMessage>();
     case MoqtMessageType::kGoAway:
       return std::make_unique<GoAwayMessage>();
-    case MoqtMessageType::kSubscribeAnnounces:
-      return std::make_unique<SubscribeAnnouncesMessage>();
-    case MoqtMessageType::kSubscribeAnnouncesOk:
-      return std::make_unique<SubscribeAnnouncesOkMessage>();
-    case MoqtMessageType::kSubscribeAnnouncesError:
-      return std::make_unique<SubscribeAnnouncesErrorMessage>();
-    case MoqtMessageType::kUnsubscribeAnnounces:
-      return std::make_unique<UnsubscribeAnnouncesMessage>();
+    case MoqtMessageType::kSubscribeNamespace:
+      return std::make_unique<SubscribeNamespaceMessage>();
+    case MoqtMessageType::kSubscribeNamespaceOk:
+      return std::make_unique<SubscribeNamespaceOkMessage>();
+    case MoqtMessageType::kSubscribeNamespaceError:
+      return std::make_unique<SubscribeNamespaceErrorMessage>();
+    case MoqtMessageType::kUnsubscribeNamespace:
+      return std::make_unique<UnsubscribeNamespaceMessage>();
     case MoqtMessageType::kMaxRequestId:
       return std::make_unique<MaxRequestIdMessage>();
     case MoqtMessageType::kFetch:
diff --git a/quiche/quic/moqt/tools/chat_client.cc b/quiche/quic/moqt/tools/chat_client.cc
index 26525da..1bfb70e 100644
--- a/quiche/quic/moqt/tools/chat_client.cc
+++ b/quiche/quic/moqt/tools/chat_client.cc
@@ -150,8 +150,8 @@
     return;
   }
   if (input_message == "/exit") {
-    // Clean teardown of SUBSCRIBE_ANNOUNCES, ANNOUNCE, SUBSCRIBE.
-    session_->UnsubscribeAnnounces(GetChatNamespace(my_track_name_));
+    // Clean teardown of SUBSCRIBE_NAMESPACE, ANNOUNCE, SUBSCRIBE.
+    session_->UnsubscribeNamespace(GetChatNamespace(my_track_name_));
     session_->Unannounce(GetUserNamespace(my_track_name_));
     for (const auto& track_name : other_users_) {
       session_->Unsubscribe(track_name);
@@ -205,7 +205,7 @@
   client_->WriteToOutput(GetUsername(*it), object);
 }
 
-bool ChatClient::AnnounceAndSubscribeAnnounces() {
+bool ChatClient::AnnounceAndSubscribeNamespace() {
   session_ = client_->session();
   if (session_ == nullptr) {
     std::cout << "Failed to connect.\n";
@@ -236,22 +236,22 @@
 
   // Send SUBSCRIBE_ANNOUNCE. Pop 3 levels of namespace to get to {moq-chat,
   // chat-id}
-  MoqtOutgoingSubscribeAnnouncesCallback subscribe_announces_callback =
+  MoqtOutgoingSubscribeNamespaceCallback subscribe_announces_callback =
       [this](TrackNamespace track_namespace,
              std::optional<RequestErrorCode> error, absl::string_view reason) {
         if (error.has_value()) {
-          std::cout << "SUBSCRIBE_ANNOUNCES rejected, " << reason << "\n";
+          std::cout << "SUBSCRIBE_NAMESPACE rejected, " << reason << "\n";
           session_->Error(MoqtError::kInternalError,
-                          "Local SUBSCRIBE_ANNOUNCES rejected");
+                          "Local SUBSCRIBE_NAMESPACE rejected");
           return;
         }
-        std::cout << "SUBSCRIBE_ANNOUNCES for " << track_namespace.ToString()
+        std::cout << "SUBSCRIBE_NAMESPACE for " << track_namespace.ToString()
                   << " accepted\n";
         return;
       };
   VersionSpecificParameters parameters(
       AuthTokenType::kOutOfBand, std::string(GetUsername(my_track_name_)));
-  session_->SubscribeAnnounces(GetChatNamespace(my_track_name_),
+  session_->SubscribeNamespace(GetChatNamespace(my_track_name_),
                                std::move(subscribe_announces_callback),
                                parameters);
 
diff --git a/quiche/quic/moqt/tools/chat_client.h b/quiche/quic/moqt/tools/chat_client.h
index bf15fa7..07a668c 100644
--- a/quiche/quic/moqt/tools/chat_client.h
+++ b/quiche/quic/moqt/tools/chat_client.h
@@ -113,7 +113,7 @@
   };
 
   // Returns false on error.
-  bool AnnounceAndSubscribeAnnounces();
+  bool AnnounceAndSubscribeNamespace();
 
   bool session_is_open() const { return session_is_open_; }
 
diff --git a/quiche/quic/moqt/tools/chat_client_bin.cc b/quiche/quic/moqt/tools/chat_client_bin.cc
index 5e9125c..e627ea4 100644
--- a/quiche/quic/moqt/tools/chat_client_bin.cc
+++ b/quiche/quic/moqt/tools/chat_client_bin.cc
@@ -152,7 +152,7 @@
   if (!client.Connect(path)) {
     return 1;
   }
-  if (!client.AnnounceAndSubscribeAnnounces()) {
+  if (!client.AnnounceAndSubscribeNamespace()) {
     return 1;
   }
   client.IoLoop();
diff --git a/quiche/quic/moqt/tools/chat_server.cc b/quiche/quic/moqt/tools/chat_server.cc
index 268c912..acc818c 100644
--- a/quiche/quic/moqt/tools/chat_server.cc
+++ b/quiche/quic/moqt/tools/chat_server.cc
@@ -88,10 +88,10 @@
              std::optional<VersionSpecificParameters> parameters) {
         if (parameters.has_value()) {
           subscribed_namespaces_.insert(chat_namespace);
-          std::cout << "Received SUBSCRIBE_ANNOUNCES for ";
+          std::cout << "Received SUBSCRIBE_NAMESPACE for ";
         } else {
           subscribed_namespaces_.erase(chat_namespace);
-          std::cout << "Received UNSUBSCRIBE_ANNOUNCES for ";
+          std::cout << "Received UNSUBSCRIBE_NAMESPACE for ";
         }
         std::cout << chat_namespace.ToString() << "\n";
         if (!IsValidChatNamespace(chat_namespace)) {
diff --git a/quiche/quic/moqt/tools/moq_chat.h b/quiche/quic/moqt/tools/moq_chat.h
index 3478b8b..9d43814 100644
--- a/quiche/quic/moqt/tools/moq_chat.h
+++ b/quiche/quic/moqt/tools/moq_chat.h
@@ -47,7 +47,7 @@
 // Strips "chat" from the end of |track_name| to use in ANNOUNCE.
 const TrackNamespace& GetUserNamespace(const FullTrackName& track_name);
 
-// Returns {"moq-chat", chat-id}, useful for SUBSCRIBE_ANNOUNCES.
+// Returns {"moq-chat", chat-id}, useful for SUBSCRIBE_NAMESPACE.
 TrackNamespace GetChatNamespace(const TrackNamespace& track_name);
 TrackNamespace GetChatNamespace(const FullTrackName& track_name);
 
diff --git a/quiche/quic/moqt/tools/moq_chat_end_to_end_test.cc b/quiche/quic/moqt/tools/moq_chat_end_to_end_test.cc
index 8807363..f808d47 100644
--- a/quiche/quic/moqt/tools/moq_chat_end_to_end_test.cc
+++ b/quiche/quic/moqt/tools/moq_chat_end_to_end_test.cc
@@ -96,8 +96,8 @@
 TEST_F(MoqChatEndToEndTest, EndToEndTest) {
   EXPECT_TRUE(client1_->Connect(moqt::moq_chat::kWebtransPath));
   EXPECT_TRUE(client2_->Connect(moqt::moq_chat::kWebtransPath));
-  EXPECT_TRUE(client1_->AnnounceAndSubscribeAnnounces());
-  EXPECT_TRUE(client2_->AnnounceAndSubscribeAnnounces());
+  EXPECT_TRUE(client1_->AnnounceAndSubscribeNamespace());
+  EXPECT_TRUE(client2_->AnnounceAndSubscribeNamespace());
   SendAndWaitForOutput(interface1_, interface2_, "client1", "Hello");
   SendAndWaitForOutput(interface2_, interface1_, "client2", "Hi");
   SendAndWaitForOutput(interface1_, interface2_, "client1", "How are you?");
@@ -113,8 +113,8 @@
 TEST_F(MoqChatEndToEndTest, LeaveAndRejoin) {
   EXPECT_TRUE(client1_->Connect(moqt::moq_chat::kWebtransPath));
   EXPECT_TRUE(client2_->Connect(moqt::moq_chat::kWebtransPath));
-  EXPECT_TRUE(client1_->AnnounceAndSubscribeAnnounces());
-  EXPECT_TRUE(client2_->AnnounceAndSubscribeAnnounces());
+  EXPECT_TRUE(client1_->AnnounceAndSubscribeNamespace());
+  EXPECT_TRUE(client2_->AnnounceAndSubscribeNamespace());
   SendAndWaitForOutput(interface1_, interface2_, "client1", "Hello");
   SendAndWaitForOutput(interface2_, interface1_, "client2", "Hi");
 
@@ -136,7 +136,7 @@
       std::move(if1bptr), "test_chat", "client1", "device1",
       server_.moqt_server().quic_server().event_loop());
   EXPECT_TRUE(client1_->Connect(moqt::moq_chat::kWebtransPath));
-  EXPECT_TRUE(client1_->AnnounceAndSubscribeAnnounces());
+  EXPECT_TRUE(client1_->AnnounceAndSubscribeNamespace());
   SendAndWaitForOutput(interface1b_, interface2_, "client1", "Hello again");
   SendAndWaitForOutput(interface2_, interface1b_, "client2", "Hi again");
 }
diff --git a/quiche/quic/moqt/tools/moqt_mock_visitor.h b/quiche/quic/moqt/tools/moqt_mock_visitor.h
index cc46881..f786918 100644
--- a/quiche/quic/moqt/tools/moqt_mock_visitor.h
+++ b/quiche/quic/moqt/tools/moqt_mock_visitor.h
@@ -40,7 +40,7 @@
     ON_CALL(incoming_announce_callback, Call(testing::_, testing::_))
         .WillByDefault(DefaultIncomingAnnounceCallback);
     ON_CALL(incoming_subscribe_announces_callback, Call(testing::_, testing::_))
-        .WillByDefault(DefaultIncomingSubscribeAnnouncesCallback);
+        .WillByDefault(DefaultIncomingSubscribeNamespaceCallback);
   }
 
   MoqtSessionCallbacks AsSessionCallbacks() {