Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in modules/filesystem

third_party/WebKit/Source/modules/filesystem/FileWriter.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 42 matching lines @@
       operation_in_progress_(kOperationNone),
       queued_operation_(kOperationNone),
       bytes_written_(0),
       bytes_to_write_(0),
       truncate_length_(-1),
       num_aborts_(0),
       recursion_depth_(0),
       last_progress_notification_time_ms_(0) {}
 
 FileWriter::~FileWriter() {
-  ASSERT(!recursion_depth_);
+  DCHECK(!recursion_depth_);
   DCHECK(!Writer());
 }
 
 const AtomicString& FileWriter::InterfaceName() const {
   return EventTargetNames::FileWriter;
 }
 
 void FileWriter::ContextDestroyed(ExecutionContext*) {
   Dispose();
 }
 
 bool FileWriter::HasPendingActivity() const {
   return operation_in_progress_ != kOperationNone ||
          queued_operation_ != kOperationNone || ready_state_ == kWriting;
 }
 
 void FileWriter::write(Blob* data, ExceptionState& exception_state) {
   if (!GetExecutionContext())
     return;
-  ASSERT(data);
-  ASSERT(Writer());
-  ASSERT(truncate_length_ == -1);
+  DCHECK(data);
+  DCHECK(Writer());
+  DCHECK_EQ(truncate_length_, -1);
   if (ready_state_ == kWriting) {
     SetError(FileError::kInvalidStateErr, exception_state);
     return;
   }
   if (recursion_depth_ > kMaxRecursionDepth) {
     SetError(FileError::kSecurityErr, exception_state);
     return;
   }
 
   blob_being_written_ = data;
   ready_state_ = kWriting;
   bytes_written_ = 0;
   bytes_to_write_ = data->size();
-  ASSERT(queued_operation_ == kOperationNone);
+  DCHECK_EQ(queued_operation_, kOperationNone);
   if (operation_in_progress_ != kOperationNone) {
     // We must be waiting for an abort to complete, since m_readyState wasn't
     // kWriting.
-    ASSERT(operation_in_progress_ == kOperationAbort);
+    DCHECK_EQ(operation_in_progress_, kOperationAbort);
     queued_operation_ = kOperationWrite;
   } else
     DoOperation(kOperationWrite);
 
   FireEvent(EventTypeNames::writestart);
 }
 
 void FileWriter::seek(long long position, ExceptionState& exception_state) {
   if (!GetExecutionContext())
     return;
-  ASSERT(Writer());
+  DCHECK(Writer());
   if (ready_state_ == kWriting) {
     SetError(FileError::kInvalidStateErr, exception_state);
     return;
   }
 
-  ASSERT(truncate_length_ == -1);
-  ASSERT(queued_operation_ == kOperationNone);
+  DCHECK_EQ(truncate_length_, -1);
+  DCHECK_EQ(queued_operation_, kOperationNone);
   SeekInternal(position);
 }
 
 void FileWriter::truncate(long long position, ExceptionState& exception_state) {
   if (!GetExecutionContext())
     return;
-  ASSERT(Writer());
-  ASSERT(truncate_length_ == -1);
+  DCHECK(Writer());
+  DCHECK_EQ(truncate_length_, -1);
   if (ready_state_ == kWriting || position < 0) {
     SetError(FileError::kInvalidStateErr, exception_state);
     return;
   }
   if (recursion_depth_ > kMaxRecursionDepth) {
     SetError(FileError::kSecurityErr, exception_state);
     return;
   }
 
   ready_state_ = kWriting;
   bytes_written_ = 0;
   bytes_to_write_ = 0;
   truncate_length_ = position;
-  ASSERT(queued_operation_ == kOperationNone);
+  DCHECK_EQ(queued_operation_, kOperationNone);
   if (operation_in_progress_ != kOperationNone) {
     // We must be waiting for an abort to complete, since m_readyState wasn't
     // kWriting.
-    ASSERT(operation_in_progress_ == kOperationAbort);
+    DCHECK_EQ(operation_in_progress_, kOperationAbort);
     queued_operation_ = kOperationTruncate;
   } else
     DoOperation(kOperationTruncate);
   FireEvent(EventTypeNames::writestart);
 }
 
 void FileWriter::abort(ExceptionState& exception_state) {
   if (!GetExecutionContext())
     return;
-  ASSERT(Writer());
+  DCHECK(Writer());
   if (ready_state_ != kWriting)
     return;
   ++num_aborts_;
 
   DoOperation(kOperationAbort);
   SignalCompletion(FileError::kAbortErr);
 }
 
 void FileWriter::DidWrite(long long bytes, bool complete) {
   if (operation_in_progress_ == kOperationAbort) {
@@ skipping 30 matching lines @@
     if (num_aborts == num_aborts_)
       SignalCompletion(FileError::kOK);
   }
 }
 
 void FileWriter::DidTruncate() {
   if (operation_in_progress_ == kOperationAbort) {
     CompleteAbort();
     return;
   }
-  ASSERT(operation_in_progress_ == kOperationTruncate);
-  ASSERT(truncate_length_ >= 0);
+  DCHECK_EQ(operation_in_progress_, kOperationTruncate);
+  DCHECK_GE(truncate_length_, 0);
   SetLength(truncate_length_);
   if (position() > length())
     SetPosition(length());
   operation_in_progress_ = kOperationNone;
   SignalCompletion(FileError::kOK);
 }
 
 void FileWriter::DidFail(WebFileError code) {
   DCHECK_NE(kOperationNone, operation_in_progress_);
   DCHECK_NE(FileError::kOK, static_cast<FileError::ErrorCode>(code));
   if (operation_in_progress_ == kOperationAbort) {
     CompleteAbort();
     return;
   }
   DCHECK_EQ(kOperationNone, queued_operation_);
   DCHECK_EQ(kWriting, ready_state_);
   blob_being_written_.Clear();
   operation_in_progress_ = kOperationNone;
   SignalCompletion(static_cast<FileError::ErrorCode>(code));
 }
 
 void FileWriter::CompleteAbort() {
-  ASSERT(operation_in_progress_ == kOperationAbort);
+  DCHECK_EQ(operation_in_progress_, kOperationAbort);
   operation_in_progress_ = kOperationNone;
   Operation operation = queued_operation_;
   queued_operation_ = kOperationNone;
   DoOperation(operation);
 }
 
 void FileWriter::DoOperation(Operation operation) {
   probe::AsyncTaskScheduled(GetExecutionContext(), "FileWriter", this);
   switch (operation) {
     case kOperationWrite:
@@ skipping 19 matching lines @@
       if (operation_in_progress_ == kOperationWrite ||
           operation_in_progress_ == kOperationTruncate)
         Writer()->Cancel();
       else if (operation_in_progress_ != kOperationAbort)
         operation = kOperationNone;
       queued_operation_ = kOperationNone;
       blob_being_written_.Clear();
       truncate_length_ = -1;
       break;
   }
-  ASSERT(queued_operation_ == kOperationNone);
+  DCHECK_EQ(queued_operation_, kOperationNone);
   operation_in_progress_ = operation;
 }
 
 void FileWriter::SignalCompletion(FileError::ErrorCode code) {
   ready_state_ = kDone;
   truncate_length_ = -1;
   if (FileError::kOK != code) {
     error_ = FileError::CreateDOMException(code);
     if (FileError::kAbortErr == code)
       FireEvent(EventTypeNames::abort);
     else
       FireEvent(EventTypeNames::error);
   } else
     FireEvent(EventTypeNames::write);
   FireEvent(EventTypeNames::writeend);
 
   probe::AsyncTaskCanceled(GetExecutionContext(), this);
 }
 
 void FileWriter::FireEvent(const AtomicString& type) {
   probe::AsyncTask async_task(GetExecutionContext(), this);
   ++recursion_depth_;
   DispatchEvent(
       ProgressEvent::Create(type, true, bytes_written_, bytes_to_write_));
   --recursion_depth_;
-  ASSERT(recursion_depth_ >= 0);
+  DCHECK_GE(recursion_depth_, 0);
 }
 
 void FileWriter::SetError(FileError::ErrorCode error_code,
                           ExceptionState& exception_state) {
-  ASSERT(error_code);
+  DCHECK(error_code);
   FileError::ThrowDOMException(exception_state, error_code);
   error_ = FileError::CreateDOMException(error_code);
 }
 
 void FileWriter::Dispose() {
   // Make sure we've actually got something to stop, and haven't already called
   // abort().
   if (Writer() && ready_state_ == kWriting) {
     DoOperation(kOperationAbort);
     ready_state_ = kDone;
   }
   ResetWriter();
 }
 
 DEFINE_TRACE(FileWriter) {
   visitor->Trace(error_);
   visitor->Trace(blob_being_written_);
   EventTargetWithInlineData::Trace(visitor);
   FileWriterBase::Trace(visitor);
   ContextLifecycleObserver::Trace(visitor);
 }
 
 }  // namespace blink