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

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

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 32 matching lines @@
 #include "wtf/text/WTFString.h"
 
 using blink::protocol::Array;
 using blink::protocol::Debugger::CallFrame;
 using blink::protocol::Debugger::CollectionEntry;
 using blink::protocol::Debugger::FunctionDetails;
 using blink::protocol::Debugger::GeneratorObjectDetails;
 using blink::protocol::Runtime::PropertyDescriptor;
 using blink::protocol::Runtime::InternalPropertyDescriptor;
 using blink::protocol::Runtime::RemoteObject;
-using blink::protocol::OptionalValue;
+using blink::protocol::Maybe;
 
 namespace blink {
 
 static PassOwnPtr<protocol::Runtime::ExceptionDetails> toExceptionDetails(PassRefPtr<JSONObject> object)
 {
     String text;
     if (!object->getString("text", &text))
         return nullptr;
 
     OwnPtr<protocol::Runtime::ExceptionDetails> exceptionDetails = protocol::Runtime::ExceptionDetails::create().setText(text).build();
@@ skipping 60 matching lines @@
     , m_native(injectedScriptNative)
     , m_contextId(contextId)
 {
     m_context.SetWeak(this, &weakCallback, v8::WeakCallbackType::kParameter);
 }
 
 InjectedScript::~InjectedScript()
 {
 }
 
-void InjectedScript::evaluate(ErrorString* errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, OwnPtr<protocol::Runtime::RemoteObject>* result, OptionalValue<bool>* wasThrown, OwnPtr<protocol::Runtime::ExceptionDetails>* exceptionDetails)
+void InjectedScript::evaluate(ErrorString* errorString, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, OwnPtr<protocol::Runtime::RemoteObject>* result, Maybe<bool>* wasThrown, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_client, context(), v8Value(), "evaluate");
     function.appendArgument(expression);
     function.appendArgument(objectGroup);
     function.appendArgument(includeCommandLineAPI);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     makeEvalCall(errorString, function, result, wasThrown, exceptionDetails);
 }
 
-void InjectedScript::callFunctionOn(ErrorString* errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, OwnPtr<protocol::Runtime::RemoteObject>* result, OptionalValue<bool>* wasThrown)
+void InjectedScript::callFunctionOn(ErrorString* errorString, const String& objectId, const String& expression, const String& arguments, bool returnByValue, bool generatePreview, OwnPtr<protocol::Runtime::RemoteObject>* result, Maybe<bool>* wasThrown)
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_client, context(), v8Value(), "callFunctionOn");
     function.appendArgument(objectId);
     function.appendArgument(expression);
     function.appendArgument(arguments);
     function.appendArgument(returnByValue);
     function.appendArgument(generatePreview);
     makeEvalCall(errorString, function, result, wasThrown);
 }
 
-void InjectedScript::evaluateOnCallFrame(ErrorString* errorString, v8::Local<v8::Object> callFrames, bool isAsyncCallStack, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, OwnPtr<RemoteObject>* result, OptionalValue<bool>* wasThrown, OwnPtr<protocol::Runtime::ExceptionDetails>* exceptionDetails)
+void InjectedScript::evaluateOnCallFrame(ErrorString* errorString, v8::Local<v8::Object> callFrames, bool isAsyncCallStack, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, OwnPtr<RemoteObject>* result, Maybe<bool>* wasThrown, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_client, context(), v8Value(), "evaluateOnCallFrame");
     function.appendArgument(callFrames);
     function.appendArgument(isAsyncCallStack);
     function.appendArgument(callFrameId);
     function.appendArgument(expression);
     function.appendArgument(objectGroup);
     function.appendArgument(includeCommandLineAPI);
     function.appendArgument(returnByValue);
@@ skipping 14 matching lines @@
             resultValue->asString(errorString);
         } else {
             bool value;
             ASSERT_UNUSED(value, resultValue->asBoolean(&value) && value);
         }
         return;
     }
     *errorString = "Internal error";
 }
 
-void InjectedScript::getStepInPositions(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String& callFrameId, OwnPtr<Array<protocol::Debugger::Location>>* positions)
+void InjectedScript::getStepInPositions(ErrorString* errorString, v8::Local<v8::Object> callFrames, const String& callFrameId, Maybe<Array<protocol::Debugger::Location>>* positions)
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_client, context(), v8Value(), "getStepInPositions");
     function.appendArgument(callFrames);
     function.appendArgument(callFrameId);
     RefPtr<JSONValue> resultValue;
     makeCall(function, &resultValue);
     if (resultValue) {
         if (resultValue->type() == JSONValue::TypeString) {
             resultValue->asString(errorString);
             return;
         }
         if (resultValue->type() == JSONValue::TypeArray) {
             *positions = Array<protocol::Debugger::Location>::runtimeCast(resultValue.release());
             return;
         }
     }
     *errorString = "Internal error";
 }
 
 void InjectedScript::setVariableValue(ErrorString* errorString,
     v8::Local<v8::Object> callFrames,
-    const protocol::OptionalValue<String>& callFrameIdOpt,
-    const protocol::OptionalValue<String>&  functionObjectIdOpt,
+    const protocol::Maybe<String>& callFrameIdOpt,
+    const protocol::Maybe<String>&  functionObjectIdOpt,
     int scopeNumber,
     const String& variableName,
     const String& newValueStr)
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_client, context(), v8Value(), "setVariableValue");
-    if (callFrameIdOpt.hasValue()) {
+    if (callFrameIdOpt.isJust()) {
         function.appendArgument(callFrames);
-        function.appendArgument(callFrameIdOpt.get());
+        function.appendArgument(callFrameIdOpt.fromJust());
     } else {
         function.appendArgument(false);
         function.appendArgument(false);
     }
-    if (functionObjectIdOpt.hasValue())
-        function.appendArgument(functionObjectIdOpt.get());
+    if (functionObjectIdOpt.isJust())
+        function.appendArgument(functionObjectIdOpt.fromJust());
     else
         function.appendArgument(false);
     function.appendArgument(scopeNumber);
     function.appendArgument(variableName);
     function.appendArgument(newValueStr);
     RefPtr<JSONValue> resultValue;
     makeCall(function, &resultValue);
     if (!resultValue) {
         *errorString = "Internal error";
         return;
@@ skipping 43 matching lines @@
     RefPtr<JSONValue> resultValue;
     makeCall(function, &resultValue);
     if (!resultValue || resultValue->type() != JSONValue::TypeArray) {
         if (!resultValue->asString(errorString))
             *errorString = "Internal error";
         return;
     }
     *result = Array<CollectionEntry>::runtimeCast(resultValue.release());
 }
 
-void InjectedScript::getProperties(ErrorString* errorString, const String& objectId, bool ownProperties, bool accessorPropertiesOnly, bool generatePreview, OwnPtr<Array<PropertyDescriptor>>* properties, OwnPtr<protocol::Runtime::ExceptionDetails>* exceptionDetails)
+void InjectedScript::getProperties(ErrorString* errorString, const String& objectId, bool ownProperties, bool accessorPropertiesOnly, bool generatePreview, OwnPtr<Array<PropertyDescriptor>>* properties, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_client, context(), v8Value(), "getProperties");
     function.appendArgument(objectId);
     function.appendArgument(ownProperties);
     function.appendArgument(accessorPropertiesOnly);
     function.appendArgument(generatePreview);
 
     RefPtr<JSONValue> result;
     makeCallWithExceptionDetails(function, &result, exceptionDetails);
-    if (*exceptionDetails) {
+    if (exceptionDetails->isJust()) {
         // FIXME: make properties optional
         *properties = Array<PropertyDescriptor>::create();
         return;
     }
     if (!result || result->type() != JSONValue::TypeArray) {
         *errorString = "Internal error";
         return;
     }
     *properties = Array<PropertyDescriptor>::runtimeCast(result.release());
 }
 
-void InjectedScript::getInternalProperties(ErrorString* errorString, const String& objectId, OwnPtr<Array<InternalPropertyDescriptor>>* properties, OwnPtr<protocol::Runtime::ExceptionDetails>* exceptionDetails)
+void InjectedScript::getInternalProperties(ErrorString* errorString, const String& objectId, Maybe<Array<InternalPropertyDescriptor>>* properties, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::HandleScope handles(m_isolate);
     V8FunctionCall function(m_client, context(), v8Value(), "getInternalProperties");
     function.appendArgument(objectId);
 
     RefPtr<JSONValue> result;
     makeCallWithExceptionDetails(function, &result, exceptionDetails);
-    if (*exceptionDetails)
+    if (exceptionDetails->isJust())
         return;
     if (!result || result->type() != JSONValue::TypeArray) {
         *errorString = "Internal error";
         return;
     }
     OwnPtr<Array<InternalPropertyDescriptor>> array = Array<InternalPropertyDescriptor>::runtimeCast(result.release());
     if (array->length() > 0)
         *properties = array.release();
 }
 
@@ skipping 153 matching lines @@
     ASSERT(!hadException);
     if (!hadException) {
         *result = toJSONValue(function.context(), resultValue);
         if (!*result)
             *result = JSONString::create(String::format("Object has too long reference chain(must not be longer than %d)", JSONValue::maxDepth));
     } else {
         *result = JSONString::create("Exception while making a call.");
     }
 }
 
-void InjectedScript::makeEvalCall(ErrorString* errorString, V8FunctionCall& function, OwnPtr<protocol::Runtime::RemoteObject>* objectResult, OptionalValue<bool>* wasThrown, OwnPtr<protocol::Runtime::ExceptionDetails>* exceptionDetails)
+void InjectedScript::makeEvalCall(ErrorString* errorString, V8FunctionCall& function, OwnPtr<protocol::Runtime::RemoteObject>* objectResult, Maybe<bool>* wasThrown, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     RefPtr<JSONValue> result;
     makeCall(function, &result);
     if (!result) {
         *errorString = "Internal error: result value is empty";
         return;
     }
     if (result->type() == JSONValue::TypeString) {
         result->asString(errorString);
         ASSERT(errorString->length());
@@ skipping 12 matching lines @@
     }
     if (wasThrownVal) {
         RefPtr<JSONObject> objectExceptionDetails = resultPair->getObject("exceptionDetails");
         if (objectExceptionDetails)
             *exceptionDetails = toExceptionDetails(objectExceptionDetails.release());
     }
     *objectResult = protocol::Runtime::RemoteObject::runtimeCast(resultObj);
     *wasThrown = wasThrownVal;
 }
 
-void InjectedScript::makeCallWithExceptionDetails(V8FunctionCall& function, RefPtr<JSONValue>* result, OwnPtr<protocol::Runtime::ExceptionDetails>* exceptionDetails)
+void InjectedScript::makeCallWithExceptionDetails(V8FunctionCall& function, RefPtr<JSONValue>* result, Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     v8::HandleScope handles(m_isolate);
     v8::Context::Scope scope(context());
     v8::TryCatch tryCatch(m_isolate);
     v8::Local<v8::Value> resultValue = function.callWithoutExceptionHandling();
     if (tryCatch.HasCaught()) {
         v8::Local<v8::Message> message = tryCatch.Message();
         String text = !message.IsEmpty() ? toWTFStringWithTypeCheck(message->Get()) : "Internal error";
         *exceptionDetails = protocol::Runtime::ExceptionDetails::create().setText(text).build();
     } else {
         *result = toJSONValue(function.context(), resultValue);
         if (!*result)
             *result = JSONString::create(String::format("Object has too long reference chain(must not be longer than %d)", JSONValue::maxDepth));
     }
 }
 
 void InjectedScript::dispose()
 {
     m_manager->discardInjectedScript(m_contextId);
 }
 
 } // namespace blink