DevTools: migrate remote debugging protocol generators to jinja2.

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/JSONValues.h"
 #include "platform/v8_inspector/AsyncCallChain.h"
 #include "platform/v8_inspector/IgnoreExceptionsScope.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InjectedScriptHost.h"
 #include "platform/v8_inspector/InjectedScriptManager.h"
 #include "platform/v8_inspector/JavaScriptCallFrame.h"
 #include "platform/v8_inspector/PromiseTracker.h"
 #include "platform/v8_inspector/RemoteObjectId.h"
 #include "platform/v8_inspector/V8AsyncCallTracker.h"
 #include "platform/v8_inspector/V8JavaScriptCallFrame.h"
 #include "platform/v8_inspector/V8Regex.h"
 #include "platform/v8_inspector/V8RuntimeAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8ContentSearchUtil.h"
 #include "platform/v8_inspector/public/V8Debugger.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 #include "wtf/Optional.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 
-using blink::protocol::TypeBuilder::Array;
-using blink::protocol::TypeBuilder::Debugger::AsyncOperation;
-using blink::protocol::TypeBuilder::Debugger::BreakpointId;
-using blink::protocol::TypeBuilder::Debugger::CallFrame;
-using blink::protocol::TypeBuilder::Debugger::CollectionEntry;
-using blink::protocol::TypeBuilder::Runtime::ExceptionDetails;
-using blink::protocol::TypeBuilder::Debugger::FunctionDetails;
-using blink::protocol::TypeBuilder::Debugger::GeneratorObjectDetails;
-using blink::protocol::TypeBuilder::Debugger::PromiseDetails;
-using blink::protocol::TypeBuilder::Runtime::ScriptId;
-using blink::protocol::TypeBuilder::Debugger::StackTrace;
-using blink::protocol::TypeBuilder::Runtime::RemoteObject;
+using blink::protocol::Array;
+using blink::protocol::OptionalValue;
+using blink::protocol::Debugger::AsyncOperation;
+using blink::protocol::Debugger::BreakpointId;
+using blink::protocol::Debugger::CallFrame;
+using blink::protocol::Debugger::CollectionEntry;
+using blink::protocol::Runtime::ExceptionDetails;
+using blink::protocol::Debugger::FunctionDetails;
+using blink::protocol::Debugger::GeneratorObjectDetails;
+using blink::protocol::Debugger::PromiseDetails;
+using blink::protocol::Runtime::ScriptId;
+using blink::protocol::Debugger::StackTrace;
+using blink::protocol::Runtime::RemoteObject;
 
 namespace blink {
 
 namespace DebuggerAgentState {
 static const char javaScriptBreakpoints[] = "javaScriptBreakopints";
 static const char pauseOnExceptionsState[] = "pauseOnExceptionsState";
 static const char asyncCallStackDepth[] = "asyncCallStackDepth";
 static const char promiseTrackerEnabled[] = "promiseTrackerEnabled";
 static const char promiseTrackerCaptureStacks[] = "promiseTrackerCaptureStacks";
 
 // Breakpoint properties.
 static const char url[] = "url";
 static const char isRegex[] = "isRegex";
 static const char lineNumber[] = "lineNumber";
 static const char columnNumber[] = "columnNumber";
 static const char condition[] = "condition";
 static const char skipAllPauses[] = "skipAllPauses";
 
 } // namespace DebuggerAgentState;
 
-inline static bool asBool(const bool* const b)
-{
-    return b ? *b : false;
-}
-
 static const int maxSkipStepFrameCount = 128;
 
 const char V8DebuggerAgent::backtraceObjectGroup[] = "backtrace";
 
 const int V8DebuggerAgent::unknownAsyncOperationId = 0;
 
 static String breakpointIdSuffix(V8DebuggerAgentImpl::BreakpointSource source)
 {
     switch (source) {
     case V8DebuggerAgentImpl::UserBreakpointSource:
@@ skipping 47 matching lines @@
 }
 
 V8DebuggerAgentImpl::V8DebuggerAgentImpl(InjectedScriptManager* injectedScriptManager, V8DebuggerImpl* debugger, int contextGroupId)
     : m_injectedScriptManager(injectedScriptManager)
     , m_debugger(debugger)
     , m_contextGroupId(contextGroupId)
     , m_enabled(false)
     , m_state(nullptr)
     , m_frontend(nullptr)
     , m_isolate(debugger->isolate())
-    , m_breakReason(protocol::Frontend::Debugger::Reason::Other)
+    , m_breakReason(protocol::Debugger::Paused::ReasonEnum::Other)
     , m_scheduledDebuggerStep(NoStep)
     , m_skipNextDebuggerStepOut(false)
     , m_javaScriptPauseScheduled(false)
     , m_steppingFromFramework(false)
     , m_pausingOnNativeEvent(false)
     , m_pausingOnAsyncOperation(false)
     , m_skippedStepFrameCount(0)
     , m_recursionLevelForStepOut(0)
     , m_recursionLevelForStepFrame(0)
     , m_skipAllPauses(false)
@@ skipping 160 matching lines @@
 
 static bool matches(V8DebuggerImpl* debugger, const String& url, const String& pattern, bool isRegex)
 {
     if (isRegex) {
         V8Regex regex(debugger, pattern, TextCaseSensitive);
         return regex.match(url) != -1;
     }
     return url == pattern;
 }
 
-void V8DebuggerAgentImpl::setBreakpointByUrl(ErrorString* errorString, int lineNumber, const String* const optionalURL, const String* const optionalURLRegex, const int* const optionalColumnNumber, const String* const optionalCondition, BreakpointId* outBreakpointId, RefPtr<Array<protocol::TypeBuilder::Debugger::Location>>& locations)
+void V8DebuggerAgentImpl::setBreakpointByUrl(ErrorString* errorString,
+    int lineNumber,
+    const OptionalValue<String>& optionalURL,
+    const OptionalValue<String>& optionalURLRegex,
+    const OptionalValue<int>& optionalColumnNumber,
+    const OptionalValue<String>& optionalCondition,
+    BreakpointId* outBreakpointId,
+    OwnPtr<protocol::Array<protocol::Debugger::Location>>* locations)
 {
-    locations = Array<protocol::TypeBuilder::Debugger::Location>::create();
-    if (!optionalURL == !optionalURLRegex) {
+    *locations = Array<protocol::Debugger::Location>::create();
+    if (optionalURL.hasValue() == optionalURLRegex.hasValue()) {
         *errorString = "Either url or urlRegex must be specified.";
         return;
     }
 
-    String url = optionalURL ? *optionalURL : *optionalURLRegex;
+    String url = optionalURL.hasValue() ? optionalURL.get() : optionalURLRegex.get();
     int columnNumber = 0;
-    if (optionalColumnNumber) {
-        columnNumber = *optionalColumnNumber;
+    if (optionalColumnNumber.hasValue()) {
+        columnNumber = optionalColumnNumber.get();
         if (columnNumber < 0) {
             *errorString = "Incorrect column number";
             return;
         }
     }
-    String condition = optionalCondition ? *optionalCondition : "";
-    bool isRegex = optionalURLRegex;
+    String condition = optionalCondition.get("");
+    bool isRegex = optionalURLRegex.hasValue();
 
     String breakpointId = (isRegex ? "/" + url + "/" : url) + ':' + String::number(lineNumber) + ':' + String::number(columnNumber);
     RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
     if (!breakpointsCookie) {
         breakpointsCookie = JSONObject::create();
         m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie);
     }
     if (breakpointsCookie->find(breakpointId) != breakpointsCookie->end()) {
         *errorString = "Breakpoint at specified location already exists.";
         return;
     }
 
     breakpointsCookie->setObject(breakpointId, buildObjectForBreakpointCookie(url, lineNumber, columnNumber, condition, isRegex));
     m_state->setObject(DebuggerAgentState::javaScriptBreakpoints, breakpointsCookie);
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     for (auto& script : m_scripts) {
         if (!matches(m_debugger, script.value.sourceURL(), url, isRegex))
             continue;
-        RefPtr<protocol::TypeBuilder::Debugger::Location> location = resolveBreakpoint(breakpointId, script.key, breakpoint, UserBreakpointSource);
+        OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(breakpointId, script.key, breakpoint, UserBreakpointSource);
         if (location)
-            locations->addItem(location);
+            (*locations)->addItem(location.release());
     }
 
     *outBreakpointId = breakpointId;
 }
 
-static bool parseLocation(ErrorString* errorString, PassRefPtr<JSONObject> location, String* scriptId, int* lineNumber, int* columnNumber)
+static bool parseLocation(ErrorString* errorString, PassOwnPtr<protocol::Debugger::Location> location, String* scriptId, int* lineNumber, int* columnNumber)
 {
-    if (!location->getString("scriptId", scriptId) || !location->getNumber("lineNumber", lineNumber)) {
+    if (!location->hasScriptId() || !location->hasLineNumber()) {
         // FIXME: replace with input validation.
         *errorString = "scriptId and lineNumber are required.";
         return false;
     }
-    *columnNumber = 0;
-    location->getNumber("columnNumber", columnNumber);
+    *scriptId = location->getScriptId();
+    *lineNumber = location->getLineNumber();
+    *columnNumber = location->getColumnNumber(0);
     return true;
 }
 
-void V8DebuggerAgentImpl::setBreakpoint(ErrorString* errorString, const RefPtr<JSONObject>& location, const String* const optionalCondition, BreakpointId* outBreakpointId, RefPtr<protocol::TypeBuilder::Debugger::Location>& actualLocation)
+void V8DebuggerAgentImpl::setBreakpoint(ErrorString* errorString,
+    PassOwnPtr<protocol::Debugger::Location> location,
+    const OptionalValue<String>& optionalCondition,
+    BreakpointId* outBreakpointId,
+    OwnPtr<protocol::Debugger::Location>* actualLocation)
 {
     String scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, location, &scriptId, &lineNumber, &columnNumber))
         return;
 
-    String condition = optionalCondition ? *optionalCondition : emptyString();
+    String condition = optionalCondition.get("");
 
     String breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, UserBreakpointSource);
     if (m_breakpointIdToDebuggerBreakpointIds.find(breakpointId) != m_breakpointIdToDebuggerBreakpointIds.end()) {
         *errorString = "Breakpoint at specified location already exists.";
         return;
     }
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
-    actualLocation = resolveBreakpoint(breakpointId, scriptId, breakpoint, UserBreakpointSource);
-    if (actualLocation)
+    *actualLocation = resolveBreakpoint(breakpointId, scriptId, breakpoint, UserBreakpointSource);
+    if (*actualLocation)
         *outBreakpointId = breakpointId;
     else
         *errorString = "Could not resolve breakpoint";
 }
 
 void V8DebuggerAgentImpl::removeBreakpoint(ErrorString* errorString, const String& breakpointId)
 {
     if (!checkEnabled(errorString))
         return;
     RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
@@ skipping 10 matching lines @@
         return;
     for (size_t i = 0; i < debuggerBreakpointIdsIterator->value.size(); ++i) {
         const String& debuggerBreakpointId = debuggerBreakpointIdsIterator->value[i];
         debugger().removeBreakpoint(debuggerBreakpointId);
         m_serverBreakpoints.remove(debuggerBreakpointId);
         m_muteBreakpoints.remove(debuggerBreakpointId);
     }
     m_breakpointIdToDebuggerBreakpointIds.remove(debuggerBreakpointIdsIterator);
 }
 
-void V8DebuggerAgentImpl::continueToLocation(ErrorString* errorString, const RefPtr<JSONObject>& location, const bool* interstateLocationOpt)
+void V8DebuggerAgentImpl::continueToLocation(ErrorString* errorString,
+    PassOwnPtr<protocol::Debugger::Location> location,
+    const protocol::OptionalValue<bool>& interstateLocationOpt)
 {
     if (!checkEnabled(errorString))
         return;
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
 
     String scriptId;
     int lineNumber;
     int columnNumber;
 
     if (!parseLocation(errorString, location, &scriptId, &lineNumber, &columnNumber))
         return;
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, "");
-    m_continueToLocationBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &lineNumber, &columnNumber, asBool(interstateLocationOpt));
+    m_continueToLocationBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &lineNumber, &columnNumber, interstateLocationOpt.get(false));
     resume(errorString);
 }
 
-void V8DebuggerAgentImpl::getStepInPositions(ErrorString* errorString, const String& callFrameId, RefPtr<Array<protocol::TypeBuilder::Debugger::Location>>& positions)
+void V8DebuggerAgentImpl::getStepInPositions(ErrorString* errorString, const String& callFrameId, OwnPtr<Array<protocol::Debugger::Location>>* positions)
 {
     if (!isPaused() || m_currentCallStack.IsEmpty()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(callFrameId);
     if (!remoteId) {
         *errorString = "Invalid call frame id";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Object> callStack = m_currentCallStack.Get(m_isolate);
     injectedScript->getStepInPositions(errorString, callStack, callFrameId, positions);
 }
 
-void V8DebuggerAgentImpl::getBacktrace(ErrorString* errorString, RefPtr<Array<CallFrame>>& callFrames, RefPtr<StackTrace>& asyncStackTrace)
+void V8DebuggerAgentImpl::getBacktrace(ErrorString* errorString, OwnPtr<Array<CallFrame>>* callFrames, OwnPtr<StackTrace>* asyncStackTrace)
 {
     if (!assertPaused(errorString))
         return;
     m_currentCallStack.Reset(m_isolate, debugger().currentCallFrames());
-    callFrames = currentCallFrames();
-    asyncStackTrace = currentAsyncStackTrace();
+    *callFrames = currentCallFrames();
+    *asyncStackTrace = currentAsyncStackTrace();
 }
 
 bool V8DebuggerAgentImpl::isCallStackEmptyOrBlackboxed()
 {
     ASSERT(enabled());
     for (int index = 0; ; ++index) {
         RefPtr<JavaScriptCallFrame> frame = debugger().callFrameNoScopes(index);
         if (!frame)
             break;
         if (!isCallFrameWithUnknownScriptOrBlackboxed(frame.release()))
@@ skipping 71 matching lines @@
     if (m_skippedStepFrameCount >= maxSkipStepFrameCount)
         return RequestStepOut;
 
     if (!m_skippedStepFrameCount)
         m_recursionLevelForStepFrame = 1;
 
     ++m_skippedStepFrameCount;
     return RequestStepFrame;
 }
 
-PassRefPtr<protocol::TypeBuilder::Debugger::Location> V8DebuggerAgentImpl::resolveBreakpoint(const String& breakpointId, const String& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
+PassOwnPtr<protocol::Debugger::Location> V8DebuggerAgentImpl::resolveBreakpoint(const String& breakpointId, const String& scriptId, const ScriptBreakpoint& breakpoint, BreakpointSource source)
 {
     ASSERT(enabled());
     // FIXME: remove these checks once crbug.com/520702 is resolved.
     RELEASE_ASSERT(!breakpointId.isEmpty());
     RELEASE_ASSERT(!scriptId.isEmpty());
     ScriptsMap::iterator scriptIterator = m_scripts.find(scriptId);
     if (scriptIterator == m_scripts.end())
         return nullptr;
     V8DebuggerScript& script = scriptIterator->value;
     if (breakpoint.lineNumber < script.startLine() || script.endLine() < breakpoint.lineNumber)
         return nullptr;
 
     int actualLineNumber;
     int actualColumnNumber;
     String debuggerBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &actualLineNumber, &actualColumnNumber, false);
     if (debuggerBreakpointId.isEmpty())
         return nullptr;
 
     m_serverBreakpoints.set(debuggerBreakpointId, std::make_pair(breakpointId, source));
     if (breakpoint.condition == "false")
         m_muteBreakpoints.set(debuggerBreakpointId, std::make_pair(scriptId, breakpoint.lineNumber));
 
     RELEASE_ASSERT(!breakpointId.isEmpty());
     BreakpointIdToDebuggerBreakpointIdsMap::iterator debuggerBreakpointIdsIterator = m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
     if (debuggerBreakpointIdsIterator == m_breakpointIdToDebuggerBreakpointIds.end())
         m_breakpointIdToDebuggerBreakpointIds.set(breakpointId, Vector<String>()).storedValue->value.append(debuggerBreakpointId);
     else
         debuggerBreakpointIdsIterator->value.append(debuggerBreakpointId);
 
-    RefPtr<protocol::TypeBuilder::Debugger::Location> location = protocol::TypeBuilder::Debugger::Location::create()
+    OwnPtr<protocol::Debugger::Location> location = protocol::Debugger::Location::create()
         .setScriptId(scriptId)
-        .setLineNumber(actualLineNumber);
-    location->setColumnNumber(actualColumnNumber);
-    return location;
+        .setLineNumber(actualLineNumber)
+        .setColumnNumber(actualColumnNumber).build();
+    return location.release();
 }
 
-void V8DebuggerAgentImpl::searchInContent(ErrorString* error, const String& scriptId, const String& query, const bool* const optionalCaseSensitive, const bool* const optionalIsRegex, RefPtr<Array<protocol::TypeBuilder::Debugger::SearchMatch>>& results)
+void V8DebuggerAgentImpl::searchInContent(ErrorString* error, const String& scriptId, const String& query,
+    const OptionalValue<bool>& optionalCaseSensitive,
+    const OptionalValue<bool>& optionalIsRegex,
+    OwnPtr<Array<protocol::Debugger::SearchMatch>>* results)
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
-        results = V8ContentSearchUtil::searchInTextByLines(m_debugger, it->value.source(), query, asBool(optionalCaseSensitive), asBool(optionalIsRegex));
+        *results = V8ContentSearchUtil::searchInTextByLines(m_debugger, it->value.source(), query, optionalCaseSensitive.get(false), optionalIsRegex.get(false));
     else
         *error = "No script for id: " + scriptId;
 }
 
-void V8DebuggerAgentImpl::setScriptSource(ErrorString* error, const String& scriptId, const String& newContent, const bool* const preview, RefPtr<Array<CallFrame>>& newCallFrames, protocol::TypeBuilder::OptOutput<bool>* stackChanged, RefPtr<StackTrace>& asyncStackTrace, RefPtr<protocol::TypeBuilder::Debugger::SetScriptSourceError>& optOutCompileError)
+void V8DebuggerAgentImpl::setScriptSource(ErrorString* error,
+    const String& scriptId,
+    const String& newContent,
+    const OptionalValue<bool>& preview,
+    OwnPtr<protocol::Array<protocol::Debugger::CallFrame>>* newCallFrames,
+    OptionalValue<bool>* stackChanged,
+    OwnPtr<StackTrace>* asyncStackTrace,
+    OwnPtr<protocol::Debugger::SetScriptSourceError>* optOutCompileError)
 {
     if (!checkEnabled(error))
         return;
-    if (!debugger().setScriptSource(scriptId, newContent, asBool(preview), error, optOutCompileError, &m_currentCallStack, stackChanged))
+    if (!debugger().setScriptSource(scriptId, newContent, preview.get(false), error, optOutCompileError, &m_currentCallStack, stackChanged))
         return;
 
-    newCallFrames = currentCallFrames();
-    asyncStackTrace = currentAsyncStackTrace();
+    *newCallFrames = currentCallFrames();
+    *asyncStackTrace = currentAsyncStackTrace();
 
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end())
         return;
     it->value.setSource(newContent);
 }
 
-void V8DebuggerAgentImpl::restartFrame(ErrorString* errorString, const String& callFrameId, RefPtr<Array<CallFrame>>& newCallFrames, RefPtr<StackTrace>& asyncStackTrace)
+void V8DebuggerAgentImpl::restartFrame(ErrorString* errorString,
+    const String& callFrameId,
+    OwnPtr<Array<CallFrame>>* newCallFrames,
+    OwnPtr<StackTrace>* asyncStackTrace)
 {
     if (!isPaused() || m_currentCallStack.IsEmpty()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(callFrameId);
     if (!remoteId) {
         *errorString = "Invalid call frame id";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Object> callStack = m_currentCallStack.Get(m_isolate);
     injectedScript->restartFrame(errorString, callStack, callFrameId);
     m_currentCallStack.Reset(m_isolate, debugger().currentCallFrames());
-    newCallFrames = currentCallFrames();
-    asyncStackTrace = currentAsyncStackTrace();
+    *newCallFrames = currentCallFrames();
+    *asyncStackTrace = currentAsyncStackTrace();
 }
 
 void V8DebuggerAgentImpl::getScriptSource(ErrorString* error, const String& scriptId, String* scriptSource)
 {
     if (!checkEnabled(error))
         return;
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end()) {
         *error = "No script for id: " + scriptId;
         return;
     }
     *scriptSource = it->value.source();
 }
 
-void V8DebuggerAgentImpl::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<FunctionDetails>& details)
+void V8DebuggerAgentImpl::getFunctionDetails(ErrorString* errorString, const String& functionId, OwnPtr<FunctionDetails>* details)
 {
     if (!checkEnabled(errorString))
         return;
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(functionId);
     if (!remoteId) {
         *errorString = "Invalid object id";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Function object id is obsolete";
         return;
     }
-    injectedScript->getFunctionDetails(errorString, functionId, &details);
+    injectedScript->getFunctionDetails(errorString, functionId, details);
 }
 
-void V8DebuggerAgentImpl::getGeneratorObjectDetails(ErrorString* errorString, const String& objectId, RefPtr<GeneratorObjectDetails>& details)
+void V8DebuggerAgentImpl::getGeneratorObjectDetails(ErrorString* errorString, const String& objectId, OwnPtr<GeneratorObjectDetails>* details)
 {
     if (!checkEnabled(errorString))
         return;
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(objectId);
     if (!remoteId) {
         *errorString = "Invalid object id";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Inspected frame has gone";
         return;
     }
-    injectedScript->getGeneratorObjectDetails(errorString, objectId, &details);
+    injectedScript->getGeneratorObjectDetails(errorString, objectId, details);
 }
 
-void V8DebuggerAgentImpl::getCollectionEntries(ErrorString* errorString, const String& objectId, RefPtr<protocol::TypeBuilder::Array<CollectionEntry>>& entries)
+void V8DebuggerAgentImpl::getCollectionEntries(ErrorString* errorString, const String& objectId, OwnPtr<protocol::Array<CollectionEntry>>* entries)
 {
     if (!checkEnabled(errorString))
         return;
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(objectId);
     if (!remoteId) {
         *errorString = "Invalid object id";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Inspected frame has gone";
         return;
     }
-    injectedScript->getCollectionEntries(errorString, objectId, &entries);
+    injectedScript->getCollectionEntries(errorString, objectId, entries);
 }
 
-void V8DebuggerAgentImpl::schedulePauseOnNextStatement(protocol::Frontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
+void V8DebuggerAgentImpl::schedulePauseOnNextStatement(const String& breakReason, PassRefPtr<JSONObject> data)
 {
     ASSERT(enabled());
     if (m_scheduledDebuggerStep == StepInto || m_javaScriptPauseScheduled || isPaused())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_pausingOnNativeEvent = true;
     m_skipNextDebuggerStepOut = false;
     debugger().setPauseOnNextStatement(true);
 }
@@ skipping 155 matching lines @@
     if (!m_currentAsyncCallChain || asyncOrdinal < 1 || asyncOrdinal > m_currentAsyncCallChain->callStacks().size()) {
         *errorString = "Async call stack not found";
         return false;
     }
     RefPtr<AsyncCallStack> asyncStack = m_currentAsyncCallChain->callStacks()[asyncOrdinal - 1];
     *callStack = asyncStack->callFrames(m_isolate);
     *isAsync = true;
     return true;
 }
 
-void V8DebuggerAgentImpl::evaluateOnCallFrame(ErrorString* errorString, const String& callFrameId, const String& expression, const String* const objectGroup, const bool* const includeCommandLineAPI, const bool* const doNotPauseOnExceptionsAndMuteConsole, const bool* const returnByValue, const bool* generatePreview, RefPtr<RemoteObject>& result, protocol::TypeBuilder::OptOutput<bool>* wasThrown, RefPtr<protocol::TypeBuilder::Runtime::ExceptionDetails>& exceptionDetails)
+void V8DebuggerAgentImpl::evaluateOnCallFrame(ErrorString* errorString,
+    const String& callFrameId,
+    const String& expression,
+    const OptionalValue<String>& objectGroup,
+    const OptionalValue<bool>& includeCommandLineAPI,
+    const OptionalValue<bool>& doNotPauseOnExceptionsAndMuteConsole,
+    const OptionalValue<bool>& returnByValue,
+    const OptionalValue<bool>& generatePreview,
+    OwnPtr<RemoteObject>* result,
+    OptionalValue<bool>* wasThrown,
+    OwnPtr<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     if (!isPaused() || m_currentCallStack.IsEmpty()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(callFrameId);
     if (!remoteId) {
         *errorString = "Invalid call frame id";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (!injectedScript) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     v8::HandleScope scope(m_isolate);
     bool isAsync = false;
     v8::Local<v8::Object> callStack;
     if (!callStackForId(errorString, *remoteId, &callStack, &isAsync))
         return;
     ASSERT(!callStack.IsEmpty());
 
     Optional<IgnoreExceptionsScope> ignoreExceptionsScope;
-    if (asBool(doNotPauseOnExceptionsAndMuteConsole))
+    if (doNotPauseOnExceptionsAndMuteConsole.get(false))
         ignoreExceptionsScope.emplace(m_debugger);
 
-    injectedScript->evaluateOnCallFrame(errorString, callStack, isAsync, callFrameId, expression, objectGroup ? *objectGroup : "", asBool(includeCommandLineAPI), asBool(returnByValue), asBool(generatePreview), &result, wasThrown, &exceptionDetails);
+    injectedScript->evaluateOnCallFrame(errorString, callStack, isAsync, callFrameId, expression, objectGroup.get(""), includeCommandLineAPI.get(false), returnByValue.get(false), generatePreview.get(false), result, wasThrown, exceptionDetails);
 }
 
-void V8DebuggerAgentImpl::setVariableValue(ErrorString* errorString, int scopeNumber, const String& variableName, const RefPtr<JSONObject>& newValue, const String* callFrameId, const String* functionObjectId)
+void V8DebuggerAgentImpl::setVariableValue(ErrorString* errorString,
+    int scopeNumber,
+    const String& variableName,
+    PassOwnPtr<protocol::Runtime::CallArgument> newValue,
+    const OptionalValue<String>& callFrameId,
+    const OptionalValue<String>& functionObjectId)
 {
     if (!checkEnabled(errorString))
         return;
     InjectedScript* injectedScript = nullptr;
-    if (callFrameId) {
+    if (callFrameId.hasValue()) {
         if (!isPaused() || m_currentCallStack.IsEmpty()) {
             *errorString = "Attempt to access callframe when debugger is not on pause";
             return;
         }
-        OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(*callFrameId);
+        OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(callFrameId.get());
         if (!remoteId) {
             *errorString = "Invalid call frame id";
             return;
         }
         injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
         if (!injectedScript) {
             *errorString = "Inspected frame has gone";
             return;
         }
-    } else if (functionObjectId) {
-        OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(*functionObjectId);
+    } else if (functionObjectId.hasValue()) {
+        OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(functionObjectId.get());
         if (!remoteId) {
             *errorString = "Invalid object id";
             return;
         }
         injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
         if (!injectedScript) {
             *errorString = "Function object id cannot be resolved";
             return;
         }
     } else {
         *errorString = "Either call frame or function object must be specified";
         return;
     }
-    String newValueString = newValue->toJSONString();
-
+    String newValueString = protocol::toValue(newValue)->toJSONString();
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Object> currentCallStack = m_currentCallStack.Get(m_isolate);
     injectedScript->setVariableValue(errorString, currentCallStack, callFrameId, functionObjectId, scopeNumber, variableName, newValueString);
 }
 
 void V8DebuggerAgentImpl::setAsyncCallStackDepth(ErrorString* errorString, int depth)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setNumber(DebuggerAgentState::asyncCallStackDepth, depth);
     internalSetAsyncCallStackDepth(depth);
 }
 
-void V8DebuggerAgentImpl::enablePromiseTracker(ErrorString* errorString, const bool* captureStacks)
+void V8DebuggerAgentImpl::enablePromiseTracker(ErrorString* errorString,
+    const OptionalValue<bool>& captureStacks)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, true);
-    m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, asBool(captureStacks));
-    m_promiseTracker->setEnabled(true, asBool(captureStacks));
+    m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, captureStacks.get(false));
+    m_promiseTracker->setEnabled(true, captureStacks.get(false));
 }
 
 void V8DebuggerAgentImpl::disablePromiseTracker(ErrorString* errorString)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, false);
     m_promiseTracker->setEnabled(false, false);
 }
 
-void V8DebuggerAgentImpl::getPromiseById(ErrorString* errorString, int promiseId, const String* objectGroup, RefPtr<RemoteObject>& promise)
+void V8DebuggerAgentImpl::getPromiseById(ErrorString* errorString, int promiseId, const OptionalValue<String>& objectGroup, OwnPtr<RemoteObject>* promise)
 {
     if (!checkEnabled(errorString))
         return;
     if (!m_promiseTracker->isEnabled()) {
         *errorString = "Promise tracking is disabled";
         return;
     }
     v8::HandleScope handles(m_isolate);
     v8::Local<v8::Object> value = m_promiseTracker->promiseById(promiseId);
     if (value.IsEmpty()) {
         *errorString = "Promise with specified ID not found.";
         return;
     }
     InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(value->CreationContext());
-    promise = injectedScript->wrapObject(value, objectGroup ? *objectGroup : "");
+    *promise = injectedScript->wrapObject(value, objectGroup.get(""));
 }
 
-void V8DebuggerAgentImpl::didUpdatePromise(protocol::Frontend::Debugger::EventType::Enum eventType, PassRefPtr<protocol::TypeBuilder::Debugger::PromiseDetails> promise)
+void V8DebuggerAgentImpl::didUpdatePromise(const String& eventType, PassOwnPtr<protocol::Debugger::PromiseDetails> promise)
 {
     if (m_frontend)
         m_frontend->promiseUpdated(eventType, promise);
 }
 
 int V8DebuggerAgentImpl::traceAsyncOperationStarting(const String& description)
 {
     v8::HandleScope scope(m_isolate);
     v8::Local<v8::Object> callFrames = debugger().currentCallFramesForAsyncStack();
     RefPtr<AsyncCallChain> chain;
@@ skipping 131 matching lines @@
             v8::Local<v8::Object> callFrames = callStacks.at(i)->callFrames(m_isolate);
             RefPtr<JavaScriptCallFrame> jsCallFrame = toJavaScriptCallFrame(chain->creationContext(m_isolate), callFrames);
             if (!jsCallFrame)
                 continue;
             Vector<V8StackTraceImpl::Frame> frames;
             toScriptCallFrames(jsCallFrame.get(), frames);
             stack = V8StackTraceImpl::create(callStacks.at(i)->description(), frames, stack.release());
         }
 
         if (stack) {
-            RefPtr<AsyncOperation> operation = AsyncOperation::create()
+            OwnPtr<AsyncOperation> operation = AsyncOperation::create()
                 .setId(operationId)
-                .release();
-            operation->setStack(stack->buildInspectorObject());
+                .setStack(stack->buildInspectorObject()).build();
             m_frontend->asyncOperationStarted(operation.release());
         }
     }
 
     m_asyncOperationNotifications.clear();
 }
 
 void V8DebuggerAgentImpl::clearCurrentAsyncOperation()
 {
     if (m_pendingTraceAsyncOperationCompleted && m_currentAsyncOperationId != unknownAsyncOperationId)
@@ skipping 38 matching lines @@
         *errorString = "Can only perform operation while tracking async call stacks.";
         return;
     }
     if (operationId <= 0) {
         *errorString = "Wrong async operation id.";
         return;
     }
     m_asyncOperationBreakpoints.remove(operationId);
 }
 
-void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String& scriptId, const RefPtr<JSONArray>& inPositions)
+void V8DebuggerAgentImpl::setBlackboxedRanges(ErrorString* error, const String& scriptId, PassOwnPtr<protocol::Array<protocol::Debugger::ScriptPosition>> inPositions)
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it == m_scripts.end()) {
         *error = "No script with passed id.";
         return;
     }
 
     if (!inPositions->length()) {
         m_blackboxedPositions.remove(scriptId);
         return;
     }
 
     Vector<std::pair<int, int>> positions(inPositions->length());
     for (size_t i = 0; i < positions.size(); ++i) {
-        RefPtr<JSONObject> positionObj;
-        int line = 0;
-        int column = 0;
-        inPositions->get(i)->asObject(&positionObj);
-        if (!positionObj->getNumber("line", &line) || line < 0) {
+        OwnPtr<protocol::Debugger::ScriptPosition> position = inPositions->get(i);
+        if (!position->hasLine() || position->getLine() < 0) {
             *error = "Position missing 'line' or 'line' < 0.";
             return;
         }
-        if (!positionObj->getNumber("column", &column) || column < 0) {
+        if (!position->hasColumn() || position->getColumn() < 0) {
             *error = "Position missing 'column' or 'column' < 0.";
             return;
         }
-        positions[i] = std::make_pair(line, column);
+        positions[i] = std::make_pair(position->getLine(), position->getColumn());
     }
 
     for (size_t i = 1; i < positions.size(); ++i) {
         if (positions[i - 1].first < positions[i].first)
             continue;
         if (positions[i - 1].first == positions[i].first && positions[i - 1].second < positions[i].second)
             continue;
         *error = "Input positions array is not sorted or contains duplicate values.";
         return;
     }
@@ skipping 44 matching lines @@
             // from the old StepFrame.
             m_skippedStepFrameCount = 0;
             if (m_scheduledDebuggerStep == NoStep)
                 debugger().clearStepping();
             else if (m_scheduledDebuggerStep == StepOut)
                 m_skipNextDebuggerStepOut = true;
         }
     }
 }
 
-PassRefPtr<Array<CallFrame>> V8DebuggerAgentImpl::currentCallFrames()
+PassOwnPtr<Array<CallFrame>> V8DebuggerAgentImpl::currentCallFrames()
 {
     if (m_pausedContext.IsEmpty() || m_currentCallStack.IsEmpty())
         return Array<CallFrame>::create();
     v8::HandleScope handles(m_isolate);
     InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedContext.Get(m_isolate));
     if (!injectedScript) {
         // Context has been reported as removed while on pause.
         return Array<CallFrame>::create();
     }
 
     v8::Local<v8::Object> currentCallStack = m_currentCallStack.Get(m_isolate);
     return injectedScript->wrapCallFrames(currentCallStack, 0);
 }
 
-PassRefPtr<StackTrace> V8DebuggerAgentImpl::currentAsyncStackTrace()
+PassOwnPtr<StackTrace> V8DebuggerAgentImpl::currentAsyncStackTrace()
 {
     if (m_pausedContext.IsEmpty() || !trackingAsyncCalls())
         return nullptr;
     const AsyncCallChain* chain = m_currentAsyncCallChain.get();
     if (!chain)
         return nullptr;
     const AsyncCallStackVector& callStacks = chain->callStacks();
     if (callStacks.isEmpty())
         return nullptr;
-    RefPtr<StackTrace> result;
+    OwnPtr<StackTrace> result;
     int asyncOrdinal = callStacks.size();
     for (AsyncCallStackVector::const_reverse_iterator it = callStacks.rbegin(); it != callStacks.rend(); ++it, --asyncOrdinal) {
         v8::HandleScope scope(m_isolate);
         v8::Local<v8::Object> callFrames = (*it)->callFrames(m_isolate);
         InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(callFrames->CreationContext());
         if (!injectedScript) {
             result.clear();
             continue;
         }
-        RefPtr<StackTrace> next = StackTrace::create()
+        OwnPtr<StackTrace> next = StackTrace::create()
             .setCallFrames(injectedScript->wrapCallFrames(callFrames, asyncOrdinal))
-            .release();
-        next->setDescription((*it)->description());
+            .setDescription((*it)->description()).build();
         if (result)
             next->setAsyncStackTrace(result.release());
         result.swap(next);
     }
     return result.release();
 }
 
 PassOwnPtr<V8StackTraceImpl> V8DebuggerAgentImpl::currentAsyncStackTraceForRuntime()
 {
     if (!trackingAsyncCalls())
@@ skipping 35 matching lines @@
 
     int executionContextId = script.executionContextId();
     bool isContentScript = script.isContentScript();
     bool isInternalScript = script.isInternalScript();
     bool isLiveEdit = script.isLiveEdit();
     bool hasSourceURL = script.hasSourceURL();
     String scriptURL = script.sourceURL();
     String sourceMapURL = script.sourceMappingURL();
     bool deprecatedCommentWasUsed = isDeprecatedSourceURL || isDeprecatedSourceMappingURL;
 
-    const String* sourceMapURLParam = sourceMapURL.isNull() ? nullptr : &sourceMapURL;
+    OptionalValue<String> sourceMapURLParam = sourceMapURL;
     const bool* isContentScriptParam = isContentScript ? &isContentScript : nullptr;
     const bool* isInternalScriptParam = isInternalScript ? &isInternalScript : nullptr;
     const bool* isLiveEditParam = isLiveEdit ? &isLiveEdit : nullptr;
     const bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : nullptr;
     const bool* deprecatedCommentWasUsedParam = deprecatedCommentWasUsed ? &deprecatedCommentWasUsed : nullptr;
     if (parsedScript.success)
         m_frontend->scriptParsed(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, isContentScriptParam, isInternalScriptParam, isLiveEditParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
     else
         m_frontend->scriptFailedToParse(parsedScript.scriptId, scriptURL, script.startLine(), script.startColumn(), script.endLine(), script.endColumn(), executionContextId, isContentScriptParam, isInternalScriptParam, sourceMapURLParam, hasSourceURLParam, deprecatedCommentWasUsedParam);
 
@@ skipping 11 matching lines @@
         bool isRegex;
         breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex);
         String url;
         breakpointObject->getString(DebuggerAgentState::url, &url);
         if (!matches(m_debugger, scriptURL, url, isRegex))
             continue;
         ScriptBreakpoint breakpoint;
         breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakpoint.lineNumber);
         breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakpoint.columnNumber);
         breakpointObject->getString(DebuggerAgentState::condition, &breakpoint.condition);
-        RefPtr<protocol::TypeBuilder::Debugger::Location> location = resolveBreakpoint(cookie.key, parsedScript.scriptId, breakpoint, UserBreakpointSource);
+        OwnPtr<protocol::Debugger::Location> location = resolveBreakpoint(cookie.key, parsedScript.scriptId, breakpoint, UserBreakpointSource);
         if (location)
-            m_frontend->breakpointResolved(cookie.key, location);
+            m_frontend->breakpointResolved(cookie.key, location.release());
     }
 }
 
 V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(v8::Local<v8::Context> context, v8::Local<v8::Object> callFrames, v8::Local<v8::Value> exception, const Vector<String>& hitBreakpoints, bool isPromiseRejection)
 {
     if (isMuteBreakpointInstalled())
         return RequestContinue;
 
     V8DebuggerAgentImpl::SkipPauseRequest result;
     if (m_skipAllPauses)
@@ skipping 16 matching lines @@
         return RequestContinue;
 
     ASSERT(m_pausedContext.IsEmpty());
     m_pausedContext.Reset(m_isolate, context);
     m_currentCallStack.Reset(m_isolate, callFrames);
     v8::HandleScope handles(m_isolate);
 
     if (!exception.IsEmpty()) {
         InjectedScript* injectedScript = m_injectedScriptManager->injectedScriptFor(context);
         if (injectedScript) {
-            m_breakReason = isPromiseRejection ? protocol::Frontend::Debugger::Reason::PromiseRejection : protocol::Frontend::Debugger::Reason::Exception;
-            m_breakAuxData = injectedScript->wrapObject(exception, V8DebuggerAgentImpl::backtraceObjectGroup)->openAccessors();
+            m_breakReason = isPromiseRejection ? protocol::Debugger::Paused::ReasonEnum::PromiseRejection : protocol::Debugger::Paused::ReasonEnum::Exception;
+            auto obj = injectedScript->wrapObject(exception, V8DebuggerAgentImpl::backtraceObjectGroup);
+            m_breakAuxData = obj ? obj->asValue() : nullptr;
             // m_breakAuxData might be null after this.
         }
     } else if (m_pausingOnAsyncOperation) {
-        m_breakReason = protocol::Frontend::Debugger::Reason::AsyncOperation;
+        m_breakReason = protocol::Debugger::Paused::ReasonEnum::AsyncOperation;
         m_breakAuxData = JSONObject::create();
         m_breakAuxData->setNumber("operationId", m_currentAsyncOperationId);
     }
 
-    RefPtr<Array<String>> hitBreakpointIds = Array<String>::create();
+    OwnPtr<Array<String>> hitBreakpointIds = Array<String>::create();
 
     for (const auto& point : hitBreakpoints) {
         DebugServerBreakpointToBreakpointIdAndSourceMap::iterator breakpointIterator = m_serverBreakpoints.find(point);
         if (breakpointIterator != m_serverBreakpoints.end()) {
             const String& localId = breakpointIterator->value.first;
             hitBreakpointIds->addItem(localId);
 
             BreakpointSource source = breakpointIterator->value.second;
-            if (m_breakReason == protocol::Frontend::Debugger::Reason::Other && source == DebugCommandBreakpointSource)
-                m_breakReason = protocol::Frontend::Debugger::Reason::DebugCommand;
+            if (m_breakReason == protocol::Debugger::Paused::ReasonEnum::Other && source == DebugCommandBreakpointSource)
+                m_breakReason = protocol::Debugger::Paused::ReasonEnum::DebugCommand;
         }
     }
 
     if (!m_asyncOperationNotifications.isEmpty())
         flushAsyncOperationEvents(nullptr);
 
-    m_frontend->paused(currentCallFrames(), m_breakReason, m_breakAuxData, hitBreakpointIds, currentAsyncStackTrace());
+    m_frontend->paused(currentCallFrames(), m_breakReason, m_breakAuxData, hitBreakpointIds.release(), currentAsyncStackTrace());
     m_scheduledDebuggerStep = NoStep;
     m_javaScriptPauseScheduled = false;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     m_skippedStepFrameCount = 0;
     m_recursionLevelForStepFrame = 0;
     clearStepIntoAsync();
 
     if (!m_continueToLocationBreakpointId.isEmpty()) {
         debugger().removeBreakpoint(m_continueToLocationBreakpointId);
         m_continueToLocationBreakpointId = "";
     }
     return result;
 }
 
 void V8DebuggerAgentImpl::didContinue()
 {
     m_pausedContext.Reset();
     m_currentCallStack.Reset();
     clearBreakDetails();
     m_frontend->resumed();
 }
 
 bool V8DebuggerAgentImpl::canBreakProgram()
 {
     return debugger().canBreakProgram();
 }
 
-void V8DebuggerAgentImpl::breakProgram(protocol::Frontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
+void V8DebuggerAgentImpl::breakProgram(const String& breakReason, PassRefPtr<JSONObject> data)
 {
     ASSERT(enabled());
     if (m_skipAllPauses || !m_pausedContext.IsEmpty() || isCallStackEmptyOrBlackboxed())
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_scheduledDebuggerStep = NoStep;
     m_steppingFromFramework = false;
     m_pausingOnNativeEvent = false;
     clearStepIntoAsync();
     debugger().breakProgram();
 }
 
-void V8DebuggerAgentImpl::breakProgramOnException(protocol::Frontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
+void V8DebuggerAgentImpl::breakProgramOnException(const String& breakReason, PassRefPtr<JSONObject> data)
 {
     if (m_debugger->pauseOnExceptionsState() == V8DebuggerImpl::DontPauseOnExceptions)
         return;
     breakProgram(breakReason, data);
 }
 
 void V8DebuggerAgentImpl::clearStepIntoAsync()
 {
     m_startingStepIntoAsync = false;
     m_pausingOnAsyncOperation = false;
     m_pausingAsyncOperations.clear();
 }
 
 bool V8DebuggerAgentImpl::assertPaused(ErrorString* errorString)
 {
     if (m_pausedContext.IsEmpty()) {
         *errorString = "Can only perform operation while paused.";
         return false;
     }
     return true;
 }
 
 void V8DebuggerAgentImpl::clearBreakDetails()
 {
-    m_breakReason = protocol::Frontend::Debugger::Reason::Other;
+    m_breakReason = protocol::Debugger::Paused::ReasonEnum::Other;
     m_breakAuxData = nullptr;
 }
 
 void V8DebuggerAgentImpl::setBreakpointAt(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource source, const String& condition)
 {
     String breakpointId = generateBreakpointId(scriptId, lineNumber, columnNumber, source);
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, condition);
     resolveBreakpoint(breakpointId, scriptId, breakpoint, source);
 }
 
 void V8DebuggerAgentImpl::removeBreakpointAt(const String& scriptId, int lineNumber, int columnNumber, BreakpointSource source)
 {
     removeBreakpoint(generateBreakpointId(scriptId, lineNumber, columnNumber, source));
 }
 
 void V8DebuggerAgentImpl::reset()
 {
     m_scheduledDebuggerStep = NoStep;
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     m_promiseTracker->clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace blink