quic: cleanup preferred address code

Author: jasnell

src/quic/preferredaddress.cc

@@ -97,23 +97,6 @@ bool resolve(const PreferredAddress::AddressInfo& address,
 }
 }  // namespace
 
-Maybe<PreferredAddress::Policy> PreferredAddress::GetPolicy(
-    Environment* env, Local<Value> value) {
-  CHECK(value->IsUint32());
-  uint32_t val = 0;
-  if (value->Uint32Value(env->context()).To(&val)) {
-    switch (val) {
-      case QUIC_PREFERRED_ADDRESS_USE:
-        return Just(Policy::USE_PREFERRED_ADDRESS);
-      case QUIC_PREFERRED_ADDRESS_IGNORE:
-        return Just(Policy::IGNORE_PREFERRED_ADDRESS);
-    }
-  }
-  THROW_ERR_INVALID_ARG_VALUE(
-      env, "%d is not a valid preferred address policy", val);
-  return Nothing<Policy>();
-}
-
 PreferredAddress::PreferredAddress(ngtcp2_path* dest,
                                    const ngtcp2_preferred_addr* paddr)
     : dest_(dest), paddr_(paddr) {
@@ -160,23 +143,22 @@ 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_PREFERRED_ADDRESS);
+    return Just(PreferredAddress::Policy::USE);
   }
   if (value->IsUint32()) {
-    auto val = value.As<Uint32>()->Value();
-    if (val == static_cast<uint32_t>(Policy::IGNORE_PREFERRED_ADDRESS))
-      return Just(Policy::IGNORE_PREFERRED_ADDRESS);
-    if (val == static_cast<uint32_t>(Policy::USE_PREFERRED_ADDRESS))
-      return Just(Policy::USE_PREFERRED_ADDRESS);
+    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");
   return Nothing<PreferredAddress::Policy>();
 }
 
 void PreferredAddress::Initialize(Environment* env,
                                   v8::Local<v8::Object> target) {
-  NODE_DEFINE_CONSTANT(target, QUIC_PREFERRED_ADDRESS_IGNORE);
-  NODE_DEFINE_CONSTANT(target, QUIC_PREFERRED_ADDRESS_USE);
+  NODE_DEFINE_CONSTANT(target, PREFERRED_ADDRESS_IGNORE);
+  NODE_DEFINE_CONSTANT(target, PREFERRED_ADDRESS_USE);
   NODE_DEFINE_CONSTANT(target, DEFAULT_PREFERRED_ADDRESS_POLICY);
 }
 

src/quic/preferredaddress.h

@@ -8,6 +8,7 @@
 #include <node_internals.h>
 #include <v8.h>
 #include <string>
+#include "defs.h"
 
 namespace node {
 namespace quic {
@@ -18,30 +19,27 @@ namespace quic {
 // the preferred address to be selected.
 class PreferredAddress final {
  public:
-  enum class Policy {
+  enum class Policy : uint32_t {
     // Ignore the server-advertised preferred address.
-    IGNORE_PREFERRED_ADDRESS,
+    IGNORE,
     // Use the server-advertised preferred address.
-    USE_PREFERRED_ADDRESS,
+    USE,
   };
 
   static v8::Maybe<Policy> tryGetPolicy(Environment* env,
                                         v8::Local<v8::Value> value);
 
   // The QUIC_* constants are expected to be exported out to be used on
   // the JavaScript side of the API.
-  static constexpr uint32_t QUIC_PREFERRED_ADDRESS_USE =
-      static_cast<uint32_t>(Policy::USE_PREFERRED_ADDRESS);
-  static constexpr uint32_t QUIC_PREFERRED_ADDRESS_IGNORE =
-      static_cast<uint32_t>(Policy::IGNORE_PREFERRED_ADDRESS);
-  static constexpr uint32_t DEFAULT_PREFERRED_ADDRESS_POLICY =
-      static_cast<uint32_t>(Policy::USE_PREFERRED_ADDRESS);
+  static constexpr auto PREFERRED_ADDRESS_USE =
+      static_cast<uint32_t>(Policy::USE);
+  static constexpr auto PREFERRED_ADDRESS_IGNORE =
+      static_cast<uint32_t>(Policy::IGNORE);
+  static constexpr auto DEFAULT_PREFERRED_ADDRESS_POLICY =
+      static_cast<uint32_t>(Policy::USE);
 
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
 
-  static v8::Maybe<Policy> GetPolicy(Environment* env,
-                                     v8::Local<v8::Value> value);
-
   struct AddressInfo final {
     char host[NI_MAXHOST];
     int family;
@@ -51,10 +49,7 @@ class PreferredAddress final {
 
   explicit PreferredAddress(ngtcp2_path* dest,
                             const ngtcp2_preferred_addr* paddr);
-  PreferredAddress(const PreferredAddress&) = delete;
-  PreferredAddress(PreferredAddress&&) = delete;
-  PreferredAddress& operator=(const PreferredAddress&) = delete;
-  PreferredAddress& operator=(PreferredAddress&&) = delete;
+  DISALLOW_COPY_AND_MOVE(PreferredAddress)
 
   void Use(const AddressInfo& address);
 

src/quic/session.cc

@@ -231,7 +231,7 @@ bool SetOption(Environment* env,
                const v8::Local<String>& name) {
   Local<Value> value;
   PreferredAddress::Policy policy =
-      PreferredAddress::Policy::USE_PREFERRED_ADDRESS;
+      PreferredAddress::Policy::USE;
   if (!object->Get(env->context(), name).ToLocal(&value) ||
       !PreferredAddress::tryGetPolicy(env, value).To(&policy)) {
     return false;
@@ -454,9 +454,9 @@ std::string Session::Options::ToString() const {
 
   auto policy = ([&] {
     switch (preferred_address_strategy) {
-      case PreferredAddress::Policy::USE_PREFERRED_ADDRESS:
+      case PreferredAddress::Policy::USE:
         return "use";
-      case PreferredAddress::Policy::IGNORE_PREFERRED_ADDRESS:
+      case PreferredAddress::Policy::IGNORE:
         return "ignore";
     }
     return "<unknown>";
@@ -1467,7 +1467,7 @@ void Session::HandshakeConfirmed() {
 
 void Session::SelectPreferredAddress(PreferredAddress* preferredAddress) {
   if (config_.options.preferred_address_strategy ==
-      PreferredAddress::Policy::IGNORE_PREFERRED_ADDRESS) {
+      PreferredAddress::Policy::IGNORE) {
     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_PREFERRED_ADDRESS;
+        PreferredAddress::Policy::USE;
 
     TransportParams::Options transport_params =
         TransportParams::Options::kDefault;