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

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

 // Copyright 2015 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/V8DebuggerAgentImpl.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
@@ skipping 205 matching lines @@
 {
     if (enabled())
         return;
 
     if (!m_session->client()->canExecuteScripts()) {
         *errorString = "Script execution is prohibited";
         return;
     }
 
     enable();
-    ASSERT(m_frontend);
+    DCHECK(m_frontend);
 }
 
 void V8DebuggerAgentImpl::disable(ErrorString*)
 {
     if (!enabled())
         return;
     m_session->changeInstrumentationCounter(-1);
 
     m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, protocol::DictionaryValue::create());
     m_state->setNumber(DebuggerAgentState::pauseOnExceptionsState, V8DebuggerImpl::DontPauseOnExceptions);
@@ skipping 37 matching lines @@
 
 void V8DebuggerAgentImpl::setInspectorState(protocol::DictionaryValue* state)
 {
     m_state = state;
 }
 
 void V8DebuggerAgentImpl::clearFrontend()
 {
     ErrorString error;
     disable(&error);
-    ASSERT(m_frontend);
+    DCHECK(m_frontend);
     m_frontend = nullptr;
 }
 
 void V8DebuggerAgentImpl::restore()
 {
-    ASSERT(!m_enabled);
+    DCHECK(!m_enabled);
     if (!m_state->booleanProperty(DebuggerAgentState::debuggerEnabled, false))
         return;
     if (!m_session->client()->canExecuteScripts())
         return;
 
     enable();
     ErrorString error;
 
     int pauseState = V8DebuggerImpl::DontPauseOnExceptions;
     m_state->getNumber(DebuggerAgentState::pauseOnExceptionsState, &pauseState);
     setPauseOnExceptionsImpl(&error, pauseState);
-    ASSERT(error.isEmpty());
+    DCHECK(error.isEmpty());
 
     m_skipAllPauses = m_state->booleanProperty(DebuggerAgentState::skipAllPauses, false);
 
     int asyncCallStackDepth = 0;
     m_state->getNumber(DebuggerAgentState::asyncCallStackDepth, &asyncCallStackDepth);
     internalSetAsyncCallStackDepth(asyncCallStackDepth);
 
     String16 blackboxPattern;
     if (m_state->getString(DebuggerAgentState::blackboxPattern, &blackboxPattern)) {
         if (!setBlackboxPattern(&error, blackboxPattern))
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
     }
 }
 
 void V8DebuggerAgentImpl::setBreakpointsActive(ErrorString* errorString, bool active)
 {
     if (!checkEnabled(errorString))
         return;
     debugger().setBreakpointsActivated(active);
 }
 
@@ skipping 117 matching lines @@
     if (!checkEnabled(errorString))
         return;
     protocol::DictionaryValue* breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (breakpointsCookie)
         breakpointsCookie->remove(breakpointId);
     removeBreakpoint(breakpointId);
 }
 
 void V8DebuggerAgentImpl::removeBreakpoint(const String16& breakpointId)
 {
-    ASSERT(enabled());
+    DCHECK(enabled());
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
     if (debuggerBreakpointIdsIterator == m_breakpointIdToDebuggerBreakpointIds.end())
         return;
     protocol::Vector<String16>* ids = debuggerBreakpointIdsIterator->second;
     for (size_t i = 0; i < ids->size(); ++i) {
         const String16& debuggerBreakpointId = ids->at(i);
 
         debugger().removeBreakpoint(debuggerBreakpointId);
         m_serverBreakpoints.remove(debuggerBreakpointId);
     }
@@ skipping 29 matching lines @@
         return;
     m_pausedCallFrames.swap(debugger().currentCallFrames());
     *callFrames = currentCallFrames(errorString);
     if (!*callFrames)
         return;
     *asyncStackTrace = currentAsyncStackTrace();
 }
 
 bool V8DebuggerAgentImpl::isCurrentCallStackEmptyOrBlackboxed()
 {
-    ASSERT(enabled());
+    DCHECK(enabled());
     JavaScriptCallFrames callFrames = debugger().currentCallFrames();
     for (size_t index = 0; index < callFrames.size(); ++index) {
-        if (!isCallFrameWithUnknownScriptOrBlackboxed(callFrames[index].get()))
+        if (!isCallFrameWithUnknownScriptOrBlackboxed(callFrames[index]))
             return false;
     }
     return true;
 }
 
 bool V8DebuggerAgentImpl::isTopPausedCallFrameBlackboxed()
 {
-    ASSERT(enabled());
-    return isCallFrameWithUnknownScriptOrBlackboxed(m_pausedCallFrames.size() ? m_pausedCallFrames[0].get() : nullptr);
+    DCHECK(enabled());
+    return isCallFrameWithUnknownScriptOrBlackboxed(m_pausedCallFrames.size() ? m_pausedCallFrames[0] : nullptr);
 }
 
 bool V8DebuggerAgentImpl::isCallFrameWithUnknownScriptOrBlackboxed(JavaScriptCallFrame* frame)
 {
     if (!frame)
         return true;
     ScriptsMap::iterator it = m_scripts.find(String16::number(frame->sourceID()));
     if (it == m_scripts.end()) {
         // Unknown scripts are blackboxed.
         return true;
@@ skipping 42 matching lines @@
 
     if (!m_skippedStepFrameCount)
         m_recursionLevelForStepFrame = 1;
 
     ++m_skippedStepFrameCount;
     return RequestStepFrame;
 }
 
 PassOwnPtr<protocol::Debugger::Location> V8DebuggerAgentImpl::resolveBreakpoint(const String16& breakpointId, const String16& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
 {
-    ASSERT(enabled());
+    DCHECK(enabled());
     // FIXME: remove these checks once crbug.com/520702 is resolved.
-    RELEASE_ASSERT(!breakpointId.isEmpty());
-    RELEASE_ASSERT(!scriptId.isEmpty());
+    CHECK(!breakpointId.isEmpty());
+    CHECK(!scriptId.isEmpty());
     ScriptsMap::iterator scriptIterator = m_scripts.find(scriptId);
     if (scriptIterator == m_scripts.end())
         return nullptr;
     V8DebuggerScript* script = scriptIterator->second;
     if (breakpoint.lineNumber < script->startLine() || script->endLine() < breakpoint.lineNumber)
         return nullptr;
 
     int actualLineNumber;
     int actualColumnNumber;
     String16 debuggerBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &actualLineNumber, &actualColumnNumber, false);
     if (debuggerBreakpointId.isEmpty())
         return nullptr;
 
     m_serverBreakpoints.set(debuggerBreakpointId, std::make_pair(breakpointId, source));
-    RELEASE_ASSERT(!breakpointId.isEmpty());
+    CHECK(!breakpointId.isEmpty());
     if (!m_breakpointIdToDebuggerBreakpointIds.contains(breakpointId))
         m_breakpointIdToDebuggerBreakpointIds.set(breakpointId, protocol::Vector<String16>());
 
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
     debuggerBreakpointIdsIterator->second->append(debuggerBreakpointId);
 
     return buildProtocolLocation(scriptId, actualLineNumber, actualColumnNumber);
 }
 
 void V8DebuggerAgentImpl::searchInContent(ErrorString* error, const String16& scriptId, const String16& query,
@@ skipping 44 matching lines @@
     InjectedScript::CallFrameScope scope(errorString, m_debugger, m_session->contextGroupId(), callFrameId);
     if (!scope.initialize())
         return;
     if (scope.frameOrdinal() >= m_pausedCallFrames.size()) {
         *errorString = "Could not find call frame with given id";
         return;
     }
 
     v8::Local<v8::Value> resultValue;
     v8::Local<v8::Boolean> result;
-    if (!m_pausedCallFrames[scope.frameOrdinal()].get()->restart().ToLocal(&resultValue) || scope.tryCatch().HasCaught() || !resultValue->ToBoolean(scope.context()).ToLocal(&result) || !result->Value()) {
+    if (!m_pausedCallFrames[scope.frameOrdinal()]->restart().ToLocal(&resultValue) || scope.tryCatch().HasCaught() || !resultValue->ToBoolean(scope.context()).ToLocal(&result) || !result->Value()) {
         *errorString = "Internal error";
         return;
     }
     m_pausedCallFrames.swap(debugger().currentCallFrames());
 
     *newCallFrames = currentCallFrames(errorString);
     if (!*newCallFrames)
         return;
     *asyncStackTrace = currentAsyncStackTrace();
 }
@@ skipping 115 matching lines @@
         return;
     m_breakReason = breakReason;
     m_breakAuxData = std::move(data);
     m_pausingOnNativeEvent = true;
     m_skipNextDebuggerStepOut = false;
     debugger().setPauseOnNextStatement(true);
 }
 
 void V8DebuggerAgentImpl::schedulePauseOnNextStatementIfSteppingInto()
 {
-    ASSERT(enabled());
+    DCHECK(enabled());
     if (m_scheduledDebuggerStep != StepInto || m_javaScriptPauseScheduled || debugger().isPaused())
         return;
     clearBreakDetails();
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     debugger().setPauseOnNextStatement(true);
 }
 
 void V8DebuggerAgentImpl::cancelPauseOnNextStatement()
 {
     if (m_javaScriptPauseScheduled || debugger().isPaused())
         return;
     clearBreakDetails();
     m_pausingOnNativeEvent = false;
     debugger().setPauseOnNextStatement(false);
 }
 
 bool V8DebuggerAgentImpl::v8AsyncTaskEventsEnabled() const
 {
     return m_maxAsyncCallStackDepth;
 }
 
 void V8DebuggerAgentImpl::didReceiveV8AsyncTaskEvent(v8::Local<v8::Context> context, const String16& eventType, const String16& eventName, int id)
 {
-    ASSERT(m_maxAsyncCallStackDepth);
+    DCHECK(m_maxAsyncCallStackDepth);
     // The scopes for the ids are defined by the eventName namespaces. There are currently two namespaces: "Object." and "Promise.".
     void* ptr = reinterpret_cast<void*>(id * 4 + (eventName[0] == 'P' ? 2 : 0) + 1);
     if (eventType == v8AsyncTaskEventEnqueue)
         asyncTaskScheduled(eventName, ptr, false);
     else if (eventType == v8AsyncTaskEventWillHandle)
         asyncTaskStarted(ptr);
     else if (eventType == v8AsyncTaskEventDidHandle)
         asyncTaskFinished(ptr);
     else
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
 }
 
 void V8DebuggerAgentImpl::pause(ErrorString* errorString)
 {
     if (!checkEnabled(errorString))
         return;
     if (m_javaScriptPauseScheduled || debugger().isPaused())
         return;
     clearBreakDetails();
     m_javaScriptPauseScheduled = true;
@@ skipping 11 matching lines @@
     m_steppingFromFramework = false;
     m_session->releaseObjectGroup(V8InspectorSession::backtraceObjectGroup);
     debugger().continueProgram();
 }
 
 void V8DebuggerAgentImpl::stepOver(ErrorString* errorString)
 {
     if (!assertPaused(errorString))
         return;
     // StepOver at function return point should fallback to StepInto.
-    JavaScriptCallFrame* frame = m_pausedCallFrames.size() ? m_pausedCallFrames[0].get() : nullptr;
+    JavaScriptCallFrame* frame = m_pausedCallFrames.size() ? m_pausedCallFrames[0] : nullptr;
     if (frame && frame->isAtReturn()) {
         stepInto(errorString);
         return;
     }
     m_scheduledDebuggerStep = StepOver;
     m_steppingFromFramework = isTopPausedCallFrameBlackboxed();
     m_session->releaseObjectGroup(V8InspectorSession::backtraceObjectGroup);
     debugger().stepOverStatement();
 }
 
@@ skipping 66 matching lines @@
     if (scope.frameOrdinal() >= m_pausedCallFrames.size()) {
         *errorString = "Could not find call frame with given id";
         return;
     }
 
     if (includeCommandLineAPI.fromMaybe(false) && !scope.installCommandLineAPI())
         return;
     if (doNotPauseOnExceptionsAndMuteConsole.fromMaybe(false))
         scope.ignoreExceptionsAndMuteConsole();
 
-    v8::MaybeLocal<v8::Value> maybeResultValue = m_pausedCallFrames[scope.frameOrdinal()].get()->evaluate(toV8String(m_isolate, expression));
+    v8::MaybeLocal<v8::Value> maybeResultValue = m_pausedCallFrames[scope.frameOrdinal()]->evaluate(toV8String(m_isolate, expression));
 
     // Re-initialize after running client's code, as it could have destroyed context or session.
     if (!scope.initialize())
         return;
     scope.injectedScript()->wrapEvaluateResult(errorString,
         maybeResultValue,
         scope.tryCatch(),
         objectGroup.fromMaybe(""),
         returnByValue.fromMaybe(false),
         generatePreview.fromMaybe(false),
@@ skipping 17 matching lines @@
         return;
 
     v8::Local<v8::Value> newValue;
     if (!scope.injectedScript()->resolveCallArgument(errorString, newValueArgument.get()).ToLocal(&newValue))
         return;
 
     if (scope.frameOrdinal() >= m_pausedCallFrames.size()) {
         *errorString = "Could not find call frame with given id";
         return;
     }
-    v8::MaybeLocal<v8::Value> result = m_pausedCallFrames[scope.frameOrdinal()].get()->setVariableValue(scopeNumber, toV8String(m_isolate, variableName), newValue);
+    v8::MaybeLocal<v8::Value> result = m_pausedCallFrames[scope.frameOrdinal()]->setVariableValue(scopeNumber, toV8String(m_isolate, variableName), newValue);
     if (scope.tryCatch().HasCaught() || result.IsEmpty()) {
         *errorString = "Internal error";
         return;
     }
 }
 
 void V8DebuggerAgentImpl::setAsyncCallStackDepth(ErrorString* errorString, int depth)
 {
     if (!checkEnabled(errorString))
         return;
@@ skipping 45 matching lines @@
 
 void V8DebuggerAgentImpl::asyncTaskFinished(void* task)
 {
     if (!m_maxAsyncCallStackDepth)
         return;
     // We could start instrumenting half way and the stack is empty.
     if (!m_currentStacks.size())
         return;
 
 #if ENABLE(ASSERT)
-    ASSERT(m_currentTasks.last() == task);
+    DCHECK(m_currentTasks.last() == task);
     m_currentTasks.removeLast();
 #endif
 
     m_currentStacks.removeLast();
     if (!m_recurringTasks.contains(task))
         m_asyncTaskStacks.remove(task);
 }
 
 void V8DebuggerAgentImpl::allAsyncTasksCanceled()
 {
@@ skipping 134 matching lines @@
         // Context has been reported as removed while on pause.
         return Array<CallFrame>::create();
     }
 
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Context> context = topFrameInjectedScript->context()->context();
     v8::Context::Scope contextScope(context);
 
     v8::Local<v8::Array> objects = v8::Array::New(m_isolate);
     for (size_t frameOrdinal = 0; frameOrdinal < m_pausedCallFrames.size(); ++frameOrdinal) {
-        JavaScriptCallFrame* currentCallFrame = m_pausedCallFrames[frameOrdinal].get();
+        JavaScriptCallFrame* currentCallFrame = m_pausedCallFrames[frameOrdinal];
 
         v8::Local<v8::Object> details = currentCallFrame->details();
         if (hasInternalError(errorString, details.IsEmpty()))
             return Array<CallFrame>::create();
 
         int contextId = currentCallFrame->contextId();
         InjectedScript* injectedScript = contextId ? m_session->findInjectedScript(&ignored, contextId) : nullptr;
         if (!injectedScript)
             injectedScript = topFrameInjectedScript;
 
@@ skipping 32 matching lines @@
     if (m_pausedContext.IsEmpty() || !m_maxAsyncCallStackDepth || !m_currentStacks.size() || !m_currentStacks.last())
         return nullptr;
 
     return m_currentStacks.last()->buildInspectorObjectForTail(this);
 }
 
 V8StackTraceImpl* V8DebuggerAgentImpl::currentAsyncCallChain()
 {
     if (!m_currentStacks.size())
         return nullptr;
-    return m_currentStacks.last().get();
+    return m_currentStacks.last();
 }
 
 void V8DebuggerAgentImpl::didParseSource(const V8DebuggerParsedScript& parsedScript)
 {
     V8DebuggerScript script = parsedScript.script;
 
     bool isDeprecatedSourceURL = false;
     if (!parsedScript.success)
         script.setSourceURL(V8ContentSearchUtil::findSourceURL(script.source(), false, &isDeprecatedSourceURL));
     else if (script.hasSourceURL())
@@ skipping 51 matching lines @@
         breakpointObject->getString(DebuggerAgentState::condition, &breakpoint.condition);
         OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(cookie.first, parsedScript.scriptId, breakpoint, UserBreakpointSource);
         if (location)
             m_frontend->breakpointResolved(cookie.first, std::move(location));
     }
 }
 
 V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Value> exception, const protocol::Vector<String16>& hitBreakpoints, bool isPromiseRejection)
 {
     JavaScriptCallFrames callFrames = debugger().currentCallFrames(1);
-    JavaScriptCallFrame* topCallFrame = callFrames.size() > 0 ? callFrames[0].get() : nullptr;
+    JavaScriptCallFrame* topCallFrame = callFrames.size() > 0 ? callFrames[0] : nullptr;
 
     V8DebuggerAgentImpl::SkipPauseRequest result;
     if (m_skipAllPauses)
         result = RequestContinue;
     else if (!hitBreakpoints.isEmpty())
         result = RequestNoSkip; // Don't skip explicit breakpoints even if set in frameworks.
     else if (!exception.IsEmpty())
         result = shouldSkipExceptionPause(topCallFrame);
     else if (m_scheduledDebuggerStep != NoStep || m_javaScriptPauseScheduled || m_pausingOnNativeEvent)
         result = shouldSkipStepPause(topCallFrame);
     else
         result = RequestNoSkip;
 
     m_skipNextDebuggerStepOut = false;
     if (result != RequestNoSkip)
         return result;
     // Skip pauses inside V8 internal scripts and on syntax errors.
     if (!topCallFrame)
         return RequestContinue;
 
-    ASSERT(m_pausedContext.IsEmpty());
+    DCHECK(m_pausedContext.IsEmpty());
     m_pausedCallFrames.swap(debugger().currentCallFrames());
     m_pausedContext.Reset(m_isolate, context);
     v8::HandleScope handles(m_isolate);
 
     if (!exception.IsEmpty()) {
         ErrorString ignored;
         InjectedScript* injectedScript = m_session->findInjectedScript(&ignored, V8Debugger::contextId(context));
         if (injectedScript) {
             m_breakReason = isPromiseRejection ? protocol::Debugger::Paused::ReasonEnum::PromiseRejection : protocol::Debugger::Paused::ReasonEnum::Exception;
             ErrorString errorString;
@@ skipping 93 matching lines @@
     if (!enabled())
         return;
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     allAsyncTasksCanceled();
 }
 
 } // namespace blink