src: remove redundant qualifiers in src/quic

PR-URL: #56967
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: anonrig

src/quic/application.cc

@@ -155,7 +155,7 @@ bool Session::Application::CanAddHeader(size_t current_count,
 
 bool Session::Application::SendHeaders(const Stream& stream,
                                        HeadersKind kind,
-                                       const v8::Local<v8::Array>& headers,
+                                       const Local<v8::Array>& headers,
                                        HeadersFlags flags) {
   // By default do nothing.
   return false;
@@ -184,10 +184,9 @@ void Session::Application::CollectSessionTicketAppData(
 
 SessionTicket::AppData::Status
 Session::Application::ExtractSessionTicketAppData(
-    const SessionTicket::AppData& app_data,
-    SessionTicket::AppData::Source::Flag flag) {
+    const SessionTicket::AppData& app_data, Flag flag) {
   // By default we do not have any application data to retrieve.
-  return flag == SessionTicket::AppData::Source::Flag::STATUS_RENEW
+  return flag == Flag::STATUS_RENEW
              ? SessionTicket::AppData::Status::TICKET_USE_RENEW
              : SessionTicket::AppData::Status::TICKET_USE;
 }
@@ -285,15 +284,15 @@ void Session::Application::SendPendingData() {
       Debug(session_, "Failed to create packet for stream data");
       // Doh! Could not create a packet. Time to bail.
       session_->SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL));
-      return session_->Close(Session::CloseMethod::SILENT);
+      return session_->Close(CloseMethod::SILENT);
     }
 
     // The stream_data is the next block of data from the application stream.
     if (GetStreamData(&stream_data) < 0) {
       Debug(session_, "Application failed to get stream data");
       packet->Done(UV_ECANCELED);
       session_->SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL));
-      return session_->Close(Session::CloseMethod::SILENT);
+      return session_->Close(CloseMethod::SILENT);
     }
 
     // If we got here, we were at least successful in checking for stream data.
@@ -374,7 +373,7 @@ void Session::Application::SendPendingData() {
             ngtcp2_strerror(nwrite));
       packet->Done(UV_ECANCELED);
       session_->SetLastError(QuicError::ForNgtcp2Error(nwrite));
-      return session_->Close(Session::CloseMethod::SILENT);
+      return session_->Close(CloseMethod::SILENT);
     } else if (ndatalen >= 0 && !StreamCommit(&stream_data, ndatalen)) {
       packet->Done(UV_ECANCELED);
       session_->SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL));
@@ -601,13 +600,13 @@ class DefaultApplication final : public Session::Application {
 };
 
 std::unique_ptr<Session::Application> Session::SelectApplication(
-    Session* session, const Session::Config& config) {
+    Session* session, const Config& config) {
   if (config.options.application_provider) {
     return config.options.application_provider->Create(session);
   }
 
-  return std::make_unique<DefaultApplication>(
-      session, Session::Application_Options::kDefault);
+  return std::make_unique<DefaultApplication>(session,
+                                              Application_Options::kDefault);
 }
 
 }  // namespace quic

src/quic/bindingdata.cc

@@ -143,7 +143,7 @@ QUIC_JS_CALLBACKS(V)
 void BindingData::SetCallbacks(const FunctionCallbackInfo<Value>& args) {
   auto env = Environment::GetCurrent(args);
   auto isolate = env->isolate();
-  auto& state = BindingData::Get(env);
+  auto& state = Get(env);
   CHECK(args[0]->IsObject());
   Local<Object> obj = args[0].As<Object>();
 
@@ -164,7 +164,7 @@ void BindingData::SetCallbacks(const FunctionCallbackInfo<Value>& args) {
 
 void BindingData::FlushPacketFreelist(const FunctionCallbackInfo<Value>& args) {
   auto env = Environment::GetCurrent(args);
-  auto& state = BindingData::Get(env);
+  auto& state = Get(env);
   state.packet_freelist.clear();
 }
 

src/quic/data.cc

@@ -88,14 +88,14 @@ Store::Store(std::unique_ptr<v8::BackingStore> store,
   CHECK_LE(length_, store_->ByteLength() - offset_);
 }
 
-Store::Store(v8::Local<v8::ArrayBuffer> buffer, Option option)
+Store::Store(Local<v8::ArrayBuffer> buffer, Option option)
     : Store(buffer->GetBackingStore(), buffer->ByteLength()) {
   if (option == Option::DETACH) {
     USE(buffer->Detach(Local<Value>()));
   }
 }
 
-Store::Store(v8::Local<v8::ArrayBufferView> view, Option option)
+Store::Store(Local<v8::ArrayBufferView> view, Option option)
     : Store(view->Buffer()->GetBackingStore(),
             view->ByteLength(),
             view->ByteOffset()) {
@@ -104,7 +104,7 @@ Store::Store(v8::Local<v8::ArrayBufferView> view, Option option)
   }
 }
 
-v8::Local<v8::Uint8Array> Store::ToUint8Array(Environment* env) const {
+Local<Uint8Array> Store::ToUint8Array(Environment* env) const {
   return !store_
              ? Uint8Array::New(v8::ArrayBuffer::New(env->isolate(), 0), 0, 0)
              : Uint8Array::New(v8::ArrayBuffer::New(env->isolate(), store_),
@@ -257,11 +257,9 @@ std::optional<int> QuicError::crypto_error() const {
 }
 
 MaybeLocal<Value> QuicError::ToV8Value(Environment* env) const {
-  if ((type() == QuicError::Type::TRANSPORT && code() == NGTCP2_NO_ERROR) ||
-      (type() == QuicError::Type::APPLICATION &&
-       code() == NGTCP2_APP_NOERROR) ||
-      (type() == QuicError::Type::APPLICATION &&
-       code() == NGHTTP3_H3_NO_ERROR)) {
+  if ((type() == Type::TRANSPORT && code() == NGTCP2_NO_ERROR) ||
+      (type() == Type::APPLICATION && code() == NGTCP2_APP_NOERROR) ||
+      (type() == Type::APPLICATION && code() == NGHTTP3_H3_NO_ERROR)) {
     return Undefined(env->isolate());
   }
 
@@ -331,14 +329,11 @@ QuicError QuicError::FromConnectionClose(ngtcp2_conn* session) {
   return QuicError(ngtcp2_conn_get_ccerr(session));
 }
 
-QuicError QuicError::TRANSPORT_NO_ERROR =
-    QuicError::ForTransport(QuicError::QUIC_NO_ERROR);
-QuicError QuicError::APPLICATION_NO_ERROR =
-    QuicError::ForApplication(QuicError::QUIC_APP_NO_ERROR);
-QuicError QuicError::VERSION_NEGOTIATION = QuicError::ForVersionNegotiation();
-QuicError QuicError::IDLE_CLOSE = QuicError::ForIdleClose();
-QuicError QuicError::INTERNAL_ERROR =
-    QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL);
+QuicError QuicError::TRANSPORT_NO_ERROR = ForTransport(QUIC_NO_ERROR);
+QuicError QuicError::APPLICATION_NO_ERROR = ForApplication(QUIC_APP_NO_ERROR);
+QuicError QuicError::VERSION_NEGOTIATION = ForVersionNegotiation();
+QuicError QuicError::IDLE_CLOSE = ForIdleClose();
+QuicError QuicError::INTERNAL_ERROR = ForNgtcp2Error(NGTCP2_ERR_INTERNAL);
 
 }  // namespace quic
 }  // namespace node

src/quic/endpoint.cc

@@ -177,7 +177,7 @@ bool SetOption(Environment* env,
 Maybe<Endpoint::Options> Endpoint::Options::From(Environment* env,
                                                  Local<Value> value) {
   if (value.IsEmpty() || !value->IsObject()) {
-    if (value->IsUndefined()) return Just(Endpoint::Options());
+    if (value->IsUndefined()) return Just(Options());
     THROW_ERR_INVALID_ARG_TYPE(env, "options must be an object");
     return Nothing<Options>();
   }
@@ -213,7 +213,7 @@ Maybe<Endpoint::Options> Endpoint::Options::From(Environment* env,
                                  "The address option must be a SocketAddress");
       return Nothing<Options>();
     }
-    auto addr = FromJSObject<SocketAddressBase>(address.As<v8::Object>());
+    auto addr = FromJSObject<SocketAddressBase>(address.As<Object>());
     options.local_address = addr->address();
   } else {
     options.local_address = std::make_shared<SocketAddress>();
@@ -286,8 +286,7 @@ class Endpoint::UDP::Impl final : public HandleWrap {
     if (tmpl.IsEmpty()) {
       tmpl = NewFunctionTemplate(env->isolate(), IllegalConstructor);
       tmpl->Inherit(HandleWrap::GetConstructorTemplate(env));
-      tmpl->InstanceTemplate()->SetInternalFieldCount(
-          HandleWrap::kInternalFieldCount);
+      tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);
       tmpl->SetClassName(state.endpoint_udp_string());
       state.set_udp_constructor_template(tmpl);
     }
@@ -317,7 +316,7 @@ class Endpoint::UDP::Impl final : public HandleWrap {
       : HandleWrap(endpoint->env(),
                    object,
                    reinterpret_cast<uv_handle_t*>(&handle_),
-                   AsyncWrap::PROVIDER_QUIC_UDP),
+                   PROVIDER_QUIC_UDP),
         endpoint_(endpoint) {
     CHECK_EQ(uv_udp_init(endpoint->env()->event_loop(), &handle_), 0);
     handle_.data = this;
@@ -376,7 +375,7 @@ Endpoint::UDP::~UDP() {
   Close();
 }
 
-int Endpoint::UDP::Bind(const Endpoint::Options& options) {
+int Endpoint::UDP::Bind(const Options& options) {
   if (is_bound_) return UV_EALREADY;
   if (is_closed_or_closing()) return UV_EBADF;
 
@@ -521,8 +520,7 @@ Local<FunctionTemplate> Endpoint::GetConstructorTemplate(Environment* env) {
     tmpl = NewFunctionTemplate(isolate, New);
     tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
     tmpl->SetClassName(state.endpoint_string());
-    tmpl->InstanceTemplate()->SetInternalFieldCount(
-        Endpoint::kInternalFieldCount);
+    tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);
     SetProtoMethod(isolate, tmpl, "listen", DoListen);
     SetProtoMethod(isolate, tmpl, "closeGracefully", DoCloseGracefully);
     SetProtoMethod(isolate, tmpl, "connect", DoConnect);
@@ -612,8 +610,8 @@ void Endpoint::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
 
 Endpoint::Endpoint(Environment* env,
                    Local<Object> object,
-                   const Endpoint::Options& options)
-    : AsyncWrap(env, object, AsyncWrap::PROVIDER_QUIC_ENDPOINT),
+                   const Options& options)
+    : AsyncWrap(env, object, PROVIDER_QUIC_ENDPOINT),
       stats_(env->isolate()),
       state_(env->isolate()),
       options_(options),

src/quic/http3.cc

@@ -42,8 +42,7 @@ Local<FunctionTemplate> Http3Application::GetConstructorTemplate(
     auto isolate = env->isolate();
     tmpl = NewFunctionTemplate(isolate, New);
     tmpl->SetClassName(state.http3application_string());
-    tmpl->InstanceTemplate()->SetInternalFieldCount(
-        Http3Application::kInternalFieldCount);
+    tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);
     state.set_http3application_constructor_template(tmpl);
   }
   return tmpl;
@@ -169,8 +168,7 @@ using Http3Header = NgHeader<Http3HeaderTraits>;
 // Implements the low-level HTTP/3 Application semantics.
 class Http3ApplicationImpl final : public Session::Application {
  public:
-  Http3ApplicationImpl(Session* session,
-                       const Session::Application::Options& options)
+  Http3ApplicationImpl(Session* session, const Options& options)
       : Application(session, options),
         allocator_(BindingData::Get(env())),
         options_(options),
@@ -403,7 +401,7 @@ class Http3ApplicationImpl final : public Session::Application {
 
   bool SendHeaders(const Stream& stream,
                    HeadersKind kind,
-                   const v8::Local<v8::Array>& headers,
+                   const Local<v8::Array>& headers,
                    HeadersFlags flags = HeadersFlags::NONE) override {
     Session::SendPendingDataScope send_scope(&session());
     Http3Headers nva(env(), headers);
@@ -728,7 +726,7 @@ class Http3ApplicationImpl final : public Session::Application {
 
   bool started_ = false;
   nghttp3_mem allocator_;
-  Session::Application::Options options_;
+  Options options_;
   Http3ConnectionPointer conn_;
   int64_t control_stream_id_ = -1;
   int64_t qpack_dec_stream_id_ = -1;

src/quic/logstream.cc

@@ -35,7 +35,7 @@ Local<FunctionTemplate> LogStream::GetConstructorTemplate(Environment* env) {
 }
 
 BaseObjectPtr<LogStream> LogStream::Create(Environment* env) {
-  v8::Local<v8::Object> obj;
+  Local<Object> obj;
   if (!GetConstructorTemplate(env)
            ->InstanceTemplate()
            ->NewInstance(env->context())
@@ -46,9 +46,9 @@ BaseObjectPtr<LogStream> LogStream::Create(Environment* env) {
 }
 
 LogStream::LogStream(Environment* env, Local<Object> obj)
-    : AsyncWrap(env, obj, AsyncWrap::PROVIDER_QUIC_LOGSTREAM), StreamBase(env) {
+    : AsyncWrap(env, obj, PROVIDER_QUIC_LOGSTREAM), StreamBase(env) {
   MakeWeak();
-  StreamBase::AttachToObject(GetObject());
+  AttachToObject(GetObject());
 }
 
 void LogStream::Emit(const uint8_t* data, size_t len, EmitOption option) {

src/quic/packet.cc

@@ -102,8 +102,7 @@ Local<FunctionTemplate> Packet::GetConstructorTemplate(Environment* env) {
   if (tmpl.IsEmpty()) {
     tmpl = NewFunctionTemplate(env->isolate(), IllegalConstructor);
     tmpl->Inherit(ReqWrap<uv_udp_send_t>::GetConstructorTemplate(env));
-    tmpl->InstanceTemplate()->SetInternalFieldCount(
-        Packet::kInternalFieldCount);
+    tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);
     tmpl->SetClassName(state.packetwrap_string());
     state.set_packet_constructor_template(tmpl);
   }
@@ -174,7 +173,7 @@ Packet::Packet(Environment* env,
                Local<Object> object,
                const SocketAddress& destination,
                std::shared_ptr<Data> data)
-    : ReqWrap<uv_udp_send_t>(env, object, AsyncWrap::PROVIDER_QUIC_PACKET),
+    : ReqWrap<uv_udp_send_t>(env, object, PROVIDER_QUIC_PACKET),
       listener_(listener),
       destination_(destination),
       data_(std::move(data)) {

src/quic/preferredaddress.cc

@@ -55,14 +55,14 @@ void copy_to_transport_params(ngtcp2_transport_params* params,
                               const sockaddr* addr) {
   params->preferred_addr_present = true;
   if constexpr (FAMILY == AF_INET) {
-    const sockaddr_in* src = reinterpret_cast<const sockaddr_in*>(addr);
+    const auto* src = reinterpret_cast<const sockaddr_in*>(addr);
     params->preferred_addr.ipv4.sin_port = SocketAddress::GetPort(addr);
     memcpy(&params->preferred_addr.ipv4.sin_addr,
            &src->sin_addr,
            sizeof(params->preferred_addr.ipv4.sin_addr));
   } else {
     DCHECK_EQ(FAMILY, AF_INET6);
-    const sockaddr_in6* src = reinterpret_cast<const sockaddr_in6*>(addr);
+    const auto* src = reinterpret_cast<const sockaddr_in6*>(addr);
     params->preferred_addr.ipv6.sin6_port = SocketAddress::GetPort(addr);
     memcpy(&params->preferred_addr.ipv6.sin6_addr,
            &src->sin6_addr,
@@ -136,29 +136,32 @@ void PreferredAddress::Set(ngtcp2_transport_params* params,
       return copy_to_transport_params<AF_INET>(params, addr);
     case AF_INET6:
       return copy_to_transport_params<AF_INET6>(params, addr);
+    default:
+      UNREACHABLE("Unreachable");
   }
   // Any other value is just ignored.
 }
 
 Maybe<PreferredAddress::Policy> PreferredAddress::tryGetPolicy(
     Environment* env, Local<Value> value) {
   if (value->IsUndefined()) {
-    return Just(PreferredAddress::Policy::USE_PREFERRED);
+    return Just(Policy::USE_PREFERRED);
   }
   if (value->IsUint32()) {
     switch (value.As<Uint32>()->Value()) {
       case PREFERRED_ADDRESS_IGNORE:
         return Just(Policy::IGNORE_PREFERRED);
       case PREFERRED_ADDRESS_USE:
         return Just(Policy::USE_PREFERRED);
+      default:
+        UNREACHABLE("Unreachable");
     }
   }
   THROW_ERR_INVALID_ARG_VALUE(env, "invalid preferred address policy");
-  return Nothing<PreferredAddress::Policy>();
+  return Nothing<Policy>();
 }
 
-void PreferredAddress::Initialize(Environment* env,
-                                  v8::Local<v8::Object> target) {
+void PreferredAddress::Initialize(Environment* env, Local<v8::Object> target) {
   NODE_DEFINE_CONSTANT(target, PREFERRED_ADDRESS_IGNORE);
   NODE_DEFINE_CONSTANT(target, PREFERRED_ADDRESS_USE);
   NODE_DEFINE_CONSTANT(target, DEFAULT_PREFERRED_ADDRESS_POLICY);

src/quic/session.cc

@@ -729,7 +729,7 @@ struct Session::Impl final : public MemoryRetainer {
       THROW_ERR_INVALID_STATE(env, "Session is destroyed");
     }
 
-    session->Close(Session::CloseMethod::GRACEFUL);
+    session->Close(CloseMethod::GRACEFUL);
   }
 
   static void SilentClose(const FunctionCallbackInfo<Value>& args) {
@@ -742,7 +742,7 @@ struct Session::Impl final : public MemoryRetainer {
       THROW_ERR_INVALID_STATE(env, "Session is destroyed");
     }
 
-    session->Close(Session::CloseMethod::SILENT);
+    session->Close(CloseMethod::SILENT);
   }
 
   static void UpdateKey(const FunctionCallbackInfo<Value>& args) {
@@ -831,7 +831,7 @@ struct Session::Impl final : public MemoryRetainer {
                                      uint64_t dgram_id,
                                      void* user_data) {
     NGTCP2_CALLBACK_SCOPE(session)
-    session->DatagramStatus(dgram_id, quic::DatagramStatus::ACKNOWLEDGED);
+    session->DatagramStatus(dgram_id, DatagramStatus::ACKNOWLEDGED);
     return NGTCP2_SUCCESS;
   }
 
@@ -934,7 +934,7 @@ struct Session::Impl final : public MemoryRetainer {
                               uint64_t dgram_id,
                               void* user_data) {
     NGTCP2_CALLBACK_SCOPE(session)
-    session->DatagramStatus(dgram_id, quic::DatagramStatus::LOST);
+    session->DatagramStatus(dgram_id, DatagramStatus::LOST);
     return NGTCP2_SUCCESS;
   }
 
@@ -1285,7 +1285,7 @@ Session::Session(Endpoint* endpoint,
                  const Config& config,
                  TLSContext* tls_context,
                  const std::optional<SessionTicket>& session_ticket)
-    : AsyncWrap(endpoint->env(), object, AsyncWrap::PROVIDER_QUIC_SESSION),
+    : AsyncWrap(endpoint->env(), object, PROVIDER_QUIC_SESSION),
       side_(config.side),
       allocator_(BindingData::Get(env())),
       impl_(std::make_unique<Impl>(this, endpoint, config)),
@@ -1386,7 +1386,7 @@ bool Session::is_destroyed_or_closing() const {
   return !impl_ || impl_->state_->closing;
 }
 
-void Session::Close(Session::CloseMethod method) {
+void Session::Close(CloseMethod method) {
   if (is_destroyed()) return;
   auto& stats_ = impl_->stats_;
 
@@ -2098,8 +2098,7 @@ void Session::CollectSessionTicketAppData(
 }
 
 SessionTicket::AppData::Status Session::ExtractSessionTicketAppData(
-    const SessionTicket::AppData& app_data,
-    SessionTicket::AppData::Source::Flag flag) {
+    const SessionTicket::AppData& app_data, Flag flag) {
   CHECK(!is_destroyed());
   return application().ExtractSessionTicketAppData(app_data, flag);
 }
@@ -2307,12 +2306,12 @@ void Session::DatagramStatus(uint64_t datagramId, quic::DatagramStatus status) {
   DCHECK(!is_destroyed());
   auto& stats_ = impl_->stats_;
   switch (status) {
-    case quic::DatagramStatus::ACKNOWLEDGED: {
+    case DatagramStatus::ACKNOWLEDGED: {
       Debug(this, "Datagram %" PRIu64 " was acknowledged", datagramId);
       STAT_INCREMENT(Stats, datagrams_acknowledged);
       break;
     }
-    case quic::DatagramStatus::LOST: {
+    case DatagramStatus::LOST: {
       Debug(this, "Datagram %" PRIu64 " was lost", datagramId);
       STAT_INCREMENT(Stats, datagrams_lost);
       break;
@@ -2559,9 +2558,9 @@ void Session::EmitDatagramStatus(uint64_t id, quic::DatagramStatus status) {
 
   const auto status_to_string = ([&] {
     switch (status) {
-      case quic::DatagramStatus::ACKNOWLEDGED:
+      case DatagramStatus::ACKNOWLEDGED:
         return state.acknowledged_string();
-      case quic::DatagramStatus::LOST:
+      case DatagramStatus::LOST:
         return state.lost_string();
     }
     UNREACHABLE();
@@ -2769,8 +2768,7 @@ Local<FunctionTemplate> Session::GetConstructorTemplate(Environment* env) {
     tmpl = NewFunctionTemplate(isolate, IllegalConstructor);
     tmpl->SetClassName(state.session_string());
     tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
-    tmpl->InstanceTemplate()->SetInternalFieldCount(
-        Session::kInternalFieldCount);
+    tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);
 #define V(name, key, no_side_effect)                                           \
   if (no_side_effect) {                                                        \
     SetProtoMethodNoSideEffect(isolate, tmpl, #key, Impl::name);               \

src/quic/sessionticket.cc

@@ -38,7 +38,7 @@ SessionTicket::SessionTicket(Store&& ticket, Store&& transport_params)
       transport_params_(std::move(transport_params)) {}
 
 Maybe<SessionTicket> SessionTicket::FromV8Value(Environment* env,
-                                                v8::Local<v8::Value> value) {
+                                                Local<Value> value) {
   if (!value->IsArrayBufferView()) {
     THROW_ERR_INVALID_ARG_TYPE(env, "The ticket must be an ArrayBufferView.");
     return Nothing<SessionTicket>();
@@ -110,7 +110,7 @@ void SessionTicket::MemoryInfo(MemoryTracker* tracker) const {
 }
 
 int SessionTicket::GenerateCallback(SSL* ssl, void* arg) {
-  SessionTicket::AppData::Collect(ssl);
+  AppData::Collect(ssl);
   return 1;
 }
 
@@ -130,8 +130,7 @@ SSL_TICKET_RETURN SessionTicket::DecryptedCallback(SSL* ssl,
     case SSL_TICKET_SUCCESS_RENEW:
       [[fallthrough]];
     case SSL_TICKET_SUCCESS:
-      return static_cast<SSL_TICKET_RETURN>(
-          SessionTicket::AppData::Extract(ssl));
+      return static_cast<SSL_TICKET_RETURN>(AppData::Extract(ssl));
   }
 }
 
@@ -155,7 +154,7 @@ std::optional<const uv_buf_t> SessionTicket::AppData::Get() const {
 }
 
 void SessionTicket::AppData::Collect(SSL* ssl) {
-  SessionTicket::AppData app_data(ssl);
+  AppData app_data(ssl);
   if (auto source = GetAppDataSource(ssl)) {
     source->CollectSessionTicketAppData(&app_data);
   }
@@ -164,7 +163,7 @@ void SessionTicket::AppData::Collect(SSL* ssl) {
 SessionTicket::AppData::Status SessionTicket::AppData::Extract(SSL* ssl) {
   auto source = GetAppDataSource(ssl);
   if (source != nullptr) {
-    SessionTicket::AppData app_data(ssl);
+    AppData app_data(ssl);
     return source->ExtractSessionTicketAppData(app_data);
   }
   return Status::TICKET_IGNORE;

src/quic/streams.cc

@@ -123,11 +123,9 @@ void PendingStream::reject(QuicError error) {
 
 struct Stream::PendingHeaders {
   HeadersKind kind;
-  v8::Global<v8::Array> headers;
+  Global<Array> headers;
   HeadersFlags flags;
-  PendingHeaders(HeadersKind kind_,
-                 v8::Global<v8::Array> headers_,
-                 HeadersFlags flags_)
+  PendingHeaders(HeadersKind kind_, Global<Array> headers_, HeadersFlags flags_)
       : kind(kind_), headers(std::move(headers_)), flags(flags_) {}
   DISALLOW_COPY_AND_MOVE(PendingHeaders)
 };
@@ -299,7 +297,7 @@ struct Stream::Impl {
         static_cast<StreamPriorityFlags>(args[1].As<Uint32>()->Value());
 
     if (stream->is_pending()) {
-      stream->pending_priority_ = Stream::PendingPriority{
+      stream->pending_priority_ = PendingPriority{
           .priority = priority,
           .flags = flags,
       };
@@ -708,8 +706,7 @@ Local<FunctionTemplate> Stream::GetConstructorTemplate(Environment* env) {
     tmpl = NewFunctionTemplate(isolate, IllegalConstructor);
     tmpl->SetClassName(state.stream_string());
     tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
-    tmpl->InstanceTemplate()->SetInternalFieldCount(
-        Stream::kInternalFieldCount);
+    tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);
 #define V(name, key, no_side_effect)                                           \
   if (no_side_effect) {                                                        \
     SetProtoMethodNoSideEffect(isolate, tmpl, #key, Impl::name);               \
@@ -813,10 +810,10 @@ BaseObjectPtr<Stream> Stream::Create(Session* session,
 }
 
 Stream::Stream(BaseObjectWeakPtr<Session> session,
-               v8::Local<v8::Object> object,
+               Local<Object> object,
                int64_t id,
                std::shared_ptr<DataQueue> source)
-    : AsyncWrap(session->env(), object, AsyncWrap::PROVIDER_QUIC_STREAM),
+    : AsyncWrap(session->env(), object, PROVIDER_QUIC_STREAM),
       stats_(env()->isolate()),
       state_(env()->isolate()),
       session_(std::move(session)),
@@ -846,10 +843,10 @@ Stream::Stream(BaseObjectWeakPtr<Session> session,
 }
 
 Stream::Stream(BaseObjectWeakPtr<Session> session,
-               v8::Local<v8::Object> object,
+               Local<Object> object,
                Direction direction,
                std::shared_ptr<DataQueue> source)
-    : AsyncWrap(session->env(), object, AsyncWrap::PROVIDER_QUIC_STREAM),
+    : AsyncWrap(session->env(), object, PROVIDER_QUIC_STREAM),
       stats_(env()->isolate()),
       state_(env()->isolate()),
       session_(std::move(session)),
@@ -1297,7 +1294,7 @@ void Stream::EmitWantTrailers() {
 
 // ============================================================================
 
-void Stream::Schedule(Stream::Queue* queue) {
+void Stream::Schedule(Queue* queue) {
   // If this stream is not already in the queue to send data, add it.
   Debug(this, "Scheduled");
   if (outbound_ && stream_queue_.IsEmpty()) queue->PushBack(this);

src/quic/tlscontext.cc

@@ -82,9 +82,9 @@ void EnableTrace(Environment* env, BIOPointer* bio, SSL* ssl) {
 template <typename T, typename Opt, std::vector<T> Opt::*member>
 bool SetOption(Environment* env,
                Opt* options,
-               const v8::Local<v8::Object>& object,
-               const v8::Local<v8::String>& name) {
-  v8::Local<v8::Value> value;
+               const Local<Object>& object,
+               const Local<v8::String>& name) {
+  Local<Value> value;
   if (!object->Get(env->context(), name).ToLocal(&value)) return false;
 
   if (value->IsUndefined()) return true;
@@ -96,7 +96,7 @@ bool SetOption(Environment* env,
     auto values = value.As<v8::Array>();
     uint32_t count = values->Length();
     for (uint32_t n = 0; n < count; n++) {
-      v8::Local<v8::Value> item;
+      Local<Value> item;
       if (!values->Get(context, n).ToLocal(&item)) {
         return false;
       }
@@ -115,7 +115,7 @@ bool SetOption(Environment* env,
         if (item->IsArrayBufferView()) {
           (options->*member).emplace_back(item.As<v8::ArrayBufferView>());
         } else if (item->IsArrayBuffer()) {
-          (options->*member).emplace_back(item.As<v8::ArrayBuffer>());
+          (options->*member).emplace_back(item.As<ArrayBuffer>());
         } else {
           Utf8Value namestr(env->isolate(), name);
           THROW_ERR_INVALID_ARG_TYPE(
@@ -140,7 +140,7 @@ bool SetOption(Environment* env,
       if (value->IsArrayBufferView()) {
         (options->*member).emplace_back(value.As<v8::ArrayBufferView>());
       } else if (value->IsArrayBuffer()) {
-        (options->*member).emplace_back(value.As<v8::ArrayBuffer>());
+        (options->*member).emplace_back(value.As<ArrayBuffer>());
       } else {
         Utf8Value namestr(env->isolate(), name);
         THROW_ERR_INVALID_ARG_TYPE(
@@ -424,7 +424,7 @@ Maybe<TLSContext::Options> TLSContext::Options::From(Environment* env,
   auto& state = BindingData::Get(env);
 
   if (value->IsUndefined()) {
-    return Just(TLSContext::Options::kDefault);
+    return Just(kDefault);
   }
 
   if (!value->IsObject()) {

src/quic/transportparams.cc

@@ -279,8 +279,7 @@ const QuicError& TransportParams::error() const {
   return error_;
 }
 
-void TransportParams::Initialize(Environment* env,
-                                 v8::Local<v8::Object> target) {
+void TransportParams::Initialize(Environment* env, Local<Object> target) {
   NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_STREAM_DATA);
   NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_DATA);
   NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_IDLE_TIMEOUT);