diff --git a/quic/core/crypto/channel_id.h b/quic/core/crypto/channel_id.h
index 309aaf2..8719394 100644
--- a/quic/core/crypto/channel_id.h
+++ b/quic/core/crypto/channel_id.h
@@ -14,54 +14,6 @@
 
 namespace quic {
 
-// ChannelIDKey is an interface that supports signing with and serializing a
-// ChannelID key.
-class QUIC_EXPORT_PRIVATE ChannelIDKey {
- public:
-  virtual ~ChannelIDKey() {}
-
-  // Sign signs |signed_data| using the ChannelID private key and puts the
-  // signature into |out_signature|. It returns true on success.
-  virtual bool Sign(QuicStringPiece signed_data,
-                    std::string* out_signature) const = 0;
-
-  // SerializeKey returns the serialized ChannelID public key.
-  virtual std::string SerializeKey() const = 0;
-};
-
-// ChannelIDSourceCallback provides a generic mechanism for a ChannelIDSource
-// to call back after an asynchronous GetChannelIDKey operation.
-class ChannelIDSourceCallback {
- public:
-  virtual ~ChannelIDSourceCallback() {}
-
-  // Run is called on the original thread to mark the completion of an
-  // asynchonous GetChannelIDKey operation. If |*channel_id_key| is not nullptr
-  // then the channel ID lookup is successful. |Run| may take ownership of
-  // |*channel_id_key| by calling |release| on it.
-  virtual void Run(std::unique_ptr<ChannelIDKey>* channel_id_key) = 0;
-};
-
-// ChannelIDSource is an abstract interface by which a QUIC client can obtain
-// a ChannelIDKey for a given hostname.
-class QUIC_EXPORT_PRIVATE ChannelIDSource {
- public:
-  virtual ~ChannelIDSource() {}
-
-  // GetChannelIDKey looks up the ChannelIDKey for |hostname|. On success it
-  // returns QUIC_SUCCESS and stores the ChannelIDKey in |*channel_id_key|,
-  // which the caller takes ownership of. On failure, it returns QUIC_FAILURE.
-  //
-  // This function may also return QUIC_PENDING, in which case the
-  // ChannelIDSource will call back, on the original thread, via |callback|
-  // when complete. In this case, the ChannelIDSource will take ownership of
-  // |callback|.
-  virtual QuicAsyncStatus GetChannelIDKey(
-      const std::string& hostname,
-      std::unique_ptr<ChannelIDKey>* channel_id_key,
-      ChannelIDSourceCallback* callback) = 0;
-};
-
 // ChannelIDVerifier verifies ChannelID signatures.
 class QUIC_EXPORT_PRIVATE ChannelIDVerifier {
  public:
diff --git a/quic/core/crypto/channel_id_test.cc b/quic/core/crypto/channel_id_test.cc
index 99a84dd..d367382 100644
--- a/quic/core/crypto/channel_id_test.cc
+++ b/quic/core/crypto/channel_id_test.cc
@@ -282,40 +282,5 @@
   }
 }
 
-TEST_F(ChannelIDTest, SignAndVerify) {
-  std::unique_ptr<ChannelIDSource> source(
-      crypto_test_utils::ChannelIDSourceForTesting());
-
-  const std::string signed_data = "signed data";
-  const std::string hostname = "foo.example.com";
-  std::unique_ptr<ChannelIDKey> channel_id_key;
-  QuicAsyncStatus status =
-      source->GetChannelIDKey(hostname, &channel_id_key, nullptr);
-  ASSERT_EQ(QUIC_SUCCESS, status);
-
-  std::string signature;
-  ASSERT_TRUE(channel_id_key->Sign(signed_data, &signature));
-
-  std::string key = channel_id_key->SerializeKey();
-  EXPECT_TRUE(ChannelIDVerifier::Verify(key, signed_data, signature));
-
-  EXPECT_FALSE(ChannelIDVerifier::Verify("a" + key, signed_data, signature));
-  EXPECT_FALSE(ChannelIDVerifier::Verify(key, "a" + signed_data, signature));
-
-  std::unique_ptr<char[]> bad_key(new char[key.size()]);
-  memcpy(bad_key.get(), key.data(), key.size());
-  bad_key[1] ^= 0x80;
-  EXPECT_FALSE(ChannelIDVerifier::Verify(std::string(bad_key.get(), key.size()),
-                                         signed_data, signature));
-
-  std::unique_ptr<char[]> bad_signature(new char[signature.size()]);
-  memcpy(bad_signature.get(), signature.data(), signature.size());
-  bad_signature[1] ^= 0x80;
-  EXPECT_FALSE(ChannelIDVerifier::Verify(
-      key, signed_data, std::string(bad_signature.get(), signature.size())));
-
-  EXPECT_FALSE(ChannelIDVerifier::Verify(key, "wrong signed data", signature));
-}
-
 }  // namespace test
 }  // namespace quic
diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc
index 3983836..d216f66 100644
--- a/quic/core/crypto/quic_crypto_client_config.cc
+++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -11,7 +11,6 @@
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/crypto/cert_compressor.h"
 #include "net/third_party/quiche/src/quic/core/crypto/chacha20_poly1305_encrypter.h"
-#include "net/third_party/quiche/src/quic/core/crypto/channel_id.h"
 #include "net/third_party/quiche/src/quic/core/crypto/common_cert_set.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
@@ -517,7 +516,6 @@
     const CachedState* cached,
     QuicWallTime now,
     QuicRandom* rand,
-    const ChannelIDKey* channel_id_key,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     CryptoHandshakeMessage* out,
     std::string* error_details) const {
@@ -643,65 +641,6 @@
   }
   out->SetValue(kXLCT, CryptoUtils::ComputeLeafCertHash(certs[0]));
 
-  if (channel_id_key) {
-    // In order to calculate the encryption key for the CETV block we need to
-    // serialise the client hello as it currently is (i.e. without the CETV
-    // block). For this, the client hello is serialized without padding.
-    const size_t orig_min_size = out->minimum_size();
-    out->set_minimum_size(0);
-
-    CryptoHandshakeMessage cetv;
-    cetv.set_tag(kCETV);
-
-    std::string hkdf_input;
-    const QuicData& client_hello_serialized = out->GetSerialized();
-    hkdf_input.append(QuicCryptoConfig::kCETVLabel,
-                      strlen(QuicCryptoConfig::kCETVLabel) + 1);
-    hkdf_input.append(connection_id.data(), connection_id.length());
-    hkdf_input.append(client_hello_serialized.data(),
-                      client_hello_serialized.length());
-    hkdf_input.append(cached->server_config());
-
-    std::string key = channel_id_key->SerializeKey();
-    std::string signature;
-    if (!channel_id_key->Sign(hkdf_input, &signature)) {
-      *error_details = "Channel ID signature failed";
-      return QUIC_INVALID_CHANNEL_ID_SIGNATURE;
-    }
-
-    cetv.SetStringPiece(kCIDK, key);
-    cetv.SetStringPiece(kCIDS, signature);
-
-    CrypterPair crypters;
-    if (!CryptoUtils::DeriveKeys(out_params->initial_premaster_secret,
-                                 out_params->aead, out_params->client_nonce,
-                                 out_params->server_nonce, pre_shared_key_,
-                                 hkdf_input, Perspective::IS_CLIENT,
-                                 CryptoUtils::Diversification::Never(),
-                                 &crypters, nullptr /* subkey secret */)) {
-      *error_details = "Symmetric key setup failed";
-      return QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED;
-    }
-
-    const QuicData& cetv_plaintext = cetv.GetSerialized();
-    const size_t encrypted_len =
-        crypters.encrypter->GetCiphertextSize(cetv_plaintext.length());
-    std::unique_ptr<char[]> output(new char[encrypted_len]);
-    size_t output_size = 0;
-    if (!crypters.encrypter->EncryptPacket(
-            0 /* packet number */, QuicStringPiece() /* associated data */,
-            cetv_plaintext.AsStringPiece(), output.get(), &output_size,
-            encrypted_len)) {
-      *error_details = "Packet encryption failed";
-      return QUIC_ENCRYPTION_FAILURE;
-    }
-
-    out->SetStringPiece(kCETV, QuicStringPiece(output.get(), output_size));
-    out->MarkDirty();
-
-    out->set_minimum_size(orig_min_size);
-  }
-
   // Derive the symmetric keys and set up the encrypters and decrypters.
   // Set the following members of out_params:
   //   out_params->hkdf_input_suffix
@@ -951,19 +890,10 @@
   return proof_verifier_.get();
 }
 
-ChannelIDSource* QuicCryptoClientConfig::channel_id_source() const {
-  return channel_id_source_.get();
-}
-
 SSL_CTX* QuicCryptoClientConfig::ssl_ctx() const {
   return ssl_ctx_.get();
 }
 
-void QuicCryptoClientConfig::SetChannelIDSource(
-    std::unique_ptr<ChannelIDSource> source) {
-  channel_id_source_ = std::move(source);
-}
-
 void QuicCryptoClientConfig::InitializeFrom(
     const QuicServerId& server_id,
     const QuicServerId& canonical_server_id,
diff --git a/quic/core/crypto/quic_crypto_client_config.h b/quic/core/crypto/quic_crypto_client_config.h
index f4293c0..2918a23 100644
--- a/quic/core/crypto/quic_crypto_client_config.h
+++ b/quic/core/crypto/quic_crypto_client_config.h
@@ -22,8 +22,6 @@
 
 namespace quic {
 
-class ChannelIDKey;
-class ChannelIDSource;
 class CryptoHandshakeMessage;
 class ProofVerifier;
 class ProofVerifyDetails;
@@ -258,7 +256,6 @@
       const CachedState* cached,
       QuicWallTime now,
       QuicRandom* rand,
-      const ChannelIDKey* channel_id_key,
       QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
       CryptoHandshakeMessage* out,
       std::string* error_details) const;
@@ -312,15 +309,8 @@
 
   ProofVerifier* proof_verifier() const;
 
-  ChannelIDSource* channel_id_source() const;
-
   SSL_CTX* ssl_ctx() const;
 
-  // SetChannelIDSource sets a ChannelIDSource that will be called, when the
-  // server supports channel IDs, to obtain a channel ID for signing a message
-  // proving possession of the channel ID.
-  void SetChannelIDSource(std::unique_ptr<ChannelIDSource> source);
-
   // Initialize the CachedState from |canonical_crypto_config| for the
   // |canonical_server_id| as the initial CachedState for |server_id|. We will
   // copy config data only if |canonical_crypto_config| has valid proof.
@@ -397,7 +387,6 @@
   std::vector<std::string> canonical_suffixes_;
 
   std::unique_ptr<ProofVerifier> proof_verifier_;
-  std::unique_ptr<ChannelIDSource> channel_id_source_;
   bssl::UniquePtr<SSL_CTX> ssl_ctx_;
 
   // The |user_agent_id_| passed in QUIC's CHLO message.
diff --git a/quic/core/crypto/quic_crypto_client_config_test.cc b/quic/core/crypto/quic_crypto_client_config_test.cc
index 2158cd3..b7dd529 100644
--- a/quic/core/crypto/quic_crypto_client_config_test.cc
+++ b/quic/core/crypto/quic_crypto_client_config_test.cc
@@ -323,7 +323,6 @@
   QuicServerId server_id("www.google.com", 443, false);
   config.FillClientHello(server_id, kConnectionId, QuicVersionMax(), &state,
                          QuicWallTime::Zero(), &rand,
-                         nullptr,  // channel_id_key
                          params, &chlo, &error_details);
 
   // Verify that the version label has been set correctly in the CHLO.
@@ -346,7 +345,6 @@
   QuicServerId server_id("www.google.com", 443, false);
   config.FillClientHello(server_id, kConnectionId, QuicVersionMax(), &state,
                          QuicWallTime::Zero(), &rand,
-                         nullptr,  // channel_id_key
                          params, &chlo, &error_details);
 
   // Verify that the version label has been set correctly in the CHLO.
diff --git a/quic/core/crypto/testdata/README.md b/quic/core/crypto/testdata/README.md
new file mode 100644
index 0000000..509d261
--- /dev/null
+++ b/quic/core/crypto/testdata/README.md
@@ -0,0 +1,15 @@
+# QUIC Crypto Test Data
+
+This directory contains certificates and keys used for testing QUIC. Most of the
+contents are generated by manual invocation of a script. The steps to
+regnenerate everything are:
+
+*   Build the ssl key encryptor: `blaze build
+    //gfe/gfe2/ssl_cert_storage:ssl_key_encryptor`
+
+*   Update the nonce (`nonce.txt`) to whatever stable value. If the nonce
+    changes, the process of encrypting keys must be repeated.
+
+*   Invoke the script: `go run generate.go`
+
+Make sure to commit everything to Piper when done.
diff --git a/quic/core/qpack/offline/README.md b/quic/core/qpack/offline/README.md
new file mode 100644
index 0000000..4f6697c
--- /dev/null
+++ b/quic/core/qpack/offline/README.md
@@ -0,0 +1,28 @@
+# QPACK Offline Interop Testing tools
+
+See
+[QPACK Offline Interop](https://github.com/quicwg/base-drafts/wiki/QPACK-Offline-Interop)
+for description of test data format.
+
+Example usage:
+
+```shell
+$ # Download test data
+$ cd $TEST_DATA
+$ git clone https://github.com/qpackers/qifs.git
+$ TEST_ENCODED_DATA=`pwd`/qifs/encoded/qpack-03
+$ TEST_QIF_DATA=`pwd`/qifs/qifs
+$
+$ # Decode encoded test data in four files and verify that they match
+$ # the original headers in corresponding files
+$ $BIN/qpack_offline_decoder \
+>   $TEST_ENCODED_DATA/f5/fb-req.qifencoded.4096.100.0 \
+>   $TEST_QIF_DATA/fb-req.qif
+>   $TEST_ENCODED_DATA/h2o/fb-req-hq.out.512.0.1 \
+>   $TEST_QIF_DATA/fb-req-hq.qif
+>   $TEST_ENCODED_DATA/ls-qpack/fb-resp-hq.out.0.0.0 \
+>   $TEST_QIF_DATA/fb-resp-hq.qif
+>   $TEST_ENCODED_DATA/proxygen/netbsd.qif.proxygen.out.4096.0.0 \
+>   $TEST_QIF_DATA/netbsd.qif
+$
+```
diff --git a/quic/core/quic_crypto_client_handshaker.cc b/quic/core/quic_crypto_client_handshaker.cc
index 1877537..57d8c28 100644
--- a/quic/core/quic_crypto_client_handshaker.cc
+++ b/quic/core/quic_crypto_client_handshaker.cc
@@ -17,32 +17,6 @@
 
 namespace quic {
 
-QuicCryptoClientHandshaker::ChannelIDSourceCallbackImpl::
-    ChannelIDSourceCallbackImpl(QuicCryptoClientHandshaker* parent)
-    : parent_(parent) {}
-
-QuicCryptoClientHandshaker::ChannelIDSourceCallbackImpl::
-    ~ChannelIDSourceCallbackImpl() {}
-
-void QuicCryptoClientHandshaker::ChannelIDSourceCallbackImpl::Run(
-    std::unique_ptr<ChannelIDKey>* channel_id_key) {
-  if (parent_ == nullptr) {
-    return;
-  }
-
-  parent_->channel_id_key_ = std::move(*channel_id_key);
-  parent_->channel_id_source_callback_run_ = true;
-  parent_->channel_id_source_callback_ = nullptr;
-  parent_->DoHandshakeLoop(nullptr);
-
-  // The ChannelIDSource owns this object and will delete it when this method
-  // returns.
-}
-
-void QuicCryptoClientHandshaker::ChannelIDSourceCallbackImpl::Cancel() {
-  parent_ = nullptr;
-}
-
 QuicCryptoClientHandshaker::ProofVerifierCallbackImpl::
     ProofVerifierCallbackImpl(QuicCryptoClientHandshaker* parent)
     : parent_(parent) {}
@@ -87,9 +61,6 @@
       crypto_config_(crypto_config),
       server_id_(server_id),
       generation_counter_(0),
-      channel_id_sent_(false),
-      channel_id_source_callback_run_(false),
-      channel_id_source_callback_(nullptr),
       verify_context_(std::move(verify_context)),
       proof_verify_callback_(nullptr),
       proof_handler_(proof_handler),
@@ -102,9 +73,6 @@
       crypto_negotiated_params_(new QuicCryptoNegotiatedParameters) {}
 
 QuicCryptoClientHandshaker::~QuicCryptoClientHandshaker() {
-  if (channel_id_source_callback_) {
-    channel_id_source_callback_->Cancel();
-  }
   if (proof_verify_callback_) {
     proof_verify_callback_->Cancel();
   }
@@ -153,14 +121,6 @@
   return num_scup_messages_received_;
 }
 
-bool QuicCryptoClientHandshaker::WasChannelIDSent() const {
-  return channel_id_sent_;
-}
-
-bool QuicCryptoClientHandshaker::WasChannelIDSourceCallbackRun() const {
-  return channel_id_source_callback_run_;
-}
-
 std::string QuicCryptoClientHandshaker::chlo_hash() const {
   return chlo_hash_;
 }
@@ -234,12 +194,6 @@
       case STATE_VERIFY_PROOF_COMPLETE:
         DoVerifyProofComplete(cached);
         break;
-      case STATE_GET_CHANNEL_ID:
-        rv = DoGetChannelID(cached);
-        break;
-      case STATE_GET_CHANNEL_ID_COMPLETE:
-        DoGetChannelIDComplete();
-        break;
       case STATE_RECV_SHLO:
         DoReceiveSHLO(in, cached);
         break;
@@ -272,7 +226,7 @@
     // If the cached state needs to be verified, do it now.
     next_state_ = STATE_VERIFY_PROOF;
   } else {
-    next_state_ = STATE_GET_CHANNEL_ID;
+    next_state_ = STATE_SEND_CHLO;
   }
 }
 
@@ -355,8 +309,8 @@
       server_id_, session()->connection()->connection_id(),
       session()->supported_versions().front(), cached,
       session()->connection()->clock()->WallNow(),
-      session()->connection()->random_generator(), channel_id_key_.get(),
-      crypto_negotiated_params_, &out, &error_details);
+      session()->connection()->random_generator(), crypto_negotiated_params_,
+      &out, &error_details);
   if (error != QUIC_NO_ERROR) {
     // Flush the cached config so that, if it's bad, the server has a
     // chance to send us another in the future.
@@ -365,7 +319,6 @@
     return;
   }
   chlo_hash_ = CryptoUtils::HashHandshakeMessage(out, Perspective::IS_CLIENT);
-  channel_id_sent_ = (channel_id_key_ != nullptr);
   if (cached->proof_verify_details()) {
     proof_handler_->OnProofVerifyDetailsAvailable(
         *cached->proof_verify_details());
@@ -461,7 +414,7 @@
       return;
     }
   }
-  next_state_ = STATE_GET_CHANNEL_ID;
+  next_state_ = STATE_SEND_CHLO;
 }
 
 QuicAsyncStatus QuicCryptoClientHandshaker::DoVerifyProof(
@@ -531,7 +484,7 @@
     SetCachedProofValid(cached);
     cached->SetProofVerifyDetails(verify_details_.release());
     if (!handshake_confirmed()) {
-      next_state_ = STATE_GET_CHANNEL_ID;
+      next_state_ = STATE_SEND_CHLO;
     } else {
       // TODO: Enable Expect-Staple. https://crbug.com/631101
       next_state_ = STATE_NONE;
@@ -539,48 +492,6 @@
   }
 }
 
-QuicAsyncStatus QuicCryptoClientHandshaker::DoGetChannelID(
-    QuicCryptoClientConfig::CachedState* cached) {
-  next_state_ = STATE_GET_CHANNEL_ID_COMPLETE;
-  channel_id_key_.reset();
-  if (!RequiresChannelID(cached)) {
-    next_state_ = STATE_SEND_CHLO;
-    return QUIC_SUCCESS;
-  }
-
-  ChannelIDSourceCallbackImpl* channel_id_source_callback =
-      new ChannelIDSourceCallbackImpl(this);
-  QuicAsyncStatus status = crypto_config_->channel_id_source()->GetChannelIDKey(
-      server_id_.host(), &channel_id_key_, channel_id_source_callback);
-
-  switch (status) {
-    case QUIC_PENDING:
-      channel_id_source_callback_ = channel_id_source_callback;
-      QUIC_DVLOG(1) << "Looking up channel ID";
-      break;
-    case QUIC_FAILURE:
-      next_state_ = STATE_NONE;
-      delete channel_id_source_callback;
-      stream_->CloseConnectionWithDetails(QUIC_INVALID_CHANNEL_ID_SIGNATURE,
-                                          "Channel ID lookup failed");
-      break;
-    case QUIC_SUCCESS:
-      delete channel_id_source_callback;
-      break;
-  }
-  return status;
-}
-
-void QuicCryptoClientHandshaker::DoGetChannelIDComplete() {
-  if (!channel_id_key_.get()) {
-    next_state_ = STATE_NONE;
-    stream_->CloseConnectionWithDetails(QUIC_INVALID_CHANNEL_ID_SIGNATURE,
-                                        "Channel ID lookup failed");
-    return;
-  }
-  next_state_ = STATE_SEND_CHLO;
-}
-
 void QuicCryptoClientHandshaker::DoReceiveSHLO(
     const CryptoHandshakeMessage* in,
     QuicCryptoClientConfig::CachedState* cached) {
@@ -677,26 +588,4 @@
   proof_handler_->OnProofValid(*cached);
 }
 
-bool QuicCryptoClientHandshaker::RequiresChannelID(
-    QuicCryptoClientConfig::CachedState* cached) {
-  if (server_id_.privacy_mode_enabled() ||
-      !crypto_config_->channel_id_source()) {
-    return false;
-  }
-  const CryptoHandshakeMessage* scfg = cached->GetServerConfig();
-  if (!scfg) {  // scfg may be null then we send an inchoate CHLO.
-    return false;
-  }
-  QuicTagVector their_proof_demands;
-  if (scfg->GetTaglist(kPDMD, &their_proof_demands) != QUIC_NO_ERROR) {
-    return false;
-  }
-  for (const QuicTag tag : their_proof_demands) {
-    if (tag == kCHID) {
-      return true;
-    }
-  }
-  return false;
-}
-
 }  // namespace quic
diff --git a/quic/core/quic_crypto_client_handshaker.h b/quic/core/quic_crypto_client_handshaker.h
index 4aa5d46..023905b 100644
--- a/quic/core/quic_crypto_client_handshaker.h
+++ b/quic/core/quic_crypto_client_handshaker.h
@@ -7,7 +7,6 @@
 
 #include <string>
 
-#include "net/third_party/quiche/src/quic/core/crypto/channel_id.h"
 #include "net/third_party/quiche/src/quic/core/crypto/proof_verifier.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_client_config.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_client_stream.h"
@@ -39,8 +38,6 @@
   bool CryptoConnect() override;
   int num_sent_client_hellos() const override;
   int num_scup_messages_received() const override;
-  bool WasChannelIDSent() const override;
-  bool WasChannelIDSourceCallbackRun() const override;
   std::string chlo_hash() const override;
   bool encryption_established() const override;
   bool handshake_confirmed() const override;
@@ -59,25 +56,6 @@
   void DoSendCHLO(QuicCryptoClientConfig::CachedState* cached);
 
  private:
-  // ChannelIDSourceCallbackImpl is passed as the callback method to
-  // GetChannelIDKey. The ChannelIDSource calls this class with the result of
-  // channel ID lookup when lookup is performed asynchronously.
-  class ChannelIDSourceCallbackImpl : public ChannelIDSourceCallback {
-   public:
-    explicit ChannelIDSourceCallbackImpl(QuicCryptoClientHandshaker* parent);
-    ~ChannelIDSourceCallbackImpl() override;
-
-    // ChannelIDSourceCallback interface.
-    void Run(std::unique_ptr<ChannelIDKey>* channel_id_key) override;
-
-    // Cancel causes any future callbacks to be ignored. It must be called on
-    // the same thread as the callback will be made on.
-    void Cancel();
-
-   private:
-    QuicCryptoClientHandshaker* parent_;
-  };
-
   // ProofVerifierCallbackImpl is passed as the callback method to VerifyProof.
   // The ProofVerifier calls this class with the result of proof verification
   // when verification is performed asynchronously.
@@ -106,8 +84,6 @@
     STATE_RECV_REJ,
     STATE_VERIFY_PROOF,
     STATE_VERIFY_PROOF_COMPLETE,
-    STATE_GET_CHANNEL_ID,
-    STATE_GET_CHANNEL_ID_COMPLETE,
     STATE_RECV_SHLO,
     STATE_INITIALIZE_SCUP,
     STATE_NONE,
@@ -137,15 +113,6 @@
   // server config). If not, it closes the connection.
   void DoVerifyProofComplete(QuicCryptoClientConfig::CachedState* cached);
 
-  // Start the look up of Channel ID process. Returns either QUIC_SUCCESS if
-  // RequiresChannelID returns false or QuicAsyncStatus returned by
-  // GetChannelIDKey.
-  QuicAsyncStatus DoGetChannelID(QuicCryptoClientConfig::CachedState* cached);
-
-  // If there is no channel ID, then close the connection otherwise transtion to
-  // STATE_SEND_CHLO state.
-  void DoGetChannelIDComplete();
-
   // Process SHLO message from the server.
   void DoReceiveSHLO(const CryptoHandshakeMessage* in,
                      QuicCryptoClientConfig::CachedState* cached);
@@ -159,10 +126,6 @@
   // OnProofValid() method.
   void SetCachedProofValid(QuicCryptoClientConfig::CachedState* cached);
 
-  // Returns true if the server crypto config in |cached| requires a ChannelID
-  // and the client config settings also allow sending a ChannelID.
-  bool RequiresChannelID(QuicCryptoClientConfig::CachedState* cached);
-
   QuicCryptoClientStream* stream_;
 
   QuicSession* session_;
@@ -183,22 +146,6 @@
   // Generation counter from QuicCryptoClientConfig's CachedState.
   uint64_t generation_counter_;
 
-  // True if a channel ID was sent.
-  bool channel_id_sent_;
-
-  // True if channel_id_source_callback_ was run.
-  bool channel_id_source_callback_run_;
-
-  // channel_id_source_callback_ contains the callback object that we passed
-  // to an asynchronous channel ID lookup. The ChannelIDSource owns this
-  // object.
-  ChannelIDSourceCallbackImpl* channel_id_source_callback_;
-
-  // These members are used to store the result of an asynchronous channel ID
-  // lookup. These members must not be used after
-  // STATE_GET_CHANNEL_ID_COMPLETE.
-  std::unique_ptr<ChannelIDKey> channel_id_key_;
-
   // verify_context_ contains the context object that we pass to asynchronous
   // proof verifications.
   std::unique_ptr<ProofVerifyContext> verify_context_;
diff --git a/quic/core/quic_crypto_client_stream.cc b/quic/core/quic_crypto_client_stream.cc
index 7c2aa40..93f2a61 100644
--- a/quic/core/quic_crypto_client_stream.cc
+++ b/quic/core/quic_crypto_client_stream.cc
@@ -84,14 +84,6 @@
   return handshaker_->crypto_message_parser();
 }
 
-bool QuicCryptoClientStream::WasChannelIDSent() const {
-  return handshaker_->WasChannelIDSent();
-}
-
-bool QuicCryptoClientStream::WasChannelIDSourceCallbackRun() const {
-  return handshaker_->WasChannelIDSourceCallbackRun();
-}
-
 std::string QuicCryptoClientStream::chlo_hash() const {
   return handshaker_->chlo_hash();
 }
diff --git a/quic/core/quic_crypto_client_stream.h b/quic/core/quic_crypto_client_stream.h
index d0e4ee1..b8dff7e 100644
--- a/quic/core/quic_crypto_client_stream.h
+++ b/quic/core/quic_crypto_client_stream.h
@@ -9,7 +9,6 @@
 #include <memory>
 #include <string>
 
-#include "net/third_party/quiche/src/quic/core/crypto/channel_id.h"
 #include "net/third_party/quiche/src/quic/core/crypto/proof_verifier.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_client_config.h"
 #include "net/third_party/quiche/src/quic/core/quic_config.h"
@@ -85,13 +84,6 @@
     // to handshake confirmation.
     virtual int num_scup_messages_received() const = 0;
 
-    // Returns true if a channel ID was sent on this connection.
-    virtual bool WasChannelIDSent() const = 0;
-
-    // Returns true if our ChannelIDSourceCallback was run, which implies the
-    // ChannelIDSource operated asynchronously. Intended for testing.
-    virtual bool WasChannelIDSourceCallbackRun() const = 0;
-
     virtual std::string chlo_hash() const = 0;
 
     // Returns true once any encrypter (initial/0RTT or final/1RTT) has been set
@@ -151,13 +143,6 @@
       const override;
   CryptoMessageParser* crypto_message_parser() override;
 
-  // Returns true if a channel ID was sent on this connection.
-  bool WasChannelIDSent() const;
-
-  // Returns true if our ChannelIDSourceCallback was run, which implies the
-  // ChannelIDSource operated asynchronously. Intended for testing.
-  bool WasChannelIDSourceCallbackRun() const;
-
   std::string chlo_hash() const;
 
  protected:
diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc
index 0cb130e..2d3702f 100644
--- a/quic/core/quic_crypto_client_stream_test.cc
+++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -321,14 +321,6 @@
       stream(), server_config_update, Perspective::IS_SERVER);
 }
 
-TEST_F(QuicCryptoClientStreamTest, NoChannelID) {
-  crypto_config_.SetChannelIDSource(nullptr);
-
-  CompleteCryptoHandshake();
-  EXPECT_FALSE(stream()->WasChannelIDSent());
-  EXPECT_FALSE(stream()->WasChannelIDSourceCallbackRun());
-}
-
 TEST_F(QuicCryptoClientStreamTest, PreferredVersion) {
   // This mimics the case where client receives version negotiation packet, such
   // that, the preferred version is different from the packets' version.
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index e01414b..ff7111c 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -418,30 +418,6 @@
                                                   Perspective::IS_SERVER);
 }
 
-TEST_P(QuicCryptoServerStreamTest, ChannelID) {
-  Initialize();
-
-  client_options_.channel_id_enabled = true;
-  client_options_.channel_id_source_async = false;
-  // CompleteCryptoHandshake verifies
-  // server_stream()->crypto_negotiated_params().channel_id is correct.
-  EXPECT_EQ(2, CompleteCryptoHandshake());
-  EXPECT_TRUE(server_stream()->encryption_established());
-  EXPECT_TRUE(server_stream()->handshake_confirmed());
-}
-
-TEST_P(QuicCryptoServerStreamTest, ChannelIDAsync) {
-  Initialize();
-
-  client_options_.channel_id_enabled = true;
-  client_options_.channel_id_source_async = true;
-  // CompleteCryptoHandshake verifies
-  // server_stream()->crypto_negotiated_params().channel_id is correct.
-  EXPECT_EQ(2, CompleteCryptoHandshake());
-  EXPECT_TRUE(server_stream()->encryption_established());
-  EXPECT_TRUE(server_stream()->handshake_confirmed());
-}
-
 TEST_P(QuicCryptoServerStreamTest, OnlySendSCUPAfterHandshakeComplete) {
   // An attempt to send a SCUP before completing handshake should fail.
   Initialize();
diff --git a/quic/core/tls_client_handshaker.cc b/quic/core/tls_client_handshaker.cc
index 1087844..db1f6b4 100644
--- a/quic/core/tls_client_handshaker.cc
+++ b/quic/core/tls_client_handshaker.cc
@@ -190,16 +190,6 @@
   return 0;
 }
 
-bool TlsClientHandshaker::WasChannelIDSent() const {
-  // Channel ID is not used with TLS in QUIC.
-  return false;
-}
-
-bool TlsClientHandshaker::WasChannelIDSourceCallbackRun() const {
-  // Channel ID is not used with TLS in QUIC.
-  return false;
-}
-
 std::string TlsClientHandshaker::chlo_hash() const {
   return "";
 }
diff --git a/quic/core/tls_client_handshaker.h b/quic/core/tls_client_handshaker.h
index c2243b3..3647e10 100644
--- a/quic/core/tls_client_handshaker.h
+++ b/quic/core/tls_client_handshaker.h
@@ -42,8 +42,6 @@
   bool CryptoConnect() override;
   int num_sent_client_hellos() const override;
   int num_scup_messages_received() const override;
-  bool WasChannelIDSent() const override;
-  bool WasChannelIDSourceCallbackRun() const override;
   std::string chlo_hash() const override;
 
   // From QuicCryptoClientStream::HandshakerDelegate and TlsHandshaker