void WebNotificationManagerProxy::populateCopyOfNotificationPermissions(HashMap<String, bool>& permissions)
{
RefPtr<ImmutableDictionary> knownPermissions = m_provider.notificationPermissions();
if (!knownPermissions)
return;
permissions.clear();
RefPtr<ImmutableArray> knownOrigins = knownPermissions->keys();
for (size_t i = 0; i < knownOrigins->size(); ++i) {
WebString* origin = knownOrigins->at<WebString>(i);
permissions.set(origin->string(), knownPermissions->get<WebBoolean>(origin->string())->value());
}
}
void WebViewHost::setStatusText(const WebString& text)
{
if (!layoutTestController()->shouldDumpStatusCallbacks())
return;
// When running tests, write to stdout.
printf("UI DELEGATE STATUS CALLBACK: setStatusText:%s\n", text.utf8().data());
}
WebString WebPageSerializer::generateBaseTagDeclaration(const WebString& baseTarget)
{
if (baseTarget.isEmpty())
return String("<base href=\".\">");
String baseString = "<base href=\".\" target=\"" + static_cast<const String&>(baseTarget) + "\">";
return baseString;
}
void WebURLRequest::setHTTPReferrer(const WebString& referrer, WebReferrerPolicy referrerPolicy)
{
if (referrer.isEmpty())
m_private->m_resourceRequest->clearHTTPReferrer();
else
m_private->m_resourceRequest->setHTTPReferrer(Referrer(referrer, static_cast<ReferrerPolicy>(referrerPolicy)));
}
void WebViewHost::didReceiveResponse(WebFrame*, unsigned identifier, const WebURLResponse& response)
{
if (m_shell->shouldDumpResourceLoadCallbacks()) {
printResourceDescription(identifier);
fputs(" - didReceiveResponse ", stdout);
printResponseDescription(response);
fputs("\n", stdout);
}
if (m_shell->shouldDumpResourceResponseMIMETypes()) {
GURL url = response.url();
WebString mimeType = response.mimeType();
printf("%s has MIME type %s\n",
url.ExtractFileName().c_str(),
// Simulate NSURLResponse's mapping of empty/unknown MIME types to application/octet-stream
mimeType.isEmpty() ? "application/octet-stream" : mimeType.utf8().data());
}
}
WebString WebFrameSerializer::generateBaseTagDeclaration(const WebString& baseTarget)
{
// TODO(yosin) We should call |FrameSerializer::baseTagDeclarationOf()|.
if (baseTarget.isEmpty())
return String("<base href=\".\">");
String baseString = "<base href=\".\" target=\"" + static_cast<const String&>(baseTarget) + "\">";
return baseString;
}
bool MockSpellCheck::spellCheckWord(const WebString& text, int* misspelledOffset, int* misspelledLength)
{
ASSERT(misspelledOffset);
ASSERT(misspelledLength);
// Initialize this spellchecker.
initializeIfNeeded();
// Reset the result values as our spellchecker does.
*misspelledOffset = 0;
*misspelledLength = 0;
// Convert to a String because we store String instances in
// m_misspelledWords and WebString has no find().
const String stringText(text.data(), text.length());
// Extract the first possible English word from the given string.
// The given string may include non-ASCII characters or numbers. So, we
// should filter out such characters before start looking up our
// misspelled-word table.
// (This is a simple version of our SpellCheckWordIterator class.)
// If the given string doesn't include any ASCII characters, we can treat the
// string as valid one.
// Unfortunately, This implementation splits a contraction, i.e. "isn't" is
// split into two pieces "isn" and "t". This is OK because webkit tests
// don't have misspelled contractions.
int wordOffset = stringText.find(isASCIIAlpha);
if (wordOffset == -1)
return true;
int wordEnd = stringText.find(isNotASCIIAlpha, wordOffset);
int wordLength = wordEnd == -1 ? stringText.length() - wordOffset : wordEnd - wordOffset;
// Look up our misspelled-word table to check if the extracted word is a
// known misspelled word, and return the offset and the length of the
// extracted word if this word is a known misspelled word.
// (See the comment in MockSpellCheck::initializeIfNeeded() why we use a
// misspelled-word table.)
String word = stringText.substring(wordOffset, wordLength);
if (!m_misspelledWords.contains(word))
return true;
*misspelledOffset = wordOffset;
*misspelledLength = wordLength;
return false;
}
static PassOwnPtr<Vector<String> > toStringVector(ImmutableArray* patterns)
{
if (!patterns)
return 0;
size_t size = patterns->size();
if (!size)
return 0;
Vector<String>* patternsVector = new Vector<String>;
patternsVector->reserveInitialCapacity(size);
for (size_t i = 0; i < size; ++i) {
WebString* entry = patterns->at<WebString>(i);
if (entry)
patternsVector->uncheckedAppend(entry->string());
}
return patternsVector;
}
static void webkitCookieManagerGetDomainsWithCookiesCallback(WKArrayRef wkDomains, WKErrorRef, void* context)
{
GRefPtr<GTask> task = adoptGRef(G_TASK(context));
if (g_task_return_error_if_cancelled(task.get()))
return;
ImmutableArray* domains = toImpl(wkDomains);
GPtrArray* returnValue = g_ptr_array_sized_new(domains->size());
for (size_t i = 0; i < domains->size(); ++i) {
WebString* domainString = static_cast<WebString*>(domains->at(i));
String domain = domainString->string();
if (domain.isEmpty())
continue;
g_ptr_array_add(returnValue, g_strdup(domain.utf8().data()));
}
g_ptr_array_add(returnValue, 0);
g_task_return_pointer(task.get(), g_ptr_array_free(returnValue, FALSE), reinterpret_cast<GDestroyNotify>(g_strfreev));
}
bool WebViewHost::shouldInsertText(const WebString& text, const WebRange& range, WebEditingAction action)
{
if (layoutTestController()->shouldDumpEditingCallbacks()) {
printf("EDITING DELEGATE: shouldInsertText:%s replacingDOMRange:", text.utf8().data());
printRangeDescription(range);
printf(" givenAction:%s\n", editingActionDescription(action).c_str());
}
return layoutTestController()->acceptsEditing();
}
bool WebViewHost::shouldApplyStyle(const WebString& style, const WebRange& range)
{
if (layoutTestController()->shouldDumpEditingCallbacks()) {
printf("EDITING DELEGATE: shouldApplyStyle:%s toElementsInDOMRange:", style.utf8().data());
printRangeDescription(range);
fputs("\n", stdout);
}
return layoutTestController()->acceptsEditing();
}
void EditorClientImpl::doAutofill(Timer<EditorClientImpl>* timer)
{
OwnPtr<AutofillArgs> args(m_autofillArgs.release());
HTMLInputElement* inputElement = args->inputElement.get();
const String& value = inputElement->value();
// Enforce autofill_on_empty_value and caret_at_end.
bool isCaretAtEnd = true;
if (args->requireCaretAtEnd)
isCaretAtEnd = inputElement->selectionStart() == inputElement->selectionEnd()
&& inputElement->selectionEnd() == static_cast<int>(value.length());
if ((!args->autofillOnEmptyValue && value.isEmpty()) || !isCaretAtEnd) {
m_webView->hideAutoFillPopup();
return;
}
// First let's see if there is a password listener for that element.
// We won't trigger form autofill in that case, as having both behavior on
// a node would be confusing.
WebFrameImpl* webframe = WebFrameImpl::fromFrame(inputElement->document()->frame());
if (!webframe)
return;
WebPasswordAutocompleteListener* listener = webframe->getPasswordListener(inputElement);
if (listener) {
if (args->autofillFormOnly)
return;
listener->performInlineAutocomplete(value,
args->backspaceOrDeletePressed,
true);
return;
}
// Then trigger form autofill.
WebString name = WebInputElement(inputElement).nameForAutofill();
ASSERT(static_cast<int>(name.length()) > 0);
if (m_webView->client())
m_webView->client()->queryAutofillSuggestions(WebNode(inputElement),
name, WebString(value));
}
bool WebSettings::isSupportedObjectMIMEType(const WebString& mimeType)
{
if (mimeType.isEmpty())
return false;
if (!s_supportedObjectMIMETypes)
return false;
return s_supportedObjectMIMETypes->contains(MIMETypeRegistry::getNormalizedMIMEType(mimeType));
}
static Vector<String> toStringVector(API::Array* array)
{
Vector<String> patternVector;
if (!array)
return patternVector;
size_t size = array->size();
if (!size)
return patternVector;
patternVector.reserveInitialCapacity(size);
for (size_t i = 0; i < size; ++i) {
WebString* webString = array->at<WebString>(i);
ASSERT(webString);
patternVector.uncheckedAppend(webString->string());
}
return patternVector;
}
static Vector<String> toStringVector(ImmutableArray* patterns)
{
Vector<String> patternsVector;
if (!patterns)
return patternsVector;
size_t size = patterns->size();
if (!size)
return patternsVector;
patternsVector.reserveInitialCapacity(size);
for (size_t i = 0; i < size; ++i) {
WebString* entry = patterns->at<WebString>(i);
if (entry)
patternsVector.uncheckedAppend(entry->string());
}
return patternsVector;
}
void PlainTextController::plainText(const CppArgumentList& arguments, CppVariant* result)
{
result->setNull();
if (arguments.size() < 1 || !arguments[0].isObject())
return;
// Check that passed-in object is, in fact, a range.
NPObject* npobject = NPVARIANT_TO_OBJECT(arguments[0]);
if (!npobject)
return;
WebRange range;
if (!WebBindings::getRange(npobject, &range))
return;
// Extract the text using the Range's text() method
WebString text = range.toPlainText();
result->set(text.utf8());
}
bool EditorClientImpl::autofill(HTMLInputElement* inputElement,
bool autofillFormOnly,
bool autofillOnEmptyValue,
bool requireCaretAtEnd)
{
// Cancel any pending DoAutofill call.
m_autofillArgs.clear();
m_autofillTimer.stop();
// FIXME: Remove the extraneous isEnabledFormControl call below.
// Let's try to trigger autofill for that field, if applicable.
if (!inputElement->isEnabledFormControl() || !inputElement->isTextField()
|| inputElement->isPasswordField() || !inputElement->autoComplete()
|| !inputElement->isEnabledFormControl()
|| inputElement->isReadOnlyFormControl())
return false;
WebString name = WebInputElement(inputElement).nameForAutofill();
if (name.isEmpty()) // If the field has no name, then we won't have values.
return false;
// Don't attempt to autofill with values that are too large.
if (inputElement->value().length() > maximumTextSizeForAutofill)
return false;
m_autofillArgs = new AutofillArgs();
m_autofillArgs->inputElement = inputElement;
m_autofillArgs->autofillFormOnly = autofillFormOnly;
m_autofillArgs->autofillOnEmptyValue = autofillOnEmptyValue;
m_autofillArgs->requireCaretAtEnd = requireCaretAtEnd;
m_autofillArgs->backspaceOrDeletePressed = m_backspaceOrDeletePressed;
if (!requireCaretAtEnd)
doAutofill(0);
else {
// We post a task for doing the autofill as the caret position is not set
// properly at this point (http://bugs.webkit.org/show_bug.cgi?id=16976)
// and we need it to determine whether or not to trigger autofill.
m_autofillTimer.startOneShot(0.0);
}
return true;
}
bool NotificationPresenter::simulateClick(const WebString& title)
{
string id(title.utf8());
if (m_activeNotifications.find(id) == m_activeNotifications.end())
return false;
const WebNotification& notification = m_activeNotifications.find(id)->second;
WebNotification eventTarget(notification);
eventTarget.dispatchClickEvent();
return true;
}
void WebSettings::setAppCachePath(const WebString& path)
{
// The directory of cacheStorage for one page group can only be initialized once.
static HashSet<WTF::String> initGroups;
if (path.isEmpty() || initGroups.contains(d->m_webCoreSettingsState->pageGroupName))
return;
initGroups.add(d->m_webCoreSettingsState->pageGroupName);
d->m_webCoreSettingsState->appCachePath = path;
WebCore::cacheStorage(d->m_webCoreSettingsState->pageGroupName).setCacheDirectory(d->m_webCoreSettingsState->appCachePath);
}
WebAnimation WebAnimation::fadeAnimation(const WebString& name, float from, float to, double duration)
{
WebAnimation tmp;
tmp.d->name = String(name.impl());
tmp.d->animation = Animation::create();
tmp.d->animation->setDuration(duration);
tmp.d->keyframes = KeyframeValueList(AnimatedPropertyOpacity);
tmp.d->keyframes.insert(new FloatAnimationValue(0, from));
tmp.d->keyframes.insert(new FloatAnimationValue(1.0, to));
return tmp;
}
void SpellCheckClient::requestCheckingOfText(const WebString& text, WebTextCheckingCompletion* completion)
{
if (text.isEmpty()) {
if (completion)
completion->didCancelCheckingText();
return;
}
m_lastRequestedTextCheckingCompletion = completion;
m_lastRequestedTextCheckString = text;
m_delegate->postDelayedTask(new HostMethodTask(this, &SpellCheckClient::finishLastTextCheck), 0);
}
void WebSettings::setDatabasePath(const WebString& path)
{
// DatabaseTracker can only be initialized for once, so it doesn't
// make sense to change database path after DatabaseTracker has
// already been initialized.
static HashSet<WTF::String> initGroups;
if (path.isEmpty() || initGroups.contains(d->m_webCoreSettingsState->pageGroupName))
return;
initGroups.add(d->m_webCoreSettingsState->pageGroupName);
d->m_webCoreSettingsState->databasePath = path;
WebCore::databaseTrackerManager().initializeTracker(d->m_webCoreSettingsState->pageGroupName, d->m_webCoreSettingsState->databasePath);
}
WebCore::ProtectionSpace getProtectionSpace(const char* url, WebString& realm, WebString& scheme)
{
WebCore::ProtectionSpaceAuthenticationScheme protectionSpaceScheme = WebCore::ProtectionSpaceAuthenticationSchemeDefault;
if (equalIgnoringCase(scheme, "ntlm"))
protectionSpaceScheme = WebCore::ProtectionSpaceAuthenticationSchemeNTLM;
else if (equalIgnoringCase(scheme, "basic"))
protectionSpaceScheme = WebCore::ProtectionSpaceAuthenticationSchemeHTTPBasic;
else if (equalIgnoringCase(scheme, "digest"))
protectionSpaceScheme = WebCore::ProtectionSpaceAuthenticationSchemeHTTPDigest;
WebCore::KURL kurl(WebCore::KURL(), url);
return WebCore::ProtectionSpace(kurl.host(), kurl.port(), realm.equalIgnoringCase("ftp") ?
WebCore::ProtectionSpaceServerFTP : WebCore::ProtectionSpaceServerHTTP, realm, protectionSpaceScheme);
}
void WebViewHost::didReceiveTitle(WebFrame* frame, const WebString& title)
{
WebCString title8 = title.utf8();
if (m_shell->shouldDumpFrameLoadCallbacks()) {
printFrameDescription(frame);
printf(" - didReceiveTitle: %s\n", title8.data());
}
if (layoutTestController()->shouldDumpTitleChanges())
printf("TITLE CHANGED: %s\n", title8.data());
setPageTitle(title);
}
GURL WebStringToGURL(const WebString& webString)
{
if (webString.isEmpty())
return GURL();
String str = webString;
if (str.is8Bit()) {
// Ensure the (possibly Latin-1) 8-bit string is UTF-8 for GURL.
StringUTF8Adaptor utf8(str);
return GURL(utf8.asStringPiece());
}
// GURL can consume UTF-16 directly.
return GURL(base::StringPiece16(str.characters16(), str.length()));
}
bool MockWebSpeechInputController::startRecognition(int requestId, const WebRect& elementRect, const WebString& language, const WebString& grammar, const WebSecurityOrigin& origin)
{
if (m_speechTask)
return false;
m_requestId = requestId;
m_requestRect = elementRect;
m_recording = true;
m_language = language.utf8();
m_speechTask = new SpeechTask(this);
m_delegate->postTask(m_speechTask);
return true;
}
bool WebSocketImpl::sendText(const WebString& message)
{
size_t size = message.utf8().length();
m_bufferedAmount += size;
if (m_isClosingOrClosed)
m_bufferedAmountAfterClose += size;
// FIXME: Deprecate this call.
m_client->didUpdateBufferedAmount(m_bufferedAmount);
if (m_isClosingOrClosed)
return true;
m_private->send(message);
return true;
}
void SpellCheckClient::requestCheckingOfText(
const WebString& text,
const WebVector<uint32_t>& markers,
const WebVector<unsigned>& markerOffsets,
WebTextCheckingCompletion* completion)
{
if (text.isEmpty()) {
if (completion)
completion->didCancelCheckingText();
return;
}
m_lastRequestedTextCheckingCompletion = completion;
m_lastRequestedTextCheckString = text;
if (m_spellcheck.hasInCache(text))
finishLastTextCheck();
else
m_delegate->postDelayedTask(new HostMethodTask(this, &SpellCheckClient::finishLastTextCheck), 0);
}
bool WebLocalFrameImpl::executeCommand(const WebString& name, const WebNode& node)
{
ASSERT(frame());
if (name.length() <= 2)
return false;
// Since we don't have NSControl, we will convert the format of command
// string and call the function on Editor directly.
String command = name;
// Make sure the first letter is upper case.
command.replace(0, 1, command.substring(0, 1).upper());
// Remove the trailing ':' if existing.
if (command[command.length() - 1] == UChar(':'))
command = command.substring(0, command.length() - 1);
return frame()->editor().executeCommand(command);
}
void EventSender::keyDown(const CppArgumentList& arguments, CppVariant* result)
{
result->setNull();
if (arguments.size() < 1 || !arguments[0].isString())
return;
bool generateChar = false;
// FIXME: I'm not exactly sure how we should convert the string to a key
// event. This seems to work in the cases I tested.
// FIXME: Should we also generate a KEY_UP?
string codeStr = arguments[0].toString();
// Convert \n -> VK_RETURN. Some layout tests use \n to mean "Enter", when
// Windows uses \r for "Enter".
int code = 0;
int text = 0;
bool needsShiftKeyModifier = false;
if ("\n" == codeStr) {
generateChar = true;
text = code = webkit_support::VKEY_RETURN;
} else if ("rightArrow" == codeStr)
code = webkit_support::VKEY_RIGHT;
else if ("downArrow" == codeStr)
code = webkit_support::VKEY_DOWN;
else if ("leftArrow" == codeStr)
code = webkit_support::VKEY_LEFT;
else if ("upArrow" == codeStr)
code = webkit_support::VKEY_UP;
else if ("insert" == codeStr)
code = webkit_support::VKEY_INSERT;
else if ("delete" == codeStr)
code = webkit_support::VKEY_DELETE;
else if ("pageUp" == codeStr)
code = webkit_support::VKEY_PRIOR;
else if ("pageDown" == codeStr)
code = webkit_support::VKEY_NEXT;
else if ("home" == codeStr)
code = webkit_support::VKEY_HOME;
else if ("end" == codeStr)
code = webkit_support::VKEY_END;
else if ("printScreen" == codeStr)
code = webkit_support::VKEY_SNAPSHOT;
else if ("menu" == codeStr)
// FIXME: Change this to webkit_support::VKEY_APPS.
code = 0x5D;
else {
// Compare the input string with the function-key names defined by the
// DOM spec (i.e. "F1",...,"F24"). If the input string is a function-key
// name, set its key code.
for (int i = 1; i <= 24; ++i) {
char functionChars[10];
snprintf(functionChars, 10, "F%d", i);
string functionKeyName(functionChars);
if (functionKeyName == codeStr) {
code = webkit_support::VKEY_F1 + (i - 1);
break;
}
}
if (!code) {
WebString webCodeStr = WebString::fromUTF8(codeStr.data(), codeStr.size());
ASSERT(webCodeStr.length() == 1);
text = code = webCodeStr.data()[0];
needsShiftKeyModifier = needsShiftModifier(code);
if ((code & 0xFF) >= 'a' && (code & 0xFF) <= 'z')
code -= 'a' - 'A';
generateChar = true;
}
}
// For one generated keyboard event, we need to generate a keyDown/keyUp
// pair; refer to EventSender.cpp in Tools/DumpRenderTree/win.
// On Windows, we might also need to generate a char event to mimic the
// Windows event flow; on other platforms we create a merged event and test
// the event flow that that platform provides.
WebKeyboardEvent eventDown, eventChar, eventUp;
eventDown.type = WebInputEvent::RawKeyDown;
eventDown.modifiers = 0;
eventDown.windowsKeyCode = code;
if (generateChar) {
eventDown.text[0] = text;
eventDown.unmodifiedText[0] = text;
}
eventDown.setKeyIdentifierFromWindowsKeyCode();
if (arguments.size() >= 2 && (arguments[1].isObject() || arguments[1].isString()))
eventDown.isSystemKey = applyKeyModifiers(&(arguments[1]), &eventDown);
if (needsShiftKeyModifier)
eventDown.modifiers |= WebInputEvent::ShiftKey;
// See if KeyLocation argument is given.
if (arguments.size() >= 3 && arguments[2].isNumber()) {
int location = arguments[2].toInt32();
if (location == DOMKeyLocationNumpad)
eventDown.modifiers |= WebInputEvent::IsKeyPad;
}
eventChar = eventUp = eventDown;
eventUp.type = WebInputEvent::KeyUp;
// EventSender.m forces a layout here, with at least one
// test (fast/forms/focus-control-to-page.html) relying on this.
webview()->layout();
// In the browser, if a keyboard event corresponds to an editor command,
// the command will be dispatched to the renderer just before dispatching
// the keyboard event, and then it will be executed in the
// RenderView::handleCurrentKeyboardEvent() method, which is called from
// third_party/WebKit/Source/WebKit/chromium/src/EditorClientImpl.cpp.
// We just simulate the same behavior here.
string editCommand;
if (getEditCommand(eventDown, &editCommand))
m_shell->webViewHost()->setEditCommand(editCommand, "");
webview()->handleInputEvent(eventDown);
m_shell->webViewHost()->clearEditCommand();
if (generateChar) {
eventChar.type = WebInputEvent::Char;
eventChar.keyIdentifier[0] = '\0';
webview()->handleInputEvent(eventChar);
}
webview()->handleInputEvent(eventUp);
}
