chore: refactor CryptoKeyUsageBitmap into a class

Author: Jake Champion

c-dependencies/js-compute-runtime/builtins/crypto-key.cpp

@@ -3,6 +3,37 @@
 
 namespace builtins {
 
+CryptoKeyUsages::CryptoKeyUsages(uint8_t mask) { this->mask = mask; };
+CryptoKeyUsages::CryptoKeyUsages(bool encrypt, bool decrypt, bool sign, bool verify,
+                                 bool derive_key, bool derive_bits, bool wrap_key,
+                                 bool unwrap_key) {
+  this->mask = 0;
+  if (encrypt) {
+    this->mask |= encrypt_flag;
+  }
+  if (decrypt) {
+    this->mask |= decrypt_flag;
+  }
+  if (sign) {
+    this->mask |= sign_flag;
+  }
+  if (verify) {
+    this->mask |= verify_flag;
+  }
+  if (derive_key) {
+    this->mask |= derive_key_flag;
+  }
+  if (derive_bits) {
+    this->mask |= derive_bits_flag;
+  }
+  if (wrap_key) {
+    this->mask |= wrap_key_flag;
+  }
+  if (unwrap_key) {
+    this->mask |= unwrap_key_flag;
+  }
+};
+
 bool CryptoKey::algorithm_get(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(0);
 
@@ -114,7 +145,7 @@ bool CryptoKey::usages_get(JSContext *cx, unsigned argc, JS::Value *vp) {
   }
   // Else, grab the CryptoKeyUsageBitmap value from Slots::Usages and convert
   // it into a JS Array and store the result in Slots::UsagesArray.
-  auto usage = JS::GetReservedSlot(self, Slots::Usages).toInt32();
+  auto usage = CryptoKeyUsages(JS::GetReservedSlot(self, Slots::Usages).toInt32());
   // The result is ordered alphabetically.
   JS::RootedValueVector result(cx);
   JS::RootedString str(cx);
@@ -128,42 +159,42 @@ bool CryptoKey::usages_get(JSContext *cx, unsigned argc, JS::Value *vp) {
     }
     return true;
   };
-  if (usage & CryptoKeyUsageDecrypt) {
+  if (usage.canDecrypt()) {
     if (!append("decrypt")) {
       return false;
     }
   }
-  if (usage & CryptoKeyUsageDeriveBits) {
+  if (usage.canDeriveBits()) {
     if (!append("deriveBits")) {
       return false;
     }
   }
-  if (usage & CryptoKeyUsageDeriveKey) {
+  if (usage.canDeriveKey()) {
     if (!append("deriveKey")) {
       return false;
     }
   }
-  if (usage & CryptoKeyUsageEncrypt) {
+  if (usage.canEncrypt()) {
     if (!append("encrypt")) {
       return false;
     }
   }
-  if (usage & CryptoKeyUsageSign) {
+  if (usage.canSign()) {
     if (!append("sign")) {
       return false;
     }
   }
-  if (usage & CryptoKeyUsageUnwrapKey) {
+  if (usage.canUnwrapKey()) {
     if (!append("unwrapKey")) {
       return false;
     }
   }
-  if (usage & CryptoKeyUsageVerify) {
+  if (usage.canVerify()) {
     if (!append("verify")) {
       return false;
     }
   }
-  if (usage & CryptoKeyUsageWrapKey) {
+  if (usage.canWrapKey()) {
     if (!append("wrapKey")) {
       return false;
     }

c-dependencies/js-compute-runtime/builtins/crypto-key.h

@@ -9,18 +9,31 @@ namespace builtins {
 
 enum class CryptoKeyType : uint8_t { Public, Private, Secret };
 
-enum {
-  CryptoKeyUsageEncrypt = 1 << 0,
-  CryptoKeyUsageDecrypt = 1 << 1,
-  CryptoKeyUsageSign = 1 << 2,
-  CryptoKeyUsageVerify = 1 << 3,
-  CryptoKeyUsageDeriveKey = 1 << 4,
-  CryptoKeyUsageDeriveBits = 1 << 5,
-  CryptoKeyUsageWrapKey = 1 << 6,
-  CryptoKeyUsageUnwrapKey = 1 << 7
-};
+class CryptoKeyUsages {
+private:
+  uint8_t mask;
+  static constexpr const uint8_t encrypt_flag = 1 << 0;
+  static constexpr const uint8_t decrypt_flag = 1 << 1;
+  static constexpr const uint8_t sign_flag = 1 << 2;
+  static constexpr const uint8_t verify_flag = 1 << 3;
+  static constexpr const uint8_t derive_key_flag = 1 << 4;
+  static constexpr const uint8_t derive_bits_flag = 1 << 5;
+  static constexpr const uint8_t wrap_key_flag = 1 << 6;
+  static constexpr const uint8_t unwrap_key_flag = 1 << 7;
 
-typedef int CryptoKeyUsageBitmap;
+public:
+  CryptoKeyUsages(uint8_t mask);
+  CryptoKeyUsages(bool encrypt, bool decrypt, bool sign, bool verify, bool derive_key,
+                  bool derive_bits, bool wrap_key, bool unwrap_key);
+  bool canEncrypt() { return this->mask & encrypt_flag; };
+  bool canDecrypt() { return this->mask & decrypt_flag; };
+  bool canSign() { return this->mask & sign_flag; };
+  bool canVerify() { return this->mask & verify_flag; };
+  bool canDeriveKey() { return this->mask & derive_key_flag; };
+  bool canDeriveBits() { return this->mask & derive_bits_flag; };
+  bool canWrapKey() { return this->mask & wrap_key_flag; };
+  bool canUnwrapKey() { return this->mask & unwrap_key_flag; };
+};
 
 class CryptoKey : public BuiltinImpl<CryptoKey> {
 public: