diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index 4c77e21..daa8d07 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -76,6 +76,7 @@
 
   std::unique_ptr<AsynchronousKeyExchange> Create(
       std::string server_config_id,
+      bool /* is_fallback */,
       QuicTag type,
       QuicStringPiece private_key) override {
     if (private_key.empty()) {
@@ -1577,8 +1578,8 @@
       }
     }
 
-    std::unique_ptr<AsynchronousKeyExchange> ka =
-        key_exchange_source_->Create(config->id, tag, private_key);
+    std::unique_ptr<AsynchronousKeyExchange> ka = key_exchange_source_->Create(
+        config->id, /* is_fallback = */ false, tag, private_key);
     if (!ka) {
       return nullptr;
     }
diff --git a/quic/core/crypto/quic_crypto_server_config.h b/quic/core/crypto/quic_crypto_server_config.h
index 0304bf3..2ba028e 100644
--- a/quic/core/crypto/quic_crypto_server_config.h
+++ b/quic/core/crypto/quic_crypto_server_config.h
@@ -160,10 +160,14 @@
   // Returns the default KeyExchangeSource.
   static std::unique_ptr<KeyExchangeSource> Default();
 
-  // Create a new KeyExchange of the specified type using the specified
-  // private key.
+  // Create a new KeyExchange using the curve specified by |type| using the
+  // specified private key.  |private_key| may be empty for key-exchange
+  // mechanisms which do not hold the private key in-process.  If |is_fallback|
+  // is set, |private_key| is required to be set, and a local key-exchange
+  // object should be returned.
   virtual std::unique_ptr<AsynchronousKeyExchange> Create(
       std::string server_config_id,
+      bool is_fallback,
       QuicTag type,
       QuicStringPiece private_key) = 0;
 };
