reflow comments in modules/[app_banner,encoding]

third_party/WebKit/Source/modules/crypto/SubtleCrypto.cpp

 /*
  * Copyright (C) 2013 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 157 matching lines @@
   return WebVector<uint8_t>(static_cast<uint8_t*>(source.data()),
                             source.byteLength());
 }
 
 SubtleCrypto::SubtleCrypto() {}
 
 ScriptPromise SubtleCrypto::encrypt(ScriptState* scriptState,
                                     const AlgorithmIdentifier& rawAlgorithm,
                                     CryptoKey* key,
                                     const BufferSource& rawData) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-encrypt
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-encrypt
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   // 14.3.1.2: Let data be the result of getting a copy of the bytes held by
   //           the data parameter passed to the encrypt method.
   WebVector<uint8_t> data = copyBytes(rawData);
@@ skipping 19 matching lines @@
                            normalizedAlgorithm, key->key());
   Platform::current()->crypto()->encrypt(normalizedAlgorithm, key->key(),
                                          std::move(data), result->result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::decrypt(ScriptState* scriptState,
                                     const AlgorithmIdentifier& rawAlgorithm,
                                     CryptoKey* key,
                                     const BufferSource& rawData) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-decrypt
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-decrypt
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   // 14.3.2.2: Let data be the result of getting a copy of the bytes held by
   //           the data parameter passed to the decrypt method.
   WebVector<uint8_t> data = copyBytes(rawData);
@@ skipping 19 matching lines @@
                            normalizedAlgorithm, key->key());
   Platform::current()->crypto()->decrypt(normalizedAlgorithm, key->key(),
                                          std::move(data), result->result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::sign(ScriptState* scriptState,
                                  const AlgorithmIdentifier& rawAlgorithm,
                                  CryptoKey* key,
                                  const BufferSource& rawData) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-sign
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-sign
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   // 14.3.3.2: Let data be the result of getting a copy of the bytes held by
   //           the data parameter passed to the sign method.
   WebVector<uint8_t> data = copyBytes(rawData);
@@ skipping 21 matching lines @@
                                       std::move(data), result->result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::verifySignature(
     ScriptState* scriptState,
     const AlgorithmIdentifier& rawAlgorithm,
     CryptoKey* key,
     const BufferSource& rawSignature,
     const BufferSource& rawData) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-verify
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-verify
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   // 14.3.4.2: Let signature be the result of getting a copy of the bytes
   //           held by the signature parameter passed to the verify method.
   WebVector<uint8_t> signature = copyBytes(rawSignature);
 
   // 14.3.4.3: Let data be the result of getting a copy of the bytes held by
   //           the data parameter passed to the verify method.
   WebVector<uint8_t> data = copyBytes(rawData);
 
   // 14.3.4.4: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to "verify".
   WebCryptoAlgorithm normalizedAlgorithm;
   if (!parseAlgorithm(rawAlgorithm, WebCryptoOperationVerify,
                       normalizedAlgorithm, result))
     return promise;
 
   // 14.3.4.9: If the name member of normalizedAlgorithm is not equal to the
-  //           name attribute of the [[algorithm]] internal slot of key then throw an
-  //           InvalidAccessError.
+  //           name attribute of the [[algorithm]] internal slot of key then
+  //           throw an InvalidAccessError.
   //
   // 14.3.4.10: If the [[usages]] internal slot of key does not contain an
   //            entry that is "verify", then throw an InvalidAccessError.
   if (!key->canBeUsedForAlgorithm(normalizedAlgorithm, WebCryptoKeyUsageVerify,
                                   result))
     return promise;
 
   histogramAlgorithmAndKey(scriptState->getExecutionContext(),
                            normalizedAlgorithm, key->key());
   Platform::current()->crypto()->verifySignature(
       normalizedAlgorithm, key->key(), std::move(signature), std::move(data),
       result->result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::digest(ScriptState* scriptState,
                                    const AlgorithmIdentifier& rawAlgorithm,
                                    const BufferSource& rawData) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-digest
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-digest
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   // 14.3.5.2: Let data be the result of getting a copy of the bytes held
   //              by the data parameter passed to the digest method.
   WebVector<uint8_t> data = copyBytes(rawData);
 
   // 14.3.5.3: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to "digest".
   WebCryptoAlgorithm normalizedAlgorithm;
   if (!parseAlgorithm(rawAlgorithm, WebCryptoOperationDigest,
                       normalizedAlgorithm, result))
     return promise;
 
   histogramAlgorithm(scriptState->getExecutionContext(), normalizedAlgorithm);
   Platform::current()->crypto()->digest(normalizedAlgorithm, std::move(data),
                                         result->result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::generateKey(ScriptState* scriptState,
                                         const AlgorithmIdentifier& rawAlgorithm,
                                         bool extractable,
                                         const Vector<String>& rawKeyUsages) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-generateKey
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-generateKey
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   WebCryptoKeyUsageMask keyUsages;
   if (!CryptoKey::parseUsageMask(rawKeyUsages, keyUsages, result))
     return promise;
@@ skipping 16 matching lines @@
   return promise;
 }
 
 ScriptPromise SubtleCrypto::importKey(
     ScriptState* scriptState,
     const String& rawFormat,
     const ArrayBufferOrArrayBufferViewOrDictionary& rawKeyData,
     const AlgorithmIdentifier& rawAlgorithm,
     bool extractable,
     const Vector<String>& rawKeyUsages) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-importKey
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-importKey
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   WebCryptoKeyFormat format;
   if (!CryptoKey::parseFormat(rawFormat, format, result))
     return promise;
@@ skipping 61 matching lines @@
   histogramAlgorithm(scriptState->getExecutionContext(), normalizedAlgorithm);
   Platform::current()->crypto()->importKey(format, std::move(keyData),
                                            normalizedAlgorithm, extractable,
                                            keyUsages, result->result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::exportKey(ScriptState* scriptState,
                                       const String& rawFormat,
                                       CryptoKey* key) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-exportKey
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-exportKey
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   WebCryptoKeyFormat format;
   if (!CryptoKey::parseFormat(rawFormat, format, result))
     return promise;
@@ skipping 11 matching lines @@
                                            result->result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::wrapKey(
     ScriptState* scriptState,
     const String& rawFormat,
     CryptoKey* key,
     CryptoKey* wrappingKey,
     const AlgorithmIdentifier& rawWrapAlgorithm) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-wrapKey
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-wrapKey
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   WebCryptoKeyFormat format;
   if (!CryptoKey::parseFormat(rawFormat, format, result))
     return promise;
@@ skipping 42 matching lines @@
 
 ScriptPromise SubtleCrypto::unwrapKey(
     ScriptState* scriptState,
     const String& rawFormat,
     const BufferSource& rawWrappedKey,
     CryptoKey* unwrappingKey,
     const AlgorithmIdentifier& rawUnwrapAlgorithm,
     const AlgorithmIdentifier& rawUnwrappedKeyAlgorithm,
     bool extractable,
     const Vector<String>& rawKeyUsages) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-unwrapKey
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-unwrapKey
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   WebCryptoKeyFormat format;
   if (!CryptoKey::parseFormat(rawFormat, format, result))
     return promise;
@@ skipping 49 matching lines @@
   Platform::current()->crypto()->unwrapKey(
       format, std::move(wrappedKey), unwrappingKey->key(), normalizedAlgorithm,
       normalizedKeyAlgorithm, extractable, keyUsages, result->result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::deriveBits(ScriptState* scriptState,
                                        const AlgorithmIdentifier& rawAlgorithm,
                                        CryptoKey* baseKey,
                                        unsigned lengthBits) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-deriveBits
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#dfn-SubtleCrypto-method-deriveBits
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   // 14.3.8.2: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to
   //           "deriveBits".
@@ skipping 19 matching lines @@
   return promise;
 }
 
 ScriptPromise SubtleCrypto::deriveKey(
     ScriptState* scriptState,
     const AlgorithmIdentifier& rawAlgorithm,
     CryptoKey* baseKey,
     const AlgorithmIdentifier& rawDerivedKeyType,
     bool extractable,
     const Vector<String>& rawKeyUsages) {
-  // Method described by: https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-deriveKey
+  // Method described by:
+  // https://w3c.github.io/webcrypto/Overview.html#SubtleCrypto-method-deriveKey
 
   CryptoResultImpl* result = CryptoResultImpl::create(scriptState);
   ScriptPromise promise = result->promise();
 
   if (!canAccessWebCrypto(scriptState, result))
     return promise;
 
   WebCryptoKeyUsageMask keyUsages;
   if (!CryptoKey::parseUsageMask(rawKeyUsages, keyUsages, result))
     return promise;
@@ skipping 45 matching lines @@
                            normalizedAlgorithm, baseKey->key());
   histogramAlgorithm(scriptState->getExecutionContext(),
                      normalizedDerivedKeyAlgorithm);
   Platform::current()->crypto()->deriveKey(
       normalizedAlgorithm, baseKey->key(), normalizedDerivedKeyAlgorithm,
       keyLengthAlgorithm, extractable, keyUsages, result->result());
   return promise;
 }
 
 }  // namespace blink