Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in modules/webdatabase

third_party/WebKit/Source/modules/webdatabase/SQLTransaction.cpp

 /*
  * Copyright (C) 2007, 2008, 2013 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
@@ skipping 53 matching lines @@
                                VoidCallback* success_callback,
                                SQLTransactionErrorCallback* error_callback,
                                bool read_only)
     : database_(db),
       callback_(callback),
       success_callback_(success_callback),
       error_callback_(error_callback),
       execute_sql_allowed_(false),
       read_only_(read_only) {
   DCHECK(IsMainThread());
-  ASSERT(database_);
+  DCHECK(database_);
   probe::AsyncTaskScheduled(db->GetExecutionContext(), "SQLTransaction", this);
 }
 
 SQLTransaction::~SQLTransaction() {}
 
 DEFINE_TRACE(SQLTransaction) {
   visitor->Trace(database_);
   visitor->Trace(backend_);
   visitor->Trace(callback_);
   visitor->Trace(success_callback_);
   visitor->Trace(error_callback_);
 }
 
 bool SQLTransaction::HasCallback() const {
   return callback_;
 }
 
 bool SQLTransaction::HasSuccessCallback() const {
   return success_callback_;
 }
 
 bool SQLTransaction::HasErrorCallback() const {
   return error_callback_;
 }
 
 void SQLTransaction::SetBackend(SQLTransactionBackend* backend) {
-  ASSERT(!backend_);
+  DCHECK(!backend_);
   backend_ = backend;
 }
 
 SQLTransaction::StateFunction SQLTransaction::StateFunctionFor(
     SQLTransactionState state) {
   static const StateFunction kStateFunctions[] = {
       &SQLTransaction::UnreachableState,    // 0. illegal
       &SQLTransaction::UnreachableState,    // 1. idle
       &SQLTransaction::UnreachableState,    // 2. acquireLock
       &SQLTransaction::UnreachableState,    // 3. openTransactionAndPreflight
       &SQLTransaction::SendToBackendState,  // 4. runStatements
       &SQLTransaction::UnreachableState,    // 5. postflightAndCommit
       &SQLTransaction::SendToBackendState,  // 6. cleanupAndTerminate
       &SQLTransaction::
           SendToBackendState,  // 7. cleanupAfterTransactionErrorCallback
       &SQLTransaction::DeliverTransactionCallback,       // 8.
       &SQLTransaction::DeliverTransactionErrorCallback,  // 9.
       &SQLTransaction::DeliverStatementCallback,         // 10.
       &SQLTransaction::DeliverQuotaIncreaseCallback,     // 11.
       &SQLTransaction::DeliverSuccessCallback            // 12.
   };
 
-  ASSERT(WTF_ARRAY_LENGTH(kStateFunctions) ==
+  DCHECK(WTF_ARRAY_LENGTH(kStateFunctions) ==
          static_cast<int>(SQLTransactionState::kNumberOfStates));
-  ASSERT(state < SQLTransactionState::kNumberOfStates);
+  DCHECK(state < SQLTransactionState::kNumberOfStates);
 
   return kStateFunctions[static_cast<int>(state)];
 }
 
 // requestTransitToState() can be called from the backend. Hence, it should
 // NOT be modifying SQLTransactionBackend in general. The only safe field to
 // modify is m_requestedState which is meant for this purpose.
 void SQLTransaction::RequestTransitToState(SQLTransactionState next_state) {
 #if DCHECK_IS_ON()
   STORAGE_DVLOG(1) << "Scheduling " << NameForSQLTransactionState(next_state)
                    << " for transaction " << this;
 #endif
   requested_state_ = next_state;
   database_->ScheduleTransactionCallback(this);
 }
 
 SQLTransactionState SQLTransaction::NextStateForTransactionError() {
-  ASSERT(transaction_error_);
+  DCHECK(transaction_error_);
   if (HasErrorCallback())
     return SQLTransactionState::kDeliverTransactionErrorCallback;
 
   // No error callback, so fast-forward to:
   // Transaction Step 11 - Rollback the transaction.
   return SQLTransactionState::kCleanupAfterTransactionErrorCallback;
 }
 
 SQLTransactionState SQLTransaction::DeliverTransactionCallback() {
   bool should_deliver_error_callback = false;
@@ skipping 26 matching lines @@
   probe::AsyncTask async_task(database_->GetExecutionContext(), this);
 
   // Spec 4.3.2.10: If exists, invoke error callback with the last
   // error to have occurred in this transaction.
   if (SQLTransactionErrorCallback* error_callback = error_callback_.Release()) {
     // If we get here with an empty m_transactionError, then the backend
     // must be waiting in the idle state waiting for this state to finish.
     // Hence, it's thread safe to fetch the backend transactionError without
     // a lock.
     if (!transaction_error_) {
-      ASSERT(backend_->TransactionError());
+      DCHECK(backend_->TransactionError());
       transaction_error_ = SQLErrorData::Create(*backend_->TransactionError());
     }
-    ASSERT(transaction_error_);
+    DCHECK(transaction_error_);
     error_callback->handleEvent(SQLError::Create(*transaction_error_));
 
     transaction_error_ = nullptr;
   }
 
   ClearCallbacks();
 
   // Spec 4.3.2.10: Rollback the transaction.
   return SQLTransactionState::kCleanupAfterTransactionErrorCallback;
 }
 
 SQLTransactionState SQLTransaction::DeliverStatementCallback() {
   DCHECK(IsMainThread());
   // Spec 4.3.2.6.6 and 4.3.2.6.3: If the statement callback went wrong, jump to
   // the transaction error callback.  Otherwise, continue to loop through the
   // statement queue.
   execute_sql_allowed_ = true;
 
   SQLStatement* current_statement = backend_->CurrentStatement();
-  ASSERT(current_statement);
+  DCHECK(current_statement);
 
   bool result = current_statement->PerformCallback(this);
 
   execute_sql_allowed_ = false;
 
   if (result) {
     database_->ReportCommitTransactionResult(2, SQLError::kUnknownErr, 0);
     transaction_error_ =
         SQLErrorData::Create(SQLError::kUnknownErr,
                              "the statement callback raised an exception or "
                              "statement error callback did not return false");
     return NextStateForTransactionError();
   }
   return SQLTransactionState::kRunStatements;
 }
 
 SQLTransactionState SQLTransaction::DeliverQuotaIncreaseCallback() {
   DCHECK(IsMainThread());
-  ASSERT(backend_->CurrentStatement());
+  DCHECK(backend_->CurrentStatement());
 
   bool should_retry_current_statement =
       database_->TransactionClient()->DidExceedQuota(GetDatabase());
   backend_->SetShouldRetryCurrentStatement(should_retry_current_statement);
 
   return SQLTransactionState::kRunStatements;
 }
 
 SQLTransactionState SQLTransaction::DeliverSuccessCallback() {
   DCHECK(IsMainThread());
   probe::AsyncTask async_task(database_->GetExecutionContext(), this);
 
   // Spec 4.3.2.8: Deliver success callback.
   if (VoidCallback* success_callback = success_callback_.Release())
     success_callback->handleEvent();
 
   ClearCallbacks();
 
   // Schedule a "post-success callback" step to return control to the database
   // thread in case there are further transactions queued up for this Database.
   return SQLTransactionState::kCleanupAndTerminate;
 }
 
 // This state function is used as a stub function to plug unimplemented states
 // in the state dispatch table. They are unimplemented because they should
 // never be reached in the course of correct execution.
 SQLTransactionState SQLTransaction::UnreachableState() {
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return SQLTransactionState::kEnd;
 }
 
 SQLTransactionState SQLTransaction::SendToBackendState() {
-  ASSERT(next_state_ != SQLTransactionState::kIdle);
+  DCHECK_NE(next_state_, SQLTransactionState::kIdle);
   backend_->RequestTransitToState(next_state_);
   return SQLTransactionState::kIdle;
 }
 
 void SQLTransaction::PerformPendingCallback() {
   DCHECK(IsMainThread());
   ComputeNextStateAndCleanupIfNeeded();
   RunStateMachine();
 }
 
@@ skipping 45 matching lines @@
         arguments.Get(), script_state->GetIsolate(), exception_state);
   ExecuteSQL(sql_statement, sql_values, callback, callback_error,
              exception_state);
 }
 
 bool SQLTransaction::ComputeNextStateAndCleanupIfNeeded() {
   // Only honor the requested state transition if we're not supposed to be
   // cleaning up and shutting down:
   if (database_->Opened()) {
     SetStateToRequestedState();
-    ASSERT(next_state_ == SQLTransactionState::kEnd ||
+    DCHECK(next_state_ == SQLTransactionState::kEnd ||
            next_state_ == SQLTransactionState::kDeliverTransactionCallback ||
            next_state_ ==
                SQLTransactionState::kDeliverTransactionErrorCallback ||
            next_state_ == SQLTransactionState::kDeliverStatementCallback ||
            next_state_ == SQLTransactionState::kDeliverQuotaIncreaseCallback ||
            next_state_ == SQLTransactionState::kDeliverSuccessCallback);
 #if DCHECK_IS_ON()
     STORAGE_DVLOG(1) << "Callback " << NameForSQLTransactionState(next_state_);
 #endif
     return false;
   }
 
   ClearCallbacks();
   next_state_ = SQLTransactionState::kCleanupAndTerminate;
 
   return true;
 }
 
 void SQLTransaction::ClearCallbacks() {
   callback_.Clear();
   success_callback_.Clear();
   error_callback_.Clear();
 }
 
 SQLTransactionErrorCallback* SQLTransaction::ReleaseErrorCallback() {
   return error_callback_.Release();
 }
 
 }  // namespace blink