Move ScriptState::GetExecutionContext (Part 5)

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 43 matching lines @@
   AlgorithmError error;
   bool success = NormalizeAlgorithm(raw, op, algorithm, &error);
   if (!success)
     result->CompleteWithError(error.error_type, error.error_details);
   return success;
 }
 
 static bool CanAccessWebCrypto(ScriptState* script_state,
                                CryptoResult* result) {
   String error_message;
-  if (!script_state->GetExecutionContext()->IsSecureContext(
-          error_message, ExecutionContext::kWebCryptoSecureContextCheck)) {
+  if (!ExecutionContext::From(script_state)
+           ->IsSecureContext(error_message,
+                             ExecutionContext::kWebCryptoSecureContextCheck)) {
     result->CompleteWithError(kWebCryptoErrorTypeNotSupported, error_message);
     return false;
   }
 
-  if (!script_state->GetExecutionContext()->IsSecureContext()) {
+  if (!ExecutionContext::From(script_state)->IsSecureContext()) {
     Deprecation::CountDeprecation(
-        script_state->GetExecutionContext(),
+        ExecutionContext::From(script_state),
         UseCounter::kSubtleCryptoOnlyStrictSecureContextCheckFailed);
   }
 
   return true;
 }
 
 static bool CopyStringProperty(const char* property,
                                const Dictionary& source,
                                JSONObject* destination) {
   String value;
@@ skipping 123 matching lines @@
   // 14.3.1.8: If the name member of normalizedAlgorithm is not equal to the
   //           name attribute of the [[algorithm]] internal slot of key then
   //           throw an InvalidAccessError.
   //
   // 14.3.1.9: If the [[usages]] internal slot of key does not contain an
   //           entry that is "encrypt", then throw an InvalidAccessError.
   if (!key->CanBeUsedForAlgorithm(normalized_algorithm,
                                   kWebCryptoKeyUsageEncrypt, result))
     return promise;
 
-  HistogramAlgorithmAndKey(script_state->GetExecutionContext(),
+  HistogramAlgorithmAndKey(ExecutionContext::From(script_state),
                            normalized_algorithm, key->Key());
   Platform::Current()->Crypto()->Encrypt(normalized_algorithm, key->Key(),
                                          std::move(data), result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::decrypt(ScriptState* script_state,
                                     const AlgorithmIdentifier& raw_algorithm,
                                     CryptoKey* key,
                                     const BufferSource& raw_data) {
@@ skipping 20 matching lines @@
   // 14.3.2.8: If the name member of normalizedAlgorithm is not equal to the
   //           name attribute of the [[algorithm]] internal slot of key then
   //           throw an InvalidAccessError.
   //
   // 14.3.2.9: If the [[usages]] internal slot of key does not contain an
   //           entry that is "decrypt", then throw an InvalidAccessError.
   if (!key->CanBeUsedForAlgorithm(normalized_algorithm,
                                   kWebCryptoKeyUsageDecrypt, result))
     return promise;
 
-  HistogramAlgorithmAndKey(script_state->GetExecutionContext(),
+  HistogramAlgorithmAndKey(ExecutionContext::From(script_state),
                            normalized_algorithm, key->Key());
   Platform::Current()->Crypto()->Decrypt(normalized_algorithm, key->Key(),
                                          std::move(data), result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::sign(ScriptState* script_state,
                                  const AlgorithmIdentifier& raw_algorithm,
                                  CryptoKey* key,
                                  const BufferSource& raw_data) {
@@ skipping 20 matching lines @@
   // 14.3.3.8: If the name member of normalizedAlgorithm is not equal to the
   //           name attribute of the [[algorithm]] internal slot of key then
   //           throw an InvalidAccessError.
   //
   // 14.3.3.9: If the [[usages]] internal slot of key does not contain an
   //           entry that is "sign", then throw an InvalidAccessError.
   if (!key->CanBeUsedForAlgorithm(normalized_algorithm, kWebCryptoKeyUsageSign,
                                   result))
     return promise;
 
-  HistogramAlgorithmAndKey(script_state->GetExecutionContext(),
+  HistogramAlgorithmAndKey(ExecutionContext::From(script_state),
                            normalized_algorithm, key->Key());
   Platform::Current()->Crypto()->Sign(normalized_algorithm, key->Key(),
                                       std::move(data), result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::verifySignature(
     ScriptState* script_state,
     const AlgorithmIdentifier& raw_algorithm,
     CryptoKey* key,
@@ skipping 26 matching lines @@
   // 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.
   //
   // 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(normalized_algorithm,
                                   kWebCryptoKeyUsageVerify, result))
     return promise;
 
-  HistogramAlgorithmAndKey(script_state->GetExecutionContext(),
+  HistogramAlgorithmAndKey(ExecutionContext::From(script_state),
                            normalized_algorithm, key->Key());
   Platform::Current()->Crypto()->VerifySignature(
       normalized_algorithm, key->Key(), std::move(signature), std::move(data),
       result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::digest(ScriptState* script_state,
                                    const AlgorithmIdentifier& raw_algorithm,
                                    const BufferSource& raw_data) {
@@ skipping 10 matching lines @@
   //              by the data parameter passed to the digest method.
   WebVector<uint8_t> data = CopyBytes(raw_data);
 
   // 14.3.5.3: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to "digest".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationDigest,
                       normalized_algorithm, result))
     return promise;
 
-  HistogramAlgorithm(script_state->GetExecutionContext(), normalized_algorithm);
+  HistogramAlgorithm(ExecutionContext::From(script_state),
+                     normalized_algorithm);
   Platform::Current()->Crypto()->Digest(normalized_algorithm, std::move(data),
                                         result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::generateKey(
     ScriptState* script_state,
     const AlgorithmIdentifier& raw_algorithm,
     bool extractable,
     const Vector<String>& raw_key_usages) {
@@ skipping 15 matching lines @@
   //           "generateKey".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationGenerateKey,
                       normalized_algorithm, result))
     return promise;
 
   // NOTE: Steps (8) and (9) disallow empty usages on secret and private
   // keys. This normative requirement is enforced by the platform
   // implementation in the call below.
 
-  HistogramAlgorithm(script_state->GetExecutionContext(), normalized_algorithm);
+  HistogramAlgorithm(ExecutionContext::From(script_state),
+                     normalized_algorithm);
   Platform::Current()->Crypto()->GenerateKey(normalized_algorithm, extractable,
                                              key_usages, result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::importKey(
     ScriptState* script_state,
     const String& raw_format,
     const ArrayBufferOrArrayBufferViewOrDictionary& raw_key_data,
     const AlgorithmIdentifier& raw_algorithm,
@@ skipping 65 matching lines @@
   }
 
   // 14.3.9.3: Let normalizedAlgorithm be the result of normalizing an
   //           algorithm, with alg set to algorithm and op set to
   //           "importKey".
   WebCryptoAlgorithm normalized_algorithm;
   if (!ParseAlgorithm(raw_algorithm, kWebCryptoOperationImportKey,
                       normalized_algorithm, result))
     return promise;
 
-  HistogramAlgorithm(script_state->GetExecutionContext(), normalized_algorithm);
+  HistogramAlgorithm(ExecutionContext::From(script_state),
+                     normalized_algorithm);
   Platform::Current()->Crypto()->ImportKey(format, std::move(key_data),
                                            normalized_algorithm, extractable,
                                            key_usages, result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::exportKey(ScriptState* script_state,
                                       const String& raw_format,
                                       CryptoKey* key) {
   // Method described by:
@@ skipping 10 matching lines @@
     return promise;
 
   // 14.3.10.6: If the [[extractable]] internal slot of key is false, then
   //            throw an InvalidAccessError.
   if (!key->extractable()) {
     result->CompleteWithError(kWebCryptoErrorTypeInvalidAccess,
                               "key is not extractable");
     return promise;
   }
 
-  HistogramKey(script_state->GetExecutionContext(), key->Key());
+  HistogramKey(ExecutionContext::From(script_state), key->Key());
   Platform::Current()->Crypto()->ExportKey(format, key->Key(),
                                            result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::wrapKey(
     ScriptState* script_state,
     const String& raw_format,
     CryptoKey* key,
     CryptoKey* wrapping_key,
@@ skipping 38 matching lines @@
   // the spec order.
 
   // 14.3.11.12: If the [[extractable]] internal slot of key is false, then
   //             throw an InvalidAccessError.
   if (!key->extractable()) {
     result->CompleteWithError(kWebCryptoErrorTypeInvalidAccess,
                               "key is not extractable");
     return promise;
   }
 
-  HistogramAlgorithmAndKey(script_state->GetExecutionContext(),
+  HistogramAlgorithmAndKey(ExecutionContext::From(script_state),
                            normalized_algorithm, wrapping_key->Key());
-  HistogramKey(script_state->GetExecutionContext(), key->Key());
+  HistogramKey(ExecutionContext::From(script_state), key->Key());
   Platform::Current()->Crypto()->WrapKey(
       format, key->Key(), wrapping_key->Key(), normalized_algorithm,
       result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::unwrapKey(
     ScriptState* script_state,
     const String& raw_format,
     const BufferSource& raw_wrapped_key,
@@ skipping 52 matching lines @@
   //             contain an entry that is "unwrapKey", then throw an
   //             InvalidAccessError.
   if (!unwrapping_key->CanBeUsedForAlgorithm(
           normalized_algorithm, kWebCryptoKeyUsageUnwrapKey, result))
     return promise;
 
   // NOTE: Step (16) disallows empty usages on secret and private keys. This
   // normative requirement is enforced by the platform implementation in the
   // call below.
 
-  HistogramAlgorithmAndKey(script_state->GetExecutionContext(),
+  HistogramAlgorithmAndKey(ExecutionContext::From(script_state),
                            normalized_algorithm, unwrapping_key->Key());
-  HistogramAlgorithm(script_state->GetExecutionContext(),
+  HistogramAlgorithm(ExecutionContext::From(script_state),
                      normalized_key_algorithm);
   Platform::Current()->Crypto()->UnwrapKey(
       format, std::move(wrapped_key), unwrapping_key->Key(),
       normalized_algorithm, normalized_key_algorithm, extractable, key_usages,
       result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::deriveBits(ScriptState* script_state,
                                        const AlgorithmIdentifier& raw_algorithm,
@@ skipping 19 matching lines @@
   // 14.3.8.7: If the name member of normalizedAlgorithm is not equal to the
   //           name attribute of the [[algorithm]] internal slot of baseKey
   //           then throw an InvalidAccessError.
   //
   // 14.3.8.8: If the [[usages]] internal slot of baseKey does not contain an
   //           entry that is "deriveBits", then throw an InvalidAccessError.
   if (!base_key->CanBeUsedForAlgorithm(normalized_algorithm,
                                        kWebCryptoKeyUsageDeriveBits, result))
     return promise;
 
-  HistogramAlgorithmAndKey(script_state->GetExecutionContext(),
+  HistogramAlgorithmAndKey(ExecutionContext::From(script_state),
                            normalized_algorithm, base_key->Key());
   Platform::Current()->Crypto()->DeriveBits(
       normalized_algorithm, base_key->Key(), length_bits, result->Result());
   return promise;
 }
 
 ScriptPromise SubtleCrypto::deriveKey(
     ScriptState* script_state,
     const AlgorithmIdentifier& raw_algorithm,
     CryptoKey* base_key,
@@ skipping 49 matching lines @@
   // 14.3.7.12: If the [[usages]] internal slot of baseKey does not contain
   //            an entry that is "deriveKey", then throw an InvalidAccessError.
   if (!base_key->CanBeUsedForAlgorithm(normalized_algorithm,
                                        kWebCryptoKeyUsageDeriveKey, result))
     return promise;
 
   // NOTE: Step (16) disallows empty usages on secret and private keys. This
   // normative requirement is enforced by the platform implementation in the
   // call below.
 
-  HistogramAlgorithmAndKey(script_state->GetExecutionContext(),
+  HistogramAlgorithmAndKey(ExecutionContext::From(script_state),
                            normalized_algorithm, base_key->Key());
-  HistogramAlgorithm(script_state->GetExecutionContext(),
+  HistogramAlgorithm(ExecutionContext::From(script_state),
                      normalized_derived_key_algorithm);
   Platform::Current()->Crypto()->DeriveKey(
       normalized_algorithm, base_key->Key(), normalized_derived_key_algorithm,
       key_length_algorithm, extractable, key_usages, result->Result());
   return promise;
 }
 
 }  // namespace blink