void InspectorDebuggerAgent::didParseSource(const String& scriptId, const Script& script) { // Don't send script content to the front end until it's really needed. const bool* isContentScript = script.isContentScript ? &script.isContentScript : 0; String sourceMapURL = sourceMapURLForScript(script); m_frontend->scriptParsed(scriptId, script.url, script.startLine, script.startColumn, script.endLine, script.endColumn, isContentScript, sourceMapURL); m_scripts.set(scriptId, script); if (script.url.isEmpty()) return; RefPtr<InspectorObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints); for (InspectorObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) { RefPtr<InspectorObject> breakpointObject = it->second->asObject(); bool isRegex; breakpointObject->getBoolean("isRegex", &isRegex); String url; breakpointObject->getString("url", &url); if (!matches(script.url, url, isRegex)) continue; ScriptBreakpoint breakpoint; breakpointObject->getNumber("lineNumber", &breakpoint.lineNumber); breakpointObject->getNumber("columnNumber", &breakpoint.columnNumber); breakpointObject->getString("condition", &breakpoint.condition); RefPtr<InspectorObject> location = resolveBreakpoint(it->first, scriptId, breakpoint); if (location) m_frontend->breakpointResolved(it->first, location); } }
void InspectorDebuggerAgent::didParseSource(const String& sourceId, const Script& script) { // Don't send script content to the front end until it's really needed. m_frontend->scriptParsed(sourceId, script.url, script.startLine, script.startColumn, script.endLine, script.endColumn, script.isContentScript); m_scripts.set(sourceId, script); if (script.url.isEmpty()) return; RefPtr<InspectorObject> breakpointsCookie = m_inspectorState->getObject(DebuggerAgentState::javaScriptBreakpoints); for (InspectorObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) { RefPtr<InspectorObject> breakpointObject = it->second->asObject(); String breakpointURL; breakpointObject->getString("url", &breakpointURL); if (breakpointURL != script.url) continue; ScriptBreakpoint breakpoint; breakpointObject->getNumber("lineNumber", &breakpoint.lineNumber); breakpointObject->getNumber("columnNumber", &breakpoint.columnNumber); breakpointObject->getString("condition", &breakpoint.condition); RefPtr<InspectorObject> location = resolveBreakpoint(it->first, sourceId, breakpoint); if (location) m_frontend->breakpointResolved(it->first, location); } }
void ForensicSetEditingValueEvent::deserialize(PassRefPtr<JSONObject> json){ RefPtr<JSONObject> guard = json; ForensicPageEvent::deserialize(guard); bool result = guard->getString("inputElementName", &m_inputElementName); ASSERT(result); result = guard->getString("value", &m_value); ASSERT(result); }
static PassRefPtr<TypeBuilder::Debugger::ExceptionDetails> toExceptionDetails(PassRefPtr<JSONObject> object) { String text; if (!object->getString("text", &text)) return nullptr; RefPtr<TypeBuilder::Debugger::ExceptionDetails> exceptionDetails = TypeBuilder::Debugger::ExceptionDetails::create().setText(text); String url; if (object->getString("url", &url)) exceptionDetails->setUrl(url); int line = 0; if (object->getNumber("line", &line)) exceptionDetails->setLine(line); int column = 0; if (object->getNumber("column", &column)) exceptionDetails->setColumn(column); int originScriptId = 0; object->getNumber("scriptId", &originScriptId); RefPtr<JSONArray> stackTrace = object->getArray("stackTrace"); if (stackTrace && stackTrace->length() > 0) { RefPtr<TypeBuilder::Array<TypeBuilder::Console::CallFrame>> frames = TypeBuilder::Array<TypeBuilder::Console::CallFrame>::create(); for (unsigned i = 0; i < stackTrace->length(); ++i) { RefPtr<JSONObject> stackFrame = stackTrace->get(i)->asObject(); int lineNumber = 0; stackFrame->getNumber("lineNumber", &lineNumber); int column = 0; stackFrame->getNumber("column", &column); int scriptId = 0; stackFrame->getNumber("scriptId", &scriptId); if (i == 0 && scriptId == originScriptId) originScriptId = 0; String sourceURL; stackFrame->getString("scriptNameOrSourceURL", &sourceURL); String functionName; stackFrame->getString("functionName", &functionName); RefPtr<TypeBuilder::Console::CallFrame> callFrame = TypeBuilder::Console::CallFrame::create() .setFunctionName(functionName) .setScriptId(String::number(scriptId)) .setUrl(sourceURL) .setLineNumber(lineNumber) .setColumnNumber(column); frames->addItem(callFrame.release()); } exceptionDetails->setStackTrace(frames.release()); } if (originScriptId) exceptionDetails->setScriptId(String::number(originScriptId)); return exceptionDetails.release(); }
void InspectorDebuggerAgent::didParseSource(JSC::SourceID sourceID, const Script& inScript) { Script script = inScript; if (script.startLine <= 0 && !script.startColumn) script.sourceURL = ContentSearchUtilities::findScriptSourceURL(script.source); script.sourceMappingURL = sourceMapURLForScript(script); bool hasSourceURL = !script.sourceURL.isEmpty(); String scriptURL = hasSourceURL ? script.sourceURL : script.url; bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : nullptr; String* sourceMapURLParam = script.sourceMappingURL.isNull() ? nullptr : &script.sourceMappingURL; const bool* isContentScript = script.isContentScript ? &script.isContentScript : nullptr; String scriptIDStr = String::number(sourceID); m_frontendDispatcher->scriptParsed(scriptIDStr, scriptURL, script.startLine, script.startColumn, script.endLine, script.endColumn, isContentScript, sourceMapURLParam, hasSourceURLParam); m_scripts.set(sourceID, script); if (scriptURL.isEmpty()) return; for (auto it = m_javaScriptBreakpoints.begin(), end = m_javaScriptBreakpoints.end(); it != end; ++it) { RefPtr<InspectorObject> breakpointObject; if (!it->value->asObject(breakpointObject)) return; bool isRegex; breakpointObject->getBoolean(ASCIILiteral("isRegex"), isRegex); String url; breakpointObject->getString(ASCIILiteral("url"), url); if (!matches(scriptURL, url, isRegex)) continue; ScriptBreakpoint breakpoint; breakpointObject->getInteger(ASCIILiteral("lineNumber"), breakpoint.lineNumber); breakpointObject->getInteger(ASCIILiteral("columnNumber"), breakpoint.columnNumber); breakpointObject->getString(ASCIILiteral("condition"), breakpoint.condition); breakpointObject->getBoolean(ASCIILiteral("autoContinue"), breakpoint.autoContinue); ErrorString errorString; RefPtr<InspectorArray> actions; breakpointObject->getArray(ASCIILiteral("actions"), actions); if (!breakpointActionsFromProtocol(errorString, actions, &breakpoint.actions)) { ASSERT_NOT_REACHED(); continue; } RefPtr<Inspector::Protocol::Debugger::Location> location = resolveBreakpoint(it->key, sourceID, breakpoint); if (location) m_frontendDispatcher->breakpointResolved(it->key, location); } }
PassOwnPtrWillBeRawPtr<StorageArea> InspectorDOMStorageAgent::findStorageArea(ErrorString* errorString, const RefPtr<JSONObject>& storageId, LocalFrame*& targetFrame) { String securityOrigin; bool isLocalStorage = false; bool success = storageId->getString("securityOrigin", &securityOrigin); if (success) success = storageId->getBoolean("isLocalStorage", &isLocalStorage); if (!success) { if (errorString) *errorString = "Invalid storageId format"; return nullptr; } LocalFrame* frame = m_pageAgent->findFrameWithSecurityOrigin(securityOrigin); if (!frame) { if (errorString) *errorString = "LocalFrame not found for the given security origin"; return nullptr; } targetFrame = frame; if (isLocalStorage) return StorageNamespace::localStorageArea(frame->document()->securityOrigin()); return m_pageAgent->page()->sessionStorage()->storageArea(frame->document()->securityOrigin()); }
PassRefPtr<StorageArea> InspectorDOMStorageAgent::findStorageArea(ErrorString* errorString, const RefPtr<InspectorObject>& storageId, Frame*& targetFrame) { String securityOrigin; bool isLocalStorage = false; bool success = storageId->getString("securityOrigin", &securityOrigin); if (success) success = storageId->getBoolean("isLocalStorage", &isLocalStorage); if (!success) { if (errorString) *errorString = "Invalid storageId format"; return 0; } Frame* frame = m_pageAgent->findFrameWithSecurityOrigin(securityOrigin); if (!frame) { if (errorString) *errorString = "Frame not found for the given security origin"; return 0; } targetFrame = frame; Page* page = m_pageAgent->page(); if (isLocalStorage) return page->group().localStorage()->storageArea(frame->document()->securityOrigin()); return page->sessionStorage()->storageArea(frame->document()->securityOrigin()); }
void InspectorRuntimeAgent::getRuntimeTypesForVariablesAtOffsets(ErrorString& errorString, const Inspector::InspectorArray& locations, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::TypeDescription>>& typeDescriptions) { static const bool verbose = false; typeDescriptions = Inspector::Protocol::Array<Inspector::Protocol::Runtime::TypeDescription>::create(); if (!m_vm.typeProfiler()) { errorString = ASCIILiteral("The VM does not currently have Type Information."); return; } double start = currentTimeMS(); m_vm.typeProfilerLog()->processLogEntries(ASCIILiteral("User Query")); for (size_t i = 0; i < locations.length(); i++) { RefPtr<Inspector::InspectorValue> value = locations.get(i); RefPtr<InspectorObject> location; if (!value->asObject(location)) { errorString = ASCIILiteral("Array of TypeLocation objects has an object that does not have type of TypeLocation."); return; } int descriptor; String sourceIDAsString; int divot; location->getInteger(ASCIILiteral("typeInformationDescriptor"), descriptor); location->getString(ASCIILiteral("sourceID"), sourceIDAsString); location->getInteger(ASCIILiteral("divot"), divot); bool okay; TypeLocation* typeLocation = m_vm.typeProfiler()->findLocation(divot, sourceIDAsString.toIntPtrStrict(&okay), static_cast<TypeProfilerSearchDescriptor>(descriptor), m_vm); ASSERT(okay); RefPtr<TypeSet> typeSet; if (typeLocation) { if (typeLocation->m_globalTypeSet && typeLocation->m_globalVariableID != TypeProfilerNoGlobalIDExists) typeSet = typeLocation->m_globalTypeSet; else typeSet = typeLocation->m_instructionTypeSet; } bool isValid = typeLocation && typeSet && !typeSet->isEmpty(); auto description = Inspector::Protocol::Runtime::TypeDescription::create() .setIsValid(isValid) .release(); if (isValid) { description->setLeastCommonAncestor(typeSet->leastCommonAncestor()); description->setStructures(typeSet->allStructureRepresentations()); description->setTypeSet(typeSet->inspectorTypeSet()); description->setIsTruncated(typeSet->isOverflown()); } typeDescriptions->addItem(WTFMove(description)); } double end = currentTimeMS(); if (verbose) dataLogF("Inspector::getRuntimeTypesForVariablesAtOffsets took %lfms\n", end - start); }
void InspectorDebuggerAgent::didParseSource(const String& scriptId, const Script& inScript) { Script script = inScript; if (!script.startLine && !script.startColumn) script.sourceURL = ContentSearchUtils::findScriptSourceURL(script.source); script.sourceMappingURL = sourceMapURLForScript(script); bool hasSourceURL = !script.sourceURL.isEmpty(); String scriptURL = hasSourceURL ? script.sourceURL : script.url; bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : 0; String* sourceMapURLParam = script.sourceMappingURL.isNull() ? 0 : &script.sourceMappingURL; const bool* isContentScript = script.isContentScript ? &script.isContentScript : 0; m_frontend->scriptParsed(scriptId, scriptURL, script.startLine, script.startColumn, script.endLine, script.endColumn, isContentScript, sourceMapURLParam, hasSourceURLParam); m_scripts.set(scriptId, script); if (scriptURL.isEmpty()) return; RefPtr<InspectorObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints); for (InspectorObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) { RefPtr<InspectorObject> breakpointObject = it->value->asObject(); bool isRegex; breakpointObject->getBoolean("isRegex", &isRegex); String url; breakpointObject->getString("url", &url); if (!matches(scriptURL, url, isRegex)) continue; ScriptBreakpoint breakpoint; breakpointObject->getNumber("lineNumber", &breakpoint.lineNumber); breakpointObject->getNumber("columnNumber", &breakpoint.columnNumber); breakpointObject->getString("condition", &breakpoint.condition); breakpointObject->getBoolean("autoContinue", &breakpoint.autoContinue); ErrorString errorString; RefPtr<InspectorArray> actions = breakpointObject->getArray("actions"); if (!breakpointActionsFromProtocol(&errorString, actions, &breakpoint.actions)) { ASSERT_NOT_REACHED(); continue; } RefPtr<TypeBuilder::Debugger::Location> location = resolveBreakpoint(it->key, scriptId, breakpoint); if (location) m_frontend->breakpointResolved(it->key, location); } }
void InspectorDebuggerAgent::didParseSource(const String& scriptId, const Script& script) { // Don't send script content to the front end until it's really needed. const bool* isContentScript = script.isContentScript ? &script.isContentScript : 0; String sourceMapURL = sourceMapURLForScript(script); String* sourceMapURLParam = sourceMapURL.isNull() ? 0 : &sourceMapURL; String sourceURL; if (!script.startLine && !script.startColumn) { bool deprecated; sourceURL = ContentSearchUtils::findSourceURL(script.source, ContentSearchUtils::JavaScriptMagicComment, &deprecated); // FIXME: add deprecated console message here. } bool hasSourceURL = !sourceURL.isEmpty(); String scriptURL = hasSourceURL ? sourceURL : script.url; bool* hasSourceURLParam = hasSourceURL ? &hasSourceURL : 0; m_frontend->scriptParsed(scriptId, scriptURL, script.startLine, script.startColumn, script.endLine, script.endColumn, isContentScript, sourceMapURLParam, hasSourceURLParam); m_scripts.set(scriptId, script); if (scriptURL.isEmpty()) return; RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints); for (JSONObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) { RefPtr<JSONObject> breakpointObject = it->value->asObject(); bool isAntibreakpoint; breakpointObject->getBoolean(DebuggerAgentState::isAnti, &isAntibreakpoint); if (isAntibreakpoint) continue; bool isRegex; breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex); String url; breakpointObject->getString(DebuggerAgentState::url, &url); if (!matches(scriptURL, url, isRegex)) continue; ScriptBreakpoint breakpoint; breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakpoint.lineNumber); breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakpoint.columnNumber); breakpointObject->getString(DebuggerAgentState::condition, &breakpoint.condition); RefPtr<TypeBuilder::Debugger::Location> location = resolveBreakpoint(it->key, scriptId, breakpoint, UserBreakpointSource); if (location) m_frontend->breakpointResolved(it->key, location); } }
bool InspectorDebuggerAgent::breakpointActionsFromProtocol(ErrorString& errorString, RefPtr<InspectorArray>& actions, BreakpointActions* result) { if (!actions) return true; unsigned actionsLength = actions->length(); if (!actionsLength) return true; result->reserveCapacity(actionsLength); for (unsigned i = 0; i < actionsLength; ++i) { RefPtr<InspectorValue> value = actions->get(i); RefPtr<InspectorObject> object; if (!value->asObject(object)) { errorString = ASCIILiteral("BreakpointAction of incorrect type, expected object"); return false; } String typeString; if (!object->getString(ASCIILiteral("type"), typeString)) { errorString = ASCIILiteral("BreakpointAction had type missing"); return false; } ScriptBreakpointActionType type; if (!breakpointActionTypeForString(typeString, &type)) { errorString = ASCIILiteral("BreakpointAction had unknown type"); return false; } // Specifying an identifier is optional. They are used to correlate probe samples // in the frontend across multiple backend probe actions and segregate object groups. int identifier = 0; object->getInteger(ASCIILiteral("id"), identifier); String data; object->getString(ASCIILiteral("data"), data); result->append(ScriptBreakpointAction(type, identifier, data)); } return true; }
static bool parseLocation(ErrorString* errorString, RefPtr<InspectorObject> location, String* scriptId, int* lineNumber, int* columnNumber) { if (!location->getString("scriptId", scriptId) || !location->getNumber("lineNumber", lineNumber)) { // FIXME: replace with input validation. *errorString = "scriptId and lineNumber are required."; return false; } *columnNumber = 0; location->getNumber("columnNumber", columnNumber); return true; }
void ForensicReceiveDataEvent::deserialize(PassRefPtr<JSONObject> json){ RefPtr<JSONObject> guard = json; ForensicEvent::deserialize(guard); String temp; bool result = guard->getString("data", &temp); ASSERT(result); base64Decode(temp, m_data); result = guard->getNumber("encodedDataLength", &m_encodedDataLength); ASSERT(result); }
static bool breakpointActionsFromProtocol(ErrorString* errorString, RefPtr<InspectorArray>& actions, Vector<ScriptBreakpointAction>* result) { if (!actions) return true; unsigned actionsLength = actions->length(); if (!actionsLength) return true; result->reserveCapacity(actionsLength); for (unsigned i = 0; i < actionsLength; ++i) { RefPtr<InspectorValue> value = actions->get(i); RefPtr<InspectorObject> object; if (!value->asObject(&object)) { *errorString = "BreakpointAction of incorrect type, expected object"; return false; } String typeString; if (!object->getString("type", &typeString)) { *errorString = "BreakpointAction had type missing"; return false; } ScriptBreakpointActionType type; if (!breakpointActionTypeForString(typeString, &type)) { *errorString = "BreakpointAction had unknown type"; return false; } String data; object->getString("data", &data); result->append(ScriptBreakpointAction(type, data)); } return true; }
ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::shouldSkipExceptionPause(RefPtr<JavaScriptCallFrame>& topFrame) { if (m_skipAllPauses) return ScriptDebugListener::Continue; String topFrameScriptUrl = scriptURL(topFrame.get()); if (m_cachedSkipStackRegExp && !topFrameScriptUrl.isEmpty() && m_cachedSkipStackRegExp->match(topFrameScriptUrl) != -1) return ScriptDebugListener::Continue; // Prepare top frame parameters; int topFrameLineNumber = topFrame->line(); int topFrameColumnNumber = topFrame->column(); // Match against breakpoints. if (topFrameScriptUrl.isEmpty()) return ScriptDebugListener::NoSkip; RefPtr<JSONObject> breakpointsCookie = m_state->getObject(DebuggerAgentState::javaScriptBreakpoints); for (JSONObject::iterator it = breakpointsCookie->begin(); it != breakpointsCookie->end(); ++it) { RefPtr<JSONObject> breakpointObject = it->value->asObject(); bool isAntibreakpoint; breakpointObject->getBoolean(DebuggerAgentState::isAnti, &isAntibreakpoint); if (!isAntibreakpoint) continue; int breakLineNumber; breakpointObject->getNumber(DebuggerAgentState::lineNumber, &breakLineNumber); int breakColumnNumber; breakpointObject->getNumber(DebuggerAgentState::columnNumber, &breakColumnNumber); if (breakLineNumber != topFrameLineNumber) continue; if (breakColumnNumber != -1 && breakColumnNumber != topFrameColumnNumber) continue; bool isRegex; breakpointObject->getBoolean(DebuggerAgentState::isRegex, &isRegex); String url; breakpointObject->getString(DebuggerAgentState::url, &url); if (!matches(topFrameScriptUrl, url, isRegex)) continue; return ScriptDebugListener::Continue; } return ScriptDebugListener::NoSkip; }
void InspectorLayerTreeAgent::loadSnapshot(ErrorString* errorString, const RefPtr<JSONArray>& tiles, String* snapshotId) { if (!tiles->length()) { *errorString = "Invalid argument, no tiles provided"; return; } Vector<RefPtr<PictureSnapshot::TilePictureStream> > decodedTiles; decodedTiles.grow(tiles->length()); for (size_t i = 0; i < tiles->length(); ++i) { RefPtr<JSONObject> item; if (!tiles->get(i)->asObject(&item)) { *errorString = "Invalid argument, array item is not an object"; return; } double x = 0, y = 0; String picture; if (!item->getNumber("x", &x) || !item->getNumber("y", &y) || !item->getString("picture", &picture)) { *errorString = "Invalid argument, missing required field"; return; } decodedTiles[i] = adoptRef(new PictureSnapshot::TilePictureStream()); decodedTiles[i]->layerOffset.set(x, y); if (!base64Decode(picture, decodedTiles[i]->data)) { *errorString = "Invalid base64 encoding"; return; } } RefPtr<PictureSnapshot> snapshot = PictureSnapshot::load(decodedTiles); if (!snapshot) { *errorString = "Invalid snapshot format"; return; } if (snapshot->isEmpty()) { *errorString = "Empty snapshot"; return; } *snapshotId = String::number(++s_lastSnapshotId); bool newEntry = m_snapshotById.add(*snapshotId, snapshot).isNewEntry; ASSERT_UNUSED(newEntry, newEntry); }
void InspectorInputAgent::dispatchTouchEvent(ErrorString* error, const String& type, const RefPtr<JSONArray>& touchPoints, const int* modifiers, const double* timestamp) { PlatformEvent::Type convertedType; if (type == "touchStart") { convertedType = PlatformEvent::TouchStart; } else if (type == "touchEnd") { convertedType = PlatformEvent::TouchEnd; } else if (type == "touchMove") { convertedType = PlatformEvent::TouchMove; } else { *error = "Unrecognized type: " + type; return; } unsigned convertedModifiers = modifiers ? *modifiers : 0; SyntheticInspectorTouchEvent event(convertedType, convertedModifiers, timestamp ? *timestamp : currentTime()); int autoId = 0; JSONArrayBase::iterator iter; for (iter = touchPoints->begin(); iter != touchPoints->end(); ++iter) { RefPtr<JSONObject> pointObj; String state; int x, y, radiusX, radiusY, id; double rotationAngle, force; (*iter)->asObject(&pointObj); if (!pointObj->getString("state", &state)) { *error = "TouchPoint missing 'state'"; return; } if (!pointObj->getNumber("x", &x)) { *error = "TouchPoint missing 'x' coordinate"; return; } if (!pointObj->getNumber("y", &y)) { *error = "TouchPoint missing 'y' coordinate"; return; } if (!pointObj->getNumber("radiusX", &radiusX)) radiusX = 1; if (!pointObj->getNumber("radiusY", &radiusY)) radiusY = 1; if (!pointObj->getNumber("rotationAngle", &rotationAngle)) rotationAngle = 0.0f; if (!pointObj->getNumber("force", &force)) force = 1.0f; if (pointObj->getNumber("id", &id)) { if (autoId > 0) id = -1; autoId = -1; } else { id = autoId++; } if (id < 0) { *error = "All or none of the provided TouchPoints must supply positive integer ids."; return; } PlatformTouchPoint::State convertedState; if (state == "touchPressed") { convertedState = PlatformTouchPoint::TouchPressed; } else if (state == "touchReleased") { convertedState = PlatformTouchPoint::TouchReleased; } else if (state == "touchMoved") { convertedState = PlatformTouchPoint::TouchMoved; } else if (state == "touchStationary") { convertedState = PlatformTouchPoint::TouchStationary; } else if (state == "touchCancelled") { convertedState = PlatformTouchPoint::TouchCancelled; } else { *error = "Unrecognized state: " + state; return; } // Some platforms may have flipped coordinate systems, but the given coordinates // assume the origin is in the top-left of the window. Convert. IntPoint convertedPoint, globalPoint; ConvertInspectorPoint(m_page, IntPoint(x, y), &convertedPoint, &globalPoint); SyntheticInspectorTouchPoint point(id++, convertedState, globalPoint, convertedPoint, radiusX, radiusY, rotationAngle, force); event.append(point); } m_page->deprecatedLocalMainFrame()->eventHandler().handleTouchEvent(event); }