LCOV - code coverage report
Current view: top level - out/Release/gen/src/inspector/protocol - Debugger.cpp (source / functions) Hit Total Coverage
Test: app.info Lines: 618 961 64.3 %
Date: 2017-04-26 Functions: 49 75 65.3 %

          Line data    Source code
       1             : // This file is generated
       2             : 
       3             : // Copyright (c) 2016 The Chromium Authors. All rights reserved.
       4             : // Use of this source code is governed by a BSD-style license that can be
       5             : // found in the LICENSE file.
       6             : 
       7             : #include "src/inspector/protocol/Debugger.h"
       8             : 
       9             : #include "src/inspector/protocol/Protocol.h"
      10             : 
      11             : namespace v8_inspector {
      12             : namespace protocol {
      13             : namespace Debugger {
      14             : 
      15             : // ------------- Enum values from types.
      16             : 
      17             : const char Metainfo::domainName[] = "Debugger";
      18             : const char Metainfo::commandPrefix[] = "Debugger.";
      19             : const char Metainfo::version[] = "1.2";
      20             : 
      21     1289318 : std::unique_ptr<Location> Location::fromValue(protocol::Value* value, ErrorSupport* errors)
      22             : {
      23     1289318 :     if (!value || value->type() != protocol::Value::TypeObject) {
      24          12 :         errors->addError("object expected");
      25             :         return nullptr;
      26             :     }
      27             : 
      28      644656 :     std::unique_ptr<Location> result(new Location());
      29             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
      30      644656 :     errors->push();
      31     1289312 :     protocol::Value* scriptIdValue = object->get("scriptId");
      32     1289312 :     errors->setName("scriptId");
      33     1289312 :     result->m_scriptId = ValueConversions<String>::fromValue(scriptIdValue, errors);
      34     1289312 :     protocol::Value* lineNumberValue = object->get("lineNumber");
      35     1289312 :     errors->setName("lineNumber");
      36      644656 :     result->m_lineNumber = ValueConversions<int>::fromValue(lineNumberValue, errors);
      37     1289312 :     protocol::Value* columnNumberValue = object->get("columnNumber");
      38      644656 :     if (columnNumberValue) {
      39     1288820 :         errors->setName("columnNumber");
      40      644410 :         result->m_columnNumber = ValueConversions<int>::fromValue(columnNumberValue, errors);
      41             :     }
      42      644656 :     errors->pop();
      43      644656 :     if (errors->hasErrors())
      44             :         return nullptr;
      45             :     return result;
      46             : }
      47             : 
      48      644140 : std::unique_ptr<protocol::DictionaryValue> Location::toValue() const
      49             : {
      50      644140 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
      51     3220700 :     result->setValue("scriptId", ValueConversions<String>::toValue(m_scriptId));
      52     3220700 :     result->setValue("lineNumber", ValueConversions<int>::toValue(m_lineNumber));
      53      644140 :     if (m_columnNumber.isJust())
      54     2576560 :         result->setValue("columnNumber", ValueConversions<int>::toValue(m_columnNumber.fromJust()));
      55      644140 :     return result;
      56             : }
      57             : 
      58           0 : std::unique_ptr<Location> Location::clone() const
      59             : {
      60           0 :     ErrorSupport errors;
      61           0 :     return fromValue(toValue().get(), &errors);
      62             : }
      63             : 
      64         228 : std::unique_ptr<ScriptPosition> ScriptPosition::fromValue(protocol::Value* value, ErrorSupport* errors)
      65             : {
      66         228 :     if (!value || value->type() != protocol::Value::TypeObject) {
      67           0 :         errors->addError("object expected");
      68             :         return nullptr;
      69             :     }
      70             : 
      71         114 :     std::unique_ptr<ScriptPosition> result(new ScriptPosition());
      72             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
      73         114 :     errors->push();
      74         228 :     protocol::Value* lineNumberValue = object->get("lineNumber");
      75         228 :     errors->setName("lineNumber");
      76         114 :     result->m_lineNumber = ValueConversions<int>::fromValue(lineNumberValue, errors);
      77         228 :     protocol::Value* columnNumberValue = object->get("columnNumber");
      78         228 :     errors->setName("columnNumber");
      79         114 :     result->m_columnNumber = ValueConversions<int>::fromValue(columnNumberValue, errors);
      80         114 :     errors->pop();
      81         114 :     if (errors->hasErrors())
      82             :         return nullptr;
      83             :     return result;
      84             : }
      85             : 
      86           0 : std::unique_ptr<protocol::DictionaryValue> ScriptPosition::toValue() const
      87             : {
      88           0 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
      89           0 :     result->setValue("lineNumber", ValueConversions<int>::toValue(m_lineNumber));
      90           0 :     result->setValue("columnNumber", ValueConversions<int>::toValue(m_columnNumber));
      91           0 :     return result;
      92             : }
      93             : 
      94           0 : std::unique_ptr<ScriptPosition> ScriptPosition::clone() const
      95             : {
      96           0 :     ErrorSupport errors;
      97           0 :     return fromValue(toValue().get(), &errors);
      98             : }
      99             : 
     100      382664 : std::unique_ptr<CallFrame> CallFrame::fromValue(protocol::Value* value, ErrorSupport* errors)
     101             : {
     102      382664 :     if (!value || value->type() != protocol::Value::TypeObject) {
     103           0 :         errors->addError("object expected");
     104             :         return nullptr;
     105             :     }
     106             : 
     107      191332 :     std::unique_ptr<CallFrame> result(new CallFrame());
     108             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
     109      191332 :     errors->push();
     110      382664 :     protocol::Value* callFrameIdValue = object->get("callFrameId");
     111      382664 :     errors->setName("callFrameId");
     112      382664 :     result->m_callFrameId = ValueConversions<String>::fromValue(callFrameIdValue, errors);
     113      382664 :     protocol::Value* functionNameValue = object->get("functionName");
     114      382664 :     errors->setName("functionName");
     115      382664 :     result->m_functionName = ValueConversions<String>::fromValue(functionNameValue, errors);
     116      382664 :     protocol::Value* functionLocationValue = object->get("functionLocation");
     117      191332 :     if (functionLocationValue) {
     118      381916 :         errors->setName("functionLocation");
     119      190958 :         result->m_functionLocation = ValueConversions<protocol::Debugger::Location>::fromValue(functionLocationValue, errors);
     120             :     }
     121      382664 :     protocol::Value* locationValue = object->get("location");
     122      382664 :     errors->setName("location");
     123      191332 :     result->m_location = ValueConversions<protocol::Debugger::Location>::fromValue(locationValue, errors);
     124      382664 :     protocol::Value* scopeChainValue = object->get("scopeChain");
     125      382664 :     errors->setName("scopeChain");
     126      191332 :     result->m_scopeChain = ValueConversions<protocol::Array<protocol::Debugger::Scope>>::fromValue(scopeChainValue, errors);
     127      382664 :     protocol::Value* thisValue = object->get("this");
     128      382664 :     errors->setName("this");
     129      191332 :     result->m_this = ValueConversions<protocol::Runtime::RemoteObject>::fromValue(thisValue, errors);
     130      382664 :     protocol::Value* returnValueValue = object->get("returnValue");
     131      191332 :     if (returnValueValue) {
     132       17372 :         errors->setName("returnValue");
     133        8686 :         result->m_returnValue = ValueConversions<protocol::Runtime::RemoteObject>::fromValue(returnValueValue, errors);
     134             :     }
     135      191332 :     errors->pop();
     136      191332 :     if (errors->hasErrors())
     137             :         return nullptr;
     138             :     return result;
     139             : }
     140             : 
     141      191332 : std::unique_ptr<protocol::DictionaryValue> CallFrame::toValue() const
     142             : {
     143      191332 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     144      956660 :     result->setValue("callFrameId", ValueConversions<String>::toValue(m_callFrameId));
     145      956660 :     result->setValue("functionName", ValueConversions<String>::toValue(m_functionName));
     146      191332 :     if (m_functionLocation.isJust())
     147      763832 :         result->setValue("functionLocation", ValueConversions<protocol::Debugger::Location>::toValue(m_functionLocation.fromJust()));
     148      765328 :     result->setValue("location", ValueConversions<protocol::Debugger::Location>::toValue(m_location.get()));
     149      765328 :     result->setValue("scopeChain", ValueConversions<protocol::Array<protocol::Debugger::Scope>>::toValue(m_scopeChain.get()));
     150      765328 :     result->setValue("this", ValueConversions<protocol::Runtime::RemoteObject>::toValue(m_this.get()));
     151      191332 :     if (m_returnValue.isJust())
     152       34744 :         result->setValue("returnValue", ValueConversions<protocol::Runtime::RemoteObject>::toValue(m_returnValue.fromJust()));
     153      191332 :     return result;
     154             : }
     155             : 
     156           0 : std::unique_ptr<CallFrame> CallFrame::clone() const
     157             : {
     158           0 :     ErrorSupport errors;
     159           0 :     return fromValue(toValue().get(), &errors);
     160             : }
     161             : 
     162             : const char* Scope::TypeEnum::Global = "global";
     163             : const char* Scope::TypeEnum::Local = "local";
     164             : const char* Scope::TypeEnum::With = "with";
     165             : const char* Scope::TypeEnum::Closure = "closure";
     166             : const char* Scope::TypeEnum::Catch = "catch";
     167             : const char* Scope::TypeEnum::Block = "block";
     168             : const char* Scope::TypeEnum::Script = "script";
     169             : const char* Scope::TypeEnum::Eval = "eval";
     170             : const char* Scope::TypeEnum::Module = "module";
     171             : 
     172      993704 : std::unique_ptr<Scope> Scope::fromValue(protocol::Value* value, ErrorSupport* errors)
     173             : {
     174      993704 :     if (!value || value->type() != protocol::Value::TypeObject) {
     175           0 :         errors->addError("object expected");
     176             :         return nullptr;
     177             :     }
     178             : 
     179      496852 :     std::unique_ptr<Scope> result(new Scope());
     180             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
     181      496852 :     errors->push();
     182      993704 :     protocol::Value* typeValue = object->get("type");
     183      993704 :     errors->setName("type");
     184      993704 :     result->m_type = ValueConversions<String>::fromValue(typeValue, errors);
     185      993704 :     protocol::Value* objectValue = object->get("object");
     186      993704 :     errors->setName("object");
     187      496852 :     result->m_object = ValueConversions<protocol::Runtime::RemoteObject>::fromValue(objectValue, errors);
     188      993704 :     protocol::Value* nameValue = object->get("name");
     189      496852 :     if (nameValue) {
     190      232592 :         errors->setName("name");
     191      232592 :         result->m_name = ValueConversions<String>::fromValue(nameValue, errors);
     192             :     }
     193      993704 :     protocol::Value* startLocationValue = object->get("startLocation");
     194      496852 :     if (startLocationValue) {
     195      259444 :         errors->setName("startLocation");
     196      129722 :         result->m_startLocation = ValueConversions<protocol::Debugger::Location>::fromValue(startLocationValue, errors);
     197             :     }
     198      993704 :     protocol::Value* endLocationValue = object->get("endLocation");
     199      496852 :     if (endLocationValue) {
     200      259444 :         errors->setName("endLocation");
     201      129722 :         result->m_endLocation = ValueConversions<protocol::Debugger::Location>::fromValue(endLocationValue, errors);
     202             :     }
     203      496852 :     errors->pop();
     204      496852 :     if (errors->hasErrors())
     205             :         return nullptr;
     206             :     return result;
     207             : }
     208             : 
     209      496852 : std::unique_ptr<protocol::DictionaryValue> Scope::toValue() const
     210             : {
     211      496852 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     212     2484260 :     result->setValue("type", ValueConversions<String>::toValue(m_type));
     213     1987408 :     result->setValue("object", ValueConversions<protocol::Runtime::RemoteObject>::toValue(m_object.get()));
     214      496852 :     if (m_name.isJust())
     215      581480 :         result->setValue("name", ValueConversions<String>::toValue(m_name.fromJust()));
     216      496852 :     if (m_startLocation.isJust())
     217      518888 :         result->setValue("startLocation", ValueConversions<protocol::Debugger::Location>::toValue(m_startLocation.fromJust()));
     218      496852 :     if (m_endLocation.isJust())
     219      518888 :         result->setValue("endLocation", ValueConversions<protocol::Debugger::Location>::toValue(m_endLocation.fromJust()));
     220      496852 :     return result;
     221             : }
     222             : 
     223           0 : std::unique_ptr<Scope> Scope::clone() const
     224             : {
     225           0 :     ErrorSupport errors;
     226           0 :     return fromValue(toValue().get(), &errors);
     227             : }
     228             : 
     229           0 : std::unique_ptr<SearchMatch> SearchMatch::fromValue(protocol::Value* value, ErrorSupport* errors)
     230             : {
     231           0 :     if (!value || value->type() != protocol::Value::TypeObject) {
     232           0 :         errors->addError("object expected");
     233             :         return nullptr;
     234             :     }
     235             : 
     236           0 :     std::unique_ptr<SearchMatch> result(new SearchMatch());
     237             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
     238           0 :     errors->push();
     239           0 :     protocol::Value* lineNumberValue = object->get("lineNumber");
     240           0 :     errors->setName("lineNumber");
     241           0 :     result->m_lineNumber = ValueConversions<double>::fromValue(lineNumberValue, errors);
     242           0 :     protocol::Value* lineContentValue = object->get("lineContent");
     243           0 :     errors->setName("lineContent");
     244           0 :     result->m_lineContent = ValueConversions<String>::fromValue(lineContentValue, errors);
     245           0 :     errors->pop();
     246           0 :     if (errors->hasErrors())
     247             :         return nullptr;
     248             :     return result;
     249             : }
     250             : 
     251           0 : std::unique_ptr<protocol::DictionaryValue> SearchMatch::toValue() const
     252             : {
     253           0 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     254           0 :     result->setValue("lineNumber", ValueConversions<double>::toValue(m_lineNumber));
     255           0 :     result->setValue("lineContent", ValueConversions<String>::toValue(m_lineContent));
     256           0 :     return result;
     257             : }
     258             : 
     259           0 : std::unique_ptr<SearchMatch> SearchMatch::clone() const
     260             : {
     261           0 :     ErrorSupport errors;
     262           0 :     return fromValue(toValue().get(), &errors);
     263             : }
     264             : 
     265           0 : std::unique_ptr<StringBuffer> SearchMatch::toJSONString() const
     266             : {
     267           0 :     String json = toValue()->serialize();
     268           0 :     return StringBufferImpl::adopt(json);
     269             : }
     270             : 
     271             : // static
     272           0 : std::unique_ptr<API::SearchMatch> API::SearchMatch::fromJSONString(const StringView& json)
     273             : {
     274           0 :     ErrorSupport errors;
     275           0 :     std::unique_ptr<Value> value = StringUtil::parseJSON(json);
     276           0 :     if (!value)
     277             :         return nullptr;
     278           0 :     return protocol::Debugger::SearchMatch::fromValue(value.get(), &errors);
     279             : }
     280             : 
     281             : const char* BreakLocation::TypeEnum::DebuggerStatement = "debuggerStatement";
     282             : const char* BreakLocation::TypeEnum::Call = "call";
     283             : const char* BreakLocation::TypeEnum::Return = "return";
     284             : 
     285           0 : std::unique_ptr<BreakLocation> BreakLocation::fromValue(protocol::Value* value, ErrorSupport* errors)
     286             : {
     287           0 :     if (!value || value->type() != protocol::Value::TypeObject) {
     288           0 :         errors->addError("object expected");
     289             :         return nullptr;
     290             :     }
     291             : 
     292           0 :     std::unique_ptr<BreakLocation> result(new BreakLocation());
     293             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
     294           0 :     errors->push();
     295           0 :     protocol::Value* scriptIdValue = object->get("scriptId");
     296           0 :     errors->setName("scriptId");
     297           0 :     result->m_scriptId = ValueConversions<String>::fromValue(scriptIdValue, errors);
     298           0 :     protocol::Value* lineNumberValue = object->get("lineNumber");
     299           0 :     errors->setName("lineNumber");
     300           0 :     result->m_lineNumber = ValueConversions<int>::fromValue(lineNumberValue, errors);
     301           0 :     protocol::Value* columnNumberValue = object->get("columnNumber");
     302           0 :     if (columnNumberValue) {
     303           0 :         errors->setName("columnNumber");
     304           0 :         result->m_columnNumber = ValueConversions<int>::fromValue(columnNumberValue, errors);
     305             :     }
     306           0 :     protocol::Value* typeValue = object->get("type");
     307           0 :     if (typeValue) {
     308           0 :         errors->setName("type");
     309           0 :         result->m_type = ValueConversions<String>::fromValue(typeValue, errors);
     310             :     }
     311           0 :     errors->pop();
     312           0 :     if (errors->hasErrors())
     313             :         return nullptr;
     314             :     return result;
     315             : }
     316             : 
     317        2838 : std::unique_ptr<protocol::DictionaryValue> BreakLocation::toValue() const
     318             : {
     319        2838 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     320       14190 :     result->setValue("scriptId", ValueConversions<String>::toValue(m_scriptId));
     321       14190 :     result->setValue("lineNumber", ValueConversions<int>::toValue(m_lineNumber));
     322        2838 :     if (m_columnNumber.isJust())
     323       11352 :         result->setValue("columnNumber", ValueConversions<int>::toValue(m_columnNumber.fromJust()));
     324        2838 :     if (m_type.isJust())
     325        8250 :         result->setValue("type", ValueConversions<String>::toValue(m_type.fromJust()));
     326        2838 :     return result;
     327             : }
     328             : 
     329           0 : std::unique_ptr<BreakLocation> BreakLocation::clone() const
     330             : {
     331           0 :     ErrorSupport errors;
     332           0 :     return fromValue(toValue().get(), &errors);
     333             : }
     334             : 
     335           0 : std::unique_ptr<ScriptParsedNotification> ScriptParsedNotification::fromValue(protocol::Value* value, ErrorSupport* errors)
     336             : {
     337           0 :     if (!value || value->type() != protocol::Value::TypeObject) {
     338           0 :         errors->addError("object expected");
     339             :         return nullptr;
     340             :     }
     341             : 
     342           0 :     std::unique_ptr<ScriptParsedNotification> result(new ScriptParsedNotification());
     343             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
     344           0 :     errors->push();
     345           0 :     protocol::Value* scriptIdValue = object->get("scriptId");
     346           0 :     errors->setName("scriptId");
     347           0 :     result->m_scriptId = ValueConversions<String>::fromValue(scriptIdValue, errors);
     348           0 :     protocol::Value* urlValue = object->get("url");
     349           0 :     errors->setName("url");
     350           0 :     result->m_url = ValueConversions<String>::fromValue(urlValue, errors);
     351           0 :     protocol::Value* startLineValue = object->get("startLine");
     352           0 :     errors->setName("startLine");
     353           0 :     result->m_startLine = ValueConversions<int>::fromValue(startLineValue, errors);
     354           0 :     protocol::Value* startColumnValue = object->get("startColumn");
     355           0 :     errors->setName("startColumn");
     356           0 :     result->m_startColumn = ValueConversions<int>::fromValue(startColumnValue, errors);
     357           0 :     protocol::Value* endLineValue = object->get("endLine");
     358           0 :     errors->setName("endLine");
     359           0 :     result->m_endLine = ValueConversions<int>::fromValue(endLineValue, errors);
     360           0 :     protocol::Value* endColumnValue = object->get("endColumn");
     361           0 :     errors->setName("endColumn");
     362           0 :     result->m_endColumn = ValueConversions<int>::fromValue(endColumnValue, errors);
     363           0 :     protocol::Value* executionContextIdValue = object->get("executionContextId");
     364           0 :     errors->setName("executionContextId");
     365           0 :     result->m_executionContextId = ValueConversions<int>::fromValue(executionContextIdValue, errors);
     366           0 :     protocol::Value* hashValue = object->get("hash");
     367           0 :     errors->setName("hash");
     368           0 :     result->m_hash = ValueConversions<String>::fromValue(hashValue, errors);
     369           0 :     protocol::Value* executionContextAuxDataValue = object->get("executionContextAuxData");
     370           0 :     if (executionContextAuxDataValue) {
     371           0 :         errors->setName("executionContextAuxData");
     372           0 :         result->m_executionContextAuxData = ValueConversions<protocol::DictionaryValue>::fromValue(executionContextAuxDataValue, errors);
     373             :     }
     374           0 :     protocol::Value* isLiveEditValue = object->get("isLiveEdit");
     375           0 :     if (isLiveEditValue) {
     376           0 :         errors->setName("isLiveEdit");
     377           0 :         result->m_isLiveEdit = ValueConversions<bool>::fromValue(isLiveEditValue, errors);
     378             :     }
     379           0 :     protocol::Value* sourceMapURLValue = object->get("sourceMapURL");
     380           0 :     if (sourceMapURLValue) {
     381           0 :         errors->setName("sourceMapURL");
     382           0 :         result->m_sourceMapURL = ValueConversions<String>::fromValue(sourceMapURLValue, errors);
     383             :     }
     384           0 :     protocol::Value* hasSourceURLValue = object->get("hasSourceURL");
     385           0 :     if (hasSourceURLValue) {
     386           0 :         errors->setName("hasSourceURL");
     387           0 :         result->m_hasSourceURL = ValueConversions<bool>::fromValue(hasSourceURLValue, errors);
     388             :     }
     389           0 :     protocol::Value* isModuleValue = object->get("isModule");
     390           0 :     if (isModuleValue) {
     391           0 :         errors->setName("isModule");
     392           0 :         result->m_isModule = ValueConversions<bool>::fromValue(isModuleValue, errors);
     393             :     }
     394           0 :     protocol::Value* lengthValue = object->get("length");
     395           0 :     if (lengthValue) {
     396           0 :         errors->setName("length");
     397           0 :         result->m_length = ValueConversions<int>::fromValue(lengthValue, errors);
     398             :     }
     399           0 :     protocol::Value* stackTraceValue = object->get("stackTrace");
     400           0 :     if (stackTraceValue) {
     401           0 :         errors->setName("stackTrace");
     402           0 :         result->m_stackTrace = ValueConversions<protocol::Runtime::StackTrace>::fromValue(stackTraceValue, errors);
     403             :     }
     404           0 :     errors->pop();
     405           0 :     if (errors->hasErrors())
     406             :         return nullptr;
     407             :     return result;
     408             : }
     409             : 
     410       36492 : std::unique_ptr<protocol::DictionaryValue> ScriptParsedNotification::toValue() const
     411             : {
     412       36492 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     413      182460 :     result->setValue("scriptId", ValueConversions<String>::toValue(m_scriptId));
     414      182460 :     result->setValue("url", ValueConversions<String>::toValue(m_url));
     415      182460 :     result->setValue("startLine", ValueConversions<int>::toValue(m_startLine));
     416      182460 :     result->setValue("startColumn", ValueConversions<int>::toValue(m_startColumn));
     417      145968 :     result->setValue("endLine", ValueConversions<int>::toValue(m_endLine));
     418      182460 :     result->setValue("endColumn", ValueConversions<int>::toValue(m_endColumn));
     419      182460 :     result->setValue("executionContextId", ValueConversions<int>::toValue(m_executionContextId));
     420      182460 :     result->setValue("hash", ValueConversions<String>::toValue(m_hash));
     421       36492 :     if (m_executionContextAuxData.isJust())
     422           0 :         result->setValue("executionContextAuxData", ValueConversions<protocol::DictionaryValue>::toValue(m_executionContextAuxData.fromJust()));
     423       36492 :     if (m_isLiveEdit.isJust())
     424      145968 :         result->setValue("isLiveEdit", ValueConversions<bool>::toValue(m_isLiveEdit.fromJust()));
     425       36492 :     if (m_sourceMapURL.isJust())
     426      182460 :         result->setValue("sourceMapURL", ValueConversions<String>::toValue(m_sourceMapURL.fromJust()));
     427       36492 :     if (m_hasSourceURL.isJust())
     428      145968 :         result->setValue("hasSourceURL", ValueConversions<bool>::toValue(m_hasSourceURL.fromJust()));
     429       36492 :     if (m_isModule.isJust())
     430      145968 :         result->setValue("isModule", ValueConversions<bool>::toValue(m_isModule.fromJust()));
     431       36492 :     if (m_length.isJust())
     432      145968 :         result->setValue("length", ValueConversions<int>::toValue(m_length.fromJust()));
     433       36492 :     if (m_stackTrace.isJust())
     434      130532 :         result->setValue("stackTrace", ValueConversions<protocol::Runtime::StackTrace>::toValue(m_stackTrace.fromJust()));
     435       36492 :     return result;
     436             : }
     437             : 
     438           0 : std::unique_ptr<ScriptParsedNotification> ScriptParsedNotification::clone() const
     439             : {
     440           0 :     ErrorSupport errors;
     441           0 :     return fromValue(toValue().get(), &errors);
     442             : }
     443             : 
     444           0 : std::unique_ptr<ScriptFailedToParseNotification> ScriptFailedToParseNotification::fromValue(protocol::Value* value, ErrorSupport* errors)
     445             : {
     446           0 :     if (!value || value->type() != protocol::Value::TypeObject) {
     447           0 :         errors->addError("object expected");
     448             :         return nullptr;
     449             :     }
     450             : 
     451           0 :     std::unique_ptr<ScriptFailedToParseNotification> result(new ScriptFailedToParseNotification());
     452             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
     453           0 :     errors->push();
     454           0 :     protocol::Value* scriptIdValue = object->get("scriptId");
     455           0 :     errors->setName("scriptId");
     456           0 :     result->m_scriptId = ValueConversions<String>::fromValue(scriptIdValue, errors);
     457           0 :     protocol::Value* urlValue = object->get("url");
     458           0 :     errors->setName("url");
     459           0 :     result->m_url = ValueConversions<String>::fromValue(urlValue, errors);
     460           0 :     protocol::Value* startLineValue = object->get("startLine");
     461           0 :     errors->setName("startLine");
     462           0 :     result->m_startLine = ValueConversions<int>::fromValue(startLineValue, errors);
     463           0 :     protocol::Value* startColumnValue = object->get("startColumn");
     464           0 :     errors->setName("startColumn");
     465           0 :     result->m_startColumn = ValueConversions<int>::fromValue(startColumnValue, errors);
     466           0 :     protocol::Value* endLineValue = object->get("endLine");
     467           0 :     errors->setName("endLine");
     468           0 :     result->m_endLine = ValueConversions<int>::fromValue(endLineValue, errors);
     469           0 :     protocol::Value* endColumnValue = object->get("endColumn");
     470           0 :     errors->setName("endColumn");
     471           0 :     result->m_endColumn = ValueConversions<int>::fromValue(endColumnValue, errors);
     472           0 :     protocol::Value* executionContextIdValue = object->get("executionContextId");
     473           0 :     errors->setName("executionContextId");
     474           0 :     result->m_executionContextId = ValueConversions<int>::fromValue(executionContextIdValue, errors);
     475           0 :     protocol::Value* hashValue = object->get("hash");
     476           0 :     errors->setName("hash");
     477           0 :     result->m_hash = ValueConversions<String>::fromValue(hashValue, errors);
     478           0 :     protocol::Value* executionContextAuxDataValue = object->get("executionContextAuxData");
     479           0 :     if (executionContextAuxDataValue) {
     480           0 :         errors->setName("executionContextAuxData");
     481           0 :         result->m_executionContextAuxData = ValueConversions<protocol::DictionaryValue>::fromValue(executionContextAuxDataValue, errors);
     482             :     }
     483           0 :     protocol::Value* sourceMapURLValue = object->get("sourceMapURL");
     484           0 :     if (sourceMapURLValue) {
     485           0 :         errors->setName("sourceMapURL");
     486           0 :         result->m_sourceMapURL = ValueConversions<String>::fromValue(sourceMapURLValue, errors);
     487             :     }
     488           0 :     protocol::Value* hasSourceURLValue = object->get("hasSourceURL");
     489           0 :     if (hasSourceURLValue) {
     490           0 :         errors->setName("hasSourceURL");
     491           0 :         result->m_hasSourceURL = ValueConversions<bool>::fromValue(hasSourceURLValue, errors);
     492             :     }
     493           0 :     protocol::Value* isModuleValue = object->get("isModule");
     494           0 :     if (isModuleValue) {
     495           0 :         errors->setName("isModule");
     496           0 :         result->m_isModule = ValueConversions<bool>::fromValue(isModuleValue, errors);
     497             :     }
     498           0 :     protocol::Value* lengthValue = object->get("length");
     499           0 :     if (lengthValue) {
     500           0 :         errors->setName("length");
     501           0 :         result->m_length = ValueConversions<int>::fromValue(lengthValue, errors);
     502             :     }
     503           0 :     protocol::Value* stackTraceValue = object->get("stackTrace");
     504           0 :     if (stackTraceValue) {
     505           0 :         errors->setName("stackTrace");
     506           0 :         result->m_stackTrace = ValueConversions<protocol::Runtime::StackTrace>::fromValue(stackTraceValue, errors);
     507             :     }
     508           0 :     errors->pop();
     509           0 :     if (errors->hasErrors())
     510             :         return nullptr;
     511             :     return result;
     512             : }
     513             : 
     514         184 : std::unique_ptr<protocol::DictionaryValue> ScriptFailedToParseNotification::toValue() const
     515             : {
     516         184 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     517         920 :     result->setValue("scriptId", ValueConversions<String>::toValue(m_scriptId));
     518         920 :     result->setValue("url", ValueConversions<String>::toValue(m_url));
     519         920 :     result->setValue("startLine", ValueConversions<int>::toValue(m_startLine));
     520         920 :     result->setValue("startColumn", ValueConversions<int>::toValue(m_startColumn));
     521         920 :     result->setValue("endLine", ValueConversions<int>::toValue(m_endLine));
     522         920 :     result->setValue("endColumn", ValueConversions<int>::toValue(m_endColumn));
     523         920 :     result->setValue("executionContextId", ValueConversions<int>::toValue(m_executionContextId));
     524         920 :     result->setValue("hash", ValueConversions<String>::toValue(m_hash));
     525         184 :     if (m_executionContextAuxData.isJust())
     526           0 :         result->setValue("executionContextAuxData", ValueConversions<protocol::DictionaryValue>::toValue(m_executionContextAuxData.fromJust()));
     527         184 :     if (m_sourceMapURL.isJust())
     528         920 :         result->setValue("sourceMapURL", ValueConversions<String>::toValue(m_sourceMapURL.fromJust()));
     529         184 :     if (m_hasSourceURL.isJust())
     530         736 :         result->setValue("hasSourceURL", ValueConversions<bool>::toValue(m_hasSourceURL.fromJust()));
     531         184 :     if (m_isModule.isJust())
     532         736 :         result->setValue("isModule", ValueConversions<bool>::toValue(m_isModule.fromJust()));
     533         184 :     if (m_length.isJust())
     534         736 :         result->setValue("length", ValueConversions<int>::toValue(m_length.fromJust()));
     535         184 :     if (m_stackTrace.isJust())
     536         568 :         result->setValue("stackTrace", ValueConversions<protocol::Runtime::StackTrace>::toValue(m_stackTrace.fromJust()));
     537         184 :     return result;
     538             : }
     539             : 
     540           0 : std::unique_ptr<ScriptFailedToParseNotification> ScriptFailedToParseNotification::clone() const
     541             : {
     542           0 :     ErrorSupport errors;
     543           0 :     return fromValue(toValue().get(), &errors);
     544             : }
     545             : 
     546           0 : std::unique_ptr<BreakpointResolvedNotification> BreakpointResolvedNotification::fromValue(protocol::Value* value, ErrorSupport* errors)
     547             : {
     548           0 :     if (!value || value->type() != protocol::Value::TypeObject) {
     549           0 :         errors->addError("object expected");
     550             :         return nullptr;
     551             :     }
     552             : 
     553           0 :     std::unique_ptr<BreakpointResolvedNotification> result(new BreakpointResolvedNotification());
     554             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
     555           0 :     errors->push();
     556           0 :     protocol::Value* breakpointIdValue = object->get("breakpointId");
     557           0 :     errors->setName("breakpointId");
     558           0 :     result->m_breakpointId = ValueConversions<String>::fromValue(breakpointIdValue, errors);
     559           0 :     protocol::Value* locationValue = object->get("location");
     560           0 :     errors->setName("location");
     561           0 :     result->m_location = ValueConversions<protocol::Debugger::Location>::fromValue(locationValue, errors);
     562           0 :     errors->pop();
     563           0 :     if (errors->hasErrors())
     564             :         return nullptr;
     565             :     return result;
     566             : }
     567             : 
     568          72 : std::unique_ptr<protocol::DictionaryValue> BreakpointResolvedNotification::toValue() const
     569             : {
     570          72 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     571         360 :     result->setValue("breakpointId", ValueConversions<String>::toValue(m_breakpointId));
     572         288 :     result->setValue("location", ValueConversions<protocol::Debugger::Location>::toValue(m_location.get()));
     573          72 :     return result;
     574             : }
     575             : 
     576           0 : std::unique_ptr<BreakpointResolvedNotification> BreakpointResolvedNotification::clone() const
     577             : {
     578           0 :     ErrorSupport errors;
     579           0 :     return fromValue(toValue().get(), &errors);
     580             : }
     581             : 
     582             : const char* PausedNotification::ReasonEnum::XHR = "XHR";
     583             : const char* PausedNotification::ReasonEnum::DOM = "DOM";
     584             : const char* PausedNotification::ReasonEnum::EventListener = "EventListener";
     585             : const char* PausedNotification::ReasonEnum::Exception = "exception";
     586             : const char* PausedNotification::ReasonEnum::Assert = "assert";
     587             : const char* PausedNotification::ReasonEnum::DebugCommand = "debugCommand";
     588             : const char* PausedNotification::ReasonEnum::PromiseRejection = "promiseRejection";
     589             : const char* PausedNotification::ReasonEnum::OOM = "OOM";
     590             : const char* PausedNotification::ReasonEnum::Other = "other";
     591             : const char* PausedNotification::ReasonEnum::Ambiguous = "ambiguous";
     592             : 
     593           0 : std::unique_ptr<PausedNotification> PausedNotification::fromValue(protocol::Value* value, ErrorSupport* errors)
     594             : {
     595           0 :     if (!value || value->type() != protocol::Value::TypeObject) {
     596           0 :         errors->addError("object expected");
     597             :         return nullptr;
     598             :     }
     599             : 
     600           0 :     std::unique_ptr<PausedNotification> result(new PausedNotification());
     601             :     protocol::DictionaryValue* object = DictionaryValue::cast(value);
     602           0 :     errors->push();
     603           0 :     protocol::Value* callFramesValue = object->get("callFrames");
     604           0 :     errors->setName("callFrames");
     605           0 :     result->m_callFrames = ValueConversions<protocol::Array<protocol::Debugger::CallFrame>>::fromValue(callFramesValue, errors);
     606           0 :     protocol::Value* reasonValue = object->get("reason");
     607           0 :     errors->setName("reason");
     608           0 :     result->m_reason = ValueConversions<String>::fromValue(reasonValue, errors);
     609           0 :     protocol::Value* dataValue = object->get("data");
     610           0 :     if (dataValue) {
     611           0 :         errors->setName("data");
     612           0 :         result->m_data = ValueConversions<protocol::DictionaryValue>::fromValue(dataValue, errors);
     613             :     }
     614           0 :     protocol::Value* hitBreakpointsValue = object->get("hitBreakpoints");
     615           0 :     if (hitBreakpointsValue) {
     616           0 :         errors->setName("hitBreakpoints");
     617           0 :         result->m_hitBreakpoints = ValueConversions<protocol::Array<String>>::fromValue(hitBreakpointsValue, errors);
     618             :     }
     619           0 :     protocol::Value* asyncStackTraceValue = object->get("asyncStackTrace");
     620           0 :     if (asyncStackTraceValue) {
     621           0 :         errors->setName("asyncStackTrace");
     622           0 :         result->m_asyncStackTrace = ValueConversions<protocol::Runtime::StackTrace>::fromValue(asyncStackTraceValue, errors);
     623             :     }
     624           0 :     errors->pop();
     625           0 :     if (errors->hasErrors())
     626             :         return nullptr;
     627             :     return result;
     628             : }
     629             : 
     630       77060 : std::unique_ptr<protocol::DictionaryValue> PausedNotification::toValue() const
     631             : {
     632       77060 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     633      308240 :     result->setValue("callFrames", ValueConversions<protocol::Array<protocol::Debugger::CallFrame>>::toValue(m_callFrames.get()));
     634      385300 :     result->setValue("reason", ValueConversions<String>::toValue(m_reason));
     635       77060 :     if (m_data.isJust())
     636       10864 :         result->setValue("data", ValueConversions<protocol::DictionaryValue>::toValue(m_data.fromJust()));
     637       77060 :     if (m_hitBreakpoints.isJust())
     638      308240 :         result->setValue("hitBreakpoints", ValueConversions<protocol::Array<String>>::toValue(m_hitBreakpoints.fromJust()));
     639       77060 :     if (m_asyncStackTrace.isJust())
     640        1512 :         result->setValue("asyncStackTrace", ValueConversions<protocol::Runtime::StackTrace>::toValue(m_asyncStackTrace.fromJust()));
     641       77060 :     return result;
     642             : }
     643             : 
     644           0 : std::unique_ptr<PausedNotification> PausedNotification::clone() const
     645             : {
     646           0 :     ErrorSupport errors;
     647           0 :     return fromValue(toValue().get(), &errors);
     648             : }
     649             : 
     650             : // ------------- Enum values from params.
     651             : 
     652             : 
     653             : namespace SetPauseOnExceptions {
     654             : namespace StateEnum {
     655             : const char* None = "none";
     656             : const char* Uncaught = "uncaught";
     657             : const char* All = "all";
     658             : } // namespace StateEnum
     659             : } // namespace SetPauseOnExceptions
     660             : 
     661             : namespace Paused {
     662             : namespace ReasonEnum {
     663             : const char* XHR = "XHR";
     664             : const char* DOM = "DOM";
     665             : const char* EventListener = "EventListener";
     666             : const char* Exception = "exception";
     667             : const char* Assert = "assert";
     668             : const char* DebugCommand = "debugCommand";
     669             : const char* PromiseRejection = "promiseRejection";
     670             : const char* OOM = "OOM";
     671             : const char* Other = "other";
     672             : const char* Ambiguous = "ambiguous";
     673             : } // namespace ReasonEnum
     674             : } // namespace Paused
     675             : 
     676             : namespace API {
     677             : namespace Paused {
     678             : namespace ReasonEnum {
     679             : const char* XHR = "XHR";
     680             : const char* DOM = "DOM";
     681             : const char* EventListener = "EventListener";
     682             : const char* Exception = "exception";
     683             : const char* Assert = "assert";
     684             : const char* DebugCommand = "debugCommand";
     685             : const char* PromiseRejection = "promiseRejection";
     686             : const char* OOM = "OOM";
     687             : const char* Other = "other";
     688             : const char* Ambiguous = "ambiguous";
     689             : } // namespace ReasonEnum
     690             : } // namespace Paused
     691             : } // namespace API
     692             : 
     693             : // ------------- Frontend notifications.
     694             : 
     695       36492 : void Frontend::scriptParsed(const String& scriptId, const String& url, int startLine, int startColumn, int endLine, int endColumn, int executionContextId, const String& hash, Maybe<protocol::DictionaryValue> executionContextAuxData, Maybe<bool> isLiveEdit, Maybe<String> sourceMapURL, Maybe<bool> hasSourceURL, Maybe<bool> isModule, Maybe<int> length, Maybe<protocol::Runtime::StackTrace> stackTrace)
     696             : {
     697       36492 :     if (!m_frontendChannel)
     698       36492 :         return;
     699             :     std::unique_ptr<ScriptParsedNotification> messageData = ScriptParsedNotification::create()
     700       36492 :         .setScriptId(scriptId)
     701             :         .setUrl(url)
     702             :         .setStartLine(startLine)
     703             :         .setStartColumn(startColumn)
     704             :         .setEndLine(endLine)
     705             :         .setEndColumn(endColumn)
     706             :         .setExecutionContextId(executionContextId)
     707             :         .setHash(hash)
     708             :         .build();
     709       36492 :     if (executionContextAuxData.isJust())
     710             :         messageData->setExecutionContextAuxData(std::move(executionContextAuxData).takeJust());
     711       36492 :     if (isLiveEdit.isJust())
     712       36492 :         messageData->setIsLiveEdit(std::move(isLiveEdit).takeJust());
     713       36492 :     if (sourceMapURL.isJust())
     714       72984 :         messageData->setSourceMapURL(std::move(sourceMapURL).takeJust());
     715       36492 :     if (hasSourceURL.isJust())
     716       36492 :         messageData->setHasSourceURL(std::move(hasSourceURL).takeJust());
     717       36492 :     if (isModule.isJust())
     718       36492 :         messageData->setIsModule(std::move(isModule).takeJust());
     719       36492 :     if (length.isJust())
     720       36492 :         messageData->setLength(std::move(length).takeJust());
     721       36492 :     if (stackTrace.isJust())
     722             :         messageData->setStackTrace(std::move(stackTrace).takeJust());
     723      255444 :     m_frontendChannel->sendProtocolNotification(InternalResponse::createNotification("Debugger.scriptParsed", std::move(messageData)));
     724             : }
     725             : 
     726         184 : void Frontend::scriptFailedToParse(const String& scriptId, const String& url, int startLine, int startColumn, int endLine, int endColumn, int executionContextId, const String& hash, Maybe<protocol::DictionaryValue> executionContextAuxData, Maybe<String> sourceMapURL, Maybe<bool> hasSourceURL, Maybe<bool> isModule, Maybe<int> length, Maybe<protocol::Runtime::StackTrace> stackTrace)
     727             : {
     728         184 :     if (!m_frontendChannel)
     729         184 :         return;
     730             :     std::unique_ptr<ScriptFailedToParseNotification> messageData = ScriptFailedToParseNotification::create()
     731         184 :         .setScriptId(scriptId)
     732             :         .setUrl(url)
     733             :         .setStartLine(startLine)
     734             :         .setStartColumn(startColumn)
     735             :         .setEndLine(endLine)
     736             :         .setEndColumn(endColumn)
     737             :         .setExecutionContextId(executionContextId)
     738             :         .setHash(hash)
     739             :         .build();
     740         184 :     if (executionContextAuxData.isJust())
     741             :         messageData->setExecutionContextAuxData(std::move(executionContextAuxData).takeJust());
     742         184 :     if (sourceMapURL.isJust())
     743         368 :         messageData->setSourceMapURL(std::move(sourceMapURL).takeJust());
     744         184 :     if (hasSourceURL.isJust())
     745         184 :         messageData->setHasSourceURL(std::move(hasSourceURL).takeJust());
     746         184 :     if (isModule.isJust())
     747         184 :         messageData->setIsModule(std::move(isModule).takeJust());
     748         184 :     if (length.isJust())
     749         184 :         messageData->setLength(std::move(length).takeJust());
     750         184 :     if (stackTrace.isJust())
     751             :         messageData->setStackTrace(std::move(stackTrace).takeJust());
     752        1288 :     m_frontendChannel->sendProtocolNotification(InternalResponse::createNotification("Debugger.scriptFailedToParse", std::move(messageData)));
     753             : }
     754             : 
     755          72 : void Frontend::breakpointResolved(const String& breakpointId, std::unique_ptr<protocol::Debugger::Location> location)
     756             : {
     757          72 :     if (!m_frontendChannel)
     758          72 :         return;
     759             :     std::unique_ptr<BreakpointResolvedNotification> messageData = BreakpointResolvedNotification::create()
     760          72 :         .setBreakpointId(breakpointId)
     761             :         .setLocation(std::move(location))
     762             :         .build();
     763         504 :     m_frontendChannel->sendProtocolNotification(InternalResponse::createNotification("Debugger.breakpointResolved", std::move(messageData)));
     764             : }
     765             : 
     766       77060 : void Frontend::paused(std::unique_ptr<protocol::Array<protocol::Debugger::CallFrame>> callFrames, const String& reason, Maybe<protocol::DictionaryValue> data, Maybe<protocol::Array<String>> hitBreakpoints, Maybe<protocol::Runtime::StackTrace> asyncStackTrace)
     767             : {
     768       77060 :     if (!m_frontendChannel)
     769       77060 :         return;
     770             :     std::unique_ptr<PausedNotification> messageData = PausedNotification::create()
     771       77060 :         .setCallFrames(std::move(callFrames))
     772             :         .setReason(reason)
     773             :         .build();
     774       77060 :     if (data.isJust())
     775             :         messageData->setData(std::move(data).takeJust());
     776       77060 :     if (hitBreakpoints.isJust())
     777             :         messageData->setHitBreakpoints(std::move(hitBreakpoints).takeJust());
     778       77060 :     if (asyncStackTrace.isJust())
     779             :         messageData->setAsyncStackTrace(std::move(asyncStackTrace).takeJust());
     780      539420 :     m_frontendChannel->sendProtocolNotification(InternalResponse::createNotification("Debugger.paused", std::move(messageData)));
     781             : }
     782             : 
     783       76975 : void Frontend::resumed()
     784             : {
     785       76975 :     if (!m_frontendChannel)
     786       76975 :         return;
     787      538825 :     m_frontendChannel->sendProtocolNotification(InternalResponse::createNotification("Debugger.resumed"));
     788             : }
     789             : 
     790           0 : void Frontend::flush()
     791             : {
     792           0 :     m_frontendChannel->flushProtocolNotifications();
     793           0 : }
     794             : 
     795           0 : void Frontend::sendRawNotification(const String& notification)
     796             : {
     797           0 :     m_frontendChannel->sendProtocolNotification(InternalRawNotification::create(notification));
     798           0 : }
     799             : 
     800             : // --------------------- Dispatcher.
     801             : 
     802             : class DispatcherImpl : public protocol::DispatcherBase {
     803             : public:
     804        4573 :     DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend, bool fallThroughForNotFound)
     805             :         : DispatcherBase(frontendChannel)
     806             :         , m_backend(backend)
     807        9146 :         , m_fallThroughForNotFound(fallThroughForNotFound) {
     808       13719 :         m_dispatchMap["Debugger.enable"] = &DispatcherImpl::enable;
     809       13719 :         m_dispatchMap["Debugger.disable"] = &DispatcherImpl::disable;
     810       13719 :         m_dispatchMap["Debugger.setBreakpointsActive"] = &DispatcherImpl::setBreakpointsActive;
     811       13719 :         m_dispatchMap["Debugger.setSkipAllPauses"] = &DispatcherImpl::setSkipAllPauses;
     812       13719 :         m_dispatchMap["Debugger.setBreakpointByUrl"] = &DispatcherImpl::setBreakpointByUrl;
     813       13719 :         m_dispatchMap["Debugger.setBreakpoint"] = &DispatcherImpl::setBreakpoint;
     814       13719 :         m_dispatchMap["Debugger.removeBreakpoint"] = &DispatcherImpl::removeBreakpoint;
     815       13719 :         m_dispatchMap["Debugger.getPossibleBreakpoints"] = &DispatcherImpl::getPossibleBreakpoints;
     816       13719 :         m_dispatchMap["Debugger.continueToLocation"] = &DispatcherImpl::continueToLocation;
     817       13719 :         m_dispatchMap["Debugger.stepOver"] = &DispatcherImpl::stepOver;
     818       13719 :         m_dispatchMap["Debugger.stepInto"] = &DispatcherImpl::stepInto;
     819       13719 :         m_dispatchMap["Debugger.stepOut"] = &DispatcherImpl::stepOut;
     820       13719 :         m_dispatchMap["Debugger.pause"] = &DispatcherImpl::pause;
     821       13719 :         m_dispatchMap["Debugger.scheduleStepIntoAsync"] = &DispatcherImpl::scheduleStepIntoAsync;
     822       13719 :         m_dispatchMap["Debugger.resume"] = &DispatcherImpl::resume;
     823       13719 :         m_dispatchMap["Debugger.searchInContent"] = &DispatcherImpl::searchInContent;
     824       13719 :         m_dispatchMap["Debugger.setScriptSource"] = &DispatcherImpl::setScriptSource;
     825       13719 :         m_dispatchMap["Debugger.restartFrame"] = &DispatcherImpl::restartFrame;
     826       13719 :         m_dispatchMap["Debugger.getScriptSource"] = &DispatcherImpl::getScriptSource;
     827       13719 :         m_dispatchMap["Debugger.setPauseOnExceptions"] = &DispatcherImpl::setPauseOnExceptions;
     828       13719 :         m_dispatchMap["Debugger.evaluateOnCallFrame"] = &DispatcherImpl::evaluateOnCallFrame;
     829       13719 :         m_dispatchMap["Debugger.setVariableValue"] = &DispatcherImpl::setVariableValue;
     830       13719 :         m_dispatchMap["Debugger.setAsyncCallStackDepth"] = &DispatcherImpl::setAsyncCallStackDepth;
     831       13719 :         m_dispatchMap["Debugger.setBlackboxPatterns"] = &DispatcherImpl::setBlackboxPatterns;
     832       13719 :         m_dispatchMap["Debugger.setBlackboxedRanges"] = &DispatcherImpl::setBlackboxedRanges;
     833        4573 :     }
     834       13719 :     ~DispatcherImpl() override { }
     835             :     DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
     836             : 
     837             : protected:
     838             :     using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
     839             :     using DispatchMap = protocol::HashMap<String, CallHandler>;
     840             :     DispatchMap m_dispatchMap;
     841             : 
     842             :     DispatchResponse::Status enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     843             :     DispatchResponse::Status disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     844             :     DispatchResponse::Status setBreakpointsActive(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     845             :     DispatchResponse::Status setSkipAllPauses(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     846             :     DispatchResponse::Status setBreakpointByUrl(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     847             :     DispatchResponse::Status setBreakpoint(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     848             :     DispatchResponse::Status removeBreakpoint(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     849             :     DispatchResponse::Status getPossibleBreakpoints(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     850             :     DispatchResponse::Status continueToLocation(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     851             :     DispatchResponse::Status stepOver(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     852             :     DispatchResponse::Status stepInto(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     853             :     DispatchResponse::Status stepOut(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     854             :     DispatchResponse::Status pause(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     855             :     DispatchResponse::Status scheduleStepIntoAsync(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     856             :     DispatchResponse::Status resume(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     857             :     DispatchResponse::Status searchInContent(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     858             :     DispatchResponse::Status setScriptSource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     859             :     DispatchResponse::Status restartFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     860             :     DispatchResponse::Status getScriptSource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     861             :     DispatchResponse::Status setPauseOnExceptions(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     862             :     DispatchResponse::Status evaluateOnCallFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     863             :     DispatchResponse::Status setVariableValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     864             :     DispatchResponse::Status setAsyncCallStackDepth(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     865             :     DispatchResponse::Status setBlackboxPatterns(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     866             :     DispatchResponse::Status setBlackboxedRanges(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
     867             : 
     868             :     Backend* m_backend;
     869             :     bool m_fallThroughForNotFound;
     870             : };
     871             : 
     872       96568 : DispatchResponse::Status DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject)
     873             : {
     874             :     protocol::HashMap<String, CallHandler>::iterator it = m_dispatchMap.find(method);
     875       96568 :     if (it == m_dispatchMap.end()) {
     876           0 :         if (m_fallThroughForNotFound)
     877             :             return DispatchResponse::kFallThrough;
     878           0 :         reportProtocolError(callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
     879           0 :         return DispatchResponse::kError;
     880             :     }
     881             : 
     882       96568 :     protocol::ErrorSupport errors;
     883      289704 :     return (this->*(it->second))(callId, std::move(messageObject), &errors);
     884             : }
     885             : 
     886             : 
     887        4341 : DispatchResponse::Status DispatcherImpl::enable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
     888             : {
     889             : 
     890        4341 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     891        4341 :     DispatchResponse response = m_backend->enable();
     892        4341 :     if (weak->get())
     893        4341 :         weak->get()->sendResponse(callId, response);
     894        8682 :     return response.status();
     895             : }
     896             : 
     897         850 : DispatchResponse::Status DispatcherImpl::disable(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
     898             : {
     899             : 
     900         850 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     901         850 :     DispatchResponse response = m_backend->disable();
     902         850 :     if (weak->get())
     903         850 :         weak->get()->sendResponse(callId, response);
     904        1700 :     return response.status();
     905             : }
     906             : 
     907         180 : DispatchResponse::Status DispatcherImpl::setBreakpointsActive(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
     908             : {
     909             :     // Prepare input parameters.
     910         540 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     911         180 :     errors->push();
     912         360 :     protocol::Value* activeValue = object ? object->get("active") : nullptr;
     913         360 :     errors->setName("active");
     914         180 :     bool in_active = ValueConversions<bool>::fromValue(activeValue, errors);
     915         180 :     errors->pop();
     916         180 :     if (errors->hasErrors()) {
     917           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
     918           0 :         return DispatchResponse::kError;
     919             :     }
     920             : 
     921         180 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     922         180 :     DispatchResponse response = m_backend->setBreakpointsActive(in_active);
     923         180 :     if (weak->get())
     924         180 :         weak->get()->sendResponse(callId, response);
     925         180 :     return response.status();
     926             : }
     927             : 
     928           0 : DispatchResponse::Status DispatcherImpl::setSkipAllPauses(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
     929             : {
     930             :     // Prepare input parameters.
     931           0 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     932           0 :     errors->push();
     933           0 :     protocol::Value* skipValue = object ? object->get("skip") : nullptr;
     934           0 :     errors->setName("skip");
     935           0 :     bool in_skip = ValueConversions<bool>::fromValue(skipValue, errors);
     936           0 :     errors->pop();
     937           0 :     if (errors->hasErrors()) {
     938           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
     939           0 :         return DispatchResponse::kError;
     940             :     }
     941             : 
     942           0 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     943           0 :     DispatchResponse response = m_backend->setSkipAllPauses(in_skip);
     944           0 :     if (weak->get())
     945           0 :         weak->get()->sendResponse(callId, response);
     946           0 :     return response.status();
     947             : }
     948             : 
     949          60 : DispatchResponse::Status DispatcherImpl::setBreakpointByUrl(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
     950             : {
     951             :     // Prepare input parameters.
     952         180 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
     953          60 :     errors->push();
     954         120 :     protocol::Value* lineNumberValue = object ? object->get("lineNumber") : nullptr;
     955         120 :     errors->setName("lineNumber");
     956          60 :     int in_lineNumber = ValueConversions<int>::fromValue(lineNumberValue, errors);
     957         120 :     protocol::Value* urlValue = object ? object->get("url") : nullptr;
     958             :     Maybe<String> in_url;
     959          60 :     if (urlValue) {
     960         120 :         errors->setName("url");
     961         120 :         in_url = ValueConversions<String>::fromValue(urlValue, errors);
     962             :     }
     963         120 :     protocol::Value* urlRegexValue = object ? object->get("urlRegex") : nullptr;
     964             :     Maybe<String> in_urlRegex;
     965          60 :     if (urlRegexValue) {
     966           0 :         errors->setName("urlRegex");
     967           0 :         in_urlRegex = ValueConversions<String>::fromValue(urlRegexValue, errors);
     968             :     }
     969         120 :     protocol::Value* columnNumberValue = object ? object->get("columnNumber") : nullptr;
     970             :     Maybe<int> in_columnNumber;
     971          60 :     if (columnNumberValue) {
     972          72 :         errors->setName("columnNumber");
     973          36 :         in_columnNumber = ValueConversions<int>::fromValue(columnNumberValue, errors);
     974             :     }
     975         120 :     protocol::Value* conditionValue = object ? object->get("condition") : nullptr;
     976             :     Maybe<String> in_condition;
     977          60 :     if (conditionValue) {
     978           0 :         errors->setName("condition");
     979           0 :         in_condition = ValueConversions<String>::fromValue(conditionValue, errors);
     980             :     }
     981          60 :     errors->pop();
     982          60 :     if (errors->hasErrors()) {
     983           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
     984           0 :         return DispatchResponse::kError;
     985             :     }
     986             :     // Declare output parameters.
     987             :     String out_breakpointId;
     988          60 :     std::unique_ptr<protocol::Array<protocol::Debugger::Location>> out_locations;
     989             : 
     990          60 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
     991         300 :     DispatchResponse response = m_backend->setBreakpointByUrl(in_lineNumber, std::move(in_url), std::move(in_urlRegex), std::move(in_columnNumber), std::move(in_condition), &out_breakpointId, &out_locations);
     992          60 :     if (response.status() == DispatchResponse::kFallThrough)
     993             :         return response.status();
     994          60 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     995          60 :     if (response.status() == DispatchResponse::kSuccess) {
     996         240 :         result->setValue("breakpointId", ValueConversions<String>::toValue(out_breakpointId));
     997         240 :         result->setValue("locations", ValueConversions<protocol::Array<protocol::Debugger::Location>>::toValue(out_locations.get()));
     998             :     }
     999          60 :     if (weak->get())
    1000         120 :         weak->get()->sendResponse(callId, response, std::move(result));
    1001          60 :     return response.status();
    1002             : }
    1003             : 
    1004        2496 : DispatchResponse::Status DispatcherImpl::setBreakpoint(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1005             : {
    1006             :     // Prepare input parameters.
    1007        7488 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1008        2496 :     errors->push();
    1009        4992 :     protocol::Value* locationValue = object ? object->get("location") : nullptr;
    1010        4992 :     errors->setName("location");
    1011             :     std::unique_ptr<protocol::Debugger::Location> in_location = ValueConversions<protocol::Debugger::Location>::fromValue(locationValue, errors);
    1012        4992 :     protocol::Value* conditionValue = object ? object->get("condition") : nullptr;
    1013             :     Maybe<String> in_condition;
    1014        2496 :     if (conditionValue) {
    1015         560 :         errors->setName("condition");
    1016         560 :         in_condition = ValueConversions<String>::fromValue(conditionValue, errors);
    1017             :     }
    1018        2496 :     errors->pop();
    1019        2496 :     if (errors->hasErrors()) {
    1020          12 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1021           6 :         return DispatchResponse::kError;
    1022             :     }
    1023             :     // Declare output parameters.
    1024             :     String out_breakpointId;
    1025        2490 :     std::unique_ptr<protocol::Debugger::Location> out_actualLocation;
    1026             : 
    1027        2490 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1028        9960 :     DispatchResponse response = m_backend->setBreakpoint(std::move(in_location), std::move(in_condition), &out_breakpointId, &out_actualLocation);
    1029        2490 :     if (response.status() == DispatchResponse::kFallThrough)
    1030             :         return response.status();
    1031        2490 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
    1032        2490 :     if (response.status() == DispatchResponse::kSuccess) {
    1033        9064 :         result->setValue("breakpointId", ValueConversions<String>::toValue(out_breakpointId));
    1034        9064 :         result->setValue("actualLocation", ValueConversions<protocol::Debugger::Location>::toValue(out_actualLocation.get()));
    1035             :     }
    1036        2490 :     if (weak->get())
    1037        4980 :         weak->get()->sendResponse(callId, response, std::move(result));
    1038        2490 :     return response.status();
    1039             : }
    1040             : 
    1041         726 : DispatchResponse::Status DispatcherImpl::removeBreakpoint(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1042             : {
    1043             :     // Prepare input parameters.
    1044        2178 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1045         726 :     errors->push();
    1046        1452 :     protocol::Value* breakpointIdValue = object ? object->get("breakpointId") : nullptr;
    1047        1452 :     errors->setName("breakpointId");
    1048         726 :     String in_breakpointId = ValueConversions<String>::fromValue(breakpointIdValue, errors);
    1049         726 :     errors->pop();
    1050         726 :     if (errors->hasErrors()) {
    1051           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1052           0 :         return DispatchResponse::kError;
    1053             :     }
    1054             : 
    1055         726 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1056         726 :     DispatchResponse response = m_backend->removeBreakpoint(in_breakpointId);
    1057         726 :     if (weak->get())
    1058         726 :         weak->get()->sendResponse(callId, response);
    1059         726 :     return response.status();
    1060             : }
    1061             : 
    1062         264 : DispatchResponse::Status DispatcherImpl::getPossibleBreakpoints(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1063             : {
    1064             :     // Prepare input parameters.
    1065         792 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1066         264 :     errors->push();
    1067         528 :     protocol::Value* startValue = object ? object->get("start") : nullptr;
    1068         528 :     errors->setName("start");
    1069             :     std::unique_ptr<protocol::Debugger::Location> in_start = ValueConversions<protocol::Debugger::Location>::fromValue(startValue, errors);
    1070         528 :     protocol::Value* endValue = object ? object->get("end") : nullptr;
    1071             :     Maybe<protocol::Debugger::Location> in_end;
    1072         264 :     if (endValue) {
    1073         264 :         errors->setName("end");
    1074         132 :         in_end = ValueConversions<protocol::Debugger::Location>::fromValue(endValue, errors);
    1075             :     }
    1076         528 :     protocol::Value* restrictToFunctionValue = object ? object->get("restrictToFunction") : nullptr;
    1077             :     Maybe<bool> in_restrictToFunction;
    1078         264 :     if (restrictToFunctionValue) {
    1079           0 :         errors->setName("restrictToFunction");
    1080           0 :         in_restrictToFunction = ValueConversions<bool>::fromValue(restrictToFunctionValue, errors);
    1081             :     }
    1082         264 :     errors->pop();
    1083         264 :     if (errors->hasErrors()) {
    1084           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1085           0 :         return DispatchResponse::kError;
    1086             :     }
    1087             :     // Declare output parameters.
    1088         264 :     std::unique_ptr<protocol::Array<protocol::Debugger::BreakLocation>> out_locations;
    1089             : 
    1090         264 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1091        1056 :     DispatchResponse response = m_backend->getPossibleBreakpoints(std::move(in_start), std::move(in_end), std::move(in_restrictToFunction), &out_locations);
    1092         264 :     if (response.status() == DispatchResponse::kFallThrough)
    1093             :         return response.status();
    1094         264 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
    1095         264 :     if (response.status() == DispatchResponse::kSuccess) {
    1096        1008 :         result->setValue("locations", ValueConversions<protocol::Array<protocol::Debugger::BreakLocation>>::toValue(out_locations.get()));
    1097             :     }
    1098         264 :     if (weak->get())
    1099         528 :         weak->get()->sendResponse(callId, response, std::move(result));
    1100         264 :     return response.status();
    1101             : }
    1102             : 
    1103          36 : DispatchResponse::Status DispatcherImpl::continueToLocation(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1104             : {
    1105             :     // Prepare input parameters.
    1106         108 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1107          36 :     errors->push();
    1108          72 :     protocol::Value* locationValue = object ? object->get("location") : nullptr;
    1109          72 :     errors->setName("location");
    1110             :     std::unique_ptr<protocol::Debugger::Location> in_location = ValueConversions<protocol::Debugger::Location>::fromValue(locationValue, errors);
    1111          36 :     errors->pop();
    1112          36 :     if (errors->hasErrors()) {
    1113           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1114           0 :         return DispatchResponse::kError;
    1115             :     }
    1116             : 
    1117          36 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1118         108 :     DispatchResponse response = m_backend->continueToLocation(std::move(in_location));
    1119          36 :     if (weak->get())
    1120          36 :         weak->get()->sendResponse(callId, response);
    1121          36 :     return response.status();
    1122             : }
    1123             : 
    1124       11616 : DispatchResponse::Status DispatcherImpl::stepOver(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1125             : {
    1126             : 
    1127       11616 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1128       11616 :     DispatchResponse response = m_backend->stepOver();
    1129       11616 :     if (weak->get())
    1130       11616 :         weak->get()->sendResponse(callId, response);
    1131       23232 :     return response.status();
    1132             : }
    1133             : 
    1134       50590 : DispatchResponse::Status DispatcherImpl::stepInto(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1135             : {
    1136             : 
    1137       50590 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1138       50590 :     DispatchResponse response = m_backend->stepInto();
    1139       50590 :     if (weak->get())
    1140       50590 :         weak->get()->sendResponse(callId, response);
    1141      101180 :     return response.status();
    1142             : }
    1143             : 
    1144         661 : DispatchResponse::Status DispatcherImpl::stepOut(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1145             : {
    1146             : 
    1147         661 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1148         661 :     DispatchResponse response = m_backend->stepOut();
    1149         661 :     if (weak->get())
    1150         661 :         weak->get()->sendResponse(callId, response);
    1151        1322 :     return response.status();
    1152             : }
    1153             : 
    1154         168 : DispatchResponse::Status DispatcherImpl::pause(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1155             : {
    1156             : 
    1157         168 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1158         168 :     DispatchResponse response = m_backend->pause();
    1159         168 :     if (weak->get())
    1160         168 :         weak->get()->sendResponse(callId, response);
    1161         336 :     return response.status();
    1162             : }
    1163             : 
    1164         180 : class ScheduleStepIntoAsyncCallbackImpl : public Backend::ScheduleStepIntoAsyncCallback, public DispatcherBase::Callback {
    1165             : public:
    1166          90 :     ScheduleStepIntoAsyncCallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, int callbackId)
    1167         180 :         : DispatcherBase::Callback(std::move(backendImpl), callId, callbackId) { }
    1168             : 
    1169          72 :     void sendSuccess() override
    1170             :     {
    1171          72 :         std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
    1172         288 :         sendIfActive(std::move(resultObject), DispatchResponse::OK());
    1173          72 :     }
    1174             : 
    1175           0 :     void fallThrough() override
    1176             :     {
    1177           0 :         fallThroughIfActive();
    1178           0 :     }
    1179             : 
    1180          18 :     void sendFailure(const DispatchResponse& response) override
    1181             :     {
    1182             :         DCHECK(response.status() == DispatchResponse::kError);
    1183          36 :         sendIfActive(nullptr, response);
    1184          18 :     }
    1185             : };
    1186             : 
    1187          90 : DispatchResponse::Status DispatcherImpl::scheduleStepIntoAsync(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1188             : {
    1189             : 
    1190          90 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1191         180 :     std::unique_ptr<ScheduleStepIntoAsyncCallbackImpl> callback(new ScheduleStepIntoAsyncCallbackImpl(weakPtr(), callId, nextCallbackId()));
    1192         270 :     m_backend->scheduleStepIntoAsync(std::move(callback));
    1193         180 :     return (weak->get() && weak->get()->lastCallbackFallThrough()) ? DispatchResponse::kFallThrough : DispatchResponse::kAsync;
    1194             : }
    1195             : 
    1196        1608 : DispatchResponse::Status DispatcherImpl::resume(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1197             : {
    1198             : 
    1199        1608 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1200        1608 :     DispatchResponse response = m_backend->resume();
    1201        1608 :     if (weak->get())
    1202        1608 :         weak->get()->sendResponse(callId, response);
    1203        3216 :     return response.status();
    1204             : }
    1205             : 
    1206           0 : DispatchResponse::Status DispatcherImpl::searchInContent(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1207             : {
    1208             :     // Prepare input parameters.
    1209           0 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1210           0 :     errors->push();
    1211           0 :     protocol::Value* scriptIdValue = object ? object->get("scriptId") : nullptr;
    1212           0 :     errors->setName("scriptId");
    1213           0 :     String in_scriptId = ValueConversions<String>::fromValue(scriptIdValue, errors);
    1214           0 :     protocol::Value* queryValue = object ? object->get("query") : nullptr;
    1215           0 :     errors->setName("query");
    1216           0 :     String in_query = ValueConversions<String>::fromValue(queryValue, errors);
    1217           0 :     protocol::Value* caseSensitiveValue = object ? object->get("caseSensitive") : nullptr;
    1218             :     Maybe<bool> in_caseSensitive;
    1219           0 :     if (caseSensitiveValue) {
    1220           0 :         errors->setName("caseSensitive");
    1221           0 :         in_caseSensitive = ValueConversions<bool>::fromValue(caseSensitiveValue, errors);
    1222             :     }
    1223           0 :     protocol::Value* isRegexValue = object ? object->get("isRegex") : nullptr;
    1224             :     Maybe<bool> in_isRegex;
    1225           0 :     if (isRegexValue) {
    1226           0 :         errors->setName("isRegex");
    1227           0 :         in_isRegex = ValueConversions<bool>::fromValue(isRegexValue, errors);
    1228             :     }
    1229           0 :     errors->pop();
    1230           0 :     if (errors->hasErrors()) {
    1231           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1232           0 :         return DispatchResponse::kError;
    1233             :     }
    1234             :     // Declare output parameters.
    1235           0 :     std::unique_ptr<protocol::Array<protocol::Debugger::SearchMatch>> out_result;
    1236             : 
    1237           0 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1238           0 :     DispatchResponse response = m_backend->searchInContent(in_scriptId, in_query, std::move(in_caseSensitive), std::move(in_isRegex), &out_result);
    1239           0 :     if (response.status() == DispatchResponse::kFallThrough)
    1240             :         return response.status();
    1241           0 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
    1242           0 :     if (response.status() == DispatchResponse::kSuccess) {
    1243           0 :         result->setValue("result", ValueConversions<protocol::Array<protocol::Debugger::SearchMatch>>::toValue(out_result.get()));
    1244             :     }
    1245           0 :     if (weak->get())
    1246           0 :         weak->get()->sendResponse(callId, response, std::move(result));
    1247           0 :     return response.status();
    1248             : }
    1249             : 
    1250          44 : DispatchResponse::Status DispatcherImpl::setScriptSource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1251             : {
    1252             :     // Prepare input parameters.
    1253         132 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1254          44 :     errors->push();
    1255          88 :     protocol::Value* scriptIdValue = object ? object->get("scriptId") : nullptr;
    1256          88 :     errors->setName("scriptId");
    1257          44 :     String in_scriptId = ValueConversions<String>::fromValue(scriptIdValue, errors);
    1258          88 :     protocol::Value* scriptSourceValue = object ? object->get("scriptSource") : nullptr;
    1259          88 :     errors->setName("scriptSource");
    1260          44 :     String in_scriptSource = ValueConversions<String>::fromValue(scriptSourceValue, errors);
    1261          88 :     protocol::Value* dryRunValue = object ? object->get("dryRun") : nullptr;
    1262             :     Maybe<bool> in_dryRun;
    1263          44 :     if (dryRunValue) {
    1264           0 :         errors->setName("dryRun");
    1265           0 :         in_dryRun = ValueConversions<bool>::fromValue(dryRunValue, errors);
    1266             :     }
    1267          44 :     errors->pop();
    1268          44 :     if (errors->hasErrors()) {
    1269          28 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1270          14 :         return DispatchResponse::kError;
    1271             :     }
    1272             :     // Declare output parameters.
    1273             :     Maybe<protocol::Array<protocol::Debugger::CallFrame>> out_callFrames;
    1274             :     Maybe<bool> out_stackChanged;
    1275             :     Maybe<protocol::Runtime::StackTrace> out_asyncStackTrace;
    1276             :     Maybe<protocol::Runtime::ExceptionDetails> out_exceptionDetails;
    1277             : 
    1278          30 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1279          60 :     DispatchResponse response = m_backend->setScriptSource(in_scriptId, in_scriptSource, std::move(in_dryRun), &out_callFrames, &out_stackChanged, &out_asyncStackTrace, &out_exceptionDetails);
    1280          30 :     if (response.status() == DispatchResponse::kFallThrough)
    1281             :         return response.status();
    1282          30 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
    1283          30 :     if (response.status() == DispatchResponse::kSuccess) {
    1284          18 :         if (out_callFrames.isJust())
    1285          24 :             result->setValue("callFrames", ValueConversions<protocol::Array<protocol::Debugger::CallFrame>>::toValue(out_callFrames.fromJust()));
    1286          18 :         if (out_stackChanged.isJust())
    1287          30 :             result->setValue("stackChanged", ValueConversions<bool>::toValue(out_stackChanged.fromJust()));
    1288          18 :         if (out_asyncStackTrace.isJust())
    1289           0 :             result->setValue("asyncStackTrace", ValueConversions<protocol::Runtime::StackTrace>::toValue(out_asyncStackTrace.fromJust()));
    1290          18 :         if (out_exceptionDetails.isJust())
    1291          48 :             result->setValue("exceptionDetails", ValueConversions<protocol::Runtime::ExceptionDetails>::toValue(out_exceptionDetails.fromJust()));
    1292             :     }
    1293          30 :     if (weak->get())
    1294          60 :         weak->get()->sendResponse(callId, response, std::move(result));
    1295          30 :     return response.status();
    1296             : }
    1297             : 
    1298         160 : DispatchResponse::Status DispatcherImpl::restartFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1299             : {
    1300             :     // Prepare input parameters.
    1301         480 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1302         160 :     errors->push();
    1303         320 :     protocol::Value* callFrameIdValue = object ? object->get("callFrameId") : nullptr;
    1304         320 :     errors->setName("callFrameId");
    1305         160 :     String in_callFrameId = ValueConversions<String>::fromValue(callFrameIdValue, errors);
    1306         160 :     errors->pop();
    1307         160 :     if (errors->hasErrors()) {
    1308           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1309           0 :         return DispatchResponse::kError;
    1310             :     }
    1311             :     // Declare output parameters.
    1312         160 :     std::unique_ptr<protocol::Array<protocol::Debugger::CallFrame>> out_callFrames;
    1313             :     Maybe<protocol::Runtime::StackTrace> out_asyncStackTrace;
    1314             : 
    1315         160 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1316         160 :     DispatchResponse response = m_backend->restartFrame(in_callFrameId, &out_callFrames, &out_asyncStackTrace);
    1317         160 :     if (response.status() == DispatchResponse::kFallThrough)
    1318             :         return response.status();
    1319         160 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
    1320         160 :     if (response.status() == DispatchResponse::kSuccess) {
    1321         616 :         result->setValue("callFrames", ValueConversions<protocol::Array<protocol::Debugger::CallFrame>>::toValue(out_callFrames.get()));
    1322         154 :         if (out_asyncStackTrace.isJust())
    1323           0 :             result->setValue("asyncStackTrace", ValueConversions<protocol::Runtime::StackTrace>::toValue(out_asyncStackTrace.fromJust()));
    1324             :     }
    1325         160 :     if (weak->get())
    1326         320 :         weak->get()->sendResponse(callId, response, std::move(result));
    1327         160 :     return response.status();
    1328             : }
    1329             : 
    1330         854 : DispatchResponse::Status DispatcherImpl::getScriptSource(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1331             : {
    1332             :     // Prepare input parameters.
    1333        2562 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1334         854 :     errors->push();
    1335        1708 :     protocol::Value* scriptIdValue = object ? object->get("scriptId") : nullptr;
    1336        1708 :     errors->setName("scriptId");
    1337         854 :     String in_scriptId = ValueConversions<String>::fromValue(scriptIdValue, errors);
    1338         854 :     errors->pop();
    1339         854 :     if (errors->hasErrors()) {
    1340           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1341           0 :         return DispatchResponse::kError;
    1342             :     }
    1343             :     // Declare output parameters.
    1344             :     String out_scriptSource;
    1345             : 
    1346         854 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1347         854 :     DispatchResponse response = m_backend->getScriptSource(in_scriptId, &out_scriptSource);
    1348         854 :     if (response.status() == DispatchResponse::kFallThrough)
    1349             :         return response.status();
    1350         854 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
    1351         854 :     if (response.status() == DispatchResponse::kSuccess) {
    1352        3416 :         result->setValue("scriptSource", ValueConversions<String>::toValue(out_scriptSource));
    1353             :     }
    1354         854 :     if (weak->get())
    1355        1708 :         weak->get()->sendResponse(callId, response, std::move(result));
    1356         854 :     return response.status();
    1357             : }
    1358             : 
    1359        7088 : DispatchResponse::Status DispatcherImpl::setPauseOnExceptions(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1360             : {
    1361             :     // Prepare input parameters.
    1362       21264 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1363        7088 :     errors->push();
    1364       14176 :     protocol::Value* stateValue = object ? object->get("state") : nullptr;
    1365       14176 :     errors->setName("state");
    1366        7088 :     String in_state = ValueConversions<String>::fromValue(stateValue, errors);
    1367        7088 :     errors->pop();
    1368        7088 :     if (errors->hasErrors()) {
    1369           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1370           0 :         return DispatchResponse::kError;
    1371             :     }
    1372             : 
    1373        7088 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1374        7088 :     DispatchResponse response = m_backend->setPauseOnExceptions(in_state);
    1375        7088 :     if (weak->get())
    1376        7088 :         weak->get()->sendResponse(callId, response);
    1377        7088 :     return response.status();
    1378             : }
    1379             : 
    1380       14240 : DispatchResponse::Status DispatcherImpl::evaluateOnCallFrame(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1381             : {
    1382             :     // Prepare input parameters.
    1383       42720 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1384       14240 :     errors->push();
    1385       28480 :     protocol::Value* callFrameIdValue = object ? object->get("callFrameId") : nullptr;
    1386       28480 :     errors->setName("callFrameId");
    1387       14240 :     String in_callFrameId = ValueConversions<String>::fromValue(callFrameIdValue, errors);
    1388       28480 :     protocol::Value* expressionValue = object ? object->get("expression") : nullptr;
    1389       28480 :     errors->setName("expression");
    1390       14240 :     String in_expression = ValueConversions<String>::fromValue(expressionValue, errors);
    1391       28480 :     protocol::Value* objectGroupValue = object ? object->get("objectGroup") : nullptr;
    1392             :     Maybe<String> in_objectGroup;
    1393       14240 :     if (objectGroupValue) {
    1394           0 :         errors->setName("objectGroup");
    1395           0 :         in_objectGroup = ValueConversions<String>::fromValue(objectGroupValue, errors);
    1396             :     }
    1397       28480 :     protocol::Value* includeCommandLineAPIValue = object ? object->get("includeCommandLineAPI") : nullptr;
    1398             :     Maybe<bool> in_includeCommandLineAPI;
    1399       14240 :     if (includeCommandLineAPIValue) {
    1400           0 :         errors->setName("includeCommandLineAPI");
    1401           0 :         in_includeCommandLineAPI = ValueConversions<bool>::fromValue(includeCommandLineAPIValue, errors);
    1402             :     }
    1403       28480 :     protocol::Value* silentValue = object ? object->get("silent") : nullptr;
    1404             :     Maybe<bool> in_silent;
    1405       14240 :     if (silentValue) {
    1406           0 :         errors->setName("silent");
    1407           0 :         in_silent = ValueConversions<bool>::fromValue(silentValue, errors);
    1408             :     }
    1409       28480 :     protocol::Value* returnByValueValue = object ? object->get("returnByValue") : nullptr;
    1410             :     Maybe<bool> in_returnByValue;
    1411       14240 :     if (returnByValueValue) {
    1412           0 :         errors->setName("returnByValue");
    1413           0 :         in_returnByValue = ValueConversions<bool>::fromValue(returnByValueValue, errors);
    1414             :     }
    1415       28480 :     protocol::Value* generatePreviewValue = object ? object->get("generatePreview") : nullptr;
    1416             :     Maybe<bool> in_generatePreview;
    1417       14240 :     if (generatePreviewValue) {
    1418           0 :         errors->setName("generatePreview");
    1419           0 :         in_generatePreview = ValueConversions<bool>::fromValue(generatePreviewValue, errors);
    1420             :     }
    1421       28480 :     protocol::Value* throwOnSideEffectValue = object ? object->get("throwOnSideEffect") : nullptr;
    1422             :     Maybe<bool> in_throwOnSideEffect;
    1423       14240 :     if (throwOnSideEffectValue) {
    1424       28332 :         errors->setName("throwOnSideEffect");
    1425       14166 :         in_throwOnSideEffect = ValueConversions<bool>::fromValue(throwOnSideEffectValue, errors);
    1426             :     }
    1427       14240 :     errors->pop();
    1428       14240 :     if (errors->hasErrors()) {
    1429           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1430           0 :         return DispatchResponse::kError;
    1431             :     }
    1432             :     // Declare output parameters.
    1433       14240 :     std::unique_ptr<protocol::Runtime::RemoteObject> out_result;
    1434             :     Maybe<protocol::Runtime::ExceptionDetails> out_exceptionDetails;
    1435             : 
    1436       14240 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1437       42720 :     DispatchResponse response = m_backend->evaluateOnCallFrame(in_callFrameId, in_expression, std::move(in_objectGroup), std::move(in_includeCommandLineAPI), std::move(in_silent), std::move(in_returnByValue), std::move(in_generatePreview), std::move(in_throwOnSideEffect), &out_result, &out_exceptionDetails);
    1438       14240 :     if (response.status() == DispatchResponse::kFallThrough)
    1439             :         return response.status();
    1440       14240 :     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
    1441       14240 :     if (response.status() == DispatchResponse::kSuccess) {
    1442       56876 :         result->setValue("result", ValueConversions<protocol::Runtime::RemoteObject>::toValue(out_result.get()));
    1443       14219 :         if (out_exceptionDetails.isJust())
    1444        5904 :             result->setValue("exceptionDetails", ValueConversions<protocol::Runtime::ExceptionDetails>::toValue(out_exceptionDetails.fromJust()));
    1445             :     }
    1446       14240 :     if (weak->get())
    1447       28480 :         weak->get()->sendResponse(callId, response, std::move(result));
    1448       14240 :     return response.status();
    1449             : }
    1450             : 
    1451         176 : DispatchResponse::Status DispatcherImpl::setVariableValue(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1452             : {
    1453             :     // Prepare input parameters.
    1454         528 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1455         176 :     errors->push();
    1456         352 :     protocol::Value* scopeNumberValue = object ? object->get("scopeNumber") : nullptr;
    1457         352 :     errors->setName("scopeNumber");
    1458         176 :     int in_scopeNumber = ValueConversions<int>::fromValue(scopeNumberValue, errors);
    1459         352 :     protocol::Value* variableNameValue = object ? object->get("variableName") : nullptr;
    1460         352 :     errors->setName("variableName");
    1461         176 :     String in_variableName = ValueConversions<String>::fromValue(variableNameValue, errors);
    1462         352 :     protocol::Value* newValueValue = object ? object->get("newValue") : nullptr;
    1463         352 :     errors->setName("newValue");
    1464             :     std::unique_ptr<protocol::Runtime::CallArgument> in_newValue = ValueConversions<protocol::Runtime::CallArgument>::fromValue(newValueValue, errors);
    1465         352 :     protocol::Value* callFrameIdValue = object ? object->get("callFrameId") : nullptr;
    1466         352 :     errors->setName("callFrameId");
    1467         176 :     String in_callFrameId = ValueConversions<String>::fromValue(callFrameIdValue, errors);
    1468         176 :     errors->pop();
    1469         176 :     if (errors->hasErrors()) {
    1470           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1471           0 :         return DispatchResponse::kError;
    1472             :     }
    1473             : 
    1474         176 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1475         528 :     DispatchResponse response = m_backend->setVariableValue(in_scopeNumber, in_variableName, std::move(in_newValue), in_callFrameId);
    1476         176 :     if (weak->get())
    1477         176 :         weak->get()->sendResponse(callId, response);
    1478         176 :     return response.status();
    1479             : }
    1480             : 
    1481         198 : DispatchResponse::Status DispatcherImpl::setAsyncCallStackDepth(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1482             : {
    1483             :     // Prepare input parameters.
    1484         594 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1485         198 :     errors->push();
    1486         396 :     protocol::Value* maxDepthValue = object ? object->get("maxDepth") : nullptr;
    1487         396 :     errors->setName("maxDepth");
    1488         198 :     int in_maxDepth = ValueConversions<int>::fromValue(maxDepthValue, errors);
    1489         198 :     errors->pop();
    1490         198 :     if (errors->hasErrors()) {
    1491           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1492           0 :         return DispatchResponse::kError;
    1493             :     }
    1494             : 
    1495         198 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1496         198 :     DispatchResponse response = m_backend->setAsyncCallStackDepth(in_maxDepth);
    1497         198 :     if (weak->get())
    1498         198 :         weak->get()->sendResponse(callId, response);
    1499         198 :     return response.status();
    1500             : }
    1501             : 
    1502          56 : DispatchResponse::Status DispatcherImpl::setBlackboxPatterns(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1503             : {
    1504             :     // Prepare input parameters.
    1505         168 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1506          56 :     errors->push();
    1507         112 :     protocol::Value* patternsValue = object ? object->get("patterns") : nullptr;
    1508         112 :     errors->setName("patterns");
    1509             :     std::unique_ptr<protocol::Array<String>> in_patterns = ValueConversions<protocol::Array<String>>::fromValue(patternsValue, errors);
    1510          56 :     errors->pop();
    1511          56 :     if (errors->hasErrors()) {
    1512           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1513           0 :         return DispatchResponse::kError;
    1514             :     }
    1515             : 
    1516          56 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1517         168 :     DispatchResponse response = m_backend->setBlackboxPatterns(std::move(in_patterns));
    1518          56 :     if (weak->get())
    1519          56 :         weak->get()->sendResponse(callId, response);
    1520          56 :     return response.status();
    1521             : }
    1522             : 
    1523          66 : DispatchResponse::Status DispatcherImpl::setBlackboxedRanges(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
    1524             : {
    1525             :     // Prepare input parameters.
    1526         198 :     protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
    1527          66 :     errors->push();
    1528         132 :     protocol::Value* scriptIdValue = object ? object->get("scriptId") : nullptr;
    1529         132 :     errors->setName("scriptId");
    1530          66 :     String in_scriptId = ValueConversions<String>::fromValue(scriptIdValue, errors);
    1531         132 :     protocol::Value* positionsValue = object ? object->get("positions") : nullptr;
    1532         132 :     errors->setName("positions");
    1533             :     std::unique_ptr<protocol::Array<protocol::Debugger::ScriptPosition>> in_positions = ValueConversions<protocol::Array<protocol::Debugger::ScriptPosition>>::fromValue(positionsValue, errors);
    1534          66 :     errors->pop();
    1535          66 :     if (errors->hasErrors()) {
    1536           0 :         reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
    1537           0 :         return DispatchResponse::kError;
    1538             :     }
    1539             : 
    1540          66 :     std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
    1541         198 :     DispatchResponse response = m_backend->setBlackboxedRanges(in_scriptId, std::move(in_positions));
    1542          66 :     if (weak->get())
    1543          66 :         weak->get()->sendResponse(callId, response);
    1544          66 :     return response.status();
    1545             : }
    1546             : 
    1547             : // static
    1548        4573 : void Dispatcher::wire(UberDispatcher* dispatcher, Backend* backend)
    1549             : {
    1550       18292 :     dispatcher->registerBackend("Debugger", std::unique_ptr<protocol::DispatcherBase>(new DispatcherImpl(dispatcher->channel(), backend, dispatcher->fallThroughForNotFound())));
    1551        4573 : }
    1552             : 
    1553             : } // Debugger
    1554             : } // namespace v8_inspector
    1555             : } // namespace protocol

Generated by: LCOV version 1.10