DevTools: expose raw pointers in protocol collections, s/ASSERT/DCHECK/.

third_party/WebKit/Source/platform/v8_inspector/V8DebuggerImpl.cpp

 /*
  * Copyright (c) 2010-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 47 matching lines @@
 
 }
 
 static bool inLiveEditScope = false;
 
 v8::MaybeLocal<v8::Value> V8DebuggerImpl::callDebuggerMethod(const char* functionName, int argc, v8::Local<v8::Value> argv[])
 {
     v8::MicrotasksScope microtasks(m_isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
     v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8InternalizedString(functionName)));
-    ASSERT(m_isolate->InContext());
+    DCHECK(m_isolate->InContext());
     return function->Call(m_isolate->GetCurrentContext(), debuggerScript, argc, argv);
 }
 
 PassOwnPtr<V8Debugger> V8Debugger::create(v8::Isolate* isolate, V8DebuggerClient* client)
 {
     return adoptPtr(new V8DebuggerImpl(isolate, client));
 }
 
 V8DebuggerImpl::V8DebuggerImpl(v8::Isolate* isolate, V8DebuggerClient* client)
     : m_isolate(isolate)
     , m_client(client)
     , m_enabledAgentsCount(0)
     , m_breakpointsActivated(true)
     , m_runningNestedMessageLoop(false)
 {
 }
 
 V8DebuggerImpl::~V8DebuggerImpl()
 {
 }
 
 void V8DebuggerImpl::enable()
 {
-    ASSERT(!enabled());
+    DCHECK(!enabled());
     v8::HandleScope scope(m_isolate);
     v8::Debug::SetDebugEventListener(m_isolate, &V8DebuggerImpl::v8DebugEventCallback, v8::External::New(m_isolate, this));
     m_debuggerContext.Reset(m_isolate, v8::Debug::GetDebugContext(m_isolate));
     compileDebuggerScript();
 }
 
 void V8DebuggerImpl::disable()
 {
-    ASSERT(enabled());
+    DCHECK(enabled());
     clearBreakpoints();
     m_debuggerScript.Reset();
     m_debuggerContext.Reset();
     v8::Debug::SetDebugEventListener(m_isolate, nullptr);
 }
 
 bool V8DebuggerImpl::enabled() const
 {
     return !m_debuggerScript.IsEmpty();
 }
@@ skipping 54 matching lines @@
 V8DebuggerAgentImpl* V8DebuggerImpl::findEnabledDebuggerAgent(v8::Local<v8::Context> context)
 {
     return findEnabledDebuggerAgent(getGroupId(context));
 }
 
 void V8DebuggerImpl::getCompiledScripts(int contextGroupId, protocol::Vector<V8DebuggerParsedScript>& result)
 {
     v8::HandleScope scope(m_isolate);
     v8::MicrotasksScope microtasks(m_isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
     v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
-    ASSERT(!debuggerScript->IsUndefined());
+    DCHECK(!debuggerScript->IsUndefined());
     v8::Local<v8::Function> getScriptsFunction = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8InternalizedString("getScripts")));
     v8::Local<v8::Value> argv[] = { v8::Integer::New(m_isolate, contextGroupId) };
     v8::Local<v8::Value> value;
     if (!getScriptsFunction->Call(debuggerContext(), debuggerScript, WTF_ARRAY_LENGTH(argv), argv).ToLocal(&value))
         return;
-    ASSERT(value->IsArray());
+    DCHECK(value->IsArray());
     v8::Local<v8::Array> scriptsArray = v8::Local<v8::Array>::Cast(value);
     result.resize(scriptsArray->Length());
     for (unsigned i = 0; i < scriptsArray->Length(); ++i)
         result[i] = createParsedScript(v8::Local<v8::Object>::Cast(scriptsArray->Get(v8::Integer::New(m_isolate, i))), true);
 }
 
 String16 V8DebuggerImpl::setBreakpoint(const String16& sourceID, const ScriptBreakpoint& scriptBreakpoint, int* actualLineNumber, int* actualColumnNumber, bool interstatementLocation)
 {
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
@@ skipping 31 matching lines @@
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Function> clearBreakpoints = v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(v8InternalizedString("clearBreakpoints")));
     v8::Debug::Call(debuggerContext(), clearBreakpoints).ToLocalChecked();
 }
 
 void V8DebuggerImpl::setBreakpointsActivated(bool activated)
 {
     if (!enabled()) {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return;
     }
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Object> info = v8::Object::New(m_isolate);
     info->Set(v8InternalizedString("enabled"), v8::Boolean::New(m_isolate, activated));
     v8::Local<v8::Function> setBreakpointsActivated = v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(v8InternalizedString("setBreakpointsActivated")));
     v8::Debug::Call(debuggerContext(), setBreakpointsActivated, info).ToLocalChecked();
 
     m_breakpointsActivated = activated;
 }
 
 V8DebuggerImpl::PauseOnExceptionsState V8DebuggerImpl::getPauseOnExceptionsState()
 {
-    ASSERT(enabled());
+    DCHECK(enabled());
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Value> argv[] = { v8::Undefined(m_isolate) };
     v8::Local<v8::Value> result = callDebuggerMethod("pauseOnExceptionsState", 0, argv).ToLocalChecked();
     return static_cast<V8DebuggerImpl::PauseOnExceptionsState>(result->Int32Value());
 }
 
 void V8DebuggerImpl::setPauseOnExceptionsState(PauseOnExceptionsState pauseOnExceptionsState)
 {
-    ASSERT(enabled());
+    DCHECK(enabled());
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Value> argv[] = { v8::Int32::New(m_isolate, pauseOnExceptionsState) };
     callDebuggerMethod("setPauseOnExceptionsState", 1, argv);
 }
 
 void V8DebuggerImpl::setPauseOnNextStatement(bool pause)
 {
     if (m_runningNestedMessageLoop)
         return;
     if (pause)
         v8::Debug::DebugBreak(m_isolate);
     else
         v8::Debug::CancelDebugBreak(m_isolate);
 }
 
 bool V8DebuggerImpl::canBreakProgram()
 {
     if (!m_breakpointsActivated)
         return false;
     return m_isolate->InContext();
 }
 
 void V8DebuggerImpl::breakProgram()
 {
     if (isPaused()) {
-        ASSERT(!m_runningNestedMessageLoop);
+        DCHECK(!m_runningNestedMessageLoop);
         v8::Local<v8::Value> exception;
         v8::Local<v8::Array> hitBreakpoints;
         handleProgramBreak(m_pausedContext, m_executionState, exception, hitBreakpoints);
         return;
     }
 
     if (!canBreakProgram())
         return;
 
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Function> breakFunction;
     if (!v8::Function::New(m_isolate->GetCurrentContext(), &V8DebuggerImpl::breakProgramCallback, v8::External::New(m_isolate, this)).ToLocal(&breakFunction))
         return;
     v8::Debug::Call(debuggerContext(), breakFunction).ToLocalChecked();
 }
 
 void V8DebuggerImpl::continueProgram()
 {
     if (isPaused())
         m_client->quitMessageLoopOnPause();
     m_pausedContext.Clear();
     m_executionState.Clear();
 }
 
 void V8DebuggerImpl::stepIntoStatement()
 {
-    ASSERT(isPaused());
-    ASSERT(!m_executionState.IsEmpty());
+    DCHECK(isPaused());
+    DCHECK(!m_executionState.IsEmpty());
     v8::HandleScope handleScope(m_isolate);
     v8::Local<v8::Value> argv[] = { m_executionState };
     callDebuggerMethod(stepIntoV8MethodName, 1, argv);
     continueProgram();
 }
 
 void V8DebuggerImpl::stepOverStatement()
 {
-    ASSERT(isPaused());
-    ASSERT(!m_executionState.IsEmpty());
+    DCHECK(isPaused());
+    DCHECK(!m_executionState.IsEmpty());
     v8::HandleScope handleScope(m_isolate);
     v8::Local<v8::Value> argv[] = { m_executionState };
     callDebuggerMethod("stepOverStatement", 1, argv);
     continueProgram();
 }
 
 void V8DebuggerImpl::stepOutOfFunction()
 {
-    ASSERT(isPaused());
-    ASSERT(!m_executionState.IsEmpty());
+    DCHECK(isPaused());
+    DCHECK(!m_executionState.IsEmpty());
     v8::HandleScope handleScope(m_isolate);
     v8::Local<v8::Value> argv[] = { m_executionState };
     callDebuggerMethod(stepOutV8MethodName, 1, argv);
     continueProgram();
 }
 
 void V8DebuggerImpl::clearStepping()
 {
-    ASSERT(enabled());
+    DCHECK(enabled());
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::Value> argv[] = { v8::Undefined(m_isolate) };
     callDebuggerMethod("clearStepping", 0, argv);
 }
 
 bool V8DebuggerImpl::setScriptSource(const String16& sourceID, const String16& newContent, bool preview, ErrorString* error, Maybe<protocol::Debugger::SetScriptSourceError>* errorData, JavaScriptCallFrames* newCallFrames, Maybe<bool>* stackChanged)
 {
     class EnableLiveEditScope {
     public:
         explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate)
         {
             v8::Debug::SetLiveEditEnabled(m_isolate, true);
             inLiveEditScope = true;
         }
         ~EnableLiveEditScope()
         {
             v8::Debug::SetLiveEditEnabled(m_isolate, false);
             inLiveEditScope = false;
         }
     private:
         v8::Isolate* m_isolate;
     };
 
-    ASSERT(enabled());
+    DCHECK(enabled());
     v8::HandleScope scope(m_isolate);
 
     OwnPtr<v8::Context::Scope> contextScope;
     if (!isPaused())
         contextScope = adoptPtr(new v8::Context::Scope(debuggerContext()));
 
     v8::Local<v8::Value> argv[] = { toV8String(m_isolate, sourceID), toV8String(m_isolate, newContent), v8Boolean(preview, m_isolate) };
 
     v8::Local<v8::Value> v8result;
     {
         EnableLiveEditScope enableLiveEditScope(m_isolate);
         v8::TryCatch tryCatch(m_isolate);
         tryCatch.SetVerbose(false);
         v8::MaybeLocal<v8::Value> maybeResult = callDebuggerMethod("liveEditScriptSource", 3, argv);
         if (tryCatch.HasCaught()) {
             v8::Local<v8::Message> message = tryCatch.Message();
             if (!message.IsEmpty())
                 *error = toProtocolStringWithTypeCheck(message->Get());
             else
                 *error = "Unknown error.";
             return false;
         }
         v8result = maybeResult.ToLocalChecked();
     }
-    ASSERT(!v8result.IsEmpty());
+    DCHECK(!v8result.IsEmpty());
     v8::Local<v8::Object> resultTuple = v8result->ToObject(m_isolate);
     int code = static_cast<int>(resultTuple->Get(0)->ToInteger(m_isolate)->Value());
     switch (code) {
     case 0:
         {
             *stackChanged = resultTuple->Get(1)->BooleanValue();
             // Call stack may have changed after if the edited function was on the stack.
             if (!preview && isPaused())
                 newCallFrames->swap(currentCallFrames());
             return true;
@@ skipping 17 matching lines @@
     if (!m_isolate->InContext())
         return JavaScriptCallFrames();
     v8::Local<v8::Value> currentCallFramesV8;
     if (m_executionState.IsEmpty()) {
         v8::Local<v8::Function> currentCallFramesFunction = v8::Local<v8::Function>::Cast(m_debuggerScript.Get(m_isolate)->Get(v8InternalizedString("currentCallFrames")));
         currentCallFramesV8 = v8::Debug::Call(debuggerContext(), currentCallFramesFunction, v8::Integer::New(m_isolate, limit)).ToLocalChecked();
     } else {
         v8::Local<v8::Value> argv[] = { m_executionState, v8::Integer::New(m_isolate, limit) };
         currentCallFramesV8 = callDebuggerMethod("currentCallFrames", WTF_ARRAY_LENGTH(argv), argv).ToLocalChecked();
     }
-    ASSERT(!currentCallFramesV8.IsEmpty());
+    DCHECK(!currentCallFramesV8.IsEmpty());
     if (!currentCallFramesV8->IsArray())
         return JavaScriptCallFrames();
     v8::Local<v8::Array> callFramesArray = currentCallFramesV8.As<v8::Array>();
     JavaScriptCallFrames callFrames;
     for (size_t i = 0; i < callFramesArray->Length(); ++i) {
         v8::Local<v8::Value> callFrameValue;
         if (!callFramesArray->Get(debuggerContext(), i).ToLocal(&callFrameValue))
             return JavaScriptCallFrames();
         if (!callFrameValue->IsObject())
             return JavaScriptCallFrames();
         v8::Local<v8::Object> callFrameObject = callFrameValue.As<v8::Object>();
         callFrames.append(JavaScriptCallFrame::create(debuggerContext(), v8::Local<v8::Object>::Cast(callFrameObject)));
     }
     return callFrames;
 }
 
 static V8DebuggerImpl* toV8DebuggerImpl(v8::Local<v8::Value> data)
 {
     void* p = v8::Local<v8::External>::Cast(data)->Value();
     return static_cast<V8DebuggerImpl*>(p);
 }
 
 void V8DebuggerImpl::breakProgramCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    ASSERT(2 == info.Length());
+    DCHECK_EQ(info.Length(), 2);
     V8DebuggerImpl* thisPtr = toV8DebuggerImpl(info.Data());
     v8::Local<v8::Context> pausedContext = thisPtr->m_isolate->GetCurrentContext();
     v8::Local<v8::Value> exception;
     v8::Local<v8::Array> hitBreakpoints;
     thisPtr->handleProgramBreak(pausedContext, v8::Local<v8::Object>::Cast(info[0]), exception, hitBreakpoints);
 }
 
 void V8DebuggerImpl::handleProgramBreak(v8::Local<v8::Context> pausedContext, v8::Local<v8::Object> executionState, v8::Local<v8::Value> exception, v8::Local<v8::Array> hitBreakpointNumbers, bool isPromiseRejection)
 {
     // Don't allow nested breaks.
     if (m_runningNestedMessageLoop)
         return;
 
     V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(pausedContext);
     if (!agent)
         return;
 
     protocol::Vector<String16> breakpointIds;
     if (!hitBreakpointNumbers.IsEmpty()) {
         breakpointIds.resize(hitBreakpointNumbers->Length());
         for (size_t i = 0; i < hitBreakpointNumbers->Length(); i++) {
             v8::Local<v8::Value> hitBreakpointNumber = hitBreakpointNumbers->Get(i);
-            ASSERT(!hitBreakpointNumber.IsEmpty() && hitBreakpointNumber->IsInt32());
+            DCHECK(!hitBreakpointNumber.IsEmpty() && hitBreakpointNumber->IsInt32());
             breakpointIds[i] = String16::number(hitBreakpointNumber->Int32Value());
         }
     }
 
     m_pausedContext = pausedContext;
     m_executionState = executionState;
     V8DebuggerAgentImpl::SkipPauseRequest result = agent->didPause(pausedContext, exception, breakpointIds, isPromiseRejection);
     if (result == V8DebuggerAgentImpl::RequestNoSkip) {
         m_runningNestedMessageLoop = true;
         int groupId = getGroupId(pausedContext);
-        ASSERT(groupId);
+        DCHECK(groupId);
         m_client->runMessageLoopOnPause(groupId);
         // The agent may have been removed in the nested loop.
         agent = findEnabledDebuggerAgent(pausedContext);
         if (agent)
             agent->didContinue();
         m_runningNestedMessageLoop = false;
     }
     m_pausedContext.Clear();
     m_executionState.Clear();
 
@@ skipping 12 matching lines @@
 void V8DebuggerImpl::v8DebugEventCallback(const v8::Debug::EventDetails& eventDetails)
 {
     V8DebuggerImpl* thisPtr = toV8DebuggerImpl(eventDetails.GetCallbackData());
     thisPtr->handleV8DebugEvent(eventDetails);
 }
 
 v8::Local<v8::Value> V8DebuggerImpl::callInternalGetterFunction(v8::Local<v8::Object> object, const char* functionName)
 {
     v8::MicrotasksScope microtasks(m_isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
     v8::Local<v8::Value> getterValue = object->Get(v8InternalizedString(functionName));
-    ASSERT(!getterValue.IsEmpty() && getterValue->IsFunction());
+    DCHECK(!getterValue.IsEmpty() && getterValue->IsFunction());
     return v8::Local<v8::Function>::Cast(getterValue)->Call(m_isolate->GetCurrentContext(), object, 0, 0).ToLocalChecked();
 }
 
 void V8DebuggerImpl::handleV8DebugEvent(const v8::Debug::EventDetails& eventDetails)
 {
     if (!enabled())
         return;
     v8::DebugEvent event = eventDetails.GetEvent();
     if (event != v8::AsyncTaskEvent && event != v8::Break && event != v8::Exception && event != v8::AfterCompile && event != v8::BeforeCompile && event != v8::CompileError)
         return;
 
     v8::Local<v8::Context> eventContext = eventDetails.GetEventContext();
-    ASSERT(!eventContext.IsEmpty());
+    DCHECK(!eventContext.IsEmpty());
 
     V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(eventContext);
     if (agent) {
         v8::HandleScope scope(m_isolate);
         if (event == v8::AfterCompile || event == v8::CompileError) {
             v8::Context::Scope contextScope(debuggerContext());
             v8::Local<v8::Value> argv[] = { eventDetails.GetEventData() };
             v8::Local<v8::Value> value = callDebuggerMethod("getAfterCompileScript", 1, argv).ToLocalChecked();
-            ASSERT(value->IsObject());
+            DCHECK(value->IsObject());
             v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(value);
             agent->didParseSource(createParsedScript(object, event == v8::AfterCompile));
         } else if (event == v8::Exception) {
             v8::Local<v8::Object> eventData = eventDetails.GetEventData();
             v8::Local<v8::Value> exception = callInternalGetterFunction(eventData, "exception");
             v8::Local<v8::Value> promise = callInternalGetterFunction(eventData, "promise");
             bool isPromiseRejection = !promise.IsEmpty() && promise->IsObject();
             handleProgramBreak(eventContext, eventDetails.GetExecutionState(), exception, v8::Local<v8::Array>(), isPromiseRejection);
         } else if (event == v8::Break) {
             v8::Local<v8::Value> argv[] = { eventDetails.GetEventData() };
             v8::Local<v8::Value> hitBreakpoints = callDebuggerMethod("getBreakpointNumbers", 1, argv).ToLocalChecked();
-            ASSERT(hitBreakpoints->IsArray());
+            DCHECK(hitBreakpoints->IsArray());
             handleProgramBreak(eventContext, eventDetails.GetExecutionState(), v8::Local<v8::Value>(), hitBreakpoints.As<v8::Array>());
         } else if (event == v8::AsyncTaskEvent) {
             if (agent->v8AsyncTaskEventsEnabled())
                 handleV8AsyncTaskEvent(agent, eventContext, eventDetails.GetExecutionState(), eventDetails.GetEventData());
         }
     }
 }
 
 void V8DebuggerImpl::handleV8AsyncTaskEvent(V8DebuggerAgentImpl* agent, v8::Local<v8::Context> context, v8::Local<v8::Object> executionState, v8::Local<v8::Object> eventData)
 {
     String16 type = toProtocolStringWithTypeCheck(callInternalGetterFunction(eventData, "type"));
     String16 name = toProtocolStringWithTypeCheck(callInternalGetterFunction(eventData, "name"));
     int id = callInternalGetterFunction(eventData, "id")->ToInteger(m_isolate)->Value();
 
     m_pausedContext = context;
     m_executionState = executionState;
     agent->didReceiveV8AsyncTaskEvent(context, type, name, id);
     m_pausedContext.Clear();
     m_executionState.Clear();
 }
 
 V8DebuggerParsedScript V8DebuggerImpl::createParsedScript(v8::Local<v8::Object> object, bool success)
 {
     v8::Local<v8::Value> id = object->Get(v8InternalizedString("id"));
-    ASSERT(!id.IsEmpty() && id->IsInt32());
+    DCHECK(!id.IsEmpty() && id->IsInt32());
 
     V8DebuggerParsedScript parsedScript;
     parsedScript.scriptId = String16::number(id->Int32Value());
     parsedScript.script.setURL(toProtocolStringWithTypeCheck(object->Get(v8InternalizedString("name"))))
         .setSourceURL(toProtocolStringWithTypeCheck(object->Get(v8InternalizedString("sourceURL"))))
         .setSourceMappingURL(toProtocolStringWithTypeCheck(object->Get(v8InternalizedString("sourceMappingURL"))))
         .setSource(toProtocolStringWithTypeCheck(object->Get(v8InternalizedString("source"))))
         .setStartLine(object->Get(v8InternalizedString("startLine"))->ToInteger(m_isolate)->Value())
         .setStartColumn(object->Get(v8InternalizedString("startColumn"))->ToInteger(m_isolate)->Value())
         .setEndLine(object->Get(v8InternalizedString("endLine"))->ToInteger(m_isolate)->Value())
         .setEndColumn(object->Get(v8InternalizedString("endColumn"))->ToInteger(m_isolate)->Value())
         .setIsContentScript(object->Get(v8InternalizedString("isContentScript"))->ToBoolean(m_isolate)->Value())
         .setIsInternalScript(object->Get(v8InternalizedString("isInternalScript"))->ToBoolean(m_isolate)->Value())
         .setExecutionContextId(object->Get(v8InternalizedString("executionContextId"))->ToInteger(m_isolate)->Value())
         .setIsLiveEdit(inLiveEditScope);
     parsedScript.success = success;
     return parsedScript;
 }
 
 void V8DebuggerImpl::compileDebuggerScript()
 {
     if (!m_debuggerScript.IsEmpty()) {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return;
     }
 
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(debuggerContext());
 
     v8::Local<v8::String> scriptValue = v8::String::NewFromUtf8(m_isolate, DebuggerScript_js, v8::NewStringType::kInternalized, sizeof(DebuggerScript_js)).ToLocalChecked();
     v8::Local<v8::Value> value;
     if (!compileAndRunInternalScript(debuggerContext(), scriptValue).ToLocal(&value))
         return;
-    ASSERT(value->IsObject());
+    DCHECK(value->IsObject());
     m_debuggerScript.Reset(m_isolate, value.As<v8::Object>());
 }
 
 v8::Local<v8::Context> V8DebuggerImpl::debuggerContext() const
 {
-    ASSERT(!m_debuggerContext.IsEmpty());
+    DCHECK(!m_debuggerContext.IsEmpty());
     return m_debuggerContext.Get(m_isolate);
 }
 
 v8::Local<v8::String> V8DebuggerImpl::v8InternalizedString(const char* str) const
 {
     return v8::String::NewFromUtf8(m_isolate, str, v8::NewStringType::kInternalized).ToLocalChecked();
 }
 
 v8::MaybeLocal<v8::Value> V8DebuggerImpl::functionScopes(v8::Local<v8::Function> function)
 {
     if (!enabled()) {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return v8::Local<v8::Value>::New(m_isolate, v8::Undefined(m_isolate));
     }
     v8::Local<v8::Value> argv[] = { function };
     return callDebuggerMethod("getFunctionScopes", 1, argv);
 }
 
 v8::Local<v8::Value> V8DebuggerImpl::generatorObjectDetails(v8::Local<v8::Object>& object)
 {
     if (!enabled()) {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return v8::Local<v8::Value>::New(m_isolate, v8::Undefined(m_isolate));
     }
     v8::Local<v8::Value> argv[] = { object };
     return callDebuggerMethod("getGeneratorObjectDetails", 1, argv).ToLocalChecked();
 }
 
 v8::Local<v8::Value> V8DebuggerImpl::collectionEntries(v8::Local<v8::Object>& object)
 {
     if (!enabled()) {
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return v8::Local<v8::Value>::New(m_isolate, v8::Undefined(m_isolate));
     }
     v8::Local<v8::Value> argv[] = { object };
     return callDebuggerMethod("getCollectionEntries", 1, argv).ToLocalChecked();
 }
 
 bool V8DebuggerImpl::isPaused()
 {
     return !m_pausedContext.IsEmpty();
 }
@@ skipping 62 matching lines @@
 }
 
 PassOwnPtr<V8StackTrace> V8DebuggerImpl::createStackTrace(v8::Local<v8::StackTrace> stackTrace, size_t maxStackSize)
 {
     V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(m_isolate->GetCurrentContext());
     return V8StackTraceImpl::create(agent, stackTrace, maxStackSize);
 }
 
 PassOwnPtr<V8InspectorSession> V8DebuggerImpl::connect(int contextGroupId)
 {
-    ASSERT(!m_sessions.contains(contextGroupId));
+    DCHECK(!m_sessions.contains(contextGroupId));
     OwnPtr<V8InspectorSessionImpl> session = V8InspectorSessionImpl::create(this, contextGroupId);
     m_sessions.set(contextGroupId, session.get());
     return std::move(session);
 }
 
 void V8DebuggerImpl::disconnect(V8InspectorSessionImpl* session)
 {
-    ASSERT(m_sessions.contains(session->contextGroupId()));
+    DCHECK(m_sessions.contains(session->contextGroupId()));
     m_sessions.remove(session->contextGroupId());
 }
 
 void V8DebuggerImpl::contextCreated(const V8ContextInfo& info)
 {
-    ASSERT(info.context->GetIsolate() == m_isolate);
+    DCHECK(info.context->GetIsolate() == m_isolate);
     // TODO(dgozman): make s_lastContextId non-static.
     int contextId = atomicIncrement(&s_lastContextId);
     String16 debugData = String16::number(info.contextGroupId) + "," + String16::number(contextId) + "," + (info.isDefault ? "default" : "nondefault");
     v8::HandleScope scope(m_isolate);
     v8::Context::Scope contextScope(info.context);
     info.context->SetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex), toV8String(m_isolate, debugData));
 
     if (!m_contexts.contains(info.contextGroupId))
         m_contexts.set(info.contextGroupId, adoptPtr(new ContextByIdMap()));
-    ASSERT(!m_contexts.get(info.contextGroupId)->contains(contextId));
+    DCHECK(!m_contexts.get(info.contextGroupId)->contains(contextId));
 
     OwnPtr<InspectedContext> contextOwner = adoptPtr(new InspectedContext(this, info, contextId));
     InspectedContext* inspectedContext = contextOwner.get();
     m_contexts.get(info.contextGroupId)->set(contextId, std::move(contextOwner));
 
     if (V8InspectorSessionImpl* session = m_sessions.get(info.contextGroupId))
         session->runtimeAgentImpl()->reportExecutionContextCreated(inspectedContext);
 }
 
 void V8DebuggerImpl::contextDestroyed(v8::Local<v8::Context> context)
@@ skipping 69 matching lines @@
         return nullptr;
     return m_contexts.get(contextGroupId);
 }
 
 V8InspectorSessionImpl* V8DebuggerImpl::sessionForContextGroup(int contextGroupId)
 {
     return contextGroupId ? m_sessions.get(contextGroupId) : nullptr;
 }
 
 } // namespace blink