TextEncoding HTMLMetaCharsetParser::encodingFromMetaAttributes(const AttributeList& attributes)
{
bool gotPragma = false;
enum { None, Charset, Pragma } mode = None;
StringView charset;
for (auto& attribute : attributes) {
const String& attributeName = attribute.first;
const String& attributeValue = attribute.second;
if (attributeName == http_equivAttr) {
if (equalIgnoringCase(attributeValue, "content-type"))
gotPragma = true;
} else if (charset.isEmpty()) {
if (attributeName == charsetAttr) {
charset = attributeValue;
mode = Charset;
} else if (attributeName == contentAttr) {
charset = extractCharset(attributeValue);
if (charset.length())
mode = Pragma;
}
}
}
if (mode == Charset || (mode == Pragma && gotPragma))
return TextEncoding(stripLeadingAndTrailingHTMLSpaces(charset.toStringWithoutCopying()));
return TextEncoding();
}
Vector<TextCheckingResult> WebEditorClient::checkTextOfParagraph(StringView stringView, WebCore::TextCheckingTypeMask checkingTypes, const VisibleSelection& currentSelection)
{
Vector<TextCheckingResult> results;
m_page->sendSync(Messages::WebPageProxy::CheckTextOfParagraph(stringView.toStringWithoutCopying(), checkingTypes, insertionPointFromCurrentSelection(currentSelection)), Messages::WebPageProxy::CheckTextOfParagraph::Reply(results));
return results;
}
Vector<TextCheckingResult> WebEditorClient::checkTextOfParagraph(StringView stringView, WebCore::TextCheckingTypeMask checkingTypes)
{
Vector<TextCheckingResult> results;
m_page->sendSync(Messages::WebPageProxy::CheckTextOfParagraph(stringView.toStringWithoutCopying(), checkingTypes), Messages::WebPageProxy::CheckTextOfParagraph::Reply(results));
return results;
}
EncodedJSValue JSC_HOST_CALL functionProtoFuncToString(ExecState* exec)
{
VM& vm = exec->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSValue thisValue = exec->thisValue();
if (thisValue.inherits(JSFunction::info())) {
JSFunction* function = jsCast<JSFunction*>(thisValue);
if (function->isHostOrBuiltinFunction()) {
scope.release();
return JSValue::encode(jsMakeNontrivialString(exec, "function ", function->name(vm), "() {\n [native code]\n}"));
}
FunctionExecutable* executable = function->jsExecutable();
if (executable->isClass()) {
StringView classSource = executable->classSource().view();
return JSValue::encode(jsString(exec, classSource.toStringWithoutCopying()));
}
if (thisValue.inherits(JSAsyncFunction::info())) {
String functionHeader = executable->isArrowFunction() ? "async " : "async function ";
StringView source = executable->source().provider()->getRange(
executable->parametersStartOffset(),
executable->parametersStartOffset() + executable->source().length());
return JSValue::encode(jsMakeNontrivialString(exec, functionHeader, function->name(vm), source));
}
String functionHeader = executable->isArrowFunction() ? "" : "function ";
StringView source = executable->source().provider()->getRange(
executable->parametersStartOffset(),
executable->parametersStartOffset() + executable->source().length());
scope.release();
return JSValue::encode(jsMakeNontrivialString(exec, functionHeader, function->name(vm), source));
}
if (thisValue.inherits(InternalFunction::info())) {
InternalFunction* function = asInternalFunction(thisValue);
scope.release();
return JSValue::encode(jsMakeNontrivialString(exec, "function ", function->name(), "() {\n [native code]\n}"));
}
if (thisValue.isObject()) {
JSObject* object = asObject(thisValue);
if (object->inlineTypeFlags() & TypeOfShouldCallGetCallData) {
CallData callData;
if (object->methodTable(vm)->getCallData(object, callData) != CallType::None) {
if (auto* classInfo = object->classInfo()) {
scope.release();
return JSValue::encode(jsMakeNontrivialString(exec, "function ", classInfo->className, "() {\n [native code]\n}"));
}
}
}
}
return throwVMTypeError(exec, scope);
}
void WebEditorClient::checkGrammarOfString(StringView text, Vector<WebCore::GrammarDetail>& grammarDetails, int* badGrammarLocation, int* badGrammarLength)
{
int32_t resultLocation = -1;
int32_t resultLength = 0;
m_page->sendSync(Messages::WebPageProxy::CheckGrammarOfString(text.toStringWithoutCopying()),
Messages::WebPageProxy::CheckGrammarOfString::Reply(grammarDetails, resultLocation, resultLength));
*badGrammarLocation = resultLocation;
*badGrammarLength = resultLength;
}
void WebEditorClient::checkSpellingOfString(StringView text, int* misspellingLocation, int* misspellingLength)
{
int32_t resultLocation = -1;
int32_t resultLength = 0;
m_page->sendSync(Messages::WebPageProxy::CheckSpellingOfString(text.toStringWithoutCopying()),
Messages::WebPageProxy::CheckSpellingOfString::Reply(resultLocation, resultLength));
*misspellingLocation = resultLocation;
*misspellingLength = resultLength;
}
size_t lastHyphenLocation(StringView string, size_t beforeIndex, const AtomicString& localeIdentifier)
{
// libhyphen accepts strings in UTF-8 format, but WebCore can only provide StringView
// which stores either UTF-16 or Latin1 data. This is unfortunate for performance
// reasons and we should consider switching to a more flexible hyphenation library
// if it is available.
CString utf8StringCopy = string.toStringWithoutCopying().utf8();
// WebCore often passes strings like " wordtohyphenate" to the platform layer. Since
// libhyphen isn't advanced enough to deal with leading spaces (presumably CoreFoundation
// can), we should find the appropriate indexes into the string to skip them.
int32_t leadingSpaceBytes;
int32_t leadingSpaceCharacters;
countLeadingSpaces(utf8StringCopy, leadingSpaceBytes, leadingSpaceCharacters);
// The libhyphen documentation specifies that this array should be 5 bytes longer than
// the byte length of the input string.
Vector<char> hyphenArray(utf8StringCopy.length() - leadingSpaceBytes + 5);
char* hyphenArrayData = hyphenArray.data();
String lowercaseLocaleIdentifier = AtomicString(localeIdentifier.string().convertToASCIILowercase());
ASSERT(availableLocales().contains(lowercaseLocaleIdentifier));
for (const auto& dictionaryPath : availableLocales().get(lowercaseLocaleIdentifier)) {
RefPtr<HyphenationDictionary> dictionary = TinyLRUCachePolicy<AtomicString, RefPtr<HyphenationDictionary>>::cache().get(AtomicString(dictionaryPath));
char** replacements = nullptr;
int* positions = nullptr;
int* removedCharacterCounts = nullptr;
hnj_hyphen_hyphenate2(dictionary->libhyphenDictionary(),
utf8StringCopy.data() + leadingSpaceBytes,
utf8StringCopy.length() - leadingSpaceBytes,
hyphenArrayData,
nullptr, /* output parameter for hyphenated word */
&replacements,
&positions,
&removedCharacterCounts);
if (replacements) {
for (unsigned i = 0; i < utf8StringCopy.length() - leadingSpaceBytes - 1; i++)
free(replacements[i]);
free(replacements);
}
free(positions);
free(removedCharacterCounts);
for (int i = beforeIndex - leadingSpaceCharacters - 2; i >= 0; i--) {
// libhyphen will put an odd number in hyphenArrayData at all
// hyphenation points. A number & 1 will be true for odd numbers.
if (hyphenArrayData[i] & 1)
return i + 1 + leadingSpaceCharacters;
}
}
return 0;
}
void TextChecker::checkSpellingOfString(int64_t spellDocumentTag, StringView text, int32_t& misspellingLocation, int32_t& misspellingLength)
{
#if ENABLE(SPELLCHECK)
WebTextChecker::shared()->client().checkSpellingOfString(spellDocumentTag, text.toStringWithoutCopying(), misspellingLocation, misspellingLength);
#else
UNUSED_PARAM(spellDocumentTag);
UNUSED_PARAM(text);
UNUSED_PARAM(misspellingLocation);
UNUSED_PARAM(misspellingLength);
#endif
}
std::chrono::microseconds CachedResource::freshnessLifetime(const ResourceResponse& response) const
{
if (!response.url().protocolIsInHTTPFamily()) {
StringView protocol = response.url().protocol();
if (!shouldCacheSchemeIndefinitely(protocol)) {
// Don't cache non-HTTP main resources since we can't check for freshness.
// FIXME: We should not cache subresources either, but when we tried this
// it caused performance and flakiness issues in our test infrastructure.
if (m_type == MainResource || SchemeRegistry::shouldAlwaysRevalidateURLScheme(protocol.toStringWithoutCopying()))
return 0us;
}
return std::chrono::microseconds::max();
}
return computeFreshnessLifetimeForHTTPFamily(response, m_responseTimestamp);
}
