Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/fileapi

third_party/WebKit/Source/core/fileapi/FileReaderLoader.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 156 matching lines @@
     // Set m_totalBytes and allocate a buffer based on the specified range.
     total_bytes_ = 1LL + range_end_ - range_start_;
     initial_buffer_length = total_bytes_;
   } else {
     // Nothing is known about the size of the resource. Normalize
     // m_totalBytes to -1 and initialize the buffer for receiving with the
     // default size.
     total_bytes_ = -1;
   }
 
-  ASSERT(!raw_data_);
+  DCHECK(!raw_data_);
 
   if (read_type_ != kReadByClient) {
     // Check that we can cast to unsigned since we have to do
     // so to call ArrayBuffer's create function.
     // FIXME: Support reading more than the current size limit of ArrayBuffer.
     if (initial_buffer_length > std::numeric_limits<unsigned>::max()) {
       Failed(FileError::kNotReadableErr);
       return;
     }
 
@@ skipping 12 matching lines @@
       // Total size is known. Set m_rawData to ignore overflowed data.
       raw_data_->SetVariableCapacity(false);
     }
   }
 
   if (client_)
     client_->DidStartLoading();
 }
 
 void FileReaderLoader::DidReceiveData(const char* data, unsigned data_length) {
-  ASSERT(data);
+  DCHECK(data);
 
   // Bail out if we already encountered an error.
   if (error_code_)
     return;
 
   if (read_type_ == kReadByClient) {
     bytes_loaded_ += data_length;
 
     if (client_)
       client_->DidReceiveDataForClient(data, data_length);
@@ skipping 56 matching lines @@
     case 403:
       return FileError::kSecurityErr;
     case 404:
       return FileError::kNotFoundErr;
     default:
       return FileError::kNotReadableErr;
   }
 }
 
 DOMArrayBuffer* FileReaderLoader::ArrayBufferResult() {
-  ASSERT(read_type_ == kReadAsArrayBuffer);
+  DCHECK_EQ(read_type_, kReadAsArrayBuffer);
 
   // If the loading is not started or an error occurs, return an empty result.
   if (!raw_data_ || error_code_)
     return nullptr;
 
   if (array_buffer_result_)
     return array_buffer_result_;
 
   DOMArrayBuffer* result = DOMArrayBuffer::Create(raw_data_->ToArrayBuffer());
   if (finished_loading_) {
     array_buffer_result_ = result;
   }
   return result;
 }
 
 String FileReaderLoader::StringResult() {
-  ASSERT(read_type_ != kReadAsArrayBuffer && read_type_ != kReadByClient);
+  DCHECK(read_type_ != kReadAsArrayBuffer && read_type_ != kReadByClient);

[tkent, 2017/04/09 23:00:20]

Split this into two.
DCHECK_NE(read_type_, kReadAsArrayBuffer);
DCHECK_NE(read_type_, kReadByClient);

[Hwanseung Lee, 2017/04/10 15:01:32]

Done.

 
   // If the loading is not started or an error occurs, return an empty result.
   if (!raw_data_ || error_code_)
     return string_result_;
 
   // If already converted from the raw data, return the result now.
   if (is_raw_data_converted_)
     return string_result_;
 
   switch (read_type_) {
     case kReadAsArrayBuffer:
       // No conversion is needed.
       break;
     case kReadAsBinaryString:
       string_result_ = raw_data_->ToString();
       is_raw_data_converted_ = true;
       break;
     case kReadAsText:
       ConvertToText();
       break;
     case kReadAsDataURL:
       // Partial data is not supported when reading as data URL.
       if (finished_loading_)
         ConvertToDataURL();
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 
   return string_result_;
 }
 
 void FileReaderLoader::ConvertToText() {
   is_raw_data_converted_ = true;
 
   if (!bytes_loaded_) {
     string_result_ = "";
@@ skipping 41 matching lines @@
 
   string_result_ = builder.ToString();
 }
 
 void FileReaderLoader::SetEncoding(const String& encoding) {
   if (!encoding.IsEmpty())
     encoding_ = WTF::TextEncoding(encoding);
 }
 
 }  // namespace blink