static void addPlugInsFromNodeListMatchingOriginHash(HTMLPlugInImageElementList& plugInList, PassRefPtr<NodeList> collection, unsigned originHash)
{
for (unsigned i = 0, length = collection->length(); i < length; i++) {
Node* node = collection->item(i);
if (node->isPluginElement()) {
HTMLPlugInElement* plugInElement = toHTMLPlugInElement(node);
if (plugInElement->isPlugInImageElement() && plugInElement->displayState() <= HTMLPlugInElement::DisplayingSnapshot && plugInElement->plugInOriginHash() == originHash)
plugInList.append(toHTMLPlugInImageElement(node));
}
}
}
static Instance* pluginInstance(Node* node)
{
if (!node)
return 0;
if (!(node->hasTagName(objectTag) || node->hasTagName(embedTag) || node->hasTagName(appletTag)))
return 0;
HTMLPlugInElement* plugInElement = static_cast<HTMLPlugInElement*>(node);
// The plugin element holds an owning reference, so we don't have to.
Instance* instance = plugInElement->getInstance().get();
if (!instance || !instance->rootObject())
return 0;
return instance;
}
v8::Handle<v8::Value> npObjectIndexedGetter(uint32_t index, const v8::AccessorInfo& info)
{
HTMLPlugInElement* imp = C::toNative(info.Holder());
ScriptInstance scriptInstance = imp->getInstance();
if (!scriptInstance)
return v8Undefined();
v8::Local<v8::Object> instance = v8::Local<v8::Object>::New(scriptInstance->instance());
if (instance.IsEmpty())
return v8Undefined();
return npObjectGetIndexedProperty(instance, index, info);
}
static v8::Handle<v8::Value> npObjectNamedSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
{
HTMLPlugInElement* imp = C::toNative(info.Holder());
ScriptInstance scriptInstance = imp->getInstance();
if (!scriptInstance)
return v8Undefined();
v8::Local<v8::Object> instance = v8::Local<v8::Object>::New(scriptInstance->instance());
if (instance.IsEmpty())
return v8Undefined();
return npObjectSetNamedProperty(instance, name, value, info);
}
static void npObjectNamedSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
{
HTMLPlugInElement* imp = C::toNative(info.Holder());
ScriptInstance scriptInstance = imp->getInstance();
if (!scriptInstance)
return;
v8::Local<v8::Object> instance = scriptInstance->newLocal(v8::Isolate::GetCurrent());
if (instance.IsEmpty())
return;
npObjectSetNamedProperty(instance, name, value, info);
}
void npObjectIndexedGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)
{
HTMLPlugInElement* imp = C::toNative(info.Holder());
ScriptInstance scriptInstance = imp->getInstance();
if (!scriptInstance)
return;
v8::Local<v8::Object> instance = scriptInstance->newLocal(v8::Isolate::GetCurrent());
if (instance.IsEmpty())
return;
npObjectGetIndexedProperty(instance, index, info);
}
Instance* pluginInstance(Node* node)
{
if (!node)
return 0;
if (!isPluginElement(node))
return 0;
HTMLPlugInElement* plugInElement = static_cast<HTMLPlugInElement*>(node);
// The plugin element holds an owning reference, so we don't have to.
Instance* instance = plugInElement->getInstance().get();
if (!instance || !instance->rootObject())
return 0;
return instance;
}
static void addPlugInsFromNodeListMatchingPlugInOrigin(HTMLPlugInImageElementList& plugInList, PassRefPtr<NodeList> collection, const String& plugInOrigin, const String& mimeType)
{
for (unsigned i = 0, length = collection->length(); i < length; i++) {
Node* node = collection->item(i);
if (node->isPluginElement()) {
HTMLPlugInElement* plugInElement = toHTMLPlugInElement(node);
if (plugInElement->isPlugInImageElement()) {
HTMLPlugInImageElement* plugInImageElement = toHTMLPlugInImageElement(node);
const KURL& loadedURL = plugInImageElement->loadedUrl();
String otherMimeType = plugInImageElement->loadedMimeType();
if (plugInOrigin == loadedURL.host() && mimeType == otherMimeType)
plugInList.append(plugInImageElement);
}
}
}
}
void RenderEmbeddedObject::handleMissingPluginIndicatorEvent(Event* event)
{
if (Page* page = document()->page()) {
if (!page->chrome()->client()->shouldMissingPluginMessageBeButton())
return;
}
if (!event->isMouseEvent())
return;
MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
HTMLPlugInElement* element = static_cast<HTMLPlugInElement*>(node());
if (event->type() == eventNames().mousedownEvent && static_cast<MouseEvent*>(event)->button() == LeftButton) {
m_mouseDownWasInMissingPluginIndicator = isInMissingPluginIndicator(mouseEvent);
if (m_mouseDownWasInMissingPluginIndicator) {
if (Frame* frame = document()->frame()) {
frame->eventHandler()->setCapturingMouseEventsNode(element);
element->setIsCapturingMouseEvents(true);
}
setMissingPluginIndicatorIsPressed(true);
}
event->setDefaultHandled();
}
if (event->type() == eventNames().mouseupEvent && static_cast<MouseEvent*>(event)->button() == LeftButton) {
if (m_missingPluginIndicatorIsPressed) {
if (Frame* frame = document()->frame()) {
frame->eventHandler()->setCapturingMouseEventsNode(0);
element->setIsCapturingMouseEvents(false);
}
setMissingPluginIndicatorIsPressed(false);
}
if (m_mouseDownWasInMissingPluginIndicator && isInMissingPluginIndicator(mouseEvent)) {
if (Page* page = document()->page())
page->chrome()->client()->missingPluginButtonClicked(element);
}
m_mouseDownWasInMissingPluginIndicator = false;
event->setDefaultHandled();
}
if (event->type() == eventNames().mousemoveEvent) {
setMissingPluginIndicatorIsPressed(m_mouseDownWasInMissingPluginIndicator && isInMissingPluginIndicator(mouseEvent));
event->setDefaultHandled();
}
}
void DOMTimer::scriptDidInteractWithPlugin(HTMLPlugInElement& pluginElement)
{
if (!DOMTimerFireState::current)
return;
if (pluginElement.isUserObservable())
DOMTimerFireState::current->scriptDidInteractWithUserObservablePlugin = true;
else
DOMTimerFireState::current->scriptDidInteractWithNonUserObservablePlugin = true;
}
void RenderEmbeddedObject::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
if (!element() || !element()->isPluginElement())
return;
HTMLPlugInElement* plugInElement = toHTMLPlugInElement(element());
if (plugInElement->displayState() > HTMLPlugInElement::DisplayingSnapshot) {
RenderPart::paintContents(paintInfo, paintOffset);
if (!plugInElement->isRestartedPlugin())
return;
}
if (!plugInElement->isPlugInImageElement())
return;
Image* snapshot = toHTMLPlugInImageElement(plugInElement)->snapshotImage();
if (snapshot)
paintSnapshotImage(paintInfo, paintOffset, snapshot);
}
JSObject* pluginScriptObject(ExecState* exec, JSHTMLElement* jsHTMLElement)
{
HTMLElement* element = jsHTMLElement->impl();
if (!isPluginElement(element))
return 0;
HTMLPlugInElement* pluginElement = static_cast<HTMLPlugInElement*>(element);
// First, see if we can ask the plug-in view for its script object.
if (JSObject* scriptObject = pluginScriptObjectFromPluginViewBase(pluginElement, jsHTMLElement->globalObject()))
return scriptObject;
// Otherwise, fall back to getting the object from the instance.
// The plugin element holds an owning reference, so we don't have to.
Instance* instance = pluginElement->getInstance().get();
if (!instance || !instance->rootObject())
return 0;
return instance->createRuntimeObject(exec);
}
void RenderEmbeddedObject::handleUnavailablePluginIndicatorEvent(Event* event)
{
if (!shouldUnavailablePluginMessageBeButton(document(), m_pluginUnavailabilityReason))
return;
if (!event->isMouseEvent())
return;
MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
HTMLPlugInElement* element = toHTMLPlugInElement(this->element());
if (event->type() == eventNames().mousedownEvent && static_cast<MouseEvent*>(event)->button() == LeftButton) {
m_mouseDownWasInUnavailablePluginIndicator = isInUnavailablePluginIndicator(mouseEvent);
if (m_mouseDownWasInUnavailablePluginIndicator) {
frame().eventHandler().setCapturingMouseEventsNode(element);
element->setIsCapturingMouseEvents(true);
setUnavailablePluginIndicatorIsPressed(true);
}
event->setDefaultHandled();
}
if (event->type() == eventNames().mouseupEvent && static_cast<MouseEvent*>(event)->button() == LeftButton) {
if (m_unavailablePluginIndicatorIsPressed) {
frame().eventHandler().setCapturingMouseEventsNode(0);
element->setIsCapturingMouseEvents(false);
setUnavailablePluginIndicatorIsPressed(false);
}
if (m_mouseDownWasInUnavailablePluginIndicator && isInUnavailablePluginIndicator(mouseEvent)) {
if (Page* page = document().page())
page->chrome().client().unavailablePluginButtonClicked(element, m_pluginUnavailabilityReason);
}
m_mouseDownWasInUnavailablePluginIndicator = false;
event->setDefaultHandled();
}
if (event->type() == eventNames().mousemoveEvent) {
setUnavailablePluginIndicatorIsPressed(m_mouseDownWasInUnavailablePluginIndicator && isInUnavailablePluginIndicator(mouseEvent));
event->setDefaultHandled();
}
}
// FIXME: need comments.
// Params: holder could be HTMLEmbedElement or NPObject
static v8::Handle<v8::Value> npObjectInvokeImpl(const v8::Arguments& args, InvokeFunctionType functionId)
{
NPObject* npObject;
// These three types are subtypes of HTMLPlugInElement.
if (V8HTMLAppletElement::HasInstance(args.Holder()) || V8HTMLEmbedElement::HasInstance(args.Holder())
|| V8HTMLObjectElement::HasInstance(args.Holder())) {
// The holder object is a subtype of HTMLPlugInElement.
HTMLPlugInElement* element = V8DOMWrapper::convertDOMWrapperToNode<HTMLPlugInElement>(args.Holder());
ScriptInstance scriptInstance = element->getInstance();
if (scriptInstance)
npObject = V8DOMWrapper::convertToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, scriptInstance->instance());
else
npObject = 0;
} else {
// The holder object is not a subtype of HTMLPlugInElement, it must be an NPObject which has three
// internal fields.
if (args.Holder()->InternalFieldCount() != V8Custom::kNPObjectInternalFieldCount)
return throwError("NPMethod called on non-NPObject", V8Proxy::ReferenceError);
npObject = V8DOMWrapper::convertToNativeObject<NPObject>(V8ClassIndex::NPOBJECT, args.Holder());
}
// Verify that our wrapper wasn't using a NPObject which has already been deleted.
if (!npObject || !_NPN_IsAlive(npObject))
return throwError("NPObject deleted", V8Proxy::ReferenceError);
// Wrap up parameters.
int numArgs = args.Length();
OwnArrayPtr<NPVariant> npArgs(new NPVariant[numArgs]);
for (int i = 0; i < numArgs; i++)
convertV8ObjectToNPVariant(args[i], npObject, &npArgs[i]);
NPVariant result;
VOID_TO_NPVARIANT(result);
switch (functionId) {
case InvokeMethod:
if (npObject->_class->invoke) {
v8::Handle<v8::String> functionName(v8::String::Cast(*args.Data()));
NPIdentifier identifier = getStringIdentifier(functionName);
npObject->_class->invoke(npObject, identifier, npArgs.get(), numArgs, &result);
}
break;
case InvokeConstruct:
if (npObject->_class->construct)
npObject->_class->construct(npObject, npArgs.get(), numArgs, &result);
break;
case InvokeDefault:
if (npObject->_class->invokeDefault)
npObject->_class->invokeDefault(npObject, npArgs.get(), numArgs, &result);
break;
default:
break;
}
for (int i=0; i < numArgs; i++)
_NPN_ReleaseVariantValue(&npArgs[i]);
// Unwrap return values.
v8::Handle<v8::Value> returnValue = convertNPVariantToV8Object(&result, npObject);
_NPN_ReleaseVariantValue(&result);
return returnValue;
}
// FIXME: need comments.
// Params: holder could be HTMLEmbedElement or NPObject
static void npObjectInvokeImpl(const v8::FunctionCallbackInfo<v8::Value>& args, InvokeFunctionType functionId)
{
NPObject* npObject;
WrapperWorldType currentWorldType = worldType(args.GetIsolate());
// These three types are subtypes of HTMLPlugInElement.
if (V8HTMLAppletElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType) || V8HTMLEmbedElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType)
|| V8HTMLObjectElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType)) {
// The holder object is a subtype of HTMLPlugInElement.
HTMLPlugInElement* element;
if (V8HTMLAppletElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType))
element = V8HTMLAppletElement::toNative(args.Holder());
else if (V8HTMLEmbedElement::HasInstance(args.Holder(), args.GetIsolate(), currentWorldType))
element = V8HTMLEmbedElement::toNative(args.Holder());
else
element = V8HTMLObjectElement::toNative(args.Holder());
ScriptInstance scriptInstance = element->getInstance();
if (scriptInstance) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handleScope(isolate);
npObject = v8ObjectToNPObject(scriptInstance->newLocal(isolate));
} else
npObject = 0;
} else {
// The holder object is not a subtype of HTMLPlugInElement, it must be an NPObject which has three
// internal fields.
if (args.Holder()->InternalFieldCount() != npObjectInternalFieldCount) {
throwError(v8ReferenceError, "NPMethod called on non-NPObject", args.GetIsolate());
return;
}
npObject = v8ObjectToNPObject(args.Holder());
}
// Verify that our wrapper wasn't using a NPObject which has already been deleted.
if (!npObject || !_NPN_IsAlive(npObject)) {
throwError(v8ReferenceError, "NPObject deleted", args.GetIsolate());
return;
}
// Wrap up parameters.
int numArgs = args.Length();
OwnArrayPtr<NPVariant> npArgs = adoptArrayPtr(new NPVariant[numArgs]);
for (int i = 0; i < numArgs; i++)
convertV8ObjectToNPVariant(args[i], npObject, &npArgs[i]);
NPVariant result;
VOID_TO_NPVARIANT(result);
bool retval = true;
switch (functionId) {
case InvokeMethod:
if (npObject->_class->invoke) {
v8::Handle<v8::String> functionName = v8::Handle<v8::String>::Cast(args.Data());
NPIdentifier identifier = getStringIdentifier(functionName);
retval = npObject->_class->invoke(npObject, identifier, npArgs.get(), numArgs, &result);
}
break;
case InvokeConstruct:
if (npObject->_class->construct)
retval = npObject->_class->construct(npObject, npArgs.get(), numArgs, &result);
break;
case InvokeDefault:
if (npObject->_class->invokeDefault)
retval = npObject->_class->invokeDefault(npObject, npArgs.get(), numArgs, &result);
break;
default:
break;
}
if (!retval)
throwError(v8GeneralError, "Error calling method on NPObject.", args.GetIsolate());
for (int i = 0; i < numArgs; i++)
_NPN_ReleaseVariantValue(&npArgs[i]);
// Unwrap return values.
v8::Handle<v8::Value> returnValue;
if (_NPN_IsAlive(npObject))
returnValue = convertNPVariantToV8Object(&result, npObject, args.GetIsolate());
_NPN_ReleaseVariantValue(&result);
v8SetReturnValue(args, returnValue);
}
bool PluginView::platformGetValue(NPNVariable variable, void* value, NPError* result)
{
switch (variable) {
case NPNVWindowNPObject: {
NPObject* windowScriptObject =
m_parentFrame->script()->windowScriptNPObject();
// Return value is expected to be retained, as described
// here:
// <http://www.mozilla.org/projects/plugin/npruntime.html>
if (windowScriptObject)
_NPN_RetainObject(windowScriptObject);
void** v = (void**)value;
*v = windowScriptObject;
*result = NPERR_NO_ERROR;
return true;
}
case NPNVPluginElementNPObject: {
NPObject* pluginScriptObject = 0;
if (m_element->hasTagName(appletTag) ||
m_element->hasTagName(embedTag) ||
m_element->hasTagName(objectTag)) {
HTMLPlugInElement* pluginElement =
static_cast<HTMLPlugInElement*>(m_element);
pluginScriptObject = pluginElement->getNPObject();
}
// Return value is expected to be retained, as described
// here:
// <http://www.mozilla.org/projects/plugin/npruntime.html>
if (pluginScriptObject)
_NPN_RetainObject(pluginScriptObject);
void** v = (void**)value;
*v = pluginScriptObject;
*result = NPERR_NO_ERROR;
return true;
}
case NPNVnetscapeWindow: {
// Return the top level WebView Java object associated
// with this instance.
jobject *retObject = static_cast<jobject*>(value);
// TODO: Is it safe for this to be NULL? It looks from the NPNVWindowNPObject case that it is.
*retObject = android::WebViewCore::getWebViewCore(parent())->getWebViewJavaObject();
*result = NPERR_NO_ERROR;
return true;
}
case NPNVisOfflineBool: {
if (value == NULL) {
*result = NPERR_GENERIC_ERROR;
return true;
}
bool* retValue = static_cast<bool*>(value);
*retValue = !networkStateNotifier().onLine();
*result = NPERR_NO_ERROR;
return true;
}
case kSupportedDrawingModel_ANPGetValue: {
uint32_t* bits = reinterpret_cast<uint32_t*>(value);
*bits = kBitmap_ANPDrawingModel & kSurface_ANPDrawingModel;
*result = NPERR_NO_ERROR;
return true;
}
case kJavaContext_ANPGetValue: {
jobject* retObject = static_cast<jobject*>(value);
// TODO: Is it safe for this to be NULL? It looks from the NPNVWindowNPObject case that it is.
*retObject = android::WebViewCore::getWebViewCore(parent())->getContext();
*result = NPERR_NO_ERROR;
return true;
}
default: {
NPError error = NPERR_GENERIC_ERROR;
(void)anp_getInterface(variable, value, &error);
*result = error;
return true;
}
}
}
void ContextMenuClientImpl::showContextMenu(const WebCore::ContextMenu* defaultMenu)
{
// Displaying the context menu in this function is a big hack as we don't
// have context, i.e. whether this is being invoked via a script or in
// response to user input (Mouse event WM_RBUTTONDOWN,
// Keyboard events KeyVK_APPS, Shift+F10). Check if this is being invoked
// in response to the above input events before popping up the context menu.
if (!m_webView->contextMenuAllowed())
return;
HitTestResult r = m_webView->page()->contextMenuController().hitTestResult();
LocalFrame* selectedFrame = r.innerNodeFrame();
WebContextMenuData data;
IntPoint mousePoint = selectedFrame->view()->contentsToWindow(r.roundedPointInInnerNodeFrame());
// FIXME(bokan): crbug.com/371902 - We shouldn't be making these scale
// related coordinate transformatios in an ad hoc way.
PinchViewport& pinchViewport = selectedFrame->host()->pinchViewport();
mousePoint -= flooredIntSize(pinchViewport.visibleRect().location());
mousePoint.scale(m_webView->pageScaleFactor(), m_webView->pageScaleFactor());
data.mousePosition = mousePoint;
// Compute edit flags.
data.editFlags = WebContextMenuData::CanDoNone;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canUndo())
data.editFlags |= WebContextMenuData::CanUndo;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canRedo())
data.editFlags |= WebContextMenuData::CanRedo;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canCut())
data.editFlags |= WebContextMenuData::CanCut;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canCopy())
data.editFlags |= WebContextMenuData::CanCopy;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canPaste())
data.editFlags |= WebContextMenuData::CanPaste;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canDelete())
data.editFlags |= WebContextMenuData::CanDelete;
// We can always select all...
data.editFlags |= WebContextMenuData::CanSelectAll;
data.editFlags |= WebContextMenuData::CanTranslate;
// Links, Images, Media tags, and Image/Media-Links take preference over
// all else.
data.linkURL = r.absoluteLinkURL();
if (isHTMLCanvasElement(r.innerNonSharedNode())) {
data.mediaType = WebContextMenuData::MediaTypeCanvas;
} else if (!r.absoluteImageURL().isEmpty()) {
data.srcURL = r.absoluteImageURL();
data.mediaType = WebContextMenuData::MediaTypeImage;
data.mediaFlags |= WebContextMenuData::MediaCanPrint;
} else if (!r.absoluteMediaURL().isEmpty()) {
data.srcURL = r.absoluteMediaURL();
// We know that if absoluteMediaURL() is not empty, then this
// is a media element.
HTMLMediaElement* mediaElement = toHTMLMediaElement(r.innerNonSharedNode());
if (isHTMLVideoElement(*mediaElement))
data.mediaType = WebContextMenuData::MediaTypeVideo;
else if (isHTMLAudioElement(*mediaElement))
data.mediaType = WebContextMenuData::MediaTypeAudio;
if (mediaElement->error())
data.mediaFlags |= WebContextMenuData::MediaInError;
if (mediaElement->paused())
data.mediaFlags |= WebContextMenuData::MediaPaused;
if (mediaElement->muted())
data.mediaFlags |= WebContextMenuData::MediaMuted;
if (mediaElement->loop())
data.mediaFlags |= WebContextMenuData::MediaLoop;
if (mediaElement->supportsSave())
data.mediaFlags |= WebContextMenuData::MediaCanSave;
if (mediaElement->hasAudio())
data.mediaFlags |= WebContextMenuData::MediaHasAudio;
// Media controls can be toggled only for video player. If we toggle
// controls for audio then the player disappears, and there is no way to
// return it back. Don't set this bit for fullscreen video, since
// toggling is ignored in that case.
if (mediaElement->hasVideo() && !mediaElement->isFullscreen())
data.mediaFlags |= WebContextMenuData::MediaCanToggleControls;
if (mediaElement->controls())
data.mediaFlags |= WebContextMenuData::MediaControls;
} else if (isHTMLObjectElement(*r.innerNonSharedNode()) || isHTMLEmbedElement(*r.innerNonSharedNode())) {
RenderObject* object = r.innerNonSharedNode()->renderer();
if (object && object->isWidget()) {
Widget* widget = toRenderWidget(object)->widget();
if (widget && widget->isPluginContainer()) {
data.mediaType = WebContextMenuData::MediaTypePlugin;
WebPluginContainerImpl* plugin = toWebPluginContainerImpl(widget);
WebString text = plugin->plugin()->selectionAsText();
if (!text.isEmpty()) {
data.selectedText = text;
data.editFlags |= WebContextMenuData::CanCopy;
}
data.editFlags &= ~WebContextMenuData::CanTranslate;
data.linkURL = plugin->plugin()->linkAtPosition(data.mousePosition);
if (plugin->plugin()->supportsPaginatedPrint())
data.mediaFlags |= WebContextMenuData::MediaCanPrint;
HTMLPlugInElement* pluginElement = toHTMLPlugInElement(r.innerNonSharedNode());
data.srcURL = pluginElement->document().completeURL(pluginElement->url());
data.mediaFlags |= WebContextMenuData::MediaCanSave;
// Add context menu commands that are supported by the plugin.
if (plugin->plugin()->canRotateView())
data.mediaFlags |= WebContextMenuData::MediaCanRotate;
}
}
}
// An image can to be null for many reasons, like being blocked, no image
// data received from server yet.
data.hasImageContents =
(data.mediaType == WebContextMenuData::MediaTypeImage)
&& r.image() && !(r.image()->isNull());
// If it's not a link, an image, a media element, or an image/media link,
// show a selection menu or a more generic page menu.
if (selectedFrame->document()->loader())
data.frameEncoding = selectedFrame->document()->encodingName();
// Send the frame and page URLs in any case.
data.pageURL = urlFromFrame(m_webView->mainFrameImpl()->frame());
if (selectedFrame != m_webView->mainFrameImpl()->frame()) {
data.frameURL = urlFromFrame(selectedFrame);
RefPtr<HistoryItem> historyItem = selectedFrame->loader().currentItem();
if (historyItem)
data.frameHistoryItem = WebHistoryItem(historyItem);
}
if (r.isSelected()) {
if (!isHTMLInputElement(*r.innerNonSharedNode()) || !toHTMLInputElement(r.innerNonSharedNode())->isPasswordField())
data.selectedText = selectedFrame->selectedText().stripWhiteSpace();
}
if (r.isContentEditable()) {
data.isEditable = true;
// When Chrome enables asynchronous spellchecking, its spellchecker adds spelling markers to misspelled
// words and attaches suggestions to these markers in the background. Therefore, when a user right-clicks
// a mouse on a word, Chrome just needs to find a spelling marker on the word instead of spellchecking it.
if (selectedFrame->settings() && selectedFrame->settings()->asynchronousSpellCheckingEnabled()) {
DocumentMarker marker;
data.misspelledWord = selectMisspellingAsync(selectedFrame, marker);
data.misspellingHash = marker.hash();
if (marker.description().length()) {
Vector<String> suggestions;
marker.description().split('\n', suggestions);
data.dictionarySuggestions = suggestions;
} else if (m_webView->spellCheckClient()) {
int misspelledOffset, misspelledLength;
m_webView->spellCheckClient()->spellCheck(data.misspelledWord, misspelledOffset, misspelledLength, &data.dictionarySuggestions);
}
} else {
data.isSpellCheckingEnabled =
toLocalFrame(m_webView->focusedWebCoreFrame())->spellChecker().isContinuousSpellCheckingEnabled();
// Spellchecking might be enabled for the field, but could be disabled on the node.
if (toLocalFrame(m_webView->focusedWebCoreFrame())->spellChecker().isSpellCheckingEnabledInFocusedNode()) {
data.misspelledWord = selectMisspelledWord(selectedFrame);
if (m_webView->spellCheckClient()) {
int misspelledOffset, misspelledLength;
m_webView->spellCheckClient()->spellCheck(
data.misspelledWord, misspelledOffset, misspelledLength,
&data.dictionarySuggestions);
if (!misspelledLength)
data.misspelledWord.reset();
}
}
}
HTMLFormElement* form = selectedFrame->selection().currentForm();
if (form && isHTMLInputElement(*r.innerNonSharedNode())) {
HTMLInputElement& selectedElement = toHTMLInputElement(*r.innerNonSharedNode());
WebSearchableFormData ws = WebSearchableFormData(WebFormElement(form), WebInputElement(&selectedElement));
if (ws.url().isValid())
data.keywordURL = ws.url();
}
}
if (selectedFrame->editor().selectionHasStyle(CSSPropertyDirection, "ltr") != FalseTriState)
data.writingDirectionLeftToRight |= WebContextMenuData::CheckableMenuItemChecked;
if (selectedFrame->editor().selectionHasStyle(CSSPropertyDirection, "rtl") != FalseTriState)
data.writingDirectionRightToLeft |= WebContextMenuData::CheckableMenuItemChecked;
// Now retrieve the security info.
DocumentLoader* dl = selectedFrame->loader().documentLoader();
WebDataSource* ds = WebDataSourceImpl::fromDocumentLoader(dl);
if (ds)
data.securityInfo = ds->response().securityInfo();
data.referrerPolicy = static_cast<WebReferrerPolicy>(selectedFrame->document()->referrerPolicy());
// Filter out custom menu elements and add them into the data.
populateCustomMenuItems(defaultMenu, &data);
// Extract suggested filename for saving file.
if (isHTMLAnchorElement(r.URLElement())) {
HTMLAnchorElement* anchor = toHTMLAnchorElement(r.URLElement());
data.suggestedFilename = anchor->fastGetAttribute(HTMLNames::downloadAttr);
}
data.node = r.innerNonSharedNode();
WebLocalFrameImpl* selectedWebFrame = WebLocalFrameImpl::fromFrame(selectedFrame);
if (selectedWebFrame->client())
selectedWebFrame->client()->showContextMenu(data);
}
void V8HTMLObjectElement::legacyCallCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
{
HTMLPlugInElement* imp = V8HTMLObjectElement::toNative(args.Holder());
UseCounter::count(&imp->document(), UseCounter::HTMLObjectElementLegacyCall);
npObjectInvokeDefaultHandler(args);
}