Clarify nullability of ProofSource pointers with absl annotations

I also made some IWYU fixes along the way.

PiperOrigin-RevId: 795593927
diff --git a/quiche/quic/core/tls_server_handshaker.cc b/quiche/quic/core/tls_server_handshaker.cc
index f0ea720..19558c5 100644
--- a/quiche/quic/core/tls_server_handshaker.cc
+++ b/quiche/quic/core/tls_server_handshaker.cc
@@ -14,6 +14,7 @@
 #include <variant>
 #include <vector>
 
+#include "absl/base/nullability.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -49,11 +50,12 @@
 #include "quiche/quic/core/tls_handshaker.h"
 #include "quiche/quic/platform/api/quic_bug_tracker.h"
 #include "quiche/quic/platform/api/quic_flag_utils.h"
-#include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_hostname_utils.h"
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/quic/platform/api/quic_server_stats.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/platform/api/quiche_reference_counted.h"
 
 #define RECORD_LATENCY_IN_US(stat_name, latency, comment)                   \
   do {                                                                      \
@@ -73,8 +75,12 @@
 }  // namespace
 
 TlsServerHandshaker::DefaultProofSourceHandle::DefaultProofSourceHandle(
-    TlsServerHandshaker* handshaker, ProofSource* proof_source)
-    : handshaker_(handshaker), proof_source_(proof_source) {}
+    TlsServerHandshaker* absl_nonnull handshaker,
+    ProofSource* absl_nonnull proof_source)
+    : handshaker_(handshaker), proof_source_(proof_source) {
+  QUICHE_DCHECK(handshaker_);
+  QUICHE_DCHECK(proof_source_);
+}
 
 TlsServerHandshaker::DefaultProofSourceHandle::~DefaultProofSourceHandle() {
   CloseHandle();
@@ -291,6 +297,7 @@
 
 std::unique_ptr<ProofSourceHandle>
 TlsServerHandshaker::MaybeCreateProofSourceHandle() {
+  QUICHE_DCHECK(proof_source_);
   return std::make_unique<DefaultProofSourceHandle>(this, proof_source_);
 }
 
diff --git a/quiche/quic/core/tls_server_handshaker.h b/quiche/quic/core/tls_server_handshaker.h
index 8541968..806fd20 100644
--- a/quiche/quic/core/tls_server_handshaker.h
+++ b/quiche/quic/core/tls_server_handshaker.h
@@ -40,6 +40,8 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/tls_handshaker.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/platform/api/quiche_reference_counted.h"
 
 namespace quic {
 
@@ -240,8 +242,8 @@
   // source.
   class QUICHE_EXPORT DefaultProofSourceHandle : public ProofSourceHandle {
    public:
-    DefaultProofSourceHandle(TlsServerHandshaker* handshaker,
-                             ProofSource* proof_source);
+    DefaultProofSourceHandle(TlsServerHandshaker* absl_nonnull handshaker,
+                             ProofSource* absl_nonnull proof_source);
 
     ~DefaultProofSourceHandle() override;
 
@@ -271,7 +273,9 @@
                                      size_t max_signature_size) override;
 
    protected:
-    ProofSourceHandleCallback* callback() override { return handshaker_; }
+    ProofSourceHandleCallback* absl_nullable callback() override {
+      return handshaker_;
+    }
 
    private:
     class QUICHE_EXPORT DefaultSignatureCallback
@@ -309,9 +313,9 @@
     };
 
     // Not nullptr on construction. Set to nullptr when cancelled.
-    TlsServerHandshaker* handshaker_;  // Not owned.
-    ProofSource* proof_source_;        // Not owned.
-    DefaultSignatureCallback* signature_callback_ = nullptr;
+    TlsServerHandshaker* absl_nullable handshaker_;  // Not owned.
+    ProofSource* absl_nullable proof_source_;        // Not owned.
+    DefaultSignatureCallback* absl_nullable signature_callback_ = nullptr;
   };
 
   struct QUICHE_EXPORT SetTransportParametersResult {
@@ -349,7 +353,7 @@
   }
 
   std::unique_ptr<ProofSourceHandle> proof_source_handle_;
-  ProofSource* proof_source_;
+  ProofSource* absl_nullable proof_source_;
 
   // proof_verifier_ is an optional object that can verify a client's
   // certificate chain. If this is null, then client certificates will always be
diff --git a/quiche/quic/core/tls_server_handshaker_test.cc b/quiche/quic/core/tls_server_handshaker_test.cc
index 9e14c79..71721e9 100644
--- a/quiche/quic/core/tls_server_handshaker_test.cc
+++ b/quiche/quic/core/tls_server_handshaker_test.cc
@@ -5,28 +5,36 @@
 #include "quiche/quic/core/tls_server_handshaker.h"
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "absl/base/attributes.h"
 #include "absl/base/macros.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "openssl/ssl.h"
 #include "quiche/quic/core/crypto/certificate_util.h"
+#include "quiche/quic/core/crypto/certificate_view.h"
 #include "quiche/quic/core/crypto/client_proof_source.h"
 #include "quiche/quic/core/crypto/proof_source.h"
 #include "quiche/quic/core/crypto/proof_verifier.h"
+#include "quiche/quic/core/crypto/quic_compressed_certs_cache.h"
+#include "quiche/quic/core/crypto/quic_crypto_client_config.h"
+#include "quiche/quic/core/crypto/quic_crypto_server_config.h"
 #include "quiche/quic/core/crypto/quic_random.h"
-#include "quiche/quic/core/quic_connection_id.h"
+#include "quiche/quic/core/crypto/transport_parameters.h"
 #include "quiche/quic/core/quic_crypto_client_stream.h"
+#include "quiche/quic/core/quic_error_codes.h"
 #include "quiche/quic/core/quic_session.h"
+#include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/core/quic_types.h"
-#include "quiche/quic/core/quic_utils.h"
 #include "quiche/quic/core/quic_versions.h"
-#include "quiche/quic/core/tls_client_handshaker.h"
+#include "quiche/quic/core/tls_handshaker.h"
 #include "quiche/quic/platform/api/quic_flags.h"
-#include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/crypto_test_utils.h"
 #include "quiche/quic/test_tools/failing_proof_source.h"
@@ -35,8 +43,9 @@
 #include "quiche/quic/test_tools/quic_config_peer.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
 #include "quiche/quic/test_tools/simple_session_cache.h"
-#include "quiche/quic/test_tools/test_certificates.h"
 #include "quiche/quic/test_tools/test_ticket_crypter.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/platform/api/quiche_reference_counted.h"
 
 namespace quic {
 class QuicConnection;
@@ -61,8 +70,8 @@
   bool disable_resumption;
 };
 
-// Used by ::testing::PrintToStringParamName().
-std::string PrintToString(const TestParams& p) {
+ABSL_ATTRIBUTE_UNUSED  // Used by ::testing::PrintToStringParamName().
+    std::string PrintToString(const TestParams& p) {
   return absl::StrCat(
       ParsedQuicVersionToString(p.version), "_",
       (p.disable_resumption ? "ResumptionDisabled" : "ResumptionEnabled"));
diff --git a/quiche/quic/test_tools/fake_proof_source_handle.cc b/quiche/quic/test_tools/fake_proof_source_handle.cc
index 63527f6..3ae09f5 100644
--- a/quiche/quic/test_tools/fake_proof_source_handle.cc
+++ b/quiche/quic/test_tools/fake_proof_source_handle.cc
@@ -12,7 +12,9 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/nullability.h"
 #include "absl/strings/string_view.h"
+#include "openssl/base.h"
 #include "quiche/quic/core/crypto/proof_source.h"
 #include "quiche/quic/core/quic_connection_id.h"
 #include "quiche/quic/core/quic_types.h"
@@ -49,11 +51,11 @@
 };
 
 ComputeSignatureResult ComputeSignatureNow(
-    ProofSource* delegate, const QuicSocketAddress& server_address,
+    ProofSource& delegate, const QuicSocketAddress& server_address,
     const QuicSocketAddress& client_address, const std::string& hostname,
     uint16_t signature_algorithm, absl::string_view in) {
   std::optional<ComputeSignatureResult> result;
-  delegate->ComputeTlsSignature(
+  delegate.ComputeTlsSignature(
       server_address, client_address, hostname, signature_algorithm, in,
       std::make_unique<ResultSavingSignatureCallback>(&result));
   QUICHE_CHECK(result.has_value())
@@ -64,14 +66,17 @@
 }  // namespace
 
 FakeProofSourceHandle::FakeProofSourceHandle(
-    ProofSource* delegate, ProofSourceHandleCallback* callback,
-    Action select_cert_action, Action compute_signature_action,
-    QuicDelayedSSLConfig delayed_ssl_config)
+    ProofSource* absl_nonnull delegate,
+    ProofSourceHandleCallback* absl_nonnull callback, Action select_cert_action,
+    Action compute_signature_action, QuicDelayedSSLConfig delayed_ssl_config)
     : delegate_(delegate),
       callback_(callback),
       select_cert_action_(select_cert_action),
       compute_signature_action_(compute_signature_action),
-      delayed_ssl_config_(delayed_ssl_config) {}
+      delayed_ssl_config_(delayed_ssl_config) {
+  QUICHE_CHECK(delegate);
+  QUICHE_CHECK(callback);
+}
 
 void FakeProofSourceHandle::CloseHandle() {
   select_cert_op_.reset();
@@ -157,7 +162,7 @@
 
   QUICHE_DCHECK(compute_signature_action_ == Action::DELEGATE_SYNC);
   ComputeSignatureResult result =
-      ComputeSignatureNow(delegate_, server_address, client_address, hostname,
+      ComputeSignatureNow(*delegate_, server_address, client_address, hostname,
                           signature_algorithm, in);
   callback_->OnComputeSignatureDone(
       result.ok, /*is_sync=*/true, result.signature, std::move(result.details));
@@ -235,7 +240,7 @@
         /*signature=*/"", /*details=*/nullptr);
   } else if (action_ == Action::DELEGATE_ASYNC) {
     ComputeSignatureResult result = ComputeSignatureNow(
-        delegate_, args_.server_address, args_.client_address, args_.hostname,
+        *delegate_, args_.server_address, args_.client_address, args_.hostname,
         args_.signature_algorithm, args_.in);
     callback_->OnComputeSignatureDone(result.ok, /*is_sync=*/false,
                                       result.signature,
diff --git a/quiche/quic/test_tools/fake_proof_source_handle.h b/quiche/quic/test_tools/fake_proof_source_handle.h
index 05faebe..b9903ad 100644
--- a/quiche/quic/test_tools/fake_proof_source_handle.h
+++ b/quiche/quic/test_tools/fake_proof_source_handle.h
@@ -5,8 +5,19 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_FAKE_PROOF_SOURCE_HANDLE_H_
 #define QUICHE_QUIC_TEST_TOOLS_FAKE_PROOF_SOURCE_HANDLE_H_
 
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "absl/base/nullability.h"
+#include "absl/strings/string_view.h"
+#include "openssl/base.h"
 #include "quiche/quic/core/crypto/proof_source.h"
 #include "quiche/quic/core/quic_connection_id.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/platform/api/quic_socket_address.h"
 
 namespace quic {
 namespace test {
@@ -33,7 +44,8 @@
   // |delegate| must do cert selection and signature synchronously.
   // |delayed_ssl_config| is the config passed to OnSelectCertificateDone.
   FakeProofSourceHandle(
-      ProofSource* delegate, ProofSourceHandleCallback* callback,
+      ProofSource* absl_nonnull delegate,
+      ProofSourceHandleCallback* absl_nonnull callback,
       Action select_cert_action, Action compute_signature_action,
       QuicDelayedSSLConfig delayed_ssl_config = QuicDelayedSSLConfig());
 
@@ -174,8 +186,8 @@
   int NumPendingOperations() const;
 
   bool closed_ = false;
-  ProofSource* delegate_;
-  ProofSourceHandleCallback* callback_;
+  ProofSource* absl_nonnull delegate_;
+  ProofSourceHandleCallback* absl_nonnull callback_;
   // Action for the next select cert operation.
   Action select_cert_action_ = Action::DELEGATE_SYNC;
   // Action for the next compute signature operation.