diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 3c95b2f..d65e360 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -102,6 +102,9 @@
 
   virtual void Initialize();
 
+  // Return the reserved crypto stream as a constant pointer.
+  virtual const QuicCryptoStream* GetCryptoStream() const = 0;
+
   // QuicConnectionVisitorInterface methods:
   void OnStreamFrame(const QuicStreamFrame& frame) override;
   void OnCryptoFrame(const QuicCryptoFrame& frame) override;
@@ -620,9 +623,6 @@
   // Return the reserved crypto stream.
   virtual QuicCryptoStream* GetMutableCryptoStream() = 0;
 
-  // Return the reserved crypto stream as a constant pointer.
-  virtual const QuicCryptoStream* GetCryptoStream() const = 0;
-
   // Adds |stream| to the stream map.
   virtual void ActivateStream(std::unique_ptr<QuicStream> stream);
 
