| // Copyright 2025 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef NET_BASE_RECONNECT_NOTIFIER_H_ |
| #define NET_BASE_RECONNECT_NOTIFIER_H_ |
| |
| #include <cstdint> |
| #include <memory> |
| #include <optional> |
| #include <set> |
| |
| #include "base/functional/callback.h" |
| #include "base/observer_list.h" |
| #include "base/observer_list_types.h" |
| #include "net/base/net_export.h" |
| |
| namespace net { |
| // TODO(crbug.com/406022435): Refactor the components to elsewhere to avoid |
| // exposing un-necessary data structures to the browser. |
| |
| // An enum which represents the possible network change event that may happen |
| // in the underlying network connection. |
| enum class NetworkChangeEvent { |
| // The current network is soon to be disconnected. |
| kSoonToDisconnect, |
| // Disconnected from the previously connected network. |
| kDisconnected, |
| // Connected to a new network. |
| kConnected, |
| // The default network has been changed. |
| kDefaultNetworkChanged, |
| kMaxValue = kDefaultNetworkChanged |
| }; |
| |
| // An interface class to notify the observer of reconnect event. This should be |
| // implemented when attempting to notify the observer of the reconnect event. |
| class NET_EXPORT ConnectionChangeNotifier { |
| public: |
| // An observer class for the `ConnectionChangeNotifier`. This class will |
| // unregister itself from the ObserverList of the notifier when destructing |
| // to avoid dangling pointers. |
| class NET_EXPORT Observer : public base::CheckedObserver { |
| public: |
| using ObserverCallback = |
| base::OnceCallback<void(const ConnectionChangeNotifier::Observer*)>; |
| |
| Observer(); |
| ~Observer() override; |
| |
| // Notify that the underlying network session has been closed. |
| virtual void OnSessionClosed() = 0; |
| |
| // Notify that the network connection could not be established. |
| virtual void OnConnectionFailed() = 0; |
| |
| // Notify on a network change event. |
| virtual void OnNetworkEvent(NetworkChangeEvent event) = 0; |
| |
| private: |
| friend class ConnectionChangeNotifier; |
| |
| // Called when the observer has been attached to the notifier. This will |
| // pass the `WeakPtr` of the notifier so that the observer can unregister |
| // itself on destruct. |
| void OnAttach(base::WeakPtr<ConnectionChangeNotifier> notifier); |
| |
| base::WeakPtr<ConnectionChangeNotifier> notifier_; |
| }; |
| |
| ConnectionChangeNotifier(); |
| ~ConnectionChangeNotifier(); |
| |
| // Notify that the underlying network session has been closed. |
| void OnSessionClosed(); |
| |
| // Notify that the network connection could not be established. |
| void OnConnectionFailed(); |
| |
| // Notify on a network change event. |
| void OnNetworkEvent(NetworkChangeEvent event); |
| |
| void AddObserver(ConnectionChangeNotifier::Observer* observer); |
| void RemoveObserver(const ConnectionChangeNotifier::Observer* observer); |
| |
| private: |
| base::ObserverList<ConnectionChangeNotifier::Observer> observer_list_; |
| |
| base::WeakPtrFactory<ConnectionChangeNotifier> weak_factory_{this}; |
| }; |
| |
| // Keeps track of the relevant information to conduct connection keep-alive. |
| struct NET_EXPORT ConnectionKeepAliveConfig { |
| ConnectionKeepAliveConfig() = default; |
| ~ConnectionKeepAliveConfig() = default; |
| |
| ConnectionKeepAliveConfig(const ConnectionKeepAliveConfig& other) = default; |
| ConnectionKeepAliveConfig& operator=(const ConnectionKeepAliveConfig& other) = |
| default; |
| ConnectionKeepAliveConfig(ConnectionKeepAliveConfig&& other) = default; |
| ConnectionKeepAliveConfig& operator=(ConnectionKeepAliveConfig&& other) = |
| default; |
| |
| // Timeout for the session to be closed. Counted from the last successful |
| // PING. This is kept as signed integer since it will be later passed as |
| // a time offset of the underlying time representation such as `QuicTime`. |
| int32_t idle_timeout_in_seconds = 0; |
| |
| // Interval between two pings. Counted from the last ping. This should be |
| // reasonably shorter than `idle_timeout` so that a PING frame can be |
| // exchanged before the idle timeout. This is kept as signed integer since it |
| // will be later passed as a time offset of the underlying time representation |
| // such as `QuicTime`. |
| int32_t ping_interval_in_seconds = 0; |
| |
| // Enables the connection keep alive mechanism to periodically send PING |
| // to the server when there are no active requests. |
| bool enable_connection_keep_alive = false; |
| |
| // The QUIC connection options which will be sent to the server in order to |
| // enable certain QUIC features. This should be set using `QuicTag`s (32-bit |
| // value represented in ASCII equivalent e.g. EXMP). If we want to set |
| // multiple features, then the values should be separated with a comma |
| // (e.g. "ABCD,EFGH"). |
| std::string quic_connection_options; |
| }; |
| |
| // Keeps track of the connection management relevant information (e.g. |
| // connection keep alive configs, reconnect notification configs) to be passed |
| // on to the underlying connection. |
| struct NET_EXPORT ConnectionManagementConfig { |
| ConnectionManagementConfig(); |
| ~ConnectionManagementConfig(); |
| ConnectionManagementConfig(const ConnectionManagementConfig& other); |
| ConnectionManagementConfig(ConnectionManagementConfig&& other); |
| |
| ConnectionManagementConfig& operator=( |
| const ConnectionManagementConfig& other) = default; |
| ConnectionManagementConfig& operator=(ConnectionManagementConfig&& other) = |
| default; |
| |
| // Connection keep alive related information. |
| std::optional<ConnectionKeepAliveConfig> keep_alive_config; |
| |
| // A reference to the `ConnectionChangeNotifier::Observer`. |
| raw_ptr<ConnectionChangeNotifier::Observer> connection_change_observer = |
| nullptr; |
| }; |
| |
| } // namespace net |
| |
| #endif // NET_BASE_RECONNECT_NOTIFIER_H_ |
