Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/fileapi

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

 /*
  * Copyright (C) 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 32 matching lines @@
 
 static String GetContentTypeFromFileName(const String& name,
                                          File::ContentTypeLookupPolicy policy) {
   String type;
   int index = name.ReverseFind('.');
   if (index != -1) {
     if (policy == File::kWellKnownContentTypes) {
       type = MIMETypeRegistry::GetWellKnownMIMETypeForExtension(
           name.Substring(index + 1));
     } else {
-      ASSERT(policy == File::kAllContentTypes);
+      DCHECK_EQ(policy, File::kAllContentTypes);
       type =
           MIMETypeRegistry::GetMIMETypeForExtension(name.Substring(index + 1));
     }
   }
   return type;
 }
 
 static std::unique_ptr<BlobData> CreateBlobDataForFileWithType(
     const String& path,
     const String& content_type) {
@@ skipping 52 matching lines @@
   return blob_data;
 }
 
 // static
 File* File::Create(
     ExecutionContext* context,
     const HeapVector<ArrayBufferOrArrayBufferViewOrBlobOrUSVString>& file_bits,
     const String& file_name,
     const FilePropertyBag& options,
     ExceptionState& exception_state) {
-  ASSERT(options.hasType());
+  DCHECK(options.hasType());
 
   double last_modified;
   if (options.hasLastModified())
     last_modified = static_cast<double>(options.lastModified());
   else
     last_modified = CurrentTimeMS();
-  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(), file_bits,
                    normalize_line_endings_to_native);
 
   long long file_size = blob_data->length();
@@ skipping 178 matching lines @@
   CaptureSnapshot(size, modification_time_ms);
   ClampSliceOffsets(size, start, end);
 
   long long length = end - start;
   std::unique_ptr<BlobData> blob_data = BlobData::Create();
   blob_data->SetContentType(NormalizeType(content_type));
   if (!file_system_url_.IsEmpty()) {
     blob_data->AppendFileSystemURL(file_system_url_, start, length,
                                    modification_time_ms / kMsPerSecond);
   } else {
-    ASSERT(!path_.IsEmpty());
+    DCHECK(!path_.IsEmpty());
     blob_data->AppendFile(path_, start, length,
                           modification_time_ms / kMsPerSecond);
   }
   return Blob::Create(BlobDataHandle::Create(std::move(blob_data), length));
 }
 
 void File::CaptureSnapshot(long long& snapshot_size,
                            double& snapshot_modification_time_ms) const {
   if (HasValidSnapshotMetadata()) {
     snapshot_size = snapshot_size_;
@@ skipping 43 matching lines @@
   // FIXME: This involves synchronous file operation. We need to figure out how
   // to make it asynchronous.
   long long size;
   double modification_time_ms;
   CaptureSnapshot(size, modification_time_ms);
   if (!file_system_url_.IsEmpty()) {
     blob_data.AppendFileSystemURL(file_system_url_, 0, size,
                                   modification_time_ms / kMsPerSecond);
     return;
   }
-  ASSERT(!path_.IsEmpty());
+  DCHECK(!path_.IsEmpty());
   blob_data.AppendFile(path_, 0, size, modification_time_ms / kMsPerSecond);
 }
 
 bool File::HasSameSource(const File& other) const {
   if (has_backing_file_ != other.has_backing_file_)
     return false;
 
   if (has_backing_file_)
     return path_ == other.path_;
 
   if (file_system_url_.IsEmpty() != other.file_system_url_.IsEmpty())
     return false;
 
   if (!file_system_url_.IsEmpty())
     return file_system_url_ == other.file_system_url_;
 
   return Uuid() == other.Uuid();
 }
 
 }  // namespace blink