DevTools: consistently use Maybe for optional values in the protocol generator.

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::Array;
-using blink::protocol::OptionalValue;
+using blink::protocol::Maybe;
 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;
@@ skipping 261 matching lines @@
 {
     if (isRegex) {
         V8Regex regex(debugger, pattern, TextCaseSensitive);
         return regex.match(url) != -1;
     }
     return url == pattern;
 }
 
 void V8DebuggerAgentImpl::setBreakpointByUrl(ErrorString* errorString,
     int lineNumber,
-    const OptionalValue<String>& optionalURL,
-    const OptionalValue<String>& optionalURLRegex,
-    const OptionalValue<int>& optionalColumnNumber,
-    const OptionalValue<String>& optionalCondition,
+    const Maybe<String>& optionalURL,
+    const Maybe<String>& optionalURLRegex,
+    const Maybe<int>& optionalColumnNumber,
+    const Maybe<String>& optionalCondition,
     BreakpointId* outBreakpointId,
     OwnPtr<protocol::Array<protocol::Debugger::Location>>* locations)
 {
     *locations = Array<protocol::Debugger::Location>::create();
-    if (optionalURL.hasValue() == optionalURLRegex.hasValue()) {
+    if (optionalURL.isJust() == optionalURLRegex.isJust()) {
         *errorString = "Either url or urlRegex must be specified.";
         return;
     }
 
-    String url = optionalURL.hasValue() ? optionalURL.get() : optionalURLRegex.get();
+    String url = optionalURL.isJust() ? optionalURL.fromJust() : optionalURLRegex.fromJust();
     int columnNumber = 0;
-    if (optionalColumnNumber.hasValue()) {
-        columnNumber = optionalColumnNumber.get();
+    if (optionalColumnNumber.isJust()) {
+        columnNumber = optionalColumnNumber.fromJust();
         if (columnNumber < 0) {
             *errorString = "Incorrect column number";
             return;
         }
     }
-    String condition = optionalCondition.get("");
-    bool isRegex = optionalURLRegex.hasValue();
+    String condition = optionalCondition.fromMaybe("");
+    bool isRegex = optionalURLRegex.isJust();
 
     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;
@@ skipping 22 matching lines @@
         return false;
     }
     *scriptId = location->getScriptId();
     *lineNumber = location->getLineNumber();
     *columnNumber = location->getColumnNumber(0);
     return true;
 }
 
 void V8DebuggerAgentImpl::setBreakpoint(ErrorString* errorString,
     PassOwnPtr<protocol::Debugger::Location> location,
-    const OptionalValue<String>& optionalCondition,
+    const Maybe<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.get("");
+    String condition = optionalCondition.fromMaybe("");
 
     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)
         *outBreakpointId = breakpointId;
@@ skipping 21 matching lines @@
         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,
     PassOwnPtr<protocol::Debugger::Location> location,
-    const protocol::OptionalValue<bool>& interstateLocationOpt)
+    const protocol::Maybe<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, interstateLocationOpt.get(false));
+    m_continueToLocationBreakpointId = debugger().setBreakpoint(scriptId, breakpoint, &lineNumber, &columnNumber, interstateLocationOpt.fromMaybe(false));
     resume(errorString);
 }
 
-void V8DebuggerAgentImpl::getStepInPositions(ErrorString* errorString, const String& callFrameId, OwnPtr<Array<protocol::Debugger::Location>>* positions)
+void V8DebuggerAgentImpl::getStepInPositions(ErrorString* errorString, const String& callFrameId, Maybe<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, OwnPtr<Array<CallFrame>>* callFrames, OwnPtr<StackTrace>* asyncStackTrace)
+void V8DebuggerAgentImpl::getBacktrace(ErrorString* errorString, OwnPtr<Array<CallFrame>>* callFrames, Maybe<StackTrace>* asyncStackTrace)
 {
     if (!assertPaused(errorString))
         return;
     m_currentCallStack.Reset(m_isolate, debugger().currentCallFrames());
     *callFrames = currentCallFrames();
     *asyncStackTrace = currentAsyncStackTrace();
 }
 
 bool V8DebuggerAgentImpl::isCallStackEmptyOrBlackboxed()
 {
@@ skipping 115 matching lines @@
         debuggerBreakpointIdsIterator->value.append(debuggerBreakpointId);
 
     OwnPtr<protocol::Debugger::Location> location = protocol::Debugger::Location::create()
         .setScriptId(scriptId)
         .setLineNumber(actualLineNumber)
         .setColumnNumber(actualColumnNumber).build();
     return location.release();
 }
 
 void V8DebuggerAgentImpl::searchInContent(ErrorString* error, const String& scriptId, const String& query,
-    const OptionalValue<bool>& optionalCaseSensitive,
-    const OptionalValue<bool>& optionalIsRegex,
+    const Maybe<bool>& optionalCaseSensitive,
+    const Maybe<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, optionalCaseSensitive.get(false), optionalIsRegex.get(false));
+        *results = V8ContentSearchUtil::searchInTextByLines(m_debugger, it->value.source(), query, optionalCaseSensitive.fromMaybe(false), optionalIsRegex.fromMaybe(false));
     else
         *error = "No script for id: " + scriptId;
 }
 
 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)
+    const Maybe<bool>& preview,
+    Maybe<protocol::Array<protocol::Debugger::CallFrame>>* newCallFrames,
+    Maybe<bool>* stackChanged,
+    Maybe<StackTrace>* asyncStackTrace,
+    Maybe<protocol::Debugger::SetScriptSourceError>* optOutCompileError)
 {
     if (!checkEnabled(error))
         return;
-    if (!debugger().setScriptSource(scriptId, newContent, preview.get(false), error, optOutCompileError, &m_currentCallStack, stackChanged))
+    if (!debugger().setScriptSource(scriptId, newContent, preview.fromMaybe(false), error, optOutCompileError, &m_currentCallStack, stackChanged))
         return;
 
     *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,
     OwnPtr<Array<CallFrame>>* newCallFrames,
-    OwnPtr<StackTrace>* asyncStackTrace)
+    Maybe<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;
     }
@@ skipping 246 matching lines @@
     }
     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 OptionalValue<String>& objectGroup,
-    const OptionalValue<bool>& includeCommandLineAPI,
-    const OptionalValue<bool>& doNotPauseOnExceptionsAndMuteConsole,
-    const OptionalValue<bool>& returnByValue,
-    const OptionalValue<bool>& generatePreview,
+    const Maybe<String>& objectGroup,
+    const Maybe<bool>& includeCommandLineAPI,
+    const Maybe<bool>& doNotPauseOnExceptionsAndMuteConsole,
+    const Maybe<bool>& returnByValue,
+    const Maybe<bool>& generatePreview,
     OwnPtr<RemoteObject>* result,
-    OptionalValue<bool>* wasThrown,
-    OwnPtr<protocol::Runtime::ExceptionDetails>* exceptionDetails)
+    Maybe<bool>* wasThrown,
+    Maybe<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 (doNotPauseOnExceptionsAndMuteConsole.get(false))
+    if (doNotPauseOnExceptionsAndMuteConsole.fromMaybe(false))
         ignoreExceptionsScope.emplace(m_debugger);
 
-    injectedScript->evaluateOnCallFrame(errorString, callStack, isAsync, callFrameId, expression, objectGroup.get(""), includeCommandLineAPI.get(false), returnByValue.get(false), generatePreview.get(false), result, wasThrown, exceptionDetails);
+    injectedScript->evaluateOnCallFrame(errorString, callStack, isAsync, callFrameId, expression, objectGroup.fromMaybe(""), includeCommandLineAPI.fromMaybe(false), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false), result, wasThrown, exceptionDetails);
 }
 
 void V8DebuggerAgentImpl::setVariableValue(ErrorString* errorString,
     int scopeNumber,
     const String& variableName,
     PassOwnPtr<protocol::Runtime::CallArgument> newValue,
-    const OptionalValue<String>& callFrameId,
-    const OptionalValue<String>& functionObjectId)
+    const Maybe<String>& callFrameId,
+    const Maybe<String>& functionObjectId)
 {
     if (!checkEnabled(errorString))
         return;
     InjectedScript* injectedScript = nullptr;
-    if (callFrameId.hasValue()) {
+    if (callFrameId.isJust()) {
         if (!isPaused() || m_currentCallStack.IsEmpty()) {
             *errorString = "Attempt to access callframe when debugger is not on pause";
             return;
         }
-        OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(callFrameId.get());
+        OwnPtr<RemoteCallFrameId> remoteId = RemoteCallFrameId::parse(callFrameId.fromJust());
         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.hasValue()) {
-        OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(functionObjectId.get());
+    } else if (functionObjectId.isJust()) {
+        OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(functionObjectId.fromJust());
         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 = 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 OptionalValue<bool>& captureStacks)
+    const Maybe<bool>& captureStacks)
 {
     if (!checkEnabled(errorString))
         return;
     m_state->setBoolean(DebuggerAgentState::promiseTrackerEnabled, true);
-    m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, captureStacks.get(false));
-    m_promiseTracker->setEnabled(true, captureStacks.get(false));
+    m_state->setBoolean(DebuggerAgentState::promiseTrackerCaptureStacks, captureStacks.fromMaybe(false));
+    m_promiseTracker->setEnabled(true, captureStacks.fromMaybe(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 OptionalValue<String>& objectGroup, OwnPtr<RemoteObject>* promise)
+void V8DebuggerAgentImpl::getPromiseById(ErrorString* errorString, int promiseId, const Maybe<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.get(""));
+    *promise = injectedScript->wrapObject(value, objectGroup.fromMaybe(""));
 }
 
 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)
 {
@@ skipping 377 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;
 
-    OptionalValue<String> sourceMapURLParam = sourceMapURL;
+    const Maybe<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 175 matching lines @@
     m_scripts.clear();
     m_blackboxedPositions.clear();
     m_breakpointIdToDebuggerBreakpointIds.clear();
     resetAsyncCallTracker();
     m_promiseTracker->clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace blink