Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in modules/webdatabase

third_party/WebKit/Source/modules/webdatabase/SQLTransactionBackend.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 371 matching lines @@
       wrapper_(wrapper),
       has_callback_(frontend_->HasCallback()),
       has_success_callback_(frontend_->HasSuccessCallback()),
       has_error_callback_(frontend_->HasErrorCallback()),
       should_retry_current_statement_(false),
       modified_database_(false),
       lock_acquired_(false),
       read_only_(read_only),
       has_version_mismatch_(false) {
   DCHECK(IsMainThread());
-  ASSERT(database_);
+  DCHECK(database_);
   frontend_->SetBackend(this);
   requested_state_ = SQLTransactionState::kAcquireLock;
 }
 
 SQLTransactionBackend::~SQLTransactionBackend() {
-  ASSERT(!sqlite_transaction_);
+  DCHECK(!sqlite_transaction_);
 }
 
 DEFINE_TRACE(SQLTransactionBackend) {
   visitor->Trace(database_);
   visitor->Trace(wrapper_);
 }
 
 void SQLTransactionBackend::DoCleanup() {
   if (!frontend_)
     return;
   // Break the reference cycle. See comment about the life-cycle above.
   frontend_ = nullptr;
 
-  ASSERT(GetDatabase()
+  DCHECK(GetDatabase()
              ->GetDatabaseContext()
              ->GetDatabaseThread()
              ->IsDatabaseThread());
 
   MutexLocker locker(statement_mutex_);
   statement_queue_.Clear();
 
   if (sqlite_transaction_) {
     // In the event we got here because of an interruption or error (i.e. if
     // the transaction is in progress), we should roll it back here. Clearing
@@ skipping 35 matching lines @@
 
 SQLStatement* SQLTransactionBackend::CurrentStatement() {
   return current_statement_backend_->GetFrontend();
 }
 
 SQLErrorData* SQLTransactionBackend::TransactionError() {
   return transaction_error_.get();
 }
 
 void SQLTransactionBackend::SetShouldRetryCurrentStatement(bool should_retry) {
-  ASSERT(!should_retry_current_statement_);
+  DCHECK(!should_retry_current_statement_);
   should_retry_current_statement_ = should_retry;
 }
 
 SQLTransactionBackend::StateFunction SQLTransactionBackend::StateFunctionFor(
     SQLTransactionState state) {
   static const StateFunction kStateFunctions[] = {
       &SQLTransactionBackend::UnreachableState,                      // 0. end
       &SQLTransactionBackend::UnreachableState,                      // 1. idle
       &SQLTransactionBackend::AcquireLock,                           // 2.
       &SQLTransactionBackend::OpenTransactionAndPreflight,           // 3.
       &SQLTransactionBackend::RunStatements,                         // 4.
       &SQLTransactionBackend::PostflightAndCommit,                   // 5.
       &SQLTransactionBackend::CleanupAndTerminate,                   // 6.
       &SQLTransactionBackend::CleanupAfterTransactionErrorCallback,  // 7.
       // 8. deliverTransactionCallback
       &SQLTransactionBackend::SendToFrontendState,
       // 9. deliverTransactionErrorCallback
       &SQLTransactionBackend::SendToFrontendState,
       // 10.  deliverStatementCallback
       &SQLTransactionBackend::SendToFrontendState,
       // 11. deliverQuotaIncreaseCallback
       &SQLTransactionBackend::SendToFrontendState,
       // 12. deliverSuccessCallback
       &SQLTransactionBackend::SendToFrontendState,
   };
 
-  ASSERT(WTF_ARRAY_LENGTH(kStateFunctions) ==
+  DCHECK(WTF_ARRAY_LENGTH(kStateFunctions) ==
          static_cast<int>(SQLTransactionState::kNumberOfStates));
-  ASSERT(state < SQLTransactionState::kNumberOfStates);
+  DCHECK_LT(state, SQLTransactionState::kNumberOfStates);
 
   return kStateFunctions[static_cast<int>(state)];
 }
 
 void SQLTransactionBackend::EnqueueStatementBackend(
     SQLStatementBackend* statement_backend) {
   DCHECK(IsMainThread());
   MutexLocker locker(statement_mutex_);
   statement_queue_.push_back(statement_backend);
 }
 
 void SQLTransactionBackend::ComputeNextStateAndCleanupIfNeeded() {
   DCHECK(GetDatabase()
              ->GetDatabaseContext()
              ->GetDatabaseThread()
              ->IsDatabaseThread());
   // 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::kAcquireLock ||
+    DCHECK(next_state_ == SQLTransactionState::kAcquireLock ||
            next_state_ == SQLTransactionState::kOpenTransactionAndPreflight ||
            next_state_ == SQLTransactionState::kRunStatements ||
            next_state_ == SQLTransactionState::kPostflightAndCommit ||
            next_state_ == SQLTransactionState::kCleanupAndTerminate ||
            next_state_ ==
                SQLTransactionState::kCleanupAfterTransactionErrorCallback);
 #if DCHECK_IS_ON()
     STORAGE_DVLOG(1) << "State " << NameForSQLTransactionState(next_state_);
 #endif
     return;
@@ skipping 31 matching lines @@
 void SQLTransactionBackend::ExecuteSQL(SQLStatement* statement,
                                        const String& sql_statement,
                                        const Vector<SQLValue>& arguments,
                                        int permissions) {
   DCHECK(IsMainThread());
   EnqueueStatementBackend(SQLStatementBackend::Create(statement, sql_statement,
                                                       arguments, permissions));
 }
 
 void SQLTransactionBackend::NotifyDatabaseThreadIsShuttingDown() {
-  ASSERT(GetDatabase()
+  DCHECK(GetDatabase()
              ->GetDatabaseContext()
              ->GetDatabaseThread()
              ->IsDatabaseThread());
 
   // If the transaction is in progress, we should roll it back here, since this
   // is our last opportunity to do something related to this transaction on the
   // DB thread. Amongst other work, doCleanup() will clear m_sqliteTransaction
   // which invokes SQLiteTransaction's destructor, which will do the roll back
   // if necessary.
   DoCleanup();
 }
 
 SQLTransactionState SQLTransactionBackend::AcquireLock() {
   database_->TransactionCoordinator()->AcquireLock(this);
   return SQLTransactionState::kIdle;
 }
 
 void SQLTransactionBackend::LockAcquired() {
   lock_acquired_ = true;
   RequestTransitToState(SQLTransactionState::kOpenTransactionAndPreflight);
 }
 
 SQLTransactionState SQLTransactionBackend::OpenTransactionAndPreflight() {
   DCHECK(GetDatabase()
              ->GetDatabaseContext()
              ->GetDatabaseThread()
              ->IsDatabaseThread());
-  ASSERT(!database_->SqliteDatabase().TransactionInProgress());
-  ASSERT(lock_acquired_);
+  DCHECK(!database_->SqliteDatabase().TransactionInProgress());
+  DCHECK(lock_acquired_);
 
   STORAGE_DVLOG(1) << "Opening and preflighting transaction " << this;
 
   // Set the maximum usage for this transaction if this transactions is not
   // read-only.
   if (!read_only_)
     database_->SqliteDatabase().SetMaximumSize(database_->MaximumSize());
 
-  ASSERT(!sqlite_transaction_);
+  DCHECK(!sqlite_transaction_);
   sqlite_transaction_ = WTF::WrapUnique(
       new SQLiteTransaction(database_->SqliteDatabase(), read_only_));
 
   database_->ResetDeletes();
   database_->DisableAuthorizer();
   sqlite_transaction_->begin();
   database_->EnableAuthorizer();
 
   // Spec 4.3.2.1+2: Open a transaction to the database, jumping to the error
   // callback if that fails.
   if (!sqlite_transaction_->InProgress()) {
-    ASSERT(!database_->SqliteDatabase().TransactionInProgress());
+    DCHECK(!database_->SqliteDatabase().TransactionInProgress());
     database_->ReportStartTransactionResult(
         2, SQLError::kDatabaseErr, database_->SqliteDatabase().LastError());
     transaction_error_ = SQLErrorData::Create(
         SQLError::kDatabaseErr, "unable to begin transaction",
         database_->SqliteDatabase().LastError(),
         database_->SqliteDatabase().LastErrorMsg());
     sqlite_transaction_.reset();
     return NextStateForTransactionError();
   }
 
@@ skipping 41 matching lines @@
 
   // If we have no callback to make, skip pass to the state after:
   return SQLTransactionState::kRunStatements;
 }
 
 SQLTransactionState SQLTransactionBackend::RunStatements() {
   DCHECK(GetDatabase()
              ->GetDatabaseContext()
              ->GetDatabaseThread()
              ->IsDatabaseThread());
-  ASSERT(lock_acquired_);
+  DCHECK(lock_acquired_);
   SQLTransactionState next_state;
 
   // If there is a series of statements queued up that are all successful and
   // have no associated SQLStatementCallback objects, then we can burn through
   // the queue.
   do {
     if (should_retry_current_statement_ &&
         !sqlite_transaction_->WasRolledBackBySqlite()) {
       should_retry_current_statement_ = false;
       // FIXME - Another place that needs fixing up after
@@ skipping 84 matching lines @@
         SQLErrorData::Create(*current_statement_backend_->SqlError());
   } else {
     database_->ReportCommitTransactionResult(1, SQLError::kDatabaseErr, 0);
     transaction_error_ = SQLErrorData::Create(
         SQLError::kDatabaseErr, "the statement failed to execute");
   }
   return NextStateForTransactionError();
 }
 
 SQLTransactionState SQLTransactionBackend::PostflightAndCommit() {
-  ASSERT(lock_acquired_);
+  DCHECK(lock_acquired_);
 
   // Spec 4.3.2.7: Perform postflight steps, jumping to the error callback if
   // they fail.
   if (wrapper_ && !wrapper_->PerformPostflight(this)) {
     if (wrapper_->SqlError()) {
       transaction_error_ = SQLErrorData::Create(*wrapper_->SqlError());
     } else {
       database_->ReportCommitTransactionResult(3, SQLError::kUnknownErr, 0);
       transaction_error_ = SQLErrorData::Create(
           SQLError::kUnknownErr,
           "unknown error occurred during transaction postflight");
     }
     return NextStateForTransactionError();
   }
 
   // Spec 4.3.2.7: Commit the transaction, jumping to the error callback if that
   // fails.
-  ASSERT(sqlite_transaction_);
+  DCHECK(sqlite_transaction_);
 
   database_->DisableAuthorizer();
   sqlite_transaction_->Commit();
   database_->EnableAuthorizer();
 
   // If the commit failed, the transaction will still be marked as "in progress"
   if (sqlite_transaction_->InProgress()) {
     if (wrapper_)
       wrapper_->HandleCommitFailedAfterPostflight(this);
     database_->ReportCommitTransactionResult(
@@ skipping 14 matching lines @@
   // The commit was successful. If the transaction modified this database,
   // notify the delegates.
   if (modified_database_)
     database_->TransactionClient()->DidCommitWriteTransaction(GetDatabase());
 
   // Spec 4.3.2.8: Deliver success callback, if there is one.
   return SQLTransactionState::kDeliverSuccessCallback;
 }
 
 SQLTransactionState SQLTransactionBackend::CleanupAndTerminate() {
-  ASSERT(lock_acquired_);
+  DCHECK(lock_acquired_);
 
   // Spec 4.3.2.9: End transaction steps. There is no next step.
   STORAGE_DVLOG(1) << "Transaction " << this << " is complete";
-  ASSERT(!database_->SqliteDatabase().TransactionInProgress());
+  DCHECK(!database_->SqliteDatabase().TransactionInProgress());
 
   // Phase 5 cleanup. See comment on the SQLTransaction life-cycle above.
   DoCleanup();
   database_->InProgressTransactionCompleted();
   return SQLTransactionState::kEnd;
 }
 
 SQLTransactionState SQLTransactionBackend::NextStateForTransactionError() {
-  ASSERT(transaction_error_);
+  DCHECK(transaction_error_);
   if (has_error_callback_)
     return SQLTransactionState::kDeliverTransactionErrorCallback;
 
   // No error callback, so fast-forward to the next state and rollback the
   // transaction.
   return SQLTransactionState::kCleanupAfterTransactionErrorCallback;
 }
 
 SQLTransactionState
 SQLTransactionBackend::CleanupAfterTransactionErrorCallback() {
-  ASSERT(lock_acquired_);
+  DCHECK(lock_acquired_);
 
   STORAGE_DVLOG(1) << "Transaction " << this << " is complete with an error";
   database_->DisableAuthorizer();
   if (sqlite_transaction_) {
     // Spec 4.3.2.10: Rollback the transaction.
     sqlite_transaction_->Rollback();
 
-    ASSERT(!database_->SqliteDatabase().TransactionInProgress());
+    DCHECK(!database_->SqliteDatabase().TransactionInProgress());
     sqlite_transaction_.reset();
   }
   database_->EnableAuthorizer();
 
-  ASSERT(!database_->SqliteDatabase().TransactionInProgress());
+  DCHECK(!database_->SqliteDatabase().TransactionInProgress());
 
   return SQLTransactionState::kCleanupAndTerminate;
 }
 
 // requestTransitToState() can be called from the frontend. 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 SQLTransactionBackend::RequestTransitToState(
     SQLTransactionState next_state) {
 #if DCHECK_IS_ON()
   STORAGE_DVLOG(1) << "Scheduling " << NameForSQLTransactionState(next_state)
                    << " for transaction " << this;
 #endif
   requested_state_ = next_state;
-  ASSERT(requested_state_ != SQLTransactionState::kEnd);
+  DCHECK_NE(requested_state_, SQLTransactionState::kEnd);
   database_->ScheduleTransactionStep(this);
 }
 
 // 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 SQLTransactionBackend::UnreachableState() {
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return SQLTransactionState::kEnd;
 }
 
 SQLTransactionState SQLTransactionBackend::SendToFrontendState() {
-  ASSERT(next_state_ != SQLTransactionState::kIdle);
+  DCHECK_NE(next_state_, SQLTransactionState::kIdle);
   frontend_->RequestTransitToState(next_state_);
   return SQLTransactionState::kIdle;
 }
 
 }  // namespace blink