Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/fileapi

third_party/WebKit/Source/core/fileapi/FileReader.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 114 matching lines @@
 
  private:
   explicit ThrottlingController(ExecutionContext& context)
       : Supplement<ExecutionContext>(context),
         max_running_readers_(kMaxOutstandingRequestsPerThread) {}
 
   void PushReader(FileReader* reader) {
     if (pending_readers_.IsEmpty() &&
         running_readers_.size() < max_running_readers_) {
       reader->ExecutePendingRead();
-      ASSERT(!running_readers_.Contains(reader));
+      DCHECK(!running_readers_.Contains(reader));
       running_readers_.insert(reader);
       return;
     }
     pending_readers_.push_back(reader);
     ExecuteReaders();
   }
 
   FinishReaderType RemoveReader(FileReader* reader) {
     FileReaderHashSet::const_iterator hash_iter = running_readers_.Find(reader);
     if (hash_iter != running_readers_.end()) {
@@ skipping 71 matching lines @@
   }
   Terminate();
 }
 
 bool FileReader::HasPendingActivity() const {
   return state_ == kLoading || still_firing_events_;
 }
 
 void FileReader::readAsArrayBuffer(Blob* blob,
                                    ExceptionState& exception_state) {
-  ASSERT(blob);
+  DCHECK(blob);
   DVLOG(1) << "reading as array buffer: " << Utf8BlobUUID(blob).Data() << " "
            << Utf8FilePath(blob).Data();
 
   ReadInternal(blob, FileReaderLoader::kReadAsArrayBuffer, exception_state);
 }
 
 void FileReader::readAsBinaryString(Blob* blob,
                                     ExceptionState& exception_state) {
-  ASSERT(blob);
+  DCHECK(blob);
   DVLOG(1) << "reading as binary: " << Utf8BlobUUID(blob).Data() << " "
            << Utf8FilePath(blob).Data();
 
   ReadInternal(blob, FileReaderLoader::kReadAsBinaryString, exception_state);
 }
 
 void FileReader::readAsText(Blob* blob,
                             const String& encoding,
                             ExceptionState& exception_state) {
-  ASSERT(blob);
+  DCHECK(blob);
   DVLOG(1) << "reading as text: " << Utf8BlobUUID(blob).Data() << " "
            << Utf8FilePath(blob).Data();
 
   encoding_ = encoding;
   ReadInternal(blob, FileReaderLoader::kReadAsText, exception_state);
 }
 
 void FileReader::readAsText(Blob* blob, ExceptionState& exception_state) {
   readAsText(blob, String(), exception_state);
 }
 
 void FileReader::readAsDataURL(Blob* blob, ExceptionState& exception_state) {
-  ASSERT(blob);
+  DCHECK(blob);
   DVLOG(1) << "reading as data URL: " << Utf8BlobUUID(blob).Data() << " "
            << Utf8FilePath(blob).Data();
 
   ReadInternal(blob, FileReaderLoader::kReadAsDataURL, exception_state);
 }
 
 void FileReader::ReadInternal(Blob* blob,
                               FileReaderLoader::ReadType type,
                               ExceptionState& exception_state) {
   // If multiple concurrent read methods are called on the same FileReader,
@@ skipping 29 matching lines @@
 
   // "Snapshot" the Blob data rather than the Blob itself as ongoing
   // read operations should not be affected if close() is called on
   // the Blob being read.
   blob_data_handle_ = blob->GetBlobDataHandle();
   blob_type_ = blob->type();
   read_type_ = type;
   state_ = kLoading;
   loading_state_ = kLoadingStatePending;
   error_ = nullptr;
-  ASSERT(ThrottlingController::From(context));
+  DCHECK(ThrottlingController::From(context));
   ThrottlingController::PushReader(context, this);
 }
 
 void FileReader::ExecutePendingRead() {
-  ASSERT(loading_state_ == kLoadingStatePending);
+  DCHECK_EQ(loading_state_, kLoadingStatePending);
   loading_state_ = kLoadingStateLoading;
 
   loader_ = FileReaderLoader::Create(read_type_, this);
   loader_->SetEncoding(encoding_);
   loader_->SetDataType(blob_type_);
   loader_->Start(GetExecutionContext(), blob_data_handle_);
   blob_data_handle_ = nullptr;
 }
 
 void FileReader::abort() {
@@ skipping 65 matching lines @@
              kProgressNotificationIntervalMS) {
     AutoReset<bool> firing_events(&still_firing_events_, true);
     FireEvent(EventTypeNames::progress);
     last_progress_notification_time_ms_ = now;
   }
 }
 
 void FileReader::DidFinishLoading() {
   if (loading_state_ == kLoadingStateAborted)
     return;
-  ASSERT(loading_state_ == kLoadingStateLoading);
+  DCHECK_EQ(loading_state_, kLoadingStateLoading);
 
   // TODO(jochen): When we set m_state to DONE below, we still need to fire
   // the load and loadend events. To avoid GC to collect this FileReader, we
   // use this separate variable to keep the wrapper of this FileReader alive.
   // An alternative would be to keep any ActiveScriptWrappables alive that is on
   // the stack.
   AutoReset<bool> firing_events(&still_firing_events_, true);
 
   // It's important that we change m_loadingState before firing any events
   // since any of the events could call abort(), which internally checks
@@ skipping 56 matching lines @@
         ProgressEvent::Create(type, false, loader_->BytesLoaded(), 0));
 }
 
 DEFINE_TRACE(FileReader) {
   visitor->Trace(error_);
   EventTargetWithInlineData::Trace(visitor);
   ContextLifecycleObserver::Trace(visitor);
 }
 
 }  // namespace blink