Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/exported

third_party/WebKit/Source/platform/exported/WebCryptoAlgorithm.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 333 matching lines @@
   if (id_int >= WTF_ARRAY_LENGTH(kAlgorithmIdToInfo))
     return 0;
   return &kAlgorithmIdToInfo[id];
 }
 
 bool WebCryptoAlgorithm::IsNull() const {
   return private_.IsNull();
 }
 
 WebCryptoAlgorithmId WebCryptoAlgorithm::Id() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   return private_->id;
 }
 
 WebCryptoAlgorithmParamsType WebCryptoAlgorithm::ParamsType() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (!private_->params)
     return kWebCryptoAlgorithmParamsTypeNone;
   return private_->params->GetType();
 }
 
 const WebCryptoAesCbcParams* WebCryptoAlgorithm::AesCbcParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeAesCbcParams)
     return static_cast<WebCryptoAesCbcParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoAesCtrParams* WebCryptoAlgorithm::AesCtrParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeAesCtrParams)
     return static_cast<WebCryptoAesCtrParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoAesKeyGenParams* WebCryptoAlgorithm::AesKeyGenParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeAesKeyGenParams)
     return static_cast<WebCryptoAesKeyGenParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoHmacImportParams* WebCryptoAlgorithm::HmacImportParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeHmacImportParams)
     return static_cast<WebCryptoHmacImportParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoHmacKeyGenParams* WebCryptoAlgorithm::HmacKeyGenParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeHmacKeyGenParams)
     return static_cast<WebCryptoHmacKeyGenParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoAesGcmParams* WebCryptoAlgorithm::AesGcmParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeAesGcmParams)
     return static_cast<WebCryptoAesGcmParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoRsaOaepParams* WebCryptoAlgorithm::RsaOaepParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeRsaOaepParams)
     return static_cast<WebCryptoRsaOaepParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoRsaHashedImportParams*
 WebCryptoAlgorithm::RsaHashedImportParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeRsaHashedImportParams)
     return static_cast<WebCryptoRsaHashedImportParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoRsaHashedKeyGenParams*
 WebCryptoAlgorithm::RsaHashedKeyGenParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams)
     return static_cast<WebCryptoRsaHashedKeyGenParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoRsaPssParams* WebCryptoAlgorithm::RsaPssParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeRsaPssParams)
     return static_cast<WebCryptoRsaPssParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoEcdsaParams* WebCryptoAlgorithm::EcdsaParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeEcdsaParams)
     return static_cast<WebCryptoEcdsaParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoEcKeyGenParams* WebCryptoAlgorithm::EcKeyGenParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeEcKeyGenParams)
     return static_cast<WebCryptoEcKeyGenParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoEcKeyImportParams* WebCryptoAlgorithm::EcKeyImportParams()
     const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeEcKeyImportParams)
     return static_cast<WebCryptoEcKeyImportParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoEcdhKeyDeriveParams* WebCryptoAlgorithm::EcdhKeyDeriveParams()
     const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeEcdhKeyDeriveParams)
     return static_cast<WebCryptoEcdhKeyDeriveParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoAesDerivedKeyParams* WebCryptoAlgorithm::AesDerivedKeyParams()
     const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeAesDerivedKeyParams)
     return static_cast<WebCryptoAesDerivedKeyParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoHkdfParams* WebCryptoAlgorithm::HkdfParams() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypeHkdfParams)
     return static_cast<WebCryptoHkdfParams*>(private_->params.get());
   return 0;
 }
 
 const WebCryptoPbkdf2Params* WebCryptoAlgorithm::Pbkdf2Params() const {
-  ASSERT(!IsNull());
+  DCHECK(!IsNull());
   if (ParamsType() == kWebCryptoAlgorithmParamsTypePbkdf2Params)
     return static_cast<WebCryptoPbkdf2Params*>(private_->params.get());
   return 0;
 }
 
 bool WebCryptoAlgorithm::IsHash(WebCryptoAlgorithmId id) {
   switch (id) {
     case kWebCryptoAlgorithmIdSha1:
     case kWebCryptoAlgorithmIdSha256:
     case kWebCryptoAlgorithmIdSha384:
@@ skipping 42 matching lines @@
 
 void WebCryptoAlgorithm::Assign(const WebCryptoAlgorithm& other) {
   private_ = other.private_;
 }
 
 void WebCryptoAlgorithm::Reset() {
   private_.Reset();
 }
 
 }  // namespace blink