Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in modules/webdatabase

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

 /*
  * Copyright (C) 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 74 matching lines @@
 // In the case of failure to open the database, the factory methods will
 // simply discard the newly instantiated database backend when they return.
 // The ref counting mechanims will automatically destruct the un-added
 // (and un-returned) databases instances.
 
 namespace blink {
 
 // Defines static local variable after making sure that guid lock is held.
 // (We can't use DEFINE_STATIC_LOCAL for this because it asserts thread
 // safety, which is externally guaranteed by the guideMutex lock)
+#if DCHECK_IS_ON()
 #define DEFINE_STATIC_LOCAL_WITH_LOCK(type, name, arguments) \
-  ASSERT(GuidMutex().Locked());                              \
+  DCHECK(GuidMutex().Locked());                              \
   static type& name = *new type arguments
+#else
+#define DEFINE_STATIC_LOCAL_WITH_LOCK(type, name, arguments) \
+  static type& name = *new type arguments
+#endif
 
 static const char kVersionKey[] = "WebKitDatabaseVersionKey";
 static const char kInfoTableName[] = "__WebKitDatabaseInfoTable__";
 
 static String FormatErrorMessage(const char* message,
                                  int sqlite_error_code,
                                  const char* sqlite_error_message) {
   return String::Format("%s (%d %s)", message, sqlite_error_code,
                         sqlite_error_message);
 }
@@ skipping 58 matching lines @@
 
 typedef HashMap<DatabaseGuid, String> GuidVersionMap;
 static GuidVersionMap& GuidToVersionMap() {
   DEFINE_STATIC_LOCAL_WITH_LOCK(GuidVersionMap, map, ());
   return map;
 }
 
 // NOTE: Caller must lock guidMutex().
 static inline void UpdateGuidVersionMap(DatabaseGuid guid, String new_version) {
   // Ensure the the mutex is locked.
-  ASSERT(GuidMutex().Locked());
+#if DCHECK_IS_ON()
+  DCHECK(GuidMutex().Locked());
+#endif
 
   // Note: It is not safe to put an empty string into the guidToVersionMap()
   // map. That's because the map is cross-thread, but empty strings are
   // per-thread. The copy() function makes a version of the string you can
   // use on the current thread, but we need a string we can keep in a
   // cross-thread data structure.
   // FIXME: This is a quite-awkward restriction to have to program with.
 
   // Map null string to empty string (see comment above).
   GuidToVersionMap().Set(
       guid, new_version.IsEmpty() ? String() : new_version.IsolatedCopy());
 }
 
 static HashCountedSet<DatabaseGuid>& GuidCount() {
   DEFINE_STATIC_LOCAL_WITH_LOCK(HashCountedSet<DatabaseGuid>, guid_count, ());
   return guid_count;
 }
 
 static DatabaseGuid GuidForOriginAndName(const String& origin,
                                          const String& name) {
   // Ensure the the mutex is locked.
-  ASSERT(GuidMutex().Locked());
+#if DCHECK_IS_ON()
+  DCHECK(GuidMutex().Locked());
+#endif
 
   String string_id = origin + "/" + name;
 
   typedef HashMap<String, int> IDGuidMap;
   DEFINE_STATIC_LOCAL_WITH_LOCK(IDGuidMap, string_identifier_to_guid_map, ());
   DatabaseGuid guid = string_identifier_to_guid_map.at(string_id);
   if (!guid) {
     static int current_new_guid = 1;
     guid = current_new_guid++;
     string_identifier_to_guid_map.Set(string_id, guid);
@@ skipping 30 matching lines @@
     MutexLocker locker(GuidMutex());
     guid_ = GuidForOriginAndName(GetSecurityOrigin()->ToString(), name);
     GuidCount().insert(guid_);
   }
 
   filename_ = DatabaseManager::Manager().FullPathForDatabase(
       GetSecurityOrigin(), name_);
 
   database_thread_security_origin_ =
       context_thread_security_origin_->IsolatedCopy();
-  ASSERT(database_context_->GetDatabaseThread());
-  ASSERT(database_context_->IsContextThread());
+  DCHECK(database_context_->GetDatabaseThread());
+  DCHECK(database_context_->IsContextThread());
   database_task_runner_ =
       TaskRunnerHelper::Get(TaskType::kDatabaseAccess, GetExecutionContext());
 }
 
 Database::~Database() {
   // SQLite is "multi-thread safe", but each database handle can only be used
   // on a single thread at a time.
   //
   // For Database, we open the SQLite database on the DatabaseThread, and
   // hence we should also close it on that same thread. This means that the
   // SQLite database need to be closed by another mechanism (see
   // DatabaseContext::stopDatabases()). By the time we get here, the SQLite
   // database should have already been closed.
 
-  ASSERT(!opened_);
+  DCHECK(!opened_);
 }
 
 DEFINE_TRACE(Database) {
   visitor->Trace(database_context_);
   visitor->Trace(sqlite_database_);
   visitor->Trace(database_authorizer_);
 }
 
 bool Database::OpenAndVerifyVersion(bool set_version_in_new_database,
                                     DatabaseError& error,
                                     String& error_message) {
   WaitableEvent event;
   if (!GetDatabaseContext()->DatabaseThreadAvailable())
     return false;
 
   DatabaseTracker::Tracker().PrepareToOpenDatabase(this);
   bool success = false;
   std::unique_ptr<DatabaseOpenTask> task = DatabaseOpenTask::Create(
       this, set_version_in_new_database, &event, error, error_message, success);
   GetDatabaseContext()->GetDatabaseThread()->ScheduleTask(std::move(task));
   event.Wait();
 
   return success;
 }
 
 void Database::Close() {
-  ASSERT(GetDatabaseContext()->GetDatabaseThread());
-  ASSERT(GetDatabaseContext()->GetDatabaseThread()->IsDatabaseThread());
+  DCHECK(GetDatabaseContext()->GetDatabaseThread());
+  DCHECK(GetDatabaseContext()->GetDatabaseThread()->IsDatabaseThread());
 
   {
     MutexLocker locker(transaction_in_progress_mutex_);
 
     // Clean up transactions that have not been scheduled yet:
     // Transaction phase 1 cleanup. See comment on "What happens if a
     // transaction is interrupted?" at the top of SQLTransactionBackend.cpp.
     SQLTransactionBackend* transaction = nullptr;
     while (!transaction_queue_.IsEmpty()) {
       transaction = transaction_queue_.TakeFirst();
@@ skipping 29 matching lines @@
   return transaction_backend;
 }
 
 void Database::InProgressTransactionCompleted() {
   MutexLocker locker(transaction_in_progress_mutex_);
   transaction_in_progress_ = false;
   ScheduleTransaction();
 }
 
 void Database::ScheduleTransaction() {
-  ASSERT(!transaction_in_progress_mutex_.TryLock());  // Locked by caller.
+  DCHECK(!transaction_in_progress_mutex_.TryLock());  // Locked by caller.
   SQLTransactionBackend* transaction = nullptr;
 
   if (is_transaction_queue_enabled_ && !transaction_queue_.IsEmpty())
     transaction = transaction_queue_.TakeFirst();
 
   if (transaction && GetDatabaseContext()->DatabaseThreadAvailable()) {
     std::unique_ptr<DatabaseTransactionTask> task =
         DatabaseTransactionTask::Create(transaction);
     STORAGE_DVLOG(1) << "Scheduling DatabaseTransactionTask " << task.get()
                      << " for transaction " << task->Transaction();
@@ skipping 32 matching lines @@
   if (!opened_)
     return;
 
   ReleaseStore(&opened_, 0);
   sqlite_database_.Close();
   // See comment at the top this file regarding calling removeOpenDatabase().
   DatabaseTracker::Tracker().RemoveOpenDatabase(this);
   {
     MutexLocker locker(GuidMutex());
 
-    ASSERT(GuidCount().Contains(guid_));
+    DCHECK(GuidCount().Contains(guid_));
     if (GuidCount().erase(guid_)) {
       GuidToVersionMap().erase(guid_);
     }
   }
 }
 
 String Database::version() const {
   // Note: In multi-process browsers the cached value may be accurate, but we
   // cannot read the actual version from the database without potentially
   // inducing a deadlock.
@@ skipping 17 matching lines @@
  private:
   CrossThreadPersistent<Database> database_;
   bool open_succeeded_;
 };
 
 bool Database::PerformOpenAndVerify(bool should_set_version_in_new_database,
                                     DatabaseError& error,
                                     String& error_message) {
   double call_start_time = WTF::MonotonicallyIncreasingTime();
   DoneCreatingDatabaseOnExitCaller on_exit_caller(this);
-  ASSERT(error_message.IsEmpty());
-  ASSERT(error == DatabaseError::kNone);  // Better not have any errors already.
+  DCHECK(error_message.IsEmpty());
+  DCHECK_EQ(error,
+            DatabaseError::kNone);  // Better not have any errors already.
   // Presumed failure. We'll clear it if we succeed below.
   error = DatabaseError::kInvalidDatabaseState;
 
   const int kMaxSqliteBusyWaitTime = 30000;
 
   if (!sqlite_database_.Open(filename_)) {
     ReportOpenDatabaseResult(
         1, kInvalidStateError, sqlite_database_.LastError(),
         WTF::MonotonicallyIncreasingTime() - call_start_time);
     error_message = FormatErrorMessage("unable to open database",
@@ skipping 122 matching lines @@
     ReportOpenDatabaseResult(
         6, kInvalidStateError, 0,
         WTF::MonotonicallyIncreasingTime() - call_start_time);
     error_message =
         "unable to open database, version mismatch, '" + expected_version_ +
         "' does not match the currentVersion of '" + current_version + "'";
     sqlite_database_.Close();
     return false;
   }
 
-  ASSERT(database_authorizer_);
+  DCHECK(database_authorizer_);
   sqlite_database_.SetAuthorizer(database_authorizer_.Get());
 
   // See comment at the top this file regarding calling addOpenDatabase().
   DatabaseTracker::Tracker().AddOpenDatabase(this);
   opened_ = 1;
 
   // Declare success:
   error = DatabaseError::kNone;  // Clear the presumed error from above.
   on_exit_caller.SetOpenSucceeded();
 
@@ skipping 85 matching lines @@
   return GuidToVersionMap().at(guid_).IsolatedCopy();
 }
 
 void Database::SetCachedVersion(const String& actual_version) {
   // Update the in memory database version map.
   MutexLocker locker(GuidMutex());
   UpdateGuidVersionMap(guid_, actual_version);
 }
 
 bool Database::GetActualVersionForTransaction(String& actual_version) {
-  ASSERT(sqlite_database_.TransactionInProgress());
+  DCHECK(sqlite_database_.TransactionInProgress());
   // Note: In multi-process browsers the cached value may be inaccurate. So we
   // retrieve the value from the database and update the cached value here.
   return GetVersionFromDatabase(actual_version, true);
 }
 
 void Database::DisableAuthorizer() {
-  ASSERT(database_authorizer_);
+  DCHECK(database_authorizer_);
   database_authorizer_->Disable();
 }
 
 void Database::EnableAuthorizer() {
-  ASSERT(database_authorizer_);
+  DCHECK(database_authorizer_);
   database_authorizer_->Enable();
 }
 
 void Database::SetAuthorizerPermissions(int permissions) {
-  ASSERT(database_authorizer_);
+  DCHECK(database_authorizer_);
   database_authorizer_->SetPermissions(permissions);
 }
 
 bool Database::LastActionChangedDatabase() {
-  ASSERT(database_authorizer_);
+  DCHECK(database_authorizer_);
   return database_authorizer_->LastActionChangedDatabase();
 }
 
 bool Database::LastActionWasInsert() {
-  ASSERT(database_authorizer_);
+  DCHECK(database_authorizer_);
   return database_authorizer_->LastActionWasInsert();
 }
 
 void Database::ResetDeletes() {
-  ASSERT(database_authorizer_);
+  DCHECK(database_authorizer_);
   database_authorizer_->ResetDeletes();
 }
 
 bool Database::HadDeletes() {
-  ASSERT(database_authorizer_);
+  DCHECK(database_authorizer_);
   return database_authorizer_->HadDeletes();
 }
 
 void Database::ResetAuthorizer() {
   if (database_authorizer_)
     database_authorizer_->Reset();
 }
 
 unsigned long long Database::MaximumSize() const {
   return DatabaseTracker::Tracker().GetMaxSizeForDatabase(this);
@@ skipping 75 matching lines @@
 void Database::LogErrorMessage(const String& message) {
   GetExecutionContext()->AddConsoleMessage(ConsoleMessage::Create(
       kStorageMessageSource, kErrorMessageLevel, message));
 }
 
 ExecutionContext* Database::GetExecutionContext() const {
   return GetDatabaseContext()->GetExecutionContext();
 }
 
 void Database::CloseImmediately() {
-  ASSERT(GetExecutionContext()->IsContextThread());
+  DCHECK(GetExecutionContext()->IsContextThread());
   if (GetDatabaseContext()->DatabaseThreadAvailable() && Opened()) {
     LogErrorMessage("forcibly closing database");
     GetDatabaseContext()->GetDatabaseThread()->ScheduleTask(
         DatabaseCloseTask::Create(this, 0));
   }
 }
 
 void Database::changeVersion(const String& old_version,
                              const String& new_version,
                              SQLTransactionCallback* callback,
@@ skipping 22 matching lines @@
 }
 
 void Database::RunTransaction(SQLTransactionCallback* callback,
                               SQLTransactionErrorCallback* error_callback,
                               VoidCallback* success_callback,
                               bool read_only,
                               const ChangeVersionData* change_version_data) {
   if (!GetExecutionContext())
     return;
 
-  ASSERT(GetExecutionContext()->IsContextThread());
+  DCHECK(GetExecutionContext()->IsContextThread());
 // FIXME: Rather than passing errorCallback to SQLTransaction and then
 // sometimes firing it ourselves, this code should probably be pushed down
 // into Database so that we only create the SQLTransaction if we're
 // actually going to run it.
 #if DCHECK_IS_ON()
   SQLTransactionErrorCallback* original_error_callback = error_callback;
 #endif
   SQLTransaction* transaction = SQLTransaction::Create(
       this, callback, success_callback, error_callback, read_only);
   SQLTransactionBackend* transaction_backend =
       RunTransaction(transaction, read_only, change_version_data);
   if (!transaction_backend) {
     SQLTransactionErrorCallback* callback = transaction->ReleaseErrorCallback();
-    ASSERT(callback == original_error_callback);
+#if DCHECK_IS_ON()
+    DCHECK_EQ(callback, original_error_callback);
+#endif
     if (callback) {
       std::unique_ptr<SQLErrorData> error = SQLErrorData::Create(
           SQLError::kUnknownErr, "database has been closed");
       GetDatabaseTaskRunner()->PostTask(
           BLINK_FROM_HERE,
           WTF::Bind(&CallTransactionErrorCallback, WrapPersistent(callback),
                     WTF::Passed(std::move(error))));
     }
   }
 }
@@ skipping 65 matching lines @@
 
 bool Database::Opened() {
   return static_cast<bool>(AcquireLoad(&opened_));
 }
 
 WebTaskRunner* Database::GetDatabaseTaskRunner() const {
   return database_task_runner_.Get();
 }
 
 }  // namespace blink