If a QuicAlarm belongs to a single QuicConnection, make sure the alarm fires under the corresponding QuicConnectionContext. Protected by FLAGS_quic_reloadable_flag_quic_restore_connection_context_in_alarms. PiperOrigin-RevId: 394230753
diff --git a/quic/core/http/quic_client_promised_info.h b/quic/core/http/quic_client_promised_info.h index 0666c3a..ec071f0 100644 --- a/quic/core/http/quic_client_promised_info.h +++ b/quic/core/http/quic_client_promised_info.h
@@ -84,7 +84,8 @@ private: friend class test::QuicClientPromisedInfoPeer; - class QUIC_EXPORT_PRIVATE CleanupAlarm : public QuicAlarm::Delegate { + class QUIC_EXPORT_PRIVATE CleanupAlarm + : public QuicAlarm::DelegateWithoutContext { public: explicit CleanupAlarm(QuicClientPromisedInfo* promised) : promised_(promised) {}
diff --git a/quic/core/quic_alarm.cc b/quic/core/quic_alarm.cc index 81640a4..67e0a74 100644 --- a/quic/core/quic_alarm.cc +++ b/quic/core/quic_alarm.cc
@@ -100,6 +100,11 @@ deadline_ = QuicTime::Zero(); if (!IsPermanentlyCancelled()) { + absl::optional<QuicConnectionContextSwitcher> context_switcher; + if (GetQuicReloadableFlag(quic_restore_connection_context_in_alarms)) { + QUIC_RELOADABLE_FLAG_COUNT(quic_restore_connection_context_in_alarms); + context_switcher.emplace(delegate_->GetConnectionContext()); + } delegate_->OnAlarm(); } }
diff --git a/quic/core/quic_alarm.h b/quic/core/quic_alarm.h index 5080fd4..26ebfe8 100644 --- a/quic/core/quic_alarm.h +++ b/quic/core/quic_alarm.h
@@ -6,6 +6,7 @@ #define QUICHE_QUIC_CORE_QUIC_ALARM_H_ #include "quic/core/quic_arena_scoped_ptr.h" +#include "quic/core/quic_connection_context.h" #include "quic/core/quic_time.h" #include "quic/platform/api/quic_export.h" @@ -22,10 +23,39 @@ public: virtual ~Delegate() {} + // If the alarm belongs to a single QuicConnection, return the corresponding + // QuicConnection.context_. Note the context_ is the first member of + // QuicConnection, so it should outlive the delegate. + // Otherwise return nullptr. + // The OnAlarm function will be called under the connection context, if any. + virtual QuicConnectionContext* GetConnectionContext() = 0; + // Invoked when the alarm fires. virtual void OnAlarm() = 0; }; + // DelegateWithContext is a Delegate with a QuicConnectionContext* stored as a + // member variable. + class QUIC_EXPORT_PRIVATE DelegateWithContext : public Delegate { + public: + explicit DelegateWithContext(QuicConnectionContext* context) + : context_(context) {} + ~DelegateWithContext() override {} + QuicConnectionContext* GetConnectionContext() override { return context_; } + + private: + QuicConnectionContext* context_; + }; + + // DelegateWithoutContext is a Delegate that does not have a corresponding + // context. Typically this means one object of the child class deals with many + // connections. + class QUIC_EXPORT_PRIVATE DelegateWithoutContext : public Delegate { + public: + ~DelegateWithoutContext() override {} + QuicConnectionContext* GetConnectionContext() override { return nullptr; } + }; + explicit QuicAlarm(QuicArenaScopedPtr<Delegate> delegate); QuicAlarm(const QuicAlarm&) = delete; QuicAlarm& operator=(const QuicAlarm&) = delete;
diff --git a/quic/core/quic_alarm_test.cc b/quic/core/quic_alarm_test.cc index ab07002..bc3ea2c 100644 --- a/quic/core/quic_alarm_test.cc +++ b/quic/core/quic_alarm_test.cc
@@ -4,21 +4,41 @@ #include "quic/core/quic_alarm.h" +#include "quic/core/quic_connection_context.h" #include "quic/platform/api/quic_expect_bug.h" #include "quic/platform/api/quic_test.h" +using testing::ElementsAre; using testing::Invoke; +using testing::Return; namespace quic { namespace test { namespace { +class TraceCollector : public QuicConnectionTracer { + public: + ~TraceCollector() override = default; + + void PrintLiteral(const char* literal) override { trace_.push_back(literal); } + + void PrintString(absl::string_view s) override { + trace_.push_back(std::string(s)); + } + + const std::vector<std::string>& trace() const { return trace_; } + + private: + std::vector<std::string> trace_; +}; + class MockDelegate : public QuicAlarm::Delegate { public: + MOCK_METHOD(QuicConnectionContext*, GetConnectionContext, (), (override)); MOCK_METHOD(void, OnAlarm, (), (override)); }; -class DestructiveDelegate : public QuicAlarm::Delegate { +class DestructiveDelegate : public QuicAlarm::DelegateWithoutContext { public: DestructiveDelegate() : alarm_(nullptr) {} @@ -204,6 +224,67 @@ alarm->FireAlarm(); } +TEST_F(QuicAlarmTest, NullAlarmContext) { + QuicTime deadline = QuicTime::Zero() + QuicTime::Delta::FromSeconds(7); + alarm_.Set(deadline); + + if (GetQuicReloadableFlag(quic_restore_connection_context_in_alarms)) { + EXPECT_CALL(*delegate_, GetConnectionContext()).WillOnce(Return(nullptr)); + } + + EXPECT_CALL(*delegate_, OnAlarm()).WillOnce(Invoke([] { + QUIC_TRACELITERAL("Alarm fired."); + })); + alarm_.FireAlarm(); +} + +TEST_F(QuicAlarmTest, AlarmContextWithNullTracer) { + QuicConnectionContext context; + ASSERT_EQ(context.tracer, nullptr); + + QuicTime deadline = QuicTime::Zero() + QuicTime::Delta::FromSeconds(7); + alarm_.Set(deadline); + + if (GetQuicReloadableFlag(quic_restore_connection_context_in_alarms)) { + EXPECT_CALL(*delegate_, GetConnectionContext()).WillOnce(Return(&context)); + } + + EXPECT_CALL(*delegate_, OnAlarm()).WillOnce(Invoke([] { + QUIC_TRACELITERAL("Alarm fired."); + })); + alarm_.FireAlarm(); +} + +TEST_F(QuicAlarmTest, AlarmContextWithTracer) { + QuicConnectionContext context; + std::unique_ptr<TraceCollector> tracer = std::make_unique<TraceCollector>(); + const TraceCollector& tracer_ref = *tracer; + context.tracer = std::move(tracer); + + QuicTime deadline = QuicTime::Zero() + QuicTime::Delta::FromSeconds(7); + alarm_.Set(deadline); + + if (GetQuicReloadableFlag(quic_restore_connection_context_in_alarms)) { + EXPECT_CALL(*delegate_, GetConnectionContext()).WillOnce(Return(&context)); + } + + EXPECT_CALL(*delegate_, OnAlarm()).WillOnce(Invoke([] { + QUIC_TRACELITERAL("Alarm fired."); + })); + + // Since |context| is not installed in the current thread, the messages before + // and after FireAlarm() should not be collected by |tracer|. + QUIC_TRACELITERAL("Should not be collected before alarm."); + alarm_.FireAlarm(); + QUIC_TRACELITERAL("Should not be collected after alarm."); + + if (GetQuicReloadableFlag(quic_restore_connection_context_in_alarms)) { + EXPECT_THAT(tracer_ref.trace(), ElementsAre("Alarm fired.")); + } else { + EXPECT_TRUE(tracer_ref.trace().empty()); + } +} + } // namespace } // namespace test } // namespace quic
diff --git a/quic/core/quic_buffered_packet_store.cc b/quic/core/quic_buffered_packet_store.cc index 9312ea5..ed1b80e 100644 --- a/quic/core/quic_buffered_packet_store.cc +++ b/quic/core/quic_buffered_packet_store.cc
@@ -24,7 +24,7 @@ namespace { // This alarm removes expired entries in map each time this alarm fires. -class ConnectionExpireAlarm : public QuicAlarm::Delegate { +class ConnectionExpireAlarm : public QuicAlarm::DelegateWithoutContext { public: explicit ConnectionExpireAlarm(QuicBufferedPacketStore* store) : connection_store_(store) {}
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc index b77bb1b..170a206 100644 --- a/quic/core/quic_connection.cc +++ b/quic/core/quic_connection.cc
@@ -72,6 +72,10 @@ QuicConnectionAlarmDelegate& operator=(const QuicConnectionAlarmDelegate&) = delete; + QuicConnectionContext* GetConnectionContext() override { + return (connection_ == nullptr) ? nullptr : connection_->context(); + } + protected: QuicConnection* connection_; }; @@ -216,16 +220,11 @@ QuicConnectionId server_connection_id, QuicSocketAddress initial_self_address, QuicSocketAddress initial_peer_address, - QuicConnectionHelperInterface* helper, - QuicAlarmFactory* alarm_factory, - QuicPacketWriter* writer, - bool owns_writer, - Perspective perspective, + QuicConnectionHelperInterface* helper, QuicAlarmFactory* alarm_factory, + QuicPacketWriter* writer, bool owns_writer, Perspective perspective, const ParsedQuicVersionVector& supported_versions) - : framer_(supported_versions, - helper->GetClock()->ApproximateNow(), - perspective, - server_connection_id.length()), + : framer_(supported_versions, helper->GetClock()->ApproximateNow(), + perspective, server_connection_id.length()), current_packet_content_(NO_FRAMES_RECEIVED), is_current_packet_connectivity_probing_(false), has_path_challenge_in_current_packet_(false), @@ -240,8 +239,7 @@ random_generator_(helper->GetRandomGenerator()), client_connection_id_is_set_(false), direct_peer_address_(initial_peer_address), - default_path_(initial_self_address, - QuicSocketAddress(), + default_path_(initial_self_address, QuicSocketAddress(), /*client_connection_id=*/EmptyQuicConnectionId(), server_connection_id, /*stateless_reset_token_received=*/false, @@ -270,23 +268,17 @@ ack_alarm_(alarm_factory_->CreateAlarm(arena_.New<AckAlarmDelegate>(this), &arena_)), retransmission_alarm_(alarm_factory_->CreateAlarm( - arena_.New<RetransmissionAlarmDelegate>(this), - &arena_)), - send_alarm_( - alarm_factory_->CreateAlarm(arena_.New<SendAlarmDelegate>(this), - &arena_)), - ping_alarm_( - alarm_factory_->CreateAlarm(arena_.New<PingAlarmDelegate>(this), - &arena_)), + arena_.New<RetransmissionAlarmDelegate>(this), &arena_)), + send_alarm_(alarm_factory_->CreateAlarm( + arena_.New<SendAlarmDelegate>(this), &arena_)), + ping_alarm_(alarm_factory_->CreateAlarm( + arena_.New<PingAlarmDelegate>(this), &arena_)), mtu_discovery_alarm_(alarm_factory_->CreateAlarm( - arena_.New<MtuDiscoveryAlarmDelegate>(this), - &arena_)), + arena_.New<MtuDiscoveryAlarmDelegate>(this), &arena_)), process_undecryptable_packets_alarm_(alarm_factory_->CreateAlarm( - arena_.New<ProcessUndecryptablePacketsAlarmDelegate>(this), - &arena_)), + arena_.New<ProcessUndecryptablePacketsAlarmDelegate>(this), &arena_)), discard_previous_one_rtt_keys_alarm_(alarm_factory_->CreateAlarm( - arena_.New<DiscardPreviousOneRttKeysAlarmDelegate>(this), - &arena_)), + arena_.New<DiscardPreviousOneRttKeysAlarmDelegate>(this), &arena_)), discard_zero_rtt_decryption_keys_alarm_(alarm_factory_->CreateAlarm( arena_.New<DiscardZeroRttDecryptionKeysAlarmDelegate>(this), &arena_)), @@ -294,10 +286,7 @@ debug_visitor_(nullptr), packet_creator_(server_connection_id, &framer_, random_generator_, this), last_received_packet_info_(clock_->ApproximateNow()), - sent_packet_manager_(perspective, - clock_, - random_generator_, - &stats_, + sent_packet_manager_(perspective, clock_, random_generator_, &stats_, GetDefaultCongestionControlType()), version_negotiated_(false), perspective_(perspective), @@ -320,12 +309,11 @@ processing_ack_frame_(false), supports_release_time_(false), release_time_into_future_(QuicTime::Delta::Zero()), - blackhole_detector_(this, &arena_, alarm_factory_), - idle_network_detector_(this, - clock_->ApproximateNow(), - &arena_, - alarm_factory_), - path_validator_(alarm_factory_, &arena_, this, random_generator_), + blackhole_detector_(this, &arena_, alarm_factory_, &context_), + idle_network_detector_(this, clock_->ApproximateNow(), &arena_, + alarm_factory_, &context_), + path_validator_(alarm_factory_, &arena_, this, random_generator_, + &context_), most_recent_frame_type_(NUM_FRAME_TYPES) { QUICHE_DCHECK(perspective_ == Perspective::IS_CLIENT || default_path_.self_address.IsInitialized()); @@ -2983,7 +2971,7 @@ peer_issued_cid_manager_ = std::make_unique<QuicPeerIssuedConnectionIdManager>( kMinNumOfActiveConnectionIds, new_server_connection_id, clock_, - alarm_factory_, this); + alarm_factory_, this, context()); } } } @@ -4070,7 +4058,7 @@ perspective_ == Perspective::IS_CLIENT ? default_path_.client_connection_id : default_path_.server_connection_id, - clock_, alarm_factory_, this); + clock_, alarm_factory_, this, context()); } void QuicConnection::MaybeSendConnectionIdToClient() { @@ -6264,7 +6252,7 @@ peer_issued_cid_manager_ = std::make_unique<QuicPeerIssuedConnectionIdManager>( kMinNumOfActiveConnectionIds, client_connection_id, clock_, - alarm_factory_, this); + alarm_factory_, this, context()); } else { // Note in Chromium client, set_client_connection_id is not called and // thus self_issued_cid_manager_ should be null. @@ -6876,7 +6864,7 @@ peer_issued_cid_manager_ = std::make_unique<QuicPeerIssuedConnectionIdManager>( kMinNumOfActiveConnectionIds, default_path_.server_connection_id, - clock_, alarm_factory_, this); + clock_, alarm_factory_, this, context()); } } else { if (!default_path_.server_connection_id.IsEmpty()) {
diff --git a/quic/core/quic_connection_id_manager.cc b/quic/core/quic_connection_id_manager.cc index c7e8972..1138a2e 100644 --- a/quic/core/quic_connection_id_manager.cc +++ b/quic/core/quic_connection_id_manager.cc
@@ -24,11 +24,13 @@ namespace { -class RetirePeerIssuedConnectionIdAlarm : public QuicAlarm::Delegate { +class RetirePeerIssuedConnectionIdAlarm + : public QuicAlarm::DelegateWithContext { public: explicit RetirePeerIssuedConnectionIdAlarm( - QuicConnectionIdManagerVisitorInterface* visitor) - : visitor_(visitor) {} + QuicConnectionIdManagerVisitorInterface* visitor, + QuicConnectionContext* context) + : QuicAlarm::DelegateWithContext(context), visitor_(visitor) {} RetirePeerIssuedConnectionIdAlarm(const RetirePeerIssuedConnectionIdAlarm&) = delete; RetirePeerIssuedConnectionIdAlarm& operator=( @@ -63,13 +65,13 @@ QuicPeerIssuedConnectionIdManager::QuicPeerIssuedConnectionIdManager( size_t active_connection_id_limit, const QuicConnectionId& initial_peer_issued_connection_id, - const QuicClock* clock, - QuicAlarmFactory* alarm_factory, - QuicConnectionIdManagerVisitorInterface* visitor) + const QuicClock* clock, QuicAlarmFactory* alarm_factory, + QuicConnectionIdManagerVisitorInterface* visitor, + QuicConnectionContext* context) : active_connection_id_limit_(active_connection_id_limit), clock_(clock), retire_connection_id_alarm_(alarm_factory->CreateAlarm( - new RetirePeerIssuedConnectionIdAlarm(visitor))) { + new RetirePeerIssuedConnectionIdAlarm(visitor, context))) { QUICHE_DCHECK_GE(active_connection_id_limit_, 2u); QUICHE_DCHECK(!initial_peer_issued_connection_id.IsEmpty()); active_connection_id_data_.emplace_back<const QuicConnectionId&, uint64_t, @@ -251,11 +253,14 @@ namespace { -class RetireSelfIssuedConnectionIdAlarmDelegate : public QuicAlarm::Delegate { +class RetireSelfIssuedConnectionIdAlarmDelegate + : public QuicAlarm::DelegateWithContext { public: explicit RetireSelfIssuedConnectionIdAlarmDelegate( - QuicSelfIssuedConnectionIdManager* connection_id_manager) - : connection_id_manager_(connection_id_manager) {} + QuicSelfIssuedConnectionIdManager* connection_id_manager, + QuicConnectionContext* context) + : QuicAlarm::DelegateWithContext(context), + connection_id_manager_(connection_id_manager) {} RetireSelfIssuedConnectionIdAlarmDelegate( const RetireSelfIssuedConnectionIdAlarmDelegate&) = delete; RetireSelfIssuedConnectionIdAlarmDelegate& operator=( @@ -271,15 +276,15 @@ QuicSelfIssuedConnectionIdManager::QuicSelfIssuedConnectionIdManager( size_t active_connection_id_limit, - const QuicConnectionId& initial_connection_id, - const QuicClock* clock, + const QuicConnectionId& initial_connection_id, const QuicClock* clock, QuicAlarmFactory* alarm_factory, - QuicConnectionIdManagerVisitorInterface* visitor) + QuicConnectionIdManagerVisitorInterface* visitor, + QuicConnectionContext* context) : active_connection_id_limit_(active_connection_id_limit), clock_(clock), visitor_(visitor), retire_connection_id_alarm_(alarm_factory->CreateAlarm( - new RetireSelfIssuedConnectionIdAlarmDelegate(this))), + new RetireSelfIssuedConnectionIdAlarmDelegate(this, context))), last_connection_id_(initial_connection_id), next_connection_id_sequence_number_(1u), last_connection_id_consumed_by_self_sequence_number_(0u) {
diff --git a/quic/core/quic_connection_id_manager.h b/quic/core/quic_connection_id_manager.h index 775c016..e23668d 100644 --- a/quic/core/quic_connection_id_manager.h +++ b/quic/core/quic_connection_id_manager.h
@@ -60,9 +60,9 @@ QuicPeerIssuedConnectionIdManager( size_t active_connection_id_limit, const QuicConnectionId& initial_peer_issued_connection_id, - const QuicClock* clock, - QuicAlarmFactory* alarm_factory, - QuicConnectionIdManagerVisitorInterface* visitor); + const QuicClock* clock, QuicAlarmFactory* alarm_factory, + QuicConnectionIdManagerVisitorInterface* visitor, + QuicConnectionContext* context); ~QuicPeerIssuedConnectionIdManager(); @@ -123,10 +123,10 @@ public: QuicSelfIssuedConnectionIdManager( size_t active_connection_id_limit, - const QuicConnectionId& initial_connection_id, - const QuicClock* clock, + const QuicConnectionId& initial_connection_id, const QuicClock* clock, QuicAlarmFactory* alarm_factory, - QuicConnectionIdManagerVisitorInterface* visitor); + QuicConnectionIdManagerVisitorInterface* visitor, + QuicConnectionContext* context); virtual ~QuicSelfIssuedConnectionIdManager();
diff --git a/quic/core/quic_connection_id_manager_test.cc b/quic/core/quic_connection_id_manager_test.cc index 7baeb2b..fdb73da 100644 --- a/quic/core/quic_connection_id_manager_test.cc +++ b/quic/core/quic_connection_id_manager_test.cc
@@ -78,11 +78,9 @@ class QuicPeerIssuedConnectionIdManagerTest : public QuicTest { public: QuicPeerIssuedConnectionIdManagerTest() - : peer_issued_cid_manager_(/*active_connection_id_limit=*/2, - initial_connection_id_, - &clock_, - &alarm_factory_, - &cid_manager_visitor_) { + : peer_issued_cid_manager_( + /*active_connection_id_limit=*/2, initial_connection_id_, &clock_, + &alarm_factory_, &cid_manager_visitor_, /*context=*/nullptr) { clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10)); cid_manager_visitor_.SetPeerIssuedConnectionIdManager( &peer_issued_cid_manager_); @@ -538,11 +536,9 @@ class QuicSelfIssuedConnectionIdManagerTest : public QuicTest { public: QuicSelfIssuedConnectionIdManagerTest() - : cid_manager_(/*active_connection_id_limit*/ 2, - initial_connection_id_, - &clock_, - &alarm_factory_, - &cid_manager_visitor_) { + : cid_manager_(/*active_connection_id_limit*/ 2, initial_connection_id_, + &clock_, &alarm_factory_, &cid_manager_visitor_, + /*context=*/nullptr) { clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10)); retire_self_issued_cid_alarm_ = QuicConnectionIdManagerPeer::GetRetireSelfIssuedConnectionIdAlarm(
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc index a7345ea..32c508b 100644 --- a/quic/core/quic_dispatcher.cc +++ b/quic/core/quic_dispatcher.cc
@@ -40,7 +40,7 @@ const QuicPacketLength kMinClientInitialPacketLength = 1200; // An alarm that informs the QuicDispatcher to delete old sessions. -class DeleteSessionsAlarm : public QuicAlarm::Delegate { +class DeleteSessionsAlarm : public QuicAlarm::DelegateWithoutContext { public: explicit DeleteSessionsAlarm(QuicDispatcher* dispatcher) : dispatcher_(dispatcher) {}
diff --git a/quic/core/quic_epoll_alarm_factory_test.cc b/quic/core/quic_epoll_alarm_factory_test.cc index e2268db..d815fae 100644 --- a/quic/core/quic_epoll_alarm_factory_test.cc +++ b/quic/core/quic_epoll_alarm_factory_test.cc
@@ -12,7 +12,7 @@ namespace test { namespace { -class TestDelegate : public QuicAlarm::Delegate { +class TestDelegate : public QuicAlarm::DelegateWithoutContext { public: TestDelegate() : fired_(false) {}
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h index e6a430d..6c715d0 100644 --- a/quic/core/quic_flags_list.h +++ b/quic/core/quic_flags_list.h
@@ -23,6 +23,8 @@ QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_tls_set_signature_algorithm_prefs, true) // If true, QUIC will default enable MTU discovery at server, with a target of 1450 bytes. QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_mtu_discovery_at_server, false) +// If true, QuicAlarms that belong to a single QuicConnection will fire under the corresponding QuicConnectionContext. +QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_restore_connection_context_in_alarms, true) // If true, QuicGsoBatchWriter will support release time if it is available and the process has the permission to do so. QUIC_FLAG(FLAGS_quic_restart_flag_quic_support_release_time_for_gso, false) // If true, abort async QPACK header decompression in QuicSpdyStream::Reset() and in QuicSpdyStream::OnStreamReset().
diff --git a/quic/core/quic_idle_network_detector.cc b/quic/core/quic_idle_network_detector.cc index 05203df..fceb1e7 100644 --- a/quic/core/quic_idle_network_detector.cc +++ b/quic/core/quic_idle_network_detector.cc
@@ -11,10 +11,11 @@ namespace { -class AlarmDelegate : public QuicAlarm::Delegate { +class AlarmDelegate : public QuicAlarm::DelegateWithContext { public: - explicit AlarmDelegate(QuicIdleNetworkDetector* detector) - : detector_(detector) {} + explicit AlarmDelegate(QuicIdleNetworkDetector* detector, + QuicConnectionContext* context) + : QuicAlarm::DelegateWithContext(context), detector_(detector) {} AlarmDelegate(const AlarmDelegate&) = delete; AlarmDelegate& operator=(const AlarmDelegate&) = delete; @@ -28,15 +29,15 @@ QuicIdleNetworkDetector::QuicIdleNetworkDetector( Delegate* delegate, QuicTime now, QuicConnectionArena* arena, - QuicAlarmFactory* alarm_factory) + QuicAlarmFactory* alarm_factory, QuicConnectionContext* context) : delegate_(delegate), start_time_(now), handshake_timeout_(QuicTime::Delta::Infinite()), time_of_last_received_packet_(now), time_of_first_packet_sent_after_receiving_(QuicTime::Zero()), idle_network_timeout_(QuicTime::Delta::Infinite()), - alarm_( - alarm_factory->CreateAlarm(arena->New<AlarmDelegate>(this), arena)) {} + alarm_(alarm_factory->CreateAlarm( + arena->New<AlarmDelegate>(this, context), arena)) {} void QuicIdleNetworkDetector::OnAlarm() { if (handshake_timeout_.IsInfinite()) {
diff --git a/quic/core/quic_idle_network_detector.h b/quic/core/quic_idle_network_detector.h index c380b0d..2381c12 100644 --- a/quic/core/quic_idle_network_detector.h +++ b/quic/core/quic_idle_network_detector.h
@@ -36,10 +36,10 @@ virtual void OnIdleNetworkDetected() = 0; }; - QuicIdleNetworkDetector(Delegate* delegate, - QuicTime now, + QuicIdleNetworkDetector(Delegate* delegate, QuicTime now, QuicConnectionArena* arena, - QuicAlarmFactory* alarm_factory); + QuicAlarmFactory* alarm_factory, + QuicConnectionContext* context); void OnAlarm();
diff --git a/quic/core/quic_idle_network_detector_test.cc b/quic/core/quic_idle_network_detector_test.cc index 21549d9..a6fd5d2 100644 --- a/quic/core/quic_idle_network_detector_test.cc +++ b/quic/core/quic_idle_network_detector_test.cc
@@ -32,7 +32,8 @@ QuicIdleNetworkDetectorTest() { clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1)); detector_ = std::make_unique<QuicIdleNetworkDetector>( - &delegate_, clock_.Now(), &arena_, &alarm_factory_); + &delegate_, clock_.Now(), &arena_, &alarm_factory_, + /*context=*/nullptr); alarm_ = static_cast<MockAlarmFactory::TestAlarm*>( QuicIdleNetworkDetectorTestPeer::GetAlarm(detector_.get())); }
diff --git a/quic/core/quic_network_blackhole_detector.cc b/quic/core/quic_network_blackhole_detector.cc index 4dca508..2d9fc2d 100644 --- a/quic/core/quic_network_blackhole_detector.cc +++ b/quic/core/quic_network_blackhole_detector.cc
@@ -10,10 +10,11 @@ namespace { -class AlarmDelegate : public QuicAlarm::Delegate { +class AlarmDelegate : public QuicAlarm::DelegateWithContext { public: - explicit AlarmDelegate(QuicNetworkBlackholeDetector* detector) - : detector_(detector) {} + explicit AlarmDelegate(QuicNetworkBlackholeDetector* detector, + QuicConnectionContext* context) + : QuicAlarm::DelegateWithContext(context), detector_(detector) {} AlarmDelegate(const AlarmDelegate&) = delete; AlarmDelegate& operator=(const AlarmDelegate&) = delete; @@ -26,12 +27,11 @@ } // namespace QuicNetworkBlackholeDetector::QuicNetworkBlackholeDetector( - Delegate* delegate, - QuicConnectionArena* arena, - QuicAlarmFactory* alarm_factory) + Delegate* delegate, QuicConnectionArena* arena, + QuicAlarmFactory* alarm_factory, QuicConnectionContext* context) : delegate_(delegate), - alarm_( - alarm_factory->CreateAlarm(arena->New<AlarmDelegate>(this), arena)) {} + alarm_(alarm_factory->CreateAlarm( + arena->New<AlarmDelegate>(this, context), arena)) {} void QuicNetworkBlackholeDetector::OnAlarm() { QuicTime next_deadline = GetEarliestDeadline();
diff --git a/quic/core/quic_network_blackhole_detector.h b/quic/core/quic_network_blackhole_detector.h index 82753f9..db52e8f 100644 --- a/quic/core/quic_network_blackhole_detector.h +++ b/quic/core/quic_network_blackhole_detector.h
@@ -40,9 +40,9 @@ virtual void OnPathMtuReductionDetected() = 0; }; - QuicNetworkBlackholeDetector(Delegate* delegate, - QuicConnectionArena* arena, - QuicAlarmFactory* alarm_factory); + QuicNetworkBlackholeDetector(Delegate* delegate, QuicConnectionArena* arena, + QuicAlarmFactory* alarm_factory, + QuicConnectionContext* context); // Called to stop all detections. If |permanent|, the alarm will be cancelled // permanently and future calls to RestartDetection will be no-op.
diff --git a/quic/core/quic_network_blackhole_detector_test.cc b/quic/core/quic_network_blackhole_detector_test.cc index 66bebfd..764ee9a 100644 --- a/quic/core/quic_network_blackhole_detector_test.cc +++ b/quic/core/quic_network_blackhole_detector_test.cc
@@ -33,7 +33,7 @@ class QuicNetworkBlackholeDetectorTest : public QuicTest { public: QuicNetworkBlackholeDetectorTest() - : detector_(&delegate_, &arena_, &alarm_factory_), + : detector_(&delegate_, &arena_, &alarm_factory_, /*context=*/nullptr), alarm_(static_cast<MockAlarmFactory::TestAlarm*>( QuicNetworkBlackholeDetectorPeer::GetAlarm(&detector_))), path_degrading_delay_(
diff --git a/quic/core/quic_one_block_arena.h b/quic/core/quic_one_block_arena.h index 53882ea..02aae87 100644 --- a/quic/core/quic_one_block_arena.h +++ b/quic/core/quic_one_block_arena.h
@@ -69,7 +69,7 @@ // QuicConnections currently use around 1KB of polymorphic types which would // ordinarily be on the heap. Instead, store them inline in an arena. -using QuicConnectionArena = QuicOneBlockArena<1056>; +using QuicConnectionArena = QuicOneBlockArena<1152>; } // namespace quic
diff --git a/quic/core/quic_path_validator.cc b/quic/core/quic_path_validator.cc index bb83e94..658dfef 100644 --- a/quic/core/quic_path_validator.cc +++ b/quic/core/quic_path_validator.cc
@@ -10,10 +10,12 @@ namespace quic { -class RetryAlarmDelegate : public QuicAlarm::Delegate { +class RetryAlarmDelegate : public QuicAlarm::DelegateWithContext { public: - explicit RetryAlarmDelegate(QuicPathValidator* path_validator) - : path_validator_(path_validator) {} + explicit RetryAlarmDelegate(QuicPathValidator* path_validator, + QuicConnectionContext* context) + : QuicAlarm::DelegateWithContext(context), + path_validator_(path_validator) {} RetryAlarmDelegate(const RetryAlarmDelegate&) = delete; RetryAlarmDelegate& operator=(const RetryAlarmDelegate&) = delete; @@ -32,12 +34,12 @@ QuicPathValidator::QuicPathValidator(QuicAlarmFactory* alarm_factory, QuicConnectionArena* arena, SendDelegate* send_delegate, - QuicRandom* random) + QuicRandom* random, + QuicConnectionContext* context) : send_delegate_(send_delegate), random_(random), - retry_timer_( - alarm_factory->CreateAlarm(arena->New<RetryAlarmDelegate>(this), - arena)), + retry_timer_(alarm_factory->CreateAlarm( + arena->New<RetryAlarmDelegate>(this, context), arena)), retry_count_(0u) {} void QuicPathValidator::OnPathResponse(const QuicPathFrameBuffer& probing_data,
diff --git a/quic/core/quic_path_validator.h b/quic/core/quic_path_validator.h index 9ea1554..9fe2cef 100644 --- a/quic/core/quic_path_validator.h +++ b/quic/core/quic_path_validator.h
@@ -13,6 +13,7 @@ #include "quic/core/quic_alarm_factory.h" #include "quic/core/quic_arena_scoped_ptr.h" #include "quic/core/quic_clock.h" +#include "quic/core/quic_connection_context.h" #include "quic/core/quic_one_block_arena.h" #include "quic/core/quic_packet_writer.h" #include "quic/core/quic_types.h" @@ -107,10 +108,9 @@ std::unique_ptr<QuicPathValidationContext> context) = 0; }; - QuicPathValidator(QuicAlarmFactory* alarm_factory, - QuicConnectionArena* arena, - SendDelegate* delegate, - QuicRandom* random); + QuicPathValidator(QuicAlarmFactory* alarm_factory, QuicConnectionArena* arena, + SendDelegate* delegate, QuicRandom* random, + QuicConnectionContext* context); // Send PATH_CHALLENGE and start the retry timer. void StartPathValidation(std::unique_ptr<QuicPathValidationContext> context,
diff --git a/quic/core/quic_path_validator_test.cc b/quic/core/quic_path_validator_test.cc index 1dfafc3..28e1259 100644 --- a/quic/core/quic_path_validator_test.cc +++ b/quic/core/quic_path_validator_test.cc
@@ -48,11 +48,10 @@ class QuicPathValidatorTest : public QuicTest { public: QuicPathValidatorTest() - : path_validator_(&alarm_factory_, &arena_, &send_delegate_, &random_), - context_(new MockQuicPathValidationContext(self_address_, - peer_address_, - effective_peer_address_, - &writer_)), + : path_validator_(&alarm_factory_, &arena_, &send_delegate_, &random_, + /*context=*/nullptr), + context_(new MockQuicPathValidationContext( + self_address_, peer_address_, effective_peer_address_, &writer_)), result_delegate_( new testing::StrictMock<MockQuicPathValidationResultDelegate>()) { clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc index 193783a..1e07162 100644 --- a/quic/core/quic_session.cc +++ b/quic/core/quic_session.cc
@@ -41,6 +41,12 @@ ClosedStreamsCleanUpDelegate& operator=(const ClosedStreamsCleanUpDelegate&) = delete; + QuicConnectionContext* GetConnectionContext() override { + return (session_->connection() == nullptr) + ? nullptr + : session_->connection()->context(); + } + void OnAlarm() override { session_->CleanUpClosedStreams(); } private:
diff --git a/quic/core/quic_time_wait_list_manager.cc b/quic/core/quic_time_wait_list_manager.cc index 69b85fa..80986a3 100644 --- a/quic/core/quic_time_wait_list_manager.cc +++ b/quic/core/quic_time_wait_list_manager.cc
@@ -30,7 +30,7 @@ // A very simple alarm that just informs the QuicTimeWaitListManager to clean // up old connection_ids. This alarm should be cancelled and deleted before // the QuicTimeWaitListManager is deleted. -class ConnectionIdCleanUpAlarm : public QuicAlarm::Delegate { +class ConnectionIdCleanUpAlarm : public QuicAlarm::DelegateWithoutContext { public: explicit ConnectionIdCleanUpAlarm( QuicTimeWaitListManager* time_wait_list_manager)
diff --git a/quic/test_tools/packet_dropping_test_writer.cc b/quic/test_tools/packet_dropping_test_writer.cc index 76dd778..079b228 100644 --- a/quic/test_tools/packet_dropping_test_writer.cc +++ b/quic/test_tools/packet_dropping_test_writer.cc
@@ -18,7 +18,7 @@ // An alarm that is scheduled if a blocked socket is simulated to indicate // it's writable again. -class WriteUnblockedAlarm : public QuicAlarm::Delegate { +class WriteUnblockedAlarm : public QuicAlarm::DelegateWithoutContext { public: explicit WriteUnblockedAlarm(PacketDroppingTestWriter* writer) : writer_(writer) {} @@ -34,7 +34,7 @@ // An alarm that is scheduled every time a new packet is to be written at a // later point. -class DelayAlarm : public QuicAlarm::Delegate { +class DelayAlarm : public QuicAlarm::DelegateWithoutContext { public: explicit DelayAlarm(PacketDroppingTestWriter* writer) : writer_(writer) {}
diff --git a/quic/test_tools/simulator/queue.h b/quic/test_tools/simulator/queue.h index 7e4be83..dd810e7 100644 --- a/quic/test_tools/simulator/queue.h +++ b/quic/test_tools/simulator/queue.h
@@ -73,7 +73,7 @@ }; // Alarm handler for aggregation timeout. - class AggregationAlarmDelegate : public QuicAlarm::Delegate { + class AggregationAlarmDelegate : public QuicAlarm::DelegateWithoutContext { public: explicit AggregationAlarmDelegate(Queue* queue);
diff --git a/quic/test_tools/simulator/simulator.h b/quic/test_tools/simulator/simulator.h index 8f31717..b4298f5 100644 --- a/quic/test_tools/simulator/simulator.h +++ b/quic/test_tools/simulator/simulator.h
@@ -88,7 +88,7 @@ }; // The delegate used for RunFor(). - class RunForDelegate : public QuicAlarm::Delegate { + class RunForDelegate : public QuicAlarm::DelegateWithoutContext { public: explicit RunForDelegate(bool* run_for_should_stop); void OnAlarm() override;
diff --git a/quic/test_tools/simulator/simulator_test.cc b/quic/test_tools/simulator/simulator_test.cc index a71649e..fe84170 100644 --- a/quic/test_tools/simulator/simulator_test.cc +++ b/quic/test_tools/simulator/simulator_test.cc
@@ -475,7 +475,7 @@ }; // Counts the number of times an alarm has fired. -class CounterDelegate : public QuicAlarm::Delegate { +class CounterDelegate : public QuicAlarm::DelegateWithoutContext { public: explicit CounterDelegate(size_t* counter) : counter_(counter) {}