Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in modules/webdatabase

third_party/WebKit/Source/modules/webdatabase/DatabaseThread.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 32 matching lines @@
 namespace blink {
 
 DatabaseThread::DatabaseThread()
     : transaction_client_(WTF::MakeUnique<SQLTransactionClient>()),
       cleanup_sync_(nullptr),
       termination_requested_(false) {
   DCHECK(IsMainThread());
 }
 
 DatabaseThread::~DatabaseThread() {
-  ASSERT(open_database_set_.IsEmpty());
-  ASSERT(!thread_);
+  DCHECK(open_database_set_.IsEmpty());
+  DCHECK(!thread_);
 }
 
 DEFINE_TRACE(DatabaseThread) {}
 
 void DatabaseThread::Start() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   if (thread_)
     return;
   thread_ = WebThreadSupportingGC::Create("WebCore: Database");
   thread_->PostTask(BLINK_FROM_HERE,
                     CrossThreadBind(&DatabaseThread::SetupDatabaseThread,
                                     WrapCrossThreadPersistent(this)));
 }
 
 void DatabaseThread::SetupDatabaseThread() {
   thread_->Initialize();
   transaction_coordinator_ = new SQLTransactionCoordinator();
 }
 
 void DatabaseThread::Terminate() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   WaitableEvent sync;
   {
     MutexLocker lock(termination_requested_mutex_);
-    ASSERT(!termination_requested_);
+    DCHECK(!termination_requested_);
     termination_requested_ = true;
     cleanup_sync_ = &sync;
     STORAGE_DVLOG(1) << "DatabaseThread " << this << " was asked to terminate";
     thread_->PostTask(BLINK_FROM_HERE,
                       CrossThreadBind(&DatabaseThread::CleanupDatabaseThread,
                                       WrapCrossThreadPersistent(this)));
   }
   sync.Wait();
   // The WebThread destructor blocks until all the tasks of the database
   // thread are processed. However, it shouldn't block at all because
@@ skipping 31 matching lines @@
                               WrapCrossThreadPersistent(this)));
 }
 
 void DatabaseThread::CleanupDatabaseThreadCompleted() {
   thread_->Shutdown();
   if (cleanup_sync_)  // Someone wanted to know when we were done cleaning up.
     cleanup_sync_->Signal();
 }
 
 void DatabaseThread::RecordDatabaseOpen(Database* database) {
-  ASSERT(IsDatabaseThread());
-  ASSERT(database);
-  ASSERT(!open_database_set_.Contains(database));
+  DCHECK(IsDatabaseThread());
+  DCHECK(database);
+  DCHECK(!open_database_set_.Contains(database));
   MutexLocker lock(termination_requested_mutex_);
   if (!termination_requested_)
     open_database_set_.insert(database);
 }
 
 void DatabaseThread::RecordDatabaseClosed(Database* database) {
-  ASSERT(IsDatabaseThread());
-  ASSERT(database);
+  DCHECK(IsDatabaseThread());
+  DCHECK(database);
 #if DCHECK_IS_ON()
   {
     MutexLocker lock(termination_requested_mutex_);
-    ASSERT(termination_requested_ || open_database_set_.Contains(database));
+    DCHECK(termination_requested_ || open_database_set_.Contains(database));
   }
 #endif
   open_database_set_.erase(database);
 }
 
 bool DatabaseThread::IsDatabaseOpen(Database* database) {
-  ASSERT(IsDatabaseThread());
-  ASSERT(database);
+  DCHECK(IsDatabaseThread());
+  DCHECK(database);
   MutexLocker lock(termination_requested_mutex_);
   return !termination_requested_ && open_database_set_.Contains(database);
 }
 
 bool DatabaseThread::IsDatabaseThread() const {
   // This function is called only from the main thread or the database
   // thread. If we are not in the main thread, we are in the database thread.
   return !IsMainThread();
 }
 
 void DatabaseThread::ScheduleTask(std::unique_ptr<DatabaseTask> task) {
-  ASSERT(thread_);
+  DCHECK(thread_);
 #if DCHECK_IS_ON()
   {
     MutexLocker lock(termination_requested_mutex_);
-    ASSERT(!termination_requested_);
+    DCHECK(!termination_requested_);
   }
 #endif
   // WebThread takes ownership of the task.
   thread_->PostTask(BLINK_FROM_HERE,
                     CrossThreadBind(&DatabaseTask::Run, std::move(task)));
 }
 
 }  // namespace blink