quic: fixup changes that were problematic on windows

Author: jasnell

src/quic/data.cc

@@ -177,8 +177,8 @@ QuicError::QuicError(const ngtcp2_ccerr& error)
       ptr_(&error_) {}
 
 QuicError::operator bool() const {
-  if ((code() == NO_ERROR && type() == Type::TRANSPORT) ||
-      ((code() == APP_NO_ERROR && type() == Type::APPLICATION))) {
+  if ((code() == QUIC_NO_ERROR && type() == Type::TRANSPORT) ||
+      ((code() == QUIC_APP_NO_ERROR && type() == Type::APPLICATION))) {
     return false;
   }
   return true;
@@ -323,9 +323,9 @@ QuicError QuicError::FromConnectionClose(ngtcp2_conn* session) {
 }
 
 QuicError QuicError::TRANSPORT_NO_ERROR =
-    QuicError::ForTransport(QuicError::NO_ERROR);
+    QuicError::ForTransport(QuicError::QUIC_NO_ERROR);
 QuicError QuicError::APPLICATION_NO_ERROR =
-    QuicError::ForApplication(QuicError::APP_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 =

src/quic/data.h

@@ -74,8 +74,8 @@ class Store final : public MemoryRetainer {
 
 class QuicError final : public MemoryRetainer {
  public:
-  static constexpr error_code NO_ERROR = NGTCP2_NO_ERROR;
-  static constexpr error_code APP_NO_ERROR = 65280;
+  static constexpr error_code QUIC_NO_ERROR = NGTCP2_NO_ERROR;
+  static constexpr error_code QUIC_APP_NO_ERROR = 65280;
 
   enum class Type {
     TRANSPORT = NGTCP2_CCERR_TYPE_TRANSPORT,

src/quic/preferredaddress.cc

@@ -143,14 +143,14 @@ void PreferredAddress::Set(ngtcp2_transport_params* params,
 Maybe<PreferredAddress::Policy> PreferredAddress::tryGetPolicy(
     Environment* env, Local<Value> value) {
   if (value->IsUndefined()) {
-    return Just(PreferredAddress::Policy::USE);
+    return Just(PreferredAddress::Policy::USE_PREFERRED);
   }
   if (value->IsUint32()) {
     switch (value.As<Uint32>()->Value()) {
       case PREFERRED_ADDRESS_IGNORE:
-        return Just(Policy::IGNORE);
+        return Just(Policy::IGNORE_PREFERRED);
       case PREFERRED_ADDRESS_USE:
-        return Just(Policy::USE);
+        return Just(Policy::USE_PREFERRED);
     }
   }
   THROW_ERR_INVALID_ARG_VALUE(env, "invalid preferred address policy");

src/quic/preferredaddress.h

@@ -21,9 +21,9 @@ class PreferredAddress final {
  public:
   enum class Policy : uint32_t {
     // Ignore the server-advertised preferred address.
-    IGNORE,
+    IGNORE_PREFERRED,
     // Use the server-advertised preferred address.
-    USE,
+    USE_PREFERRED,
   };
 
   static v8::Maybe<Policy> tryGetPolicy(Environment* env,
@@ -32,11 +32,11 @@ class PreferredAddress final {
   // The QUIC_* constants are expected to be exported out to be used on
   // the JavaScript side of the API.
   static constexpr auto PREFERRED_ADDRESS_USE =
-      static_cast<uint32_t>(Policy::USE);
+      static_cast<uint32_t>(Policy::USE_PREFERRED);
   static constexpr auto PREFERRED_ADDRESS_IGNORE =
-      static_cast<uint32_t>(Policy::IGNORE);
+      static_cast<uint32_t>(Policy::IGNORE_PREFERRED);
   static constexpr auto DEFAULT_PREFERRED_ADDRESS_POLICY =
-      static_cast<uint32_t>(Policy::USE);
+      static_cast<uint32_t>(Policy::USE_PREFERRED);
 
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
 

src/quic/session.cc

@@ -226,7 +226,7 @@ bool SetOption(Environment* env,
                const v8::Local<Object>& object,
                const v8::Local<String>& name) {
   Local<Value> value;
-  PreferredAddress::Policy policy = PreferredAddress::Policy::USE;
+  PreferredAddress::Policy policy = PreferredAddress::Policy::USE_PREFERRED;
   if (!object->Get(env->context(), name).ToLocal(&value) ||
       !PreferredAddress::tryGetPolicy(env, value).To(&policy)) {
     return false;
@@ -449,9 +449,9 @@ std::string Session::Options::ToString() const {
 
   auto policy = ([&] {
     switch (preferred_address_strategy) {
-      case PreferredAddress::Policy::USE:
+      case PreferredAddress::Policy::USE_PREFERRED:
         return "use";
-      case PreferredAddress::Policy::IGNORE:
+      case PreferredAddress::Policy::IGNORE_PREFERRED:
         return "ignore";
     }
     return "<unknown>";
@@ -1463,7 +1463,7 @@ void Session::HandshakeConfirmed() {
 
 void Session::SelectPreferredAddress(PreferredAddress* preferredAddress) {
   if (config_.options.preferred_address_strategy ==
-      PreferredAddress::Policy::IGNORE) {
+      PreferredAddress::Policy::IGNORE_PREFERRED) {
     Debug(this, "Ignoring preferred address");
     return;
   }

src/quic/session.h

@@ -106,7 +106,7 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
     // By default a client session will use the preferred address advertised by
     // the the server. This option is only relevant for client sessions.
     PreferredAddress::Policy preferred_address_strategy =
-        PreferredAddress::Policy::USE;
+        PreferredAddress::Policy::USE_PREFERRED;
 
     TransportParams::Options transport_params =
         TransportParams::Options::kDefault;

test/cctest/test_quic_error.cc

@@ -9,22 +9,22 @@ using node::quic::QuicError;
 
 TEST(QuicError, NoError) {
   QuicError err;
-  CHECK_EQ(err.code(), QuicError::NO_ERROR);
+  CHECK_EQ(err.code(), QuicError::QUIC_NO_ERROR);
   CHECK_EQ(err.type(), QuicError::Type::TRANSPORT);
   CHECK_EQ(err.reason(), "");
   CHECK_EQ(err, QuicError::TRANSPORT_NO_ERROR);
   CHECK(!err);
 
   QuicError err2("a reason");
-  CHECK_EQ(err2.code(), QuicError::NO_ERROR);
+  CHECK_EQ(err2.code(), QuicError::QUIC_NO_ERROR);
   CHECK_EQ(err2.type(), QuicError::Type::TRANSPORT);
   CHECK_EQ(err2.reason(), "a reason");
 
   // Equality check ignores the reason
   CHECK_EQ(err2, QuicError::TRANSPORT_NO_ERROR);
 
-  auto err3 = QuicError::ForTransport(QuicError::NO_ERROR);
-  CHECK_EQ(err3.code(), QuicError::NO_ERROR);
+  auto err3 = QuicError::ForTransport(QuicError::QUIC_NO_ERROR);
+  CHECK_EQ(err3.code(), QuicError::QUIC_NO_ERROR);
   CHECK_EQ(err3.type(), QuicError::Type::TRANSPORT);
   CHECK_EQ(err3.reason(), "");
   CHECK_EQ(err3, QuicError::TRANSPORT_NO_ERROR);
@@ -68,13 +68,13 @@ TEST(QuicError, NoError) {
 }
 
 TEST(QuicError, ApplicationNoError) {
-  CHECK_EQ(QuicError::APPLICATION_NO_ERROR.code(), QuicError::APP_NO_ERROR);
+  CHECK_EQ(QuicError::APPLICATION_NO_ERROR.code(), QuicError::QUIC_APP_NO_ERROR);
   CHECK_EQ(QuicError::APPLICATION_NO_ERROR.type(),
            QuicError::Type::APPLICATION);
   CHECK_EQ(QuicError::APPLICATION_NO_ERROR.reason(), "");
 
-  auto err = QuicError::ForApplication(QuicError::APP_NO_ERROR, "a reason");
-  CHECK_EQ(err.code(), QuicError::APP_NO_ERROR);
+  auto err = QuicError::ForApplication(QuicError::QUIC_APP_NO_ERROR, "a reason");
+  CHECK_EQ(err.code(), QuicError::QUIC_APP_NO_ERROR);
   CHECK_EQ(err.type(), QuicError::Type::APPLICATION);
   CHECK_EQ(err.reason(), "a reason");
   CHECK_EQ(err.ToString(), "QuicError(APPLICATION) 65280: a reason");