Replace ASSERT, RELEASE_ASSERT, and ASSERT_NOT_REACHED in bindings

third_party/WebKit/Source/bindings/core/v8/DOMWrapperWorld.cpp

 /*
  * Copyright (C) 2009 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 117 matching lines @@
       DCHECK(!map.Contains(world_id_));
       map.insert(world_id_, this);
       if (IsMainThread())
         number_of_non_main_worlds_in_main_thread_++;
       break;
     }
   }
 }
 
 DOMWrapperWorld& DOMWrapperWorld::MainWorld() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   DEFINE_STATIC_REF(
       DOMWrapperWorld, cached_main_world,
       (DOMWrapperWorld::Create(v8::Isolate::GetCurrent(), WorldType::kMain)));
   return *cached_main_world;
 }
 
 void DOMWrapperWorld::AllWorldsInCurrentThread(
     Vector<RefPtr<DOMWrapperWorld>>& worlds) {
   if (IsMainThread())
     worlds.push_back(&MainWorld());
@@ skipping 11 matching lines @@
     if (data_store.ContainsWrapper(script_wrappable))
       data_store.MarkWrapper(script_wrappable);
   }
 
   // Marking for the main world.
   if (IsMainThread())
     script_wrappable->MarkWrapper(visitor);
 }
 
 DOMWrapperWorld::~DOMWrapperWorld() {
-  ASSERT(!IsMainWorld());
+  DCHECK(!IsMainWorld());
   if (IsMainThread())
     number_of_non_main_worlds_in_main_thread_--;
 
   // WorkerWorld should be disposed of before the dtor.
   if (!IsWorkerWorld())
     Dispose();
   DCHECK(!GetWorldMap().Contains(world_id_));
 }
 
 void DOMWrapperWorld::Dispose() {
   dom_object_holders_.Clear();
   dom_data_store_.reset();
   DCHECK(GetWorldMap().Contains(world_id_));
   GetWorldMap().erase(world_id_);
 }
 
 PassRefPtr<DOMWrapperWorld> DOMWrapperWorld::EnsureIsolatedWorld(
     v8::Isolate* isolate,
     int world_id) {
-  ASSERT(IsIsolatedWorldId(world_id));
+#if DCHECK_IS_ON()
+  DCHECK(IsIsolatedWorldId(world_id));
+#endif
 
   WorldMap& map = GetWorldMap();
   auto it = map.Find(world_id);
   if (it != map.end()) {
     RefPtr<DOMWrapperWorld> world = it->value;
     DCHECK(world->IsIsolatedWorld());
     DCHECK_EQ(world_id, world->GetWorldId());
     return world.Release();
   }
 
   return AdoptRef(new DOMWrapperWorld(isolate, WorldType::kIsolated, world_id));
 }
 
 typedef HashMap<int, RefPtr<SecurityOrigin>> IsolatedWorldSecurityOriginMap;
 static IsolatedWorldSecurityOriginMap& IsolatedWorldSecurityOrigins() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   DEFINE_STATIC_LOCAL(IsolatedWorldSecurityOriginMap, map, ());
   return map;
 }
 
 SecurityOrigin* DOMWrapperWorld::IsolatedWorldSecurityOrigin() {
-  ASSERT(this->IsIsolatedWorld());
+  DCHECK(this->IsIsolatedWorld());
   IsolatedWorldSecurityOriginMap& origins = IsolatedWorldSecurityOrigins();
   IsolatedWorldSecurityOriginMap::iterator it = origins.Find(GetWorldId());
   return it == origins.end() ? 0 : it->value.Get();
 }
 
 void DOMWrapperWorld::SetIsolatedWorldSecurityOrigin(
     int world_id,
     PassRefPtr<SecurityOrigin> security_origin) {
-  ASSERT(IsIsolatedWorldId(world_id));
+#if DCHECK_IS_ON()
+  DCHECK(IsIsolatedWorldId(world_id));
+#endif
   if (security_origin)
     IsolatedWorldSecurityOrigins().Set(world_id, std::move(security_origin));
   else
     IsolatedWorldSecurityOrigins().erase(world_id);
 }
 
 typedef HashMap<int, String> IsolatedWorldHumanReadableNameMap;
 static IsolatedWorldHumanReadableNameMap& IsolatedWorldHumanReadableNames() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   DEFINE_STATIC_LOCAL(IsolatedWorldHumanReadableNameMap, map, ());
   return map;
 }
 
 String DOMWrapperWorld::IsolatedWorldHumanReadableName() {
   ASSERT(this->IsIsolatedWorld());
   return IsolatedWorldHumanReadableNames().at(GetWorldId());
 }
 
 void DOMWrapperWorld::SetIsolatedWorldHumanReadableName(
     int world_id,
     const String& human_readable_name) {
-  ASSERT(IsIsolatedWorldId(world_id));
+#if DCHECK_IS_ON()
+  DCHECK(IsIsolatedWorldId(world_id));
+#endif
   IsolatedWorldHumanReadableNames().Set(world_id, human_readable_name);
 }
 
 typedef HashMap<int, bool> IsolatedWorldContentSecurityPolicyMap;
 static IsolatedWorldContentSecurityPolicyMap&
 IsolatedWorldContentSecurityPolicies() {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   DEFINE_STATIC_LOCAL(IsolatedWorldContentSecurityPolicyMap, map, ());
   return map;
 }
 
 bool DOMWrapperWorld::IsolatedWorldHasContentSecurityPolicy() {
-  ASSERT(this->IsIsolatedWorld());
+  DCHECK(this->IsIsolatedWorld());
   IsolatedWorldContentSecurityPolicyMap& policies =
       IsolatedWorldContentSecurityPolicies();
   IsolatedWorldContentSecurityPolicyMap::iterator it =
       policies.Find(GetWorldId());
   return it == policies.end() ? false : it->value;
 }
 
 void DOMWrapperWorld::SetIsolatedWorldContentSecurityPolicy(
     int world_id,
     const String& policy) {
-  ASSERT(IsIsolatedWorldId(world_id));
+#if DCHECK_IS_ON()
+  DCHECK(IsIsolatedWorldId(world_id));
+#endif
   if (!policy.IsEmpty())
     IsolatedWorldContentSecurityPolicies().Set(world_id, true);
   else
     IsolatedWorldContentSecurityPolicies().erase(world_id);
 }
 
 template <typename T>
 void DOMWrapperWorld::RegisterDOMObjectHolder(v8::Isolate* isolate,
                                               T* object,
                                               v8::Local<v8::Value> wrapper) {
   RegisterDOMObjectHolderInternal(
       DOMObjectHolder<T>::Create(isolate, object, wrapper));
 }
 
 template void DOMWrapperWorld::RegisterDOMObjectHolder(v8::Isolate*,
                                                        ScriptFunction*,
                                                        v8::Local<v8::Value>);
 
 void DOMWrapperWorld::RegisterDOMObjectHolderInternal(
     std::unique_ptr<DOMObjectHolderBase> holder_base) {
-  ASSERT(!dom_object_holders_.Contains(holder_base.get()));
+  DCHECK(!dom_object_holders_.Contains(holder_base.get()));
   holder_base->SetWorld(this);
   holder_base->SetWeak(&DOMWrapperWorld::WeakCallbackForDOMObjectHolder);
   dom_object_holders_.insert(std::move(holder_base));
 }
 
 void DOMWrapperWorld::UnregisterDOMObjectHolder(
     DOMObjectHolderBase* holder_base) {
-  ASSERT(dom_object_holders_.Contains(holder_base));
+  DCHECK(dom_object_holders_.Contains(holder_base));
   dom_object_holders_.erase(holder_base);
 }
 
 void DOMWrapperWorld::WeakCallbackForDOMObjectHolder(
     const v8::WeakCallbackInfo<DOMObjectHolderBase>& data) {
   DOMObjectHolderBase* holder_base = data.GetParameter();
   holder_base->World()->UnregisterDOMObjectHolder(holder_base);
 }
 
 int DOMWrapperWorld::GenerateWorldIdForType(WorldType world_type) {
@@ skipping 16 matching lines @@
       int world_id = *next_world_id;
       CHECK_GE(world_id, WorldId::kUnspecifiedWorldIdStart);
       *next_world_id = world_id + 1;
       return world_id;
   }
   NOTREACHED();
   return kInvalidWorldId;
 }
 
 }  // namespace blink