[webcrypto] Add key usage for 'deriveBits'

Source/bindings/v8/SerializedScriptValue.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 275 matching lines @@
     // it fits conveniently into this bitfield.
     ExtractableUsage = 1 << 0,
 
     EncryptUsage = 1 << 1,
     DecryptUsage = 1 << 2,
     SignUsage = 1 << 3,
     VerifyUsage = 1 << 4,
     DeriveKeyUsage = 1 << 5,
     WrapKeyUsage = 1 << 6,
     UnwrapKeyUsage = 1 << 7,
+    DeriveBitsUsage = 1 << 8,
     // Maximum allowed value is 1 << 31
 };
 
 static bool shouldCheckForCycles(int depth)
 {
     ASSERT(depth >= 0);
     // Since we are not required to spot the cycle as soon as it
     // happens we can check for cycles only when the current depth
     // is a power of two.
     return !(depth & (depth - 1));
@@ skipping 480 matching lines @@
             return doWriteUint32(AesCtrTag);
         case blink::WebCryptoAlgorithmIdAesKw:
             return doWriteUint32(AesKwTag);
         }
         ASSERT_NOT_REACHED();
     }
 
     void doWriteKeyUsages(const blink::WebCryptoKeyUsageMask usages, bool extractable)
     {
         // Reminder to update this when adding new key usages.
-        COMPILE_ASSERT(blink::EndOfWebCryptoKeyUsage == (1 << 6) + 1, UpdateMe);
+        COMPILE_ASSERT(blink::EndOfWebCryptoKeyUsage == (1 << 7) + 1, UpdateMe);
 
         uint32_t value = 0;
 
         if (extractable)
             value |= ExtractableUsage;
 
         if (usages & blink::WebCryptoKeyUsageEncrypt)
             value |= EncryptUsage;
         if (usages & blink::WebCryptoKeyUsageDecrypt)
             value |= DecryptUsage;
         if (usages & blink::WebCryptoKeyUsageSign)
             value |= SignUsage;
         if (usages & blink::WebCryptoKeyUsageVerify)
             value |= VerifyUsage;
         if (usages & blink::WebCryptoKeyUsageDeriveKey)
             value |= DeriveKeyUsage;
         if (usages & blink::WebCryptoKeyUsageWrapKey)
             value |= WrapKeyUsage;
         if (usages & blink::WebCryptoKeyUsageUnwrapKey)
             value |= UnwrapKeyUsage;
+        if (usages & blink::WebCryptoKeyUsageDeriveBits)
+            value |= DeriveBitsUsage;
 
         doWriteUint32(value);
     }
 
     int bytesNeededToWireEncode(uint32_t value)
     {
         int bytes = 1;
         while (true) {
             value >>= varIntShift;
             if (!value)
@@ skipping 1674 matching lines @@
             id = blink::WebCryptoAlgorithmIdAesKw;
             return true;
         }
 
         return false;
     }
 
     bool doReadKeyUsages(blink::WebCryptoKeyUsageMask& usages, bool& extractable)
     {
         // Reminder to update this when adding new key usages.
-        COMPILE_ASSERT(blink::EndOfWebCryptoKeyUsage == (1 << 6) + 1, UpdateMe);
-        const uint32_t allPossibleUsages = ExtractableUsage | EncryptUsage | DecryptUsage | SignUsage | VerifyUsage | DeriveKeyUsage | WrapKeyUsage | UnwrapKeyUsage;
+        COMPILE_ASSERT(blink::EndOfWebCryptoKeyUsage == (1 << 7) + 1, UpdateMe);
+        const uint32_t allPossibleUsages = ExtractableUsage | EncryptUsage | DecryptUsage | SignUsage | VerifyUsage | DeriveKeyUsage | WrapKeyUsage | UnwrapKeyUsage | DeriveBitsUsage;
 
         uint32_t rawUsages;
         if (!doReadUint32(&rawUsages))
             return false;
 
         // Make sure it doesn't contain an unrecognized usage value.
         if (rawUsages & ~allPossibleUsages)
             return false;
 
         usages = 0;
 
         extractable = rawUsages & ExtractableUsage;
 
         if (rawUsages & EncryptUsage)
             usages |= blink::WebCryptoKeyUsageEncrypt;
         if (rawUsages & DecryptUsage)
             usages |= blink::WebCryptoKeyUsageDecrypt;
         if (rawUsages & SignUsage)
             usages |= blink::WebCryptoKeyUsageSign;
         if (rawUsages & VerifyUsage)
             usages |= blink::WebCryptoKeyUsageVerify;
         if (rawUsages & DeriveKeyUsage)
             usages |= blink::WebCryptoKeyUsageDeriveKey;
         if (rawUsages & WrapKeyUsage)
             usages |= blink::WebCryptoKeyUsageWrapKey;
         if (rawUsages & UnwrapKeyUsage)
             usages |= blink::WebCryptoKeyUsageUnwrapKey;
+        if (rawUsages & DeriveBitsUsage)
+            usages |= blink::WebCryptoKeyUsageDeriveBits;
 
         return true;
     }
 
     const uint8_t* m_buffer;
     const unsigned m_length;
     unsigned m_position;
     uint32_t m_version;
     v8::Isolate* m_isolate;
     const WebBlobInfoArray* m_blobInfo;
@@ skipping 504 matching lines @@
     // If the allocated memory was not registered before, then this class is likely
     // used in a context other then Worker's onmessage environment and the presence of
     // current v8 context is not guaranteed. Avoid calling v8 then.
     if (m_externallyAllocatedMemory) {
         ASSERT(v8::Isolate::GetCurrent());
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 } // namespace WebCore