Remove BLINK_ASSERT() and BLINK_ASSERT_NOT_REACHED() macros.

third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h

 /*
  * 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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebCryptoAlgorithmParams_h
 #define WebCryptoAlgorithmParams_h
 
 #include "WebCommon.h"
 #include "WebCryptoAlgorithm.h"
 #include "WebCryptoKey.h"
 #include "WebVector.h"
+#include "base/logging.h"
 
 namespace blink {
 
 // NOTE: For documentation on the meaning of each of the parameters see the
 //       Web crypto spec:
 //
 //       http://www.w3.org/TR/WebCryptoAPI
 //
 //       For the most part, the parameters in the spec have the same name,
 //       except that in the blink code:
@@ skipping 22 matching lines @@
 
 private:
     const WebVector<unsigned char> m_iv;
 };
 
 class WebCryptoAlgorithmParamsWithHash : public WebCryptoAlgorithmParams {
 public:
     explicit WebCryptoAlgorithmParamsWithHash(const WebCryptoAlgorithm& hash)
         : m_hash(hash)
     {
-        BLINK_ASSERT(!hash.isNull());
+        DCHECK(!hash.isNull());
     }
 
     const WebCryptoAlgorithm& hash() const { return m_hash; }
 
 private:
     const WebCryptoAlgorithm m_hash;
 };
 
 class WebCryptoAesCtrParams : public WebCryptoAlgorithmParams {
 public:
@@ skipping 37 matching lines @@
         , m_hasLengthBits(false)
         , m_optionalLengthBits(0)
     {
     }
 
     WebCryptoHmacImportParams(const WebCryptoAlgorithm& hash, bool hasLengthBits, unsigned lengthBits)
         : WebCryptoAlgorithmParamsWithHash(hash)
         , m_hasLengthBits(hasLengthBits)
         , m_optionalLengthBits(lengthBits)
     {
-        BLINK_ASSERT(hasLengthBits || !lengthBits);
+        DCHECK(hasLengthBits || !lengthBits);
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeHmacImportParams; }
 
     bool hasLengthBits() const { return m_hasLengthBits; }
 
     unsigned optionalLengthBits() const { return m_optionalLengthBits; }
 
 private:
     const bool m_hasLengthBits;
     const unsigned m_optionalLengthBits;
 };
 
 class WebCryptoHmacKeyGenParams : public WebCryptoAlgorithmParamsWithHash {
 public:
     WebCryptoHmacKeyGenParams(const WebCryptoAlgorithm& hash, bool hasLengthBits, unsigned lengthBits)
         : WebCryptoAlgorithmParamsWithHash(hash)
         , m_hasLengthBits(hasLengthBits)
         , m_optionalLengthBits(lengthBits)
     {
-        BLINK_ASSERT(hasLengthBits || !lengthBits);
+        DCHECK(hasLengthBits || !lengthBits);
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeHmacKeyGenParams; }
 
     bool hasLengthBits() const { return m_hasLengthBits; }
 
     unsigned optionalLengthBits() const { return m_optionalLengthBits; }
 
 private:
     const bool m_hasLengthBits;
     const unsigned m_optionalLengthBits;
 };
 
 class WebCryptoAesGcmParams : public WebCryptoAlgorithmParams {
 public:
     WebCryptoAesGcmParams(const unsigned char* iv, unsigned ivSize, bool hasAdditionalData, const unsigned char* additionalData, unsigned additionalDataSize, bool hasTagLengthBits, unsigned char tagLengthBits)
         : m_iv(iv, ivSize)
         , m_hasAdditionalData(hasAdditionalData)
         , m_optionalAdditionalData(additionalData, additionalDataSize)
         , m_hasTagLengthBits(hasTagLengthBits)
         , m_optionalTagLengthBits(tagLengthBits)
     {
-        BLINK_ASSERT(hasAdditionalData || !additionalDataSize);
-        BLINK_ASSERT(hasTagLengthBits || !tagLengthBits);
+        DCHECK(hasAdditionalData || !additionalDataSize);
+        DCHECK(hasTagLengthBits || !tagLengthBits);
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeAesGcmParams; }
 
     const WebVector<unsigned char>& iv() const { return m_iv; }
 
     bool hasAdditionalData() const { return m_hasAdditionalData; }
     const WebVector<unsigned char>& optionalAdditionalData() const { return m_optionalAdditionalData; }
 
     bool hasTagLengthBits() const { return m_hasTagLengthBits; }
@@ skipping 17 matching lines @@
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeRsaHashedImportParams; }
 };
 
 class WebCryptoRsaHashedKeyGenParams : public WebCryptoAlgorithmParams {
 public:
     explicit WebCryptoRsaHashedKeyGenParams(const WebCryptoAlgorithm& hash, unsigned modulusLengthBits, const unsigned char* publicExponent, unsigned publicExponentSize)
         : m_modulusLengthBits(modulusLengthBits)
         , m_publicExponent(publicExponent, publicExponentSize)
         , m_hash(hash)
     {
-        BLINK_ASSERT(!hash.isNull());
+        DCHECK(!hash.isNull());
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams; }
 
     unsigned modulusLengthBits() const { return m_modulusLengthBits; }
     const WebVector<unsigned char>& publicExponent() const { return m_publicExponent; }
     const WebCryptoAlgorithm& hash() const { return m_hash; }
 
     // Converts the public exponent (big-endian WebCrypto BigInteger),
     // with or without leading zeros, to unsigned int. Returns true on success.
@@ skipping 16 matching lines @@
     const WebVector<unsigned char> m_publicExponent;
     const WebCryptoAlgorithm m_hash;
 };
 
 class WebCryptoRsaOaepParams : public WebCryptoAlgorithmParams {
 public:
     WebCryptoRsaOaepParams(bool hasLabel, const unsigned char* label, unsigned labelSize)
         : m_hasLabel(hasLabel)
         , m_optionalLabel(label, labelSize)
     {
-        BLINK_ASSERT(hasLabel || !labelSize);
+        DCHECK(hasLabel || !labelSize);
     }
 
     virtual WebCryptoAlgorithmParamsType type() const { return WebCryptoAlgorithmParamsTypeRsaOaepParams; }
 
     bool hasLabel() const { return m_hasLabel; }
     const WebVector<unsigned char>& optionalLabel() const { return m_optionalLabel; }
 
 private:
     const bool m_hasLabel;
     const WebVector<unsigned char> m_optionalLabel;
@@ skipping 122 matching lines @@
     unsigned iterations() const { return m_iterations; }
 
 private:
     const WebVector<unsigned char> m_salt;
     const unsigned m_iterations;
 };
 
 } // namespace blink
 
 #endif