Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/fileapi

third_party/WebKit/Source/core/fileapi/Blob.cpp

 /*
  * Copyright (C) 2010 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 41 matching lines @@
   // using BlobURL::getOrigin().
   void RegisterURL(SecurityOrigin*, const KURL&, URLRegistrable*) override;
   void UnregisterURL(const KURL&) override;
 
   static URLRegistry& Registry();
 };
 
 void BlobURLRegistry::RegisterURL(SecurityOrigin* origin,
                                   const KURL& public_url,
                                   URLRegistrable* registrable_object) {
-  ASSERT(&registrable_object->Registry() == this);
+  DCHECK_EQ(&registrable_object->Registry(), this);
   Blob* blob = static_cast<Blob*>(registrable_object);
   BlobRegistry::RegisterPublicBlobURL(origin, public_url,
                                       blob->GetBlobDataHandle());
 }
 
 void BlobURLRegistry::UnregisterURL(const KURL& public_url) {
   BlobRegistry::RevokePublicBlobURL(public_url);
 }
 
 URLRegistry& BlobURLRegistry::Registry() {
@@ skipping 12 matching lines @@
     : blob_data_handle_(std::move(data_handle)), is_closed_(false) {}
 
 Blob::~Blob() {}
 
 // static
 Blob* Blob::Create(
     ExecutionContext* context,
     const HeapVector<ArrayBufferOrArrayBufferViewOrBlobOrUSVString>& blob_parts,
     const BlobPropertyBag& options,
     ExceptionState& exception_state) {
-  ASSERT(options.hasType());
+  DCHECK(options.hasType());
 
-  ASSERT(options.hasEndings());
+  DCHECK(options.hasEndings());
   bool normalize_line_endings_to_native = options.endings() == "native";
   if (normalize_line_endings_to_native)
     UseCounter::Count(context, UseCounter::kFileAPINativeLineEndings);
 
   std::unique_ptr<BlobData> blob_data = BlobData::Create();
   blob_data->SetContentType(NormalizeType(options.type()));
 
   PopulateBlobData(blob_data.get(), blob_parts,
                    normalize_line_endings_to_native);
 
   long long blob_size = blob_data->length();
   return new Blob(BlobDataHandle::Create(std::move(blob_data), blob_size));
 }
 
 Blob* Blob::Create(const unsigned char* data,
                    size_t bytes,
                    const String& content_type) {
-  ASSERT(data);
+  DCHECK(data);
 
   std::unique_ptr<BlobData> blob_data = BlobData::Create();
   blob_data->SetContentType(content_type);
   blob_data->AppendBytes(data, bytes);
   long long blob_size = blob_data->length();
 
   return new Blob(BlobDataHandle::Create(std::move(blob_data), blob_size));
 }
 
 // static
@@ skipping 15 matching lines @@
       blob_data->AppendText(item.getAsUSVString(),
                             normalize_line_endings_to_native);
     } else {
       NOTREACHED();
     }
   }
 }
 
 // static
 void Blob::ClampSliceOffsets(long long size, long long& start, long long& end) {
-  ASSERT(size != -1);
+  DCHECK_NE(size, -1);
 
   // Convert the negative value that is used to select from the end.
   if (start < 0)
     start = start + size;
   if (end < 0)
     end = end + size;
 
   // Clamp the range if it exceeds the size limit.
   if (start < 0)
     start = 0;
@@ skipping 74 matching lines @@
     const UChar* chars = type.Characters16();
     for (size_t i = 0; i < length; ++i) {
       if (chars[i] < 0x0020 || chars[i] > 0x007e)
         return g_empty_string;
     }
   }
   return type.Lower();
 }
 
 }  // namespace blink