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

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

 // 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.
 
 #ifndef V8DebuggerAgentImpl_h
 #define V8DebuggerAgentImpl_h
 
 #include "platform/inspector_protocol/Dispatcher.h"
 #include "platform/inspector_protocol/Frontend.h"
 #include "platform/v8_inspector/ScriptBreakpoint.h"
@@ skipping 17 matching lines @@
 class JavaScriptCallFrame;
 class JSONObject;
 class PromiseTracker;
 class RemoteCallFrameId;
 class ScriptRegexp;
 class V8AsyncCallTracker;
 class V8StackTraceImpl;
 
 typedef String ErrorString;
 
-using protocol::OptionalValue;
+using protocol::Maybe;
 
 class V8DebuggerAgentImpl : public V8DebuggerAgent {
     WTF_MAKE_NONCOPYABLE(V8DebuggerAgentImpl);
     USING_FAST_MALLOC(V8DebuggerAgentImpl);
 public:
     enum SkipPauseRequest {
         RequestNoSkip,
         RequestContinue,
         RequestStepInto,
         RequestStepOut,
@@ skipping 17 matching lines @@
 
     bool isPaused() override;
 
     // Part of the protocol.
     void enable(ErrorString*) override;
     void setBreakpointsActive(ErrorString*, bool active) override;
     void setSkipAllPauses(ErrorString*, bool skipped) override;
 
     void setBreakpointByUrl(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,
         protocol::Debugger::BreakpointId*,
         OwnPtr<protocol::Array<protocol::Debugger::Location>>* locations) override;
     void setBreakpoint(ErrorString*,
         PassOwnPtr<protocol::Debugger::Location>,
-        const OptionalValue<String>& optionalCondition,
+        const Maybe<String>& optionalCondition,
         protocol::Debugger::BreakpointId*,
         OwnPtr<protocol::Debugger::Location>* actualLocation) override;
     void removeBreakpoint(ErrorString*, const String& breakpointId) override;
     void continueToLocation(ErrorString*,
         PassOwnPtr<protocol::Debugger::Location>,
-        const OptionalValue<bool>& interstateLocationOpt) override;
+        const Maybe<bool>& interstateLocationOpt) override;
     void getStepInPositions(ErrorString*,
         const String& callFrameId,
-        OwnPtr<protocol::Array<protocol::Debugger::Location>>* positions) override;
+        Maybe<protocol::Array<protocol::Debugger::Location>>* positions) override;
     void getBacktrace(ErrorString*,
         OwnPtr<protocol::Array<protocol::Debugger::CallFrame>>*,
-        OwnPtr<protocol::Debugger::StackTrace>*) override;
+        Maybe<protocol::Debugger::StackTrace>*) override;
     void searchInContent(ErrorString*,
         const String& scriptId,
         const String& query,
-        const OptionalValue<bool>& optionalCaseSensitive,
-        const OptionalValue<bool>& optionalIsRegex,
+        const Maybe<bool>& optionalCaseSensitive,
+        const Maybe<bool>& optionalIsRegex,
         OwnPtr<protocol::Array<protocol::Debugger::SearchMatch>>*) override;
     void canSetScriptSource(ErrorString*, bool* result) override { *result = true; }
     void setScriptSource(ErrorString*,
         const String& inScriptId,
         const String& inScriptSource,
-        const OptionalValue<bool>& inPreview,
-        OwnPtr<protocol::Array<protocol::Debugger::CallFrame>>* optOutCallFrames,
-        OptionalValue<bool>* optOutStackChanged,
-        OwnPtr<protocol::Debugger::StackTrace>* optOutAsyncStackTrace,
-        OwnPtr<protocol::Debugger::SetScriptSourceError>* optOutCompileError) override;
+        const Maybe<bool>& inPreview,
+        Maybe<protocol::Array<protocol::Debugger::CallFrame>>* optOutCallFrames,
+        Maybe<bool>* optOutStackChanged,
+        Maybe<protocol::Debugger::StackTrace>* optOutAsyncStackTrace,
+        Maybe<protocol::Debugger::SetScriptSourceError>* optOutCompileError) override;
     void restartFrame(ErrorString*,
         const String& callFrameId,
         OwnPtr<protocol::Array<protocol::Debugger::CallFrame>>* newCallFrames,
-        OwnPtr<protocol::Debugger::StackTrace>* asyncStackTrace) override;
+        Maybe<protocol::Debugger::StackTrace>* asyncStackTrace) override;
     void getScriptSource(ErrorString*, const String& scriptId, String* scriptSource) override;
     void getFunctionDetails(ErrorString*,
         const String& functionId,
         OwnPtr<protocol::Debugger::FunctionDetails>*) override;
     void getGeneratorObjectDetails(ErrorString*,
         const String& objectId,
         OwnPtr<protocol::Debugger::GeneratorObjectDetails>*) override;
     void getCollectionEntries(ErrorString*,
         const String& objectId,
         OwnPtr<protocol::Array<protocol::Debugger::CollectionEntry>>*) override;
     void pause(ErrorString*) override;
     void resume(ErrorString*) override;
     void stepOver(ErrorString*) override;
     void stepInto(ErrorString*) override;
     void stepOut(ErrorString*) override;
     void stepIntoAsync(ErrorString*) override;
     void setPauseOnExceptions(ErrorString*, const String& pauseState) override;
     void evaluateOnCallFrame(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<protocol::Runtime::RemoteObject>* result,
-        OptionalValue<bool>* wasThrown,
-        OwnPtr<protocol::Runtime::ExceptionDetails>*) override;
+        Maybe<bool>* wasThrown,
+        Maybe<protocol::Runtime::ExceptionDetails>*) override;
     void setVariableValue(ErrorString*,
         int scopeNumber,
         const String& variableName,
         PassOwnPtr<protocol::Runtime::CallArgument> newValue,
-        const OptionalValue<String>& callFrame,
-        const OptionalValue<String>& functionObjectId) override;
+        const Maybe<String>& callFrame,
+        const Maybe<String>& functionObjectId) override;
     void setAsyncCallStackDepth(ErrorString*, int depth) override;
     void enablePromiseTracker(ErrorString*,
-        const OptionalValue<bool>& captureStacks) override;
+        const Maybe<bool>& captureStacks) override;
     void disablePromiseTracker(ErrorString*) override;
     void getPromiseById(ErrorString*,
         int promiseId,
-        const OptionalValue<String>& objectGroup,
+        const Maybe<String>& objectGroup,
         OwnPtr<protocol::Runtime::RemoteObject>* promise) override;
     void flushAsyncOperationEvents(ErrorString*) override;
     void setAsyncOperationBreakpoint(ErrorString*, int operationId) override;
     void removeAsyncOperationBreakpoint(ErrorString*, int operationId) override;
     void setBlackboxedRanges(ErrorString*,
         const String& scriptId,
         PassOwnPtr<protocol::Array<protocol::Debugger::ScriptPosition>> positions) override;
 
     void schedulePauseOnNextStatement(const String& breakReason, PassRefPtr<JSONObject> data) override;
     void cancelPauseOnNextStatement() override;
@@ skipping 121 matching lines @@
     int m_currentAsyncOperationId;
     bool m_pendingTraceAsyncOperationCompleted;
     bool m_startingStepIntoAsync;
     HashMap<String, Vector<std::pair<int, int>>> m_blackboxedPositions;
 };
 
 } // namespace blink
 
 
 #endif // V8DebuggerAgentImpl_h