Replace ASSERT, RELEASE_ASSERT, and ASSERT_NOT_REACHED in bindings

third_party/WebKit/Source/bindings/core/v8/V8ScriptRunner.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:
  * 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 242 matching lines @@
 bool IsResourceHotForCaching(CachedMetadataHandler* cache_handler,
                              int hot_hours) {
   const double cache_within_seconds = hot_hours * 60 * 60;
   uint32_t tag = CacheTag(kCacheTagTimeStamp, cache_handler);
   RefPtr<CachedMetadata> cached_metadata =
       cache_handler->GetCachedMetadata(tag);
   if (!cached_metadata)
     return false;
   double time_stamp;
   const int size = sizeof(time_stamp);
-  ASSERT(cached_metadata->size() == size);
+  DCHECK_EQ(cached_metadata->size(), static_cast<unsigned long>(size));
   memcpy(&time_stamp, cached_metadata->Data(), size);
   return (WTF::CurrentTime() - time_stamp) < cache_within_seconds;
 }
 
 // Final compile call for a streamed compilation. Most decisions have already
 // been made, but we need to write back data into the cache.
 v8::MaybeLocal<v8::Script> PostStreamCompile(
     V8CacheOptions cache_options,
     CachedMetadataHandler* cache_handler,
     ScriptStreamer* streamer,
@@ skipping 28 matching lines @@
       break;
     }
 
     case kV8CacheOptionsDefault:
     case kV8CacheOptionsCode:
       V8ScriptRunner::SetCacheTimeStamp(cache_handler);
       break;
 
     case kV8CacheOptionsAlways:
       // Currently V8CacheOptionsAlways doesn't support streaming.
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
     case kV8CacheOptionsNone:
       break;
   }
   return script;
 }
 
 typedef Function<v8::MaybeLocal<v8::Script>(v8::Isolate*,
                                             v8::Local<v8::String>,
                                             v8::ScriptOrigin)>
     CompileFn;
@@ skipping 59 matching lines @@
       uint32_t code_cache_tag = CacheTag(kCacheTagCode, cache_handler);
       return Bind(CompileAndProduceCache, WrapPersistent(cache_handler),
                   code_cache_tag, v8::ScriptCompiler::kProduceCodeCache,
                   CachedMetadataHandler::kSendToPlatform);
       break;
     }
 
     case kV8CacheOptionsNone:
       // Shouldn't happen, as this is handled above.
       // Case is here so that compiler can check all cases are handled.
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
   }
 
   // All switch branches should return and we should never get here.
   // But some compilers aren't sure, hence this default.
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return Bind(CompileWithoutOptions, V8CompileHistogram::kCacheable);
 }
 
 // Select a compile function for a streaming compile.
 std::unique_ptr<CompileFn> SelectCompileFunction(V8CacheOptions cache_options,
                                                  ScriptResource* resource,
                                                  ScriptStreamer* streamer) {
   // We don't stream scripts which don't have a Resource.
-  ASSERT(resource);
+  DCHECK(resource);
   // Failed resources should never get this far.
-  ASSERT(!resource->ErrorOccurred());
-  ASSERT(streamer->IsFinished());
-  ASSERT(!streamer->StreamingSuppressed());
+  DCHECK(!resource->ErrorOccurred());
+  DCHECK(streamer->IsFinished());
+  DCHECK(!streamer->StreamingSuppressed());
   return WTF::Bind(PostStreamCompile, cache_options,
                    WrapPersistent(resource->CacheHandler()),
                    WrapPersistent(streamer));
 }
 }  // namespace
 
 v8::MaybeLocal<v8::Script> V8ScriptRunner::CompileScript(
     const ScriptSourceCode& source,
     v8::Isolate* isolate,
     AccessControlStatus access_control_status,
@@ skipping 37 matching lines @@
     ScriptResource* resource,
     ScriptStreamer* streamer,
     CachedMetadataHandler* cache_handler,
     AccessControlStatus access_control_status,
     V8CacheOptions cache_options) {
   TRACE_EVENT2(
       "v8,devtools.timeline", "v8.compile", "fileName", file_name.Utf8(),
       "data",
       InspectorCompileScriptEvent::Data(file_name, script_start_position));
 
-  ASSERT(!streamer || resource);
-  ASSERT(!resource || resource->CacheHandler() == cache_handler);
+  DCHECK(!streamer || resource);
+  DCHECK(!resource || resource->CacheHandler() == cache_handler);
 
   // NOTE: For compatibility with WebCore, ScriptSourceCode's line starts at
   // 1, whereas v8 starts at 0.
   v8::ScriptOrigin origin(
       V8String(isolate, file_name),
       v8::Integer::New(isolate, script_start_position.line_.ZeroBasedInt()),
       v8::Integer::New(isolate, script_start_position.column_.ZeroBasedInt()),
       V8Boolean(access_control_status == kSharableCrossOrigin, isolate),
       v8::Local<v8::Integer>(), V8String(isolate, source_map_url),
       V8Boolean(access_control_status == kOpaqueResource, isolate));
@@ skipping 37 matching lines @@
       V8Boolean(true, isolate));  // is_module
 
   v8::ScriptCompiler::Source script_source(V8String(isolate, source), origin);
   return v8::ScriptCompiler::CompileModule(isolate, &script_source);
 }
 
 v8::MaybeLocal<v8::Value> V8ScriptRunner::RunCompiledScript(
     v8::Isolate* isolate,
     v8::Local<v8::Script> script,
     ExecutionContext* context) {
-  ASSERT(!script.IsEmpty());
+  DCHECK(!script.IsEmpty());
   ScopedFrameBlamer frame_blamer(
       context->IsDocument() ? ToDocument(context)->GetFrame() : nullptr);
   TRACE_EVENT1("v8", "v8.run", "fileName",
                TRACE_STR_COPY(*v8::String::Utf8Value(
                    script->GetUnboundScript()->GetScriptName())));
 
   if (v8::MicrotasksScope::GetCurrentDepth(isolate) >= kMaxRecursionDepth)
     return ThrowStackOverflowExceptionIfNeeded(isolate);
 
-  RELEASE_ASSERT(!context->IsIteratingOverObservers());
+  CHECK(!context->IsIteratingOverObservers());
 
   // Run the script and keep track of the current recursion depth.
   v8::MaybeLocal<v8::Value> result;
   {
     if (ScriptForbiddenScope::IsScriptForbidden()) {
       ThrowScriptForbiddenException(isolate);
       return v8::MaybeLocal<v8::Value>();
     }
     v8::MicrotasksScope microtasks_scope(isolate,
                                          v8::MicrotasksScope::kRunMicrotasks);
@@ skipping 82 matching lines @@
   LocalFrame* frame =
       context->IsDocument() ? ToDocument(context)->GetFrame() : nullptr;
   ScopedFrameBlamer frame_blamer(frame);
   TRACE_EVENT0("v8", "v8.callFunction");
 
   int depth = v8::MicrotasksScope::GetCurrentDepth(isolate);
   if (depth >= kMaxRecursionDepth)
     return v8::MaybeLocal<v8::Value>(
         ThrowStackOverflowExceptionIfNeeded(isolate));
 
-  RELEASE_ASSERT(!context->IsIteratingOverObservers());
+  CHECK(!context->IsIteratingOverObservers());
 
   if (ScriptForbiddenScope::IsScriptForbidden()) {
     ThrowScriptForbiddenException(isolate);
     return v8::MaybeLocal<v8::Value>();
   }
 
   DCHECK(!frame || BindingSecurity::ShouldAllowAccessToFrame(
                        ToLocalDOMWindow(function->CreationContext()), frame,
                        BindingSecurity::ErrorReportOption::kDoNotReport));
   CHECK(!ThreadState::Current()->IsWrapperTracingForbidden());
@@ skipping 71 matching lines @@
           V8AtomicString(isolate, "((e) => { throw e; })"), origin)
           .ToLocalChecked();
   v8::Local<v8::Function> thrower = RunCompiledInternalScript(isolate, script)
                                         .ToLocalChecked()
                                         .As<v8::Function>();
   v8::Local<v8::Value> args[] = {exception};
   CallInternalFunction(thrower, thrower, WTF_ARRAY_LENGTH(args), args, isolate);
 }
 
 }  // namespace blink