quic: fixup linting issues

Author: jasnell

src/quic/application.cc

@@ -3,9 +3,9 @@
 #include "application.h"
 #include <async_wrap-inl.h>
 #include <debug_utils-inl.h>
+#include <ngtcp2/ngtcp2.h>
 #include <node_bob.h>
 #include <node_sockaddr-inl.h>
-#include <ngtcp2/ngtcp2.h>
 #include <uv.h>
 #include <v8.h>
 #include "defs.h"
@@ -246,8 +246,7 @@ void Session::Application::SendPendingData() {
 
   // The maximum number of packets to send in this call to SendPendingData.
   const size_t max_packet_count = std::min(
-      kMaxPackets,
-      ngtcp2_conn_get_send_quantum(*session_) / max_packet_size);
+      kMaxPackets, ngtcp2_conn_get_send_quantum(*session_) / max_packet_size);
 
   // The number of packets that have been sent in this call to SendPendingData.
   size_t packet_send_count = 0;
@@ -295,11 +294,12 @@ void Session::Application::SendPendingData() {
     Debug(session_, "Application using stream data: %s", stream_data);
 
     // Awesome, let's write our packet!
-    ssize_t nwrite = WriteVStream(&path, pos, &ndatalen, max_packet_size, stream_data);
+    ssize_t nwrite =
+        WriteVStream(&path, pos, &ndatalen, max_packet_size, stream_data);
     Debug(session_, "Application accepted %zu bytes into packet", ndatalen);
 
-    // A negative nwrite value indicates either an error or that there is more data
-    // to write into the packet.
+    // A negative nwrite value indicates either an error or that there is more
+    // data to write into the packet.
     if (nwrite < 0) {
       switch (nwrite) {
         case NGTCP2_ERR_STREAM_DATA_BLOCKED: {
@@ -317,7 +317,8 @@ void Session::Application::SendPendingData() {
           // Indicates that the writable side of the stream should be closed
           // locally or the stream is being reset. In either case, we can't send
           // any stream data!
-          Debug(session_, "Stream %" PRIi64 " should be closed for writing",
+          Debug(session_,
+                "Stream %" PRIi64 " should be closed for writing",
                 stream_data.id);
           // ndatalen = -1 means that no stream data was accepted into the
           // packet, which is what we want here.
@@ -341,7 +342,8 @@ void Session::Application::SendPendingData() {
 
       // Some other type of error happened.
       DCHECK_EQ(ndatalen, -1);
-      Debug(session_, "Application encountered error while writing packet: %s",
+      Debug(session_,
+            "Application encountered error while writing packet: %s",
             ngtcp2_strerror(nwrite));
       session_->SetLastError(QuicError::ForNgtcp2Error(nwrite));
       packet->Done(UV_ECANCELED);
@@ -363,14 +365,16 @@ void Session::Application::SendPendingData() {
       size_t datalen = pos - begin;
       if (datalen) {
         Debug(session_, "Packet has %zu bytes to send", datalen);
-        // At least some data had been written into the packet. We should send it.
+        // At least some data had been written into the packet. We should send
+        // it.
         packet->Truncate(datalen);
         session_->Send(packet, path);
       } else {
         packet->Done(UV_ECANCELED);
       }
 
-      // If there was stream data selected, we should reschedule it to try sending again.
+      // If there was stream data selected, we should reschedule it to try
+      // sending again.
       if (stream_data.id >= 0) ResumeStream(stream_data.id);
 
       return session_->UpdatePacketTxTime();
@@ -403,18 +407,17 @@ ssize_t Session::Application::WriteVStream(PathStorage* path,
   uint32_t flags = NGTCP2_WRITE_STREAM_FLAG_MORE;
   if (stream_data.fin) flags |= NGTCP2_WRITE_STREAM_FLAG_FIN;
   ngtcp2_pkt_info pi;
-  return ngtcp2_conn_writev_stream(
-      *session_,
-      &path->path,
-      &pi,
-      dest,
-      max_packet_size,
-      ndatalen,
-      flags,
-      stream_data.id,
-      stream_data.buf,
-      stream_data.count,
-      uv_hrtime());
+  return ngtcp2_conn_writev_stream(*session_,
+                                   &path->path,
+                                   &pi,
+                                   dest,
+                                   max_packet_size,
+                                   ndatalen,
+                                   flags,
+                                   stream_data.id,
+                                   stream_data.buf,
+                                   stream_data.count,
+                                   uv_hrtime());
 }
 
 // The DefaultApplication is the default implementation of Session::Application

src/quic/cid.cc

@@ -1,10 +1,10 @@
-#include "quic/defs.h"
 #if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
 #include "cid.h"
 #include <crypto/crypto_util.h>
 #include <memory_tracker-inl.h>
 #include <node_mutex.h>
 #include <string_bytes.h>
+#include "quic/defs.h"
 
 namespace node {
 namespace quic {

src/quic/data.cc

@@ -1,13 +1,12 @@
-#include "nghttp3/nghttp3.h"
 #if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC
 
-#include "data.h"
 #include <env-inl.h>
 #include <memory_tracker-inl.h>
 #include <ngtcp2/ngtcp2.h>
 #include <node_sockaddr-inl.h>
 #include <string_bytes.h>
 #include <v8.h>
+#include "data.h"
 #include "defs.h"
 #include "util.h"
 
@@ -48,7 +47,9 @@ std::string Path::ToString() const {
   return res;
 }
 
-PathStorage::PathStorage() { Reset(); }
+PathStorage::PathStorage() {
+  Reset();
+}
 PathStorage::operator ngtcp2_path() {
   return path;
 }
@@ -281,16 +282,14 @@ void QuicError::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("reason", reason_.length());
 }
 
-QuicError QuicError::ForTransport(error_code code,
-                                  std::string reason) {
+QuicError QuicError::ForTransport(error_code code, std::string reason) {
   QuicError error(std::move(reason));
   ngtcp2_ccerr_set_transport_error(
       &error.error_, code, error.reason_c_str(), reason.length());
   return error;
 }
 
-QuicError QuicError::ForApplication(error_code code,
-                                    std::string reason) {
+QuicError QuicError::ForApplication(error_code code, std::string reason) {
   QuicError error(std::move(reason));
   ngtcp2_ccerr_set_application_error(
       &error.error_, code, error.reason_c_str(), reason.length());

src/quic/data.h

@@ -120,10 +120,8 @@ class QuicError final : public MemoryRetainer {
   static error_code liberr_to_code(int liberr);
   static error_code h3_liberr_to_code(int liberr);
 
-  static QuicError ForTransport(error_code code,
-                                std::string reason = "");
-  static QuicError ForApplication(error_code code,
-                                  std::string reason = "");
+  static QuicError ForTransport(error_code code, std::string reason = "");
+  static QuicError ForApplication(error_code code, std::string reason = "");
   static QuicError ForVersionNegotiation(std::string reason = "");
   static QuicError ForIdleClose(std::string reason = "");
   static QuicError ForNgtcp2Error(int code, std::string reason = "");

src/quic/defs.h

@@ -2,9 +2,9 @@
 
 #include <aliased_struct.h>
 #include <env.h>
-#include <node_errors.h>
-#include <ngtcp2/ngtcp2.h>
 #include <nghttp3/nghttp3.h>
+#include <ngtcp2/ngtcp2.h>
+#include <node_errors.h>
 #include <uv.h>
 #include <v8.h>
 #include <limits>

src/quic/endpoint.cc

@@ -336,7 +336,9 @@ std::string Endpoint::Options::ToString() const {
 
   auto ccalg = ([&] {
     switch (cc_algorithm) {
-#define V(name, label) case NGTCP2_CC_ALGO_##name: return #label;
+#define V(name, label)                                                         \
+  case NGTCP2_CC_ALGO_##name:                                                  \
+    return #label;
       ENDPOINT_CC(V)
 #undef V
     }
@@ -615,7 +617,7 @@ void Endpoint::InitPerIsolate(IsolateData* data, Local<ObjectTemplate> target) {
 
 void Endpoint::InitPerContext(Realm* realm, Local<Object> target) {
 #define V(name, str)                                                           \
-  NODE_DEFINE_CONSTANT(target, CC_ALGO_##name);                           \
+  NODE_DEFINE_CONSTANT(target, CC_ALGO_##name);                                \
   NODE_DEFINE_STRING_CONSTANT(target, "CC_ALGO_" #name "_STR", #str);
   ENDPOINT_CC(V)
 #undef V

src/quic/endpoint.h

@@ -38,8 +38,7 @@ class Endpoint final : public AsyncWrap, public Packet::Listener {
   static constexpr uint64_t DEFAULT_MAX_STATELESS_RESETS = 10;
   static constexpr uint64_t DEFAULT_MAX_RETRY_LIMIT = 10;
 
-#define V(name, _)                                                             \
-  static constexpr auto CC_ALGO_##name = NGTCP2_CC_ALGO_##name;
+#define V(name, _) static constexpr auto CC_ALGO_##name = NGTCP2_CC_ALGO_##name;
   ENDPOINT_CC(V)
 #undef V
 

src/quic/http3.cc

@@ -367,7 +367,7 @@ class Http3Application final : public Session::Application {
         }
       }
     }
-    DCHECK_NOT_NULL(stream_data.buf);
+    DCHECK_NOT_NULL(data->buf);
     return 0;
   }
 

src/quic/packet.h

@@ -77,7 +77,7 @@ class Packet final : public ReqWrap<uv_udp_send_t> {
          const SocketAddress& destination,
          std::shared_ptr<Data> data);
 
-  DISALLOW_COPY_AND_MOVE(Packet);
+  DISALLOW_COPY_AND_MOVE(Packet)
 
   const SocketAddress& destination() const;
   size_t length() const;

src/quic/preferredaddress.cc

@@ -146,9 +146,11 @@ Maybe<PreferredAddress::Policy> PreferredAddress::tryGetPolicy(
     return Just(PreferredAddress::Policy::USE);
   }
   if (value->IsUint32()) {
-    switch(value.As<Uint32>()->Value()) {
-      case PREFERRED_ADDRESS_IGNORE: return Just(Policy::IGNORE);
-      case PREFERRED_ADDRESS_USE: return Just(Policy::USE);
+    switch (value.As<Uint32>()->Value()) {
+      case PREFERRED_ADDRESS_IGNORE:
+        return Just(Policy::IGNORE);
+      case PREFERRED_ADDRESS_USE:
+        return Just(Policy::USE);
     }
   }
   THROW_ERR_INVALID_ARG_VALUE(env, "invalid preferred address policy");