Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in modules/webdatabase

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

 /*
  * Copyright (C) 2011 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 100 matching lines @@
     name_map->Set(name, database_set);
   }
 
   database_set->insert(database);
 }
 
 void DatabaseTracker::RemoveOpenDatabase(Database* database) {
   {
     MutexLocker open_database_map_lock(open_database_map_guard_);
     String origin_string = database->GetSecurityOrigin()->ToRawString();
-    ASSERT(open_database_map_);
+    DCHECK(open_database_map_);
     DatabaseNameMap* name_map = open_database_map_->at(origin_string);
     if (!name_map)
       return;
 
     String name(database->StringIdentifier());
     DatabaseSet* database_set = name_map->at(name);
     if (!database_set)
       return;
 
     DatabaseSet::iterator found = database_set->Find(database);
     if (found == database_set->end())
       return;
 
     database_set->erase(found);
     if (database_set->IsEmpty()) {
       name_map->erase(name);
       delete database_set;
       if (name_map->IsEmpty()) {
         open_database_map_->erase(origin_string);
         delete name_map;
       }
     }
   }
   DatabaseClosed(database);
 }
 
 void DatabaseTracker::PrepareToOpenDatabase(Database* database) {
-  ASSERT(
+  DCHECK(
       database->GetDatabaseContext()->GetExecutionContext()->IsContextThread());
   if (Platform::Current()->DatabaseObserver()) {
     Platform::Current()->DatabaseObserver()->DatabaseOpened(
         WebSecurityOrigin(database->GetSecurityOrigin()),
         database->StringIdentifier(), database->DisplayName(),
         database->EstimatedSize());
   }
 }
 
 void DatabaseTracker::FailedToOpenDatabase(Database* database) {
@@ skipping 38 matching lines @@
 void DatabaseTracker::ForEachOpenDatabaseInPage(
     Page* page,
     std::unique_ptr<DatabaseCallback> callback) {
   MutexLocker open_database_map_lock(open_database_map_guard_);
   if (!open_database_map_)
     return;
   for (auto& origin_map : *open_database_map_) {
     for (auto& name_database_set : *origin_map.value) {
       for (Database* database : *name_database_set.value) {
         ExecutionContext* context = database->GetExecutionContext();
-        ASSERT(context->IsDocument());
+        DCHECK(context->IsDocument());
         if (ToDocument(context)->GetFrame()->GetPage() == page)
           (*callback)(database);
       }
     }
   }
 }
 
 void DatabaseTracker::CloseOneDatabaseImmediately(const String& origin_string,
                                                   const String& name,
                                                   Database* database) {
@@ skipping 15 matching lines @@
     if (found == database_set->end())
       return;
   }
 
   // And we have to call closeImmediately() without our collection lock being
   // held.
   database->CloseImmediately();
 }
 
 }  // namespace blink