diff --git a/quic/test_tools/simple_session_notifier.cc b/quic/test_tools/simple_session_notifier.cc
index c56831e..d1ee832 100644
--- a/quic/test_tools/simple_session_notifier.cc
+++ b/quic/test_tools/simple_session_notifier.cc
@@ -386,7 +386,7 @@
 }
 
 bool SimpleSessionNotifier::HasUnackedCryptoData() const {
-  if (connection_->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
       const StreamState& state = crypto_state_[i];
       if (state.bytes_total > state.bytes_sent) {
