Fix missed autoformatting

pimterry · pimterry · commit 0f764fbf8ac4 · 2026-06-19T01:17:08.000+02:00
diff --git a/src/quic/application.h b/src/quic/application.h
@@ -199,9 +199,8 @@ struct ApplicationFactory {
   // exists. Returns the parsed data for the ApplySessionTicketData()
   // call at install time, or nullptr to reject the ticket (0-RTT is
   // abandoned and the handshake falls back to a full 1-RTT exchange).
-  PendingTicketAppData (*parse_ticket)(const uv_buf_t& data,
-                                       const Session::Options& options) =
-      nullptr;
+  PendingTicketAppData (*parse_ticket)(
+      const uv_buf_t& data, const Session::Options& options) = nullptr;
 };
 void RegisterApplicationFactory(std::string_view name,
                                 const ApplicationFactory& factory);
diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc
@@ -7,14 +7,14 @@
 #include <nghttp3/nghttp3.h>
 #include <ngtcp2/ngtcp2.h>
 #include <node.h>
-#include "http3.h"
 #include <node_errors.h>
 #include <node_external_reference.h>
 #include <node_mem-inl.h>
 #include <node_realm-inl.h>
 #include <node_sockaddr-inl.h>
 #include <v8.h>
 #include "bindingdata.h"
+#include "http3.h"
 #include "session.h"
 #include "session_manager.h"
 
@@ -394,14 +394,12 @@ Local<DictionaryTemplate> BindingData::transport_params_template() const {
                                     transport_params_template_);
 }
 
-void BindingData::set_http3_settings_template(
-    Local<DictionaryTemplate> tmpl) {
+void BindingData::set_http3_settings_template(Local<DictionaryTemplate> tmpl) {
   http3_settings_template_.Reset(env()->isolate(), tmpl);
 }
 
 Local<DictionaryTemplate> BindingData::http3_settings_template() const {
-  return PersistentToLocal::Default(env()->isolate(),
-                                    http3_settings_template_);
+  return PersistentToLocal::Default(env()->isolate(), http3_settings_template_);
 }
 
 #define V(name, _)                                                             \
diff --git a/src/quic/http3.cc b/src/quic/http3.cc
@@ -210,8 +210,7 @@ std::string Http3Settings::ToString() const {
   return res;
 }
 
-Maybe<Http3Settings> Http3Settings::From(Environment* env,
-                                         Local<Value> value) {
+Maybe<Http3Settings> Http3Settings::From(Environment* env, Local<Value> value) {
   if (value.IsEmpty() || !value->IsObject()) [[unlikely]] {
     THROW_ERR_INVALID_ARG_TYPE(env, "settings must be an object");
     return Nothing<Http3Settings>();
@@ -249,15 +248,13 @@ Maybe<Http3Settings> Http3Settings::From(Environment* env,
 MaybeLocal<Object> Http3Settings::ToObject(Environment* env) const {
   auto& binding_data = BindingData::Get(env);
   auto tmpl = binding_data.http3_settings_template();
-  static constexpr std::string_view names[] = {
-      "maxHeaderPairs",
-      "maxHeaderLength",
-      "maxFieldSectionSize",
-      "qpackMaxDtableCapacity",
-      "qpackEncoderMaxDtableCapacity",
-      "qpackBlockedStreams",
-      "enableConnectProtocol"
-  };
+  static constexpr std::string_view names[] = {"maxHeaderPairs",
+                                               "maxHeaderLength",
+                                               "maxFieldSectionSize",
+                                               "qpackMaxDtableCapacity",
+                                               "qpackEncoderMaxDtableCapacity",
+                                               "qpackBlockedStreams",
+                                               "enableConnectProtocol"};
   if (tmpl.IsEmpty()) {
     tmpl = DictionaryTemplate::New(env->isolate(), names);
     binding_data.set_http3_settings_template(tmpl);
@@ -414,9 +411,8 @@ class Http3Application final : public Session::Application {
       Session& s = session();
       if (s.is_destroyed() || !s.env()->can_call_into_js()) return;
       CallbackScope<Session> cb_scope(&s);
-      s.MakeCallback(BindingData::Get(s.env()).session_application_callback(),
-                     0,
-                     nullptr);
+      s.MakeCallback(
+          BindingData::Get(s.env()).session_application_callback(), 0, nullptr);
     });
   }
 
@@ -874,12 +870,12 @@ class Http3Application final : public Session::Application {
     ssize_t ret = 0;
     Debug(&session(), "HTTP/3 application getting stream data");
     if (conn_ && session().max_data_left()) {
-      ret = nghttp3_conn_writev_stream(
-          *this,
-          &data->id,
-          &data->fin,
-          reinterpret_cast<nghttp3_vec*>(data->data),
-          data->count);
+      ret =
+          nghttp3_conn_writev_stream(*this,
+                                     &data->id,
+                                     &data->fin,
+                                     reinterpret_cast<nghttp3_vec*>(data->data),
+                                     data->count);
       // A negative return value indicates an error.
       if (ret < 0) {
         return static_cast<int>(ret);
@@ -1151,10 +1147,9 @@ class Http3Application final : public Session::Application {
     hs.headers.clear();
     hs.headers_length = 0;
 
-    Local<Value> argv[] = {
-        Array::New(env()->isolate(), values.data(), count),
-        Integer::NewFromUnsigned(env()->isolate(),
-                                 static_cast<uint32_t>(kind))};
+    Local<Value> argv[] = {Array::New(env()->isolate(), values.data(), count),
+                           Integer::NewFromUnsigned(
+                               env()->isolate(), static_cast<uint32_t>(kind))};
 
     stream->MakeCallback(
         binding.stream_headers_callback(), arraysize(argv), argv);
@@ -1722,8 +1717,8 @@ JS_METHOD_IMPL(Http3Binding::SendHeaders) {
   // A pending stream has no id yet; defer the submission until the transport
   // opens it (the priority header, if any, rides along in this header block).
   if (stream->is_pending()) {
-    auto held = std::make_shared<Global<Array>>(binding->env()->isolate(),
-                                                headers);
+    auto held =
+        std::make_shared<Global<Array>>(binding->env()->isolate(), headers);
     stream->RunWhenOpen([stream, flags, held]() {
       Session& session = stream->session();
       if (!session.has_application()) return;
@@ -1807,9 +1802,8 @@ JS_METHOD_IMPL(Http3Binding::GetPriority) {
   if (!session.has_application() || stream->is_pending()) return;
 
   auto result = Http3App(session).GetStreamPriority(*stream);
-  uint32_t packed =
-      (static_cast<uint32_t>(result.priority) << 1) |
-      (result.flags == StreamPriorityFlags::INCREMENTAL ? 1 : 0);
+  uint32_t packed = (static_cast<uint32_t>(result.priority) << 1) |
+                    (result.flags == StreamPriorityFlags::INCREMENTAL ? 1 : 0);
   args.GetReturnValue().Set(packed);
 }
 
@@ -1836,9 +1830,8 @@ void CreateHttp3Handle(const FunctionCallbackInfo<Value>& args) {
     if (session->is_server() && !session->application().Start()) {
       // Start() failed (e.g. the peer's initial_max_streams_uni is < 3), so
       // the application cannot run HTTP/3.
-      THROW_ERR_INVALID_STATE(
-          session->env(),
-          "The HTTP/3 application could not be started");
+      THROW_ERR_INVALID_STATE(session->env(),
+                              "The HTTP/3 application could not be started");
       return;
     }
   }
@@ -1888,8 +1881,7 @@ Http3Settings ResolveHttp3Settings(const Session::Options& options) {
 std::unique_ptr<Session::Application> CreateHttp3Application(Session* session) {
   Debug(session, "Installing HTTP/3 application");
   return std::make_unique<Http3Application>(
-      session,
-      ResolveHttp3Settings(std::as_const(*session).config().options));
+      session, ResolveHttp3Settings(std::as_const(*session).config().options));
 }
 
 Maybe<std::shared_ptr<void>> ParseHttp3Settings(Environment* env,
diff --git a/src/quic/session.cc b/src/quic/session.cc
@@ -612,8 +612,7 @@ Maybe<Session::Options> Session::Options::From(Environment* env,
 
   if (!SET(version) || !SET(min_version) || !SET(preferred_address_strategy) ||
       !SET(transport_params) || !SET(tls_options) || !SET(qlog) ||
-      !SET(application) ||
-      !SET(handshake_timeout) || !SET(initial_rtt) ||
+      !SET(application) || !SET(handshake_timeout) || !SET(initial_rtt) ||
       !SET(keep_alive_timeout) || !SET(max_stream_window) || !SET(max_window) ||
       !SET(max_payload_size) || !SET(unacknowledged_packet_threshold) ||
       !SET(cc_algorithm) || !SET(draining_period_multiplier) ||
@@ -1612,10 +1611,9 @@ struct Session::Impl final : public MemoryRetainer {
     NGTCP2_CALLBACK_SCOPE(session)
     auto* stream = Stream::From(stream_user_data);
     if (stream == nullptr) return NGTCP2_SUCCESS;
-    QuicError error =
-        (flags & NGTCP2_STREAM_CLOSE_FLAG_APP_ERROR_CODE_SET)
-            ? QuicError::ForApplication(app_error_code)
-            : QuicError();
+    QuicError error = (flags & NGTCP2_STREAM_CLOSE_FLAG_APP_ERROR_CODE_SET)
+                          ? QuicError::ForApplication(app_error_code)
+                          : QuicError();
     if (session->impl_->application_) {
       session->application().ReceiveStreamClose(stream, std::move(error));
     } else {
@@ -2842,8 +2840,7 @@ bool Session::can_send_pending_data() const {
   // before the application is installed: the application owns stream
   // scheduling from its first flight. With no application requested the
   // native path is always ready.
-  return impl_->application_ != nullptr ||
-         config().options.application.empty();
+  return impl_->application_ != nullptr || config().options.application.empty();
 }
 
 bool Session::stream_fin_managed_by_application() const {
@@ -2867,8 +2864,7 @@ std::unique_ptr<Session::Application> Session::SelectApplication() {
 bool Session::AttachApplication(std::unique_ptr<Application> app) {
   if (config().options.app_ticket_data.has_value()) {
     THROW_ERR_INVALID_STATE(
-        env(),
-        "A QUIC application cannot be combined with appTicketData");
+        env(), "A QUIC application cannot be combined with appTicketData");
     return false;
   }
   SetApplication(std::move(app));
@@ -4348,9 +4344,8 @@ void Session::EmitDatagram(Store&& datagram, DatagramReceivedFlags flag) {
 
   if (must_defer_emits()) {
     auto held = std::make_shared<Store>(std::move(datagram));
-    impl_->deferred_emits_.emplace_back([this, held, flag]() {
-      EmitDatagram(std::move(*held), flag);
-    });
+    impl_->deferred_emits_.emplace_back(
+        [this, held, flag]() { EmitDatagram(std::move(*held), flag); });
     return;
   }
 
@@ -4526,7 +4521,6 @@ void Session::EmitSessionTicket(Store&& ticket) {
   }
 }
 
-
 void Session::DestroyAllStreams(const QuicError& error) {
   DCHECK(!is_destroyed());
   // Copy the streams map since streams remove themselves during
