diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index 4b27575..805e478 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -388,10 +388,12 @@
   kExpiredAuthToken = 0x12,
 };
 
-struct MoqtSubscribeErrorReason {
+struct MoqtRequestError {
   RequestErrorCode error_code;
   std::string reason_phrase;
 };
+// TODO(martinduke): These are deprecated. Replace them in the code.
+using MoqtSubscribeErrorReason = MoqtRequestError;
 using MoqtAnnounceErrorReason = MoqtSubscribeErrorReason;
 
 class TrackNamespace {
diff --git a/quiche/quic/moqt/moqt_relay_publisher_test.cc b/quiche/quic/moqt/moqt_relay_publisher_test.cc
index abe7af0..0cb83b4 100644
--- a/quiche/quic/moqt/moqt_relay_publisher_test.cc
+++ b/quiche/quic/moqt/moqt_relay_publisher_test.cc
@@ -27,23 +27,20 @@
               (override));
   MOCK_METHOD(bool, SubscribeAbsolute,
               (const FullTrackName& name, uint64_t start_group,
-               uint64_t start_object, SubscribeRemoteTrack::Visitor* visitor,
+               uint64_t start_object, SubscribeVisitor* visitor,
                VersionSpecificParameters parameters),
               (override));
   MOCK_METHOD(bool, SubscribeAbsolute,
               (const FullTrackName& name, uint64_t start_group,
                uint64_t start_object, uint64_t end_group,
-               SubscribeRemoteTrack::Visitor* visitor,
-               VersionSpecificParameters parameters),
+               SubscribeVisitor* visitor, VersionSpecificParameters parameters),
               (override));
   MOCK_METHOD(bool, SubscribeCurrentObject,
-              (const FullTrackName& name,
-               SubscribeRemoteTrack::Visitor* visitor,
+              (const FullTrackName& name, SubscribeVisitor* visitor,
                VersionSpecificParameters parameters),
               (override));
   MOCK_METHOD(bool, SubscribeNextGroup,
-              (const FullTrackName& name,
-               SubscribeRemoteTrack::Visitor* visitor,
+              (const FullTrackName& name, SubscribeVisitor* visitor,
                VersionSpecificParameters parameters),
               (override));
   MOCK_METHOD(bool, SubscribeUpdate,
@@ -62,14 +59,12 @@
                VersionSpecificParameters parameters),
               (override));
   MOCK_METHOD(bool, RelativeJoiningFetch,
-              (const FullTrackName& name,
-               SubscribeRemoteTrack::Visitor* visitor,
+              (const FullTrackName& name, SubscribeVisitor* visitor,
                uint64_t num_previous_groups,
                VersionSpecificParameters parameters),
               (override));
   MOCK_METHOD(bool, RelativeJoiningFetch,
-              (const FullTrackName& name,
-               SubscribeRemoteTrack::Visitor* visitor,
+              (const FullTrackName& name, SubscribeVisitor* visitor,
                FetchResponseCallback callback, uint64_t num_previous_groups,
                MoqtPriority priority,
                std::optional<MoqtDeliveryOrder> delivery_order,
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher.h b/quiche/quic/moqt/moqt_relay_track_publisher.h
index 2a1d153..c379f34 100644
--- a/quiche/quic/moqt/moqt_relay_track_publisher.h
+++ b/quiche/quic/moqt/moqt_relay_track_publisher.h
@@ -40,7 +40,7 @@
 // This class is primarily meant to be used by live relays to buffer the
 // frames that arrive for a short time.
 class MoqtRelayTrackPublisher : public MoqtTrackPublisher,
-                                public SubscribeRemoteTrack::Visitor {
+                                public SubscribeVisitor {
  public:
   MoqtRelayTrackPublisher(
       FullTrackName track,
@@ -60,7 +60,7 @@
   MoqtRelayTrackPublisher& operator=(const MoqtRelayTrackPublisher&) = delete;
   MoqtRelayTrackPublisher& operator=(MoqtRelayTrackPublisher&&) = default;
 
-  // SubscribeRemoteTrack::Visitor implementation.
+  // SubscribeVisitor implementation.
   // TODO(martinduke): Implement these.
   void OnReply(
       const FullTrackName& /*full_track_name*/,
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index 1dc806b..ee45395 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -227,7 +227,7 @@
     return;
   }
   QUICHE_CHECK(!track->is_fetch());
-  SubscribeRemoteTrack::Visitor* visitor = track->visitor();
+  SubscribeVisitor* visitor = track->visitor();
   if (visitor != nullptr) {
     // TODO(martinduke): Handle extension headers.
     PublishedObjectMetadata metadata;
@@ -380,7 +380,7 @@
 
 bool MoqtSession::SubscribeAbsolute(const FullTrackName& name,
                                     uint64_t start_group, uint64_t start_object,
-                                    SubscribeRemoteTrack::Visitor* visitor,
+                                    SubscribeVisitor* visitor,
                                     VersionSpecificParameters parameters) {
   QUICHE_DCHECK(name.IsValid());
   MoqtSubscribe message;
@@ -398,7 +398,7 @@
 bool MoqtSession::SubscribeAbsolute(const FullTrackName& name,
                                     uint64_t start_group, uint64_t start_object,
                                     uint64_t end_group,
-                                    SubscribeRemoteTrack::Visitor* visitor,
+                                    SubscribeVisitor* visitor,
                                     VersionSpecificParameters parameters) {
   QUICHE_DCHECK(name.IsValid());
   if (end_group < start_group) {
@@ -418,7 +418,7 @@
 }
 
 bool MoqtSession::SubscribeCurrentObject(const FullTrackName& name,
-                                         SubscribeRemoteTrack::Visitor* visitor,
+                                         SubscribeVisitor* visitor,
                                          VersionSpecificParameters parameters) {
   QUICHE_DCHECK(name.IsValid());
   MoqtSubscribe message;
@@ -434,7 +434,7 @@
 }
 
 bool MoqtSession::SubscribeNextGroup(const FullTrackName& name,
-                                     SubscribeRemoteTrack::Visitor* visitor,
+                                     SubscribeVisitor* visitor,
                                      VersionSpecificParameters parameters) {
   QUICHE_DCHECK(name.IsValid());
   MoqtSubscribe message;
@@ -541,7 +541,7 @@
 }
 
 bool MoqtSession::RelativeJoiningFetch(const FullTrackName& name,
-                                       SubscribeRemoteTrack::Visitor* visitor,
+                                       SubscribeVisitor* visitor,
                                        uint64_t num_previous_groups,
                                        VersionSpecificParameters parameters) {
   QUICHE_DCHECK(name.IsValid());
@@ -563,7 +563,7 @@
 }
 
 bool MoqtSession::RelativeJoiningFetch(
-    const FullTrackName& name, SubscribeRemoteTrack::Visitor* visitor,
+    const FullTrackName& name, SubscribeVisitor* visitor,
     FetchResponseCallback callback, uint64_t num_previous_groups,
     MoqtPriority priority, std::optional<MoqtDeliveryOrder> delivery_order,
     VersionSpecificParameters parameters) {
@@ -717,8 +717,7 @@
   }
 }
 
-bool MoqtSession::Subscribe(MoqtSubscribe& message,
-                            SubscribeRemoteTrack::Visitor* visitor) {
+bool MoqtSession::Subscribe(MoqtSubscribe& message, SubscribeVisitor* visitor) {
   // TODO(martinduke): support authorization info
   if (next_request_id_ >= peer_max_request_id_) {
     if (!last_requests_blocked_sent_.has_value() ||
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index c274748..571d659 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -118,18 +118,16 @@
   MoqtSessionCallbacks& callbacks() override { return callbacks_; }
   void Error(MoqtError code, absl::string_view error) override;
   bool SubscribeAbsolute(const FullTrackName& name, uint64_t start_group,
-                         uint64_t start_object,
-                         SubscribeRemoteTrack::Visitor* visitor,
+                         uint64_t start_object, SubscribeVisitor* visitor,
                          VersionSpecificParameters parameters) override;
   bool SubscribeAbsolute(const FullTrackName& name, uint64_t start_group,
                          uint64_t start_object, uint64_t end_group,
-                         SubscribeRemoteTrack::Visitor* visitor,
+                         SubscribeVisitor* visitor,
                          VersionSpecificParameters parameters) override;
   bool SubscribeCurrentObject(const FullTrackName& name,
-                              SubscribeRemoteTrack::Visitor* visitor,
+                              SubscribeVisitor* visitor,
                               VersionSpecificParameters parameters) override;
-  bool SubscribeNextGroup(const FullTrackName& name,
-                          SubscribeRemoteTrack::Visitor* visitor,
+  bool SubscribeNextGroup(const FullTrackName& name, SubscribeVisitor* visitor,
                           VersionSpecificParameters parameters) override;
   bool SubscribeUpdate(const FullTrackName& name, std::optional<Location> start,
                        std::optional<uint64_t> end_group,
@@ -143,11 +141,11 @@
              std::optional<MoqtDeliveryOrder> delivery_order,
              VersionSpecificParameters parameters) override;
   bool RelativeJoiningFetch(const FullTrackName& name,
-                            SubscribeRemoteTrack::Visitor* visitor,
+                            SubscribeVisitor* visitor,
                             uint64_t num_previous_groups,
                             VersionSpecificParameters parameters) override;
   bool RelativeJoiningFetch(const FullTrackName& name,
-                            SubscribeRemoteTrack::Visitor* visitor,
+                            SubscribeVisitor* visitor,
                             FetchResponseCallback callback,
                             uint64_t num_previous_groups, MoqtPriority priority,
                             std::optional<MoqtDeliveryOrder> delivery_order,
@@ -718,8 +716,7 @@
   void SendControlMessage(quiche::QuicheBuffer message);
 
   // Returns false if the SUBSCRIBE isn't sent.
-  bool Subscribe(MoqtSubscribe& message,
-                 SubscribeRemoteTrack::Visitor* visitor);
+  bool Subscribe(MoqtSubscribe& message, SubscribeVisitor* visitor);
 
   // Opens a new data stream, or queues it if the session is flow control
   // blocked.
diff --git a/quiche/quic/moqt/moqt_session_interface.h b/quiche/quic/moqt/moqt_session_interface.h
index a703a3d..5083a09 100644
--- a/quiche/quic/moqt/moqt_session_interface.h
+++ b/quiche/quic/moqt/moqt_session_interface.h
@@ -6,18 +6,66 @@
 #define QUICHE_QUIC_MOQT_MOQT_SESSION_INTERFACE_H_
 
 #include <cstdint>
+#include <memory>
 #include <optional>
 
 #include "absl/strings/string_view.h"
+#include "quiche/quic/core/quic_time.h"
+#include "quiche/quic/moqt/moqt_fetch_task.h"
 #include "quiche/quic/moqt/moqt_messages.h"
+#include "quiche/quic/moqt/moqt_object.h"
 #include "quiche/quic/moqt/moqt_priority.h"
 #include "quiche/quic/moqt/moqt_session_callbacks.h"
-#include "quiche/quic/moqt/moqt_track.h"
 #include "quiche/common/quiche_callbacks.h"
 #include "quiche/common/quiche_weak_ptr.h"
 
 namespace moqt {
 
+// The callback we'll use for all request types going forward. Can only be used
+// once; if the argument is nullopt, an OK response was received. Otherwise, an
+// ERROR response was received.
+using MoqtRequestCallback =
+    quiche::SingleUseCallback<void(std::optional<MoqtRequestError>)>;
+
+using MoqtObjectAckFunction =
+    quiche::MultiUseCallback<void(uint64_t group_id, uint64_t object_id,
+                                  quic::QuicTimeDelta delta_from_deadline)>;
+
+class SubscribeVisitor {
+ public:
+  virtual ~SubscribeVisitor() = default;
+  // Called when the session receives a response to the SUBSCRIBE, unless it's
+  // a SUBSCRIBE_ERROR with a new track_alias. In that case, the session will
+  // automatically retry.
+  virtual void OnReply(
+      const FullTrackName& full_track_name,
+      std::optional<Location> largest_location,
+      std::optional<absl::string_view> error_reason_phrase) = 0;
+  // Called when the subscription process is far enough that it is possible to
+  // send OBJECT_ACK messages; provides a callback to do so. The callback is
+  // valid for as long as the session is valid.
+  virtual void OnCanAckObjects(MoqtObjectAckFunction ack_function) = 0;
+  // Called when an object fragment (or an entire object) is received.
+  virtual void OnObjectFragment(const FullTrackName& full_track_name,
+                                const PublishedObjectMetadata& metadata,
+                                absl::string_view object,
+                                bool end_of_message) = 0;
+  virtual void OnSubscribeDone(FullTrackName full_track_name) = 0;
+  // Called when the track is malformed per Section 2.5 of
+  // draft-ietf-moqt-moq-transport-12. If the application is a relay, it MUST
+  // terminate downstream delivery of the track.
+  virtual void OnMalformedTrack(const FullTrackName& full_track_name) = 0;
+};
+
+// MoqtSession calls this when a FETCH_OK or FETCH_ERROR is received. The
+// destination of the callback owns |fetch_task| and MoqtSession will react
+// safely if the owner destroys it.
+using FetchResponseCallback =
+    quiche::SingleUseCallback<void(std::unique_ptr<MoqtFetchTask> fetch_task)>;
+
+// TODO(martinduke): MoqtOutgoingAnnounceCallback and
+// MoqtOutgoingSubscribeNamespaceCallback are deprecated. Remove.
+
 // If |error_message| is nullopt, this is triggered by an ANNOUNCE_OK.
 // Otherwise, it is triggered by ANNOUNCE_ERROR or ANNOUNCE_CANCEL. For
 // ERROR or CANCEL, MoqtSession is deleting all ANNOUNCE state immediately
@@ -49,22 +97,21 @@
   // Subscribe from (start_group, start_object) to the end of the track.
   virtual bool SubscribeAbsolute(const FullTrackName& name,
                                  uint64_t start_group, uint64_t start_object,
-                                 SubscribeRemoteTrack::Visitor* visitor,
+                                 SubscribeVisitor* visitor,
                                  VersionSpecificParameters parameters) = 0;
   // Subscribe from (start_group, start_object) to the end of end_group.
   virtual bool SubscribeAbsolute(const FullTrackName& name,
                                  uint64_t start_group, uint64_t start_object,
-                                 uint64_t end_group,
-                                 SubscribeRemoteTrack::Visitor* visitor,
+                                 uint64_t end_group, SubscribeVisitor* visitor,
                                  VersionSpecificParameters parameters) = 0;
   // Subscribe to all objects that are larger than the current Largest
   // Group/Object ID.
   virtual bool SubscribeCurrentObject(const FullTrackName& name,
-                                      SubscribeRemoteTrack::Visitor* visitor,
+                                      SubscribeVisitor* visitor,
                                       VersionSpecificParameters parameters) = 0;
   // Start with the first group after the current Largest Group/Object ID.
   virtual bool SubscribeNextGroup(const FullTrackName& name,
-                                  SubscribeRemoteTrack::Visitor* visitor,
+                                  SubscribeVisitor* visitor,
                                   VersionSpecificParameters parameters) = 0;
 
   // If an argument is nullopt, there is no change to the current value.
@@ -96,7 +143,7 @@
   // fails for any reason, the application will not receive a notification; it
   // will just appear to be missing objects.
   virtual bool RelativeJoiningFetch(const FullTrackName& name,
-                                    SubscribeRemoteTrack::Visitor* visitor,
+                                    SubscribeVisitor* visitor,
                                     uint64_t num_previous_groups,
                                     VersionSpecificParameters parameters) = 0;
 
@@ -104,7 +151,7 @@
   // groups before the current group.  `callback` acts the same way as the
   // callback for the regular Fetch() call.
   virtual bool RelativeJoiningFetch(
-      const FullTrackName& name, SubscribeRemoteTrack::Visitor* visitor,
+      const FullTrackName& name, SubscribeVisitor* visitor,
       FetchResponseCallback callback, uint64_t num_previous_groups,
       MoqtPriority priority, std::optional<MoqtDeliveryOrder> delivery_order,
       VersionSpecificParameters parameters) = 0;
diff --git a/quiche/quic/moqt/moqt_track.h b/quiche/quic/moqt/moqt_track.h
index 3568de6..34dc3bf 100644
--- a/quiche/quic/moqt/moqt_track.h
+++ b/quiche/quic/moqt/moqt_track.h
@@ -18,6 +18,7 @@
 #include "quiche/quic/moqt/moqt_messages.h"
 #include "quiche/quic/moqt/moqt_object.h"
 #include "quiche/quic/moqt/moqt_priority.h"
+#include "quiche/quic/moqt/moqt_session_interface.h"
 #include "quiche/quic/moqt/moqt_subscribe_windows.h"
 #include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_callbacks.h"
@@ -31,10 +32,6 @@
 class SubscribeRemoteTrackPeer;
 }  // namespace test
 
-using MoqtObjectAckFunction =
-    quiche::MultiUseCallback<void(uint64_t group_id, uint64_t object_id,
-                                  quic::QuicTimeDelta delta_from_deadline)>;
-
 // State common to both SUBSCRIBE and FETCH upstream.
 class RemoteTrack {
  public:
@@ -93,34 +90,8 @@
 // A track on the peer to which the session has subscribed.
 class SubscribeRemoteTrack : public RemoteTrack {
  public:
-  // TODO: Separate this out (as it's used by the application) and give it a
-  // name like MoqtTrackSubscriber,
-  class Visitor {
-   public:
-    virtual ~Visitor() = default;
-    // Called when the session receives a response to the SUBSCRIBE, unless it's
-    // a SUBSCRIBE_ERROR with a new track_alias. In that case, the session will
-    // automatically retry.
-    virtual void OnReply(
-        const FullTrackName& full_track_name,
-        std::optional<Location> largest_location,
-        std::optional<absl::string_view> error_reason_phrase) = 0;
-    // Called when the subscription process is far enough that it is possible to
-    // send OBJECT_ACK messages; provides a callback to do so. The callback is
-    // valid for as long as the session is valid.
-    virtual void OnCanAckObjects(MoqtObjectAckFunction ack_function) = 0;
-    // Called when an object fragment (or an entire object) is received.
-    virtual void OnObjectFragment(const FullTrackName& full_track_name,
-                                  const PublishedObjectMetadata& metadata,
-                                  absl::string_view object,
-                                  bool end_of_message) = 0;
-    virtual void OnSubscribeDone(FullTrackName full_track_name) = 0;
-    // Called when the track is malformed per Section 2.5 of
-    // draft-ietf-moqt-moq-transport-12. If the application is a relay, it MUST
-    // terminate downstream delivery of the track.
-    virtual void OnMalformedTrack(const FullTrackName& full_track_name) = 0;
-  };
-  SubscribeRemoteTrack(const MoqtSubscribe& subscribe, Visitor* visitor)
+  SubscribeRemoteTrack(const MoqtSubscribe& subscribe,
+                       SubscribeVisitor* visitor)
       : RemoteTrack(subscribe.full_track_name, subscribe.request_id,
                     SubscribeWindow(subscribe.start.value_or(Location()),
                                     subscribe.end_group),
@@ -141,7 +112,7 @@
   void set_track_alias(uint64_t track_alias) {
     track_alias_.emplace(track_alias);
   }
-  Visitor* visitor() { return visitor_; }
+  SubscribeVisitor* visitor() { return visitor_; }
 
   // Returns false if the forwarding preference is changing on the track.
   bool OnObject(bool is_datagram) {
@@ -190,7 +161,7 @@
 
   std::optional<const uint64_t> track_alias_;
   bool forward_;
-  Visitor* visitor_;
+  SubscribeVisitor* visitor_;
   std::optional<bool> is_datagram_;
   int currently_open_streams_ = 0;
   // Every stream that has received FIN or RESET_STREAM.
@@ -204,12 +175,6 @@
   const quic::QuicClock* clock_ = nullptr;
 };
 
-// MoqtSession calls this when a FETCH_OK or FETCH_ERROR is received. The
-// destination of the callback owns |fetch_task| and MoqtSession will react
-// safely if the owner destroys it.
-using FetchResponseCallback =
-    quiche::SingleUseCallback<void(std::unique_ptr<MoqtFetchTask> fetch_task)>;
-
 // This is a callback to MoqtSession::IncomingDataStream. Called when the
 // FetchTask has its object cache empty, on creation, and whenever the
 // application reads it.
diff --git a/quiche/quic/moqt/test_tools/moqt_session_peer.h b/quiche/quic/moqt/test_tools/moqt_session_peer.h
index 414e364..18366c0 100644
--- a/quiche/quic/moqt/test_tools/moqt_session_peer.h
+++ b/quiche/quic/moqt/test_tools/moqt_session_peer.h
@@ -87,7 +87,7 @@
   static void CreateRemoteTrack(MoqtSession* session,
                                 const MoqtSubscribe& subscribe,
                                 const std::optional<uint64_t> track_alias,
-                                SubscribeRemoteTrack::Visitor* visitor) {
+                                SubscribeVisitor* visitor) {
     auto track = std::make_unique<SubscribeRemoteTrack>(subscribe, visitor);
     if (track_alias.has_value()) {
       track->set_track_alias(*track_alias);
diff --git a/quiche/quic/moqt/tools/chat_client.h b/quiche/quic/moqt/tools/chat_client.h
index 07a668c..99071e9 100644
--- a/quiche/quic/moqt/tools/chat_client.h
+++ b/quiche/quic/moqt/tools/chat_client.h
@@ -87,8 +87,7 @@
 
   quic::QuicEventLoop* event_loop() { return event_loop_; }
 
-  class QUICHE_EXPORT RemoteTrackVisitor
-      : public moqt::SubscribeRemoteTrack::Visitor {
+  class QUICHE_EXPORT RemoteTrackVisitor : public moqt::SubscribeVisitor {
    public:
     RemoteTrackVisitor(ChatClient* client) : client_(client) {}
 
diff --git a/quiche/quic/moqt/tools/chat_server.h b/quiche/quic/moqt/tools/chat_server.h
index 352b2eb..eacf67e 100644
--- a/quiche/quic/moqt/tools/chat_server.h
+++ b/quiche/quic/moqt/tools/chat_server.h
@@ -35,7 +35,7 @@
              absl::string_view output_file);
   ~ChatServer();
 
-  class RemoteTrackVisitor : public SubscribeRemoteTrack::Visitor {
+  class RemoteTrackVisitor : public SubscribeVisitor {
    public:
     explicit RemoteTrackVisitor(ChatServer* server);
     void OnReply(const moqt::FullTrackName& full_track_name,
diff --git a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
index 416f133..d139961 100644
--- a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
+++ b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
@@ -163,7 +163,7 @@
   }
 
  private:
-  class NamespaceHandler : public SubscribeRemoteTrack::Visitor {
+  class NamespaceHandler : public SubscribeVisitor {
    public:
     explicit NamespaceHandler(absl::string_view directory)
         : directory_(directory) {}
diff --git a/quiche/quic/moqt/tools/moqt_mock_visitor.h b/quiche/quic/moqt/tools/moqt_mock_visitor.h
index b3ff683..da2a337 100644
--- a/quiche/quic/moqt/tools/moqt_mock_visitor.h
+++ b/quiche/quic/moqt/tools/moqt_mock_visitor.h
@@ -88,7 +88,7 @@
   FullTrackName track_name_;
 };
 
-class MockSubscribeRemoteTrackVisitor : public SubscribeRemoteTrack::Visitor {
+class MockSubscribeRemoteTrackVisitor : public SubscribeVisitor {
  public:
   MOCK_METHOD(void, OnReply,
               (const FullTrackName& full_track_name,
diff --git a/quiche/quic/moqt/tools/moqt_relay_test.cc b/quiche/quic/moqt/tools/moqt_relay_test.cc
index 159eb72..8e23ebf 100644
--- a/quiche/quic/moqt/tools/moqt_relay_test.cc
+++ b/quiche/quic/moqt/tools/moqt_relay_test.cc
@@ -13,7 +13,6 @@
 #include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/moqt/moqt_relay_publisher.h"
 #include "quiche/quic/moqt/moqt_session.h"
-#include "quiche/quic/moqt/moqt_session_interface.h"
 #include "quiche/quic/moqt/tools/moqt_client.h"
 #include "quiche/quic/moqt/tools/moqt_server.h"
 #include "quiche/quic/test_tools/crypto_test_utils.h"
diff --git a/quiche/quic/moqt/tools/moqt_simulator_bin.cc b/quiche/quic/moqt/tools/moqt_simulator_bin.cc
index 9fbaeb9..4048ba0 100644
--- a/quiche/quic/moqt/tools/moqt_simulator_bin.cc
+++ b/quiche/quic/moqt/tools/moqt_simulator_bin.cc
@@ -289,7 +289,7 @@
   std::vector<QuicBandwidth> bitrate_history_;
 };
 
-class ObjectReceiver : public SubscribeRemoteTrack::Visitor {
+class ObjectReceiver : public SubscribeVisitor {
  public:
   explicit ObjectReceiver(const QuicClock* clock, QuicTimeDelta deadline)
       : clock_(clock), deadline_(deadline) {}