DevTools: Runtime.compileScript with persistScript = false should not report script

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

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/v8_inspector/V8Debugger.h"
 
 #include "platform/v8_inspector/DebuggerScript.h"
 #include "platform/v8_inspector/ScriptBreakpoint.h"
 #include "platform/v8_inspector/V8Compat.h"
 #include "platform/v8_inspector/V8DebuggerAgentImpl.h"
@@ skipping 30 matching lines @@
     return function->Call(m_isolate->GetCurrentContext(), debuggerScript, argc, argv);
 }
 
 V8Debugger::V8Debugger(v8::Isolate* isolate, V8InspectorImpl* inspector)
     : m_isolate(isolate)
     , m_inspector(inspector)
     , m_lastContextId(0)
     , m_enableCount(0)
     , m_breakpointsActivated(true)
     , m_runningNestedMessageLoop(false)
+    , m_ignoreScriptParsedEventsCounter(0)
     , m_maxAsyncCallStackDepth(0)
 {
 }
 
 V8Debugger::~V8Debugger()
 {
 }
 
 void V8Debugger::enable()
 {
@@ skipping 436 matching lines @@
 
     if (event == v8::AsyncTaskEvent) {
         v8::HandleScope scope(m_isolate);
         handleV8AsyncTaskEvent(eventContext, eventDetails.GetExecutionState(), eventDetails.GetEventData());
         return;
     }
 
     V8DebuggerAgentImpl* agent = m_inspector->enabledDebuggerAgentForGroup(getGroupId(eventContext));
     if (agent) {
         v8::HandleScope scope(m_isolate);
-        if (event == v8::AfterCompile || event == v8::CompileError) {
+        if (m_ignoreScriptParsedEventsCounter == 0 && (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();
             DCHECK(value->IsObject());
             v8::Local<v8::Object> scriptObject = v8::Local<v8::Object>::Cast(value);
             agent->didParseSource(wrapUnique(new V8DebuggerScript(m_isolate, scriptObject, inLiveEditScope)), 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");
@@ skipping 281 matching lines @@
 }
 
 void V8Debugger::allAsyncTasksCanceled()
 {
     m_asyncTaskStacks.clear();
     m_recurringTasks.clear();
     m_currentStacks.clear();
     m_currentTasks.clear();
 }
 
+void V8Debugger::muteScriptParsedEvents()
+{
+    ++m_ignoreScriptParsedEventsCounter;
+}
+
+void V8Debugger::unmuteScriptParsedEvents()
+{
+    --m_ignoreScriptParsedEventsCounter;
+    DCHECK_GE(m_ignoreScriptParsedEventsCounter, 0);
+}
+
 std::unique_ptr<V8StackTraceImpl> V8Debugger::captureStackTrace(bool fullStack)
 {
     if (!m_isolate->InContext())
         return nullptr;
 
     v8::HandleScope handles(m_isolate);
     int contextGroupId = getGroupId(m_isolate->GetCurrentContext());
     if (!contextGroupId)
         return nullptr;
 
     size_t stackSize = fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
     if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
         stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
 
     return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
 } // namespace blink