[webcrypto] Set the error type for failures.

content/child/webcrypto/shared_crypto.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/child/webcrypto/shared_crypto.h"
 
 #include "base/logging.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/platform_crypto.h"
@@ skipping 109 matching lines @@
                              const blink::WebCryptoKey& key,
                              const CryptoData& data,
                              blink::WebArrayBuffer* buffer) {
   platform::PublicKey* public_key;
   Status status = ToPlatformPublicKey(key, &public_key);
   if (status.IsError())
     return status;
 
   // RSAES encryption does not support empty input
   if (!data.byte_length())
-    return Status::Error();
+    return Status::ErrorDataTooSmall();
 
   return platform::EncryptRsaEsPkcs1v1_5(public_key, data, buffer);
 }
 
 Status DecryptRsaEsPkcs1v1_5(const blink::WebCryptoAlgorithm& algorithm,
                              const blink::WebCryptoKey& key,
                              const CryptoData& data,
                              blink::WebArrayBuffer* buffer) {
   platform::PrivateKey* private_key;
   Status status = ToPlatformPrivateKey(key, &private_key);
   if (status.IsError())
     return status;
 
   // RSAES decryption does not support empty input
   if (!data.byte_length())
-    return Status::Error();
+    return Status::ErrorDataTooSmall();
 
   return platform::DecryptRsaEsPkcs1v1_5(private_key, data, buffer);
 }
 
 Status SignHmac(const blink::WebCryptoAlgorithm& algorithm,
                 const blink::WebCryptoKey& key,
                 const CryptoData& data,
                 blink::WebArrayBuffer* buffer) {
   platform::SymKey* sym_key;
   Status status = ToPlatformSymKey(key, &sym_key);
@@ skipping 58 matching lines @@
                     const blink::WebCryptoAlgorithm& algorithm,
                     bool extractable,
                     blink::WebCryptoKeyUsageMask usage_mask,
                     blink::WebCryptoKey* key) {
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCtr:
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesKw:
       if (!IsValidAesKeyLengthBytes(key_data.byte_length()))
-        return Status::Error();
+        return Status::ErrorImportAesKeyLength();
     // Fallthrough intentional!
     case blink::WebCryptoAlgorithmIdHmac:
       return platform::ImportKeyRaw(
           algorithm, key_data, extractable, usage_mask, key);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 // Returns the key format to use for structured cloning.
@@ skipping 223 matching lines @@
     blink::WebCryptoKey* key) {
   blink::WebArrayBuffer buffer;
   Status status = DecryptDontCheckKeyUsage(
       wrapping_algorithm, wrapping_key, wrapped_key_data, &buffer);
   if (status.IsError())
     return status;
   status = ImportKey(
       format, CryptoData(buffer), algorithm, extractable, usage_mask, key);
   // NOTE! Returning the details of any ImportKey() failure here would leak
   // information about the plaintext internals of the encrypted key. Instead,
-  // collapse any error into the generic Status::Error().
-  return status.IsError() ? Status::Error() : Status::Success();
+  // collapse any error into the generic Status::OperationError().
+  return status.IsError() ? Status::OperationError() : Status::Success();
 }
 
 Status WrapKeyExportAndEncrypt(
     blink::WebCryptoKeyFormat format,
     const blink::WebCryptoKey& wrapping_key,
     const blink::WebCryptoKey& key_to_wrap,
     const blink::WebCryptoAlgorithm& wrapping_algorithm,
     blink::WebArrayBuffer* buffer) {
   blink::WebArrayBuffer exported_data;
   Status status = ExportKey(format, key_to_wrap, &exported_data);
@@ skipping 347 matching lines @@
                             key);
   if (status.IsError())
     return status;
 
   return ValidateDeserializedKey(*key, algorithm, type);
 }
 
 }  // namespace webcrypto
 
 }  // namespace content