void WebFrameLoaderClient::dispatchDidFailLoad(const ResourceError& error)
{
WebView* webView = m_webFrame->webView();
COMPtr<IWebFrameLoadDelegate> frameLoadDelegate;
if (SUCCEEDED(webView->frameLoadDelegate(&frameLoadDelegate))) {
COMPtr<IWebError> webError;
webError.adoptRef(WebError::createInstance(error));
frameLoadDelegate->didFailLoadWithError(webView, webError.get(), m_webFrame);
}
}
PassRefPtr<Clipboard> EventHandler::createDraggingClipboard() const
{
#if PLATFORM(WIN_OS)
COMPtr<WCDataObject> dataObject;
WCDataObject::createInstance(&dataObject);
return ClipboardWin::create(true, dataObject.get(), ClipboardWritable);
#else
return PassRefPtr<Clipboard>(0);
#endif
}
// IWebDatabaseManager -------------------------------------------------------------
HRESULT STDMETHODCALLTYPE WebDatabaseManager::sharedWebDatabaseManager(
/* [retval][out] */ IWebDatabaseManager** result)
{
if (!s_sharedWebDatabaseManager) {
s_sharedWebDatabaseManager.adoptRef(WebDatabaseManager::createInstance());
DatabaseTracker::tracker().setClient(s_sharedWebDatabaseManager.get());
}
return s_sharedWebDatabaseManager.copyRefTo(result);
}
static void resetWebViewToConsistentStateBeforeTesting()
{
COMPtr<IWebView> webView;
if (FAILED(frame->webView(&webView)))
return;
webView->setPolicyDelegate(0);
policyDelegate->setPermissive(false);
policyDelegate->setControllerToNotifyDone(0);
COMPtr<IWebIBActions> webIBActions(Query, webView);
if (webIBActions) {
webIBActions->makeTextStandardSize(0);
webIBActions->resetPageZoom(0);
}
COMPtr<IWebPreferences> preferences;
if (SUCCEEDED(webView->preferences(&preferences)))
resetDefaultsToConsistentValues(preferences.get());
COMPtr<IWebViewEditing> viewEditing;
if (SUCCEEDED(webView->QueryInterface(&viewEditing)))
viewEditing->setSmartInsertDeleteEnabled(TRUE);
COMPtr<IWebViewPrivate> webViewPrivate(Query, webView);
if (!webViewPrivate)
return;
double minimumInterval = 0;
if (SUCCEEDED(webViewPrivate->defaultMinimumTimerInterval(&minimumInterval)))
webViewPrivate->setMinimumTimerInterval(minimumInterval);
HWND viewWindow;
if (SUCCEEDED(webViewPrivate->viewWindow(reinterpret_cast<OLE_HANDLE*>(&viewWindow))) && viewWindow)
SetFocus(viewWindow);
webViewPrivate->clearMainFrameName();
webViewPrivate->resetOriginAccessWhitelists();
BSTR groupName;
if (SUCCEEDED(webView->groupName(&groupName))) {
webViewPrivate->removeAllUserContentFromGroup(groupName);
SysFreeString(groupName);
}
sharedUIDelegate->resetUndoManager();
sharedFrameLoadDelegate->resetToConsistentState();
COMPtr<IWebFramePrivate> framePrivate;
if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
framePrivate->clearOpener();
}
void WebChromeClient::mouseDidMoveOverElement(const HitTestResult& result, unsigned modifierFlags)
{
COMPtr<IWebUIDelegate> uiDelegate;
if (FAILED(m_webView->uiDelegate(&uiDelegate)))
return;
COMPtr<WebElementPropertyBag> element;
element.adoptRef(WebElementPropertyBag::createInstance(result));
uiDelegate->mouseDidMoveOverElement(m_webView, element.get(), modifierFlags);
}
bool AccessibilityUIElement::isEqual(AccessibilityUIElement* otherElement)
{
COMPtr<IAccessibleComparable> comparable = comparableObject(m_element.get());
COMPtr<IAccessibleComparable> otherComparable = comparableObject(otherElement->m_element.get());
if (!comparable || !otherComparable)
return false;
BOOL isSame = FALSE;
if (FAILED(comparable->isSameObject(otherComparable.get(), &isSame)))
return false;
return isSame;
}
void WebFrameLoaderClient::dispatchDidFailToStartPlugin(const PluginView* pluginView) const
{
WebView* webView = m_webFrame->webView();
COMPtr<IWebResourceLoadDelegate> resourceLoadDelegate;
if (FAILED(webView->resourceLoadDelegate(&resourceLoadDelegate)))
return;
RetainPtr<CFMutableDictionaryRef> userInfo(AdoptCF, CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
Frame* frame = core(m_webFrame);
ASSERT(frame == pluginView->parentFrame());
if (!pluginView->pluginsPage().isNull()) {
KURL pluginPageURL = frame->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(pluginView->pluginsPage()));
if (pluginPageURL.protocolIsInHTTPFamily()) {
static CFStringRef key = MarshallingHelpers::LPCOLESTRToCFStringRef(WebKitErrorPlugInPageURLStringKey);
CFDictionarySetValue(userInfo.get(), key, pluginPageURL.string().createCFString().get());
}
}
if (!pluginView->mimeType().isNull()) {
static CFStringRef key = MarshallingHelpers::LPCOLESTRToCFStringRef(WebKitErrorMIMETypeKey);
CFDictionarySetValue(userInfo.get(), key, pluginView->mimeType().createCFString().get());
}
if (pluginView->plugin()) {
String pluginName = pluginView->plugin()->name();
if (!pluginName.isNull()) {
static CFStringRef key = MarshallingHelpers::LPCOLESTRToCFStringRef(WebKitErrorPlugInNameKey);
CFDictionarySetValue(userInfo.get(), key, pluginName.createCFString().get());
}
}
COMPtr<CFDictionaryPropertyBag> userInfoBag = CFDictionaryPropertyBag::createInstance();
userInfoBag->setDictionary(userInfo.get());
int errorCode = 0;
switch (pluginView->status()) {
case PluginStatusCanNotFindPlugin:
errorCode = WebKitErrorCannotFindPlugIn;
break;
case PluginStatusCanNotLoadPlugin:
errorCode = WebKitErrorCannotLoadPlugIn;
break;
default:
ASSERT_NOT_REACHED();
}
ResourceError resourceError(String(WebKitErrorDomain), errorCode, pluginView->url().string(), String());
COMPtr<IWebError> error(AdoptCOM, WebError::createInstance(resourceError, userInfoBag.get()));
resourceLoadDelegate->plugInFailedWithError(webView, error.get(), getWebDataSource(frame->loader()->documentLoader()));
}
bool WebEditorClient::spellingUIIsShowing()
{
COMPtr<IWebEditingDelegate> ed;
if (FAILED(m_webView->editingDelegate(&ed)) || !ed.get())
return false;
BOOL showing;
if (FAILED(ed->spellingUIIsShowing(&showing)))
return false;
return !!showing;
}
// IWebDatabaseManager -------------------------------------------------------------
HRESULT WebDatabaseManager::sharedWebDatabaseManager(_COM_Outptr_opt_ IWebDatabaseManager** result)
{
if (!result)
return E_POINTER;
if (!s_sharedWebDatabaseManager) {
s_sharedWebDatabaseManager.adoptRef(WebDatabaseManager::createInstance());
DatabaseManager::singleton().setClient(s_sharedWebDatabaseManager.get());
}
return s_sharedWebDatabaseManager.copyRefTo(result);
}
void WebEditorClient::checkSpellingOfString(StringView text, int* misspellingLocation, int* misspellingLength)
{
*misspellingLocation = -1;
*misspellingLength = 0;
COMPtr<IWebEditingDelegate> ed;
if (FAILED(m_webView->editingDelegate(&ed)) || !ed.get())
return;
initViewSpecificSpelling(m_webView);
ed->checkSpellingOfString(m_webView, text.upconvertedCharacters(), text.length(), misspellingLocation, misspellingLength);
}
void LayoutTestController::addUserScript(JSStringRef source, bool runAtStart)
{
COMPtr<IWebViewPrivate> webView;
if (FAILED(WebKitCreateInstance(__uuidof(WebView), 0, __uuidof(webView), reinterpret_cast<void**>(&webView))))
return;
COMPtr<IWebScriptWorld> world;
if (FAILED(WebKitCreateInstance(__uuidof(WebScriptWorld), 0, __uuidof(world), reinterpret_cast<void**>(&world))))
return;
webView->addUserScriptToGroup(_bstr_t(L"org.webkit.DumpRenderTree").GetBSTR(), world.get(), bstrT(source).GetBSTR(), 0, 0, 0, 0, 0, runAtStart ? WebInjectAtDocumentStart : WebInjectAtDocumentEnd);
}
void LayoutTestController::keepWebHistory()
{
COMPtr<IWebHistory> history;
if (FAILED(WebKitCreateInstance(CLSID_WebHistory, 0, __uuidof(history), reinterpret_cast<void**>(&history))))
return;
COMPtr<IWebHistory> sharedHistory;
if (FAILED(WebKitCreateInstance(CLSID_WebHistory, 0, __uuidof(sharedHistory), reinterpret_cast<void**>(&sharedHistory))))
return;
history->setOptionalSharedHistory(sharedHistory.get());
}
void WebEditorClient::checkSpellingOfString(const UChar* text, int length, int* misspellingLocation, int* misspellingLength)
{
*misspellingLocation = -1;
*misspellingLength = 0;
COMPtr<IWebEditingDelegate> ed;
if (FAILED(m_webView->editingDelegate(&ed)) || !ed.get())
return;
initViewSpecificSpelling(m_webView);
ed->checkSpellingOfString(m_webView, text, length, misspellingLocation, misspellingLength);
}
static void resetWebViewToConsistentStateBeforeTesting()
{
COMPtr<IWebView> webView;
if (FAILED(frame->webView(&webView)))
return;
webView->setPolicyDelegate(0);
policyDelegate->setPermissive(false);
policyDelegate->setControllerToNotifyDone(0);
COMPtr<IWebIBActions> webIBActions(Query, webView);
if (webIBActions) {
webIBActions->makeTextStandardSize(0);
webIBActions->resetPageZoom(0);
}
COMPtr<IWebPreferences> preferences;
if (SUCCEEDED(webView->preferences(&preferences)))
resetDefaultsToConsistentValues(preferences.get());
if (gTestRunner) {
JSGlobalContextRef context = frame->globalContext();
WebCoreTestSupport::resetInternalsObject(context);
}
COMPtr<IWebViewPrivate> webViewPrivate(Query, webView);
if (!webViewPrivate)
return;
HWND viewWindow;
if (SUCCEEDED(webViewPrivate->viewWindow(reinterpret_cast<OLE_HANDLE*>(&viewWindow))) && viewWindow)
SetFocus(viewWindow);
webViewPrivate->clearMainFrameName();
webViewPrivate->resetOriginAccessWhitelists();
BSTR groupName;
if (SUCCEEDED(webView->groupName(&groupName))) {
webViewPrivate->removeAllUserContentFromGroup(groupName);
SysFreeString(groupName);
}
sharedUIDelegate->resetUndoManager();
sharedFrameLoadDelegate->resetToConsistentState();
COMPtr<IWebFramePrivate> framePrivate;
if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
framePrivate->clearOpener();
}
void WebDragClient::willPerformDragSourceAction(DragSourceAction action, const IntPoint& intPoint, DataTransfer& dataTransfer)
{
COMPtr<IWebUIDelegate> uiDelegate;
if (!SUCCEEDED(m_webView->uiDelegate(&uiDelegate)))
return;
POINT point = intPoint;
COMPtr<IDataObject> dataObject = dataTransfer.pasteboard().dataObject();
COMPtr<IDataObject> newDataObject;
HRESULT result = uiDelegate->willPerformDragSourceAction(m_webView, static_cast<WebDragSourceAction>(action), &point, dataObject.get(), &newDataObject);
if (result == S_OK && newDataObject != dataObject)
const_cast<Pasteboard&>(dataTransfer.pasteboard()).setExternalDataObject(newDataObject.get());
}
GEN_DOMImplementation* GEN_DOMImplementation::createInstance(WebCore::DOMImplementation* impl)
{
if (!impl)
return 0;
if (GEN_DOMObject* cachedInstance = getDOMWrapper(impl)) {
cachedInstance->AddRef();
return static_cast<GEN_DOMImplementation*>(cachedInstance);
}
COMPtr<GEN_DOMImplementation> comDOMObject = new GEN_DOMImplementation(impl);
setDOMWrapper(impl, comDOMObject.get());
return comDOMObject.releaseRef();
}
void WebDragClient::willPerformDragSourceAction(DragSourceAction action, const IntPoint& intPoint, Clipboard* clipboard)
{
COMPtr<IWebUIDelegate> uiDelegate;
if (!SUCCEEDED(m_webView->uiDelegate(&uiDelegate)))
return;
POINT point = intPoint;
COMPtr<IDataObject> dataObject = static_cast<ClipboardWin*>(clipboard)->dataObject();
COMPtr<IDataObject> newDataObject;
HRESULT result = uiDelegate->willPerformDragSourceAction(m_webView, static_cast<WebDragSourceAction>(action), &point, dataObject.get(), &newDataObject);
if (result == S_OK && newDataObject != dataObject)
static_cast<ClipboardWin*>(clipboard)->setExternalDataObject(newDataObject.get());
}
bool WebEditorClient::shouldDeleteRange(Range* range)
{
COMPtr<IWebEditingDelegate> ed;
if (FAILED(m_webView->editingDelegate(&ed)) || !ed.get())
return true;
COMPtr<IDOMRange> currentRange(AdoptCOM, DOMRange::createInstance(range));
BOOL shouldDelete = FALSE;
if (FAILED(ed->shouldDeleteDOMRange(m_webView, currentRange.get(), &shouldDelete)))
return true;
return shouldDelete;
}
GeolocationPosition* WebGeolocationControllerClient::lastPosition()
{
#if ENABLE(CLIENT_BASED_GEOLOCATION)
COMPtr<IWebGeolocationProvider> provider;
if (FAILED(m_webView->geolocationProvider(&provider)))
return 0;
COMPtr<IWebGeolocationPosition> position;
if (FAILED(provider->lastPosition(&position)))
return 0;
return core(position.get());
#else
return 0;
#endif
}
void TestRunner::addUserScript(JSStringRef source, bool runAtStart, bool allFrames)
{
COMPtr<IWebViewPrivate2> webView;
if (FAILED(WebKitCreateInstance(__uuidof(WebView), 0, __uuidof(webView), reinterpret_cast<void**>(&webView))))
return;
COMPtr<IWebScriptWorld> world;
if (FAILED(WebKitCreateInstance(__uuidof(WebScriptWorld), 0, __uuidof(world), reinterpret_cast<void**>(&world))))
return;
webView->addUserScriptToGroup(_bstr_t(L"org.webkit.DumpRenderTree").GetBSTR(), world.get(), bstrT(source).GetBSTR(),
nullptr, 0, nullptr, 0, nullptr, runAtStart ? WebInjectAtDocumentStart : WebInjectAtDocumentEnd,
allFrames ? WebInjectInAllFrames : WebInjectInTopFrameOnly);
}
Page* WebChromeClient::createWindow(Frame* frame, const FrameLoadRequest&, const WindowFeatures& features, const NavigationAction& navigationAction)
{
COMPtr<IWebUIDelegate> delegate = uiDelegate();
if (!delegate)
return 0;
#if ENABLE(FULLSCREEN_API)
if (frame->document() && frame->document()->webkitCurrentFullScreenElement())
frame->document()->webkitCancelFullScreen();
#endif
COMPtr<WebMutableURLRequest> request = adoptCOM(WebMutableURLRequest::createInstance(ResourceRequest(navigationAction.url())));
COMPtr<IWebUIDelegatePrivate2> delegatePrivate(Query, delegate);
if (delegatePrivate) {
COMPtr<IWebView> newWebView;
HRESULT hr = delegatePrivate->createWebViewWithRequest(m_webView, request.get(), createWindowFeaturesPropertyBag(features).get(), &newWebView);
if (SUCCEEDED(hr) && newWebView)
return core(newWebView.get());
// If the delegate doesn't implement the IWebUIDelegatePrivate2 version of the call, fall back
// to the old versions (even if they support the IWebUIDelegatePrivate2 interface).
if (hr != E_NOTIMPL)
return 0;
}
COMPtr<IWebView> newWebView;
if (features.dialog) {
if (FAILED(delegate->createModalDialog(m_webView, request.get(), &newWebView)))
return 0;
} else if (FAILED(delegate->createWebViewWithRequest(m_webView, request.get(), &newWebView)))
return 0;
return newWebView ? core(newWebView.get()) : 0;
}
bool WebEditorClient::shouldChangeSelectedRange(WebCore::Range* currentRange, WebCore::Range* proposedRange, WebCore::EAffinity selectionAffinity, bool flag)
{
COMPtr<IWebEditingDelegate> ed;
if (FAILED(m_webView->editingDelegate(&ed)) || !ed.get())
return true;
COMPtr<IDOMRange> currentIDOMRange(AdoptCOM, DOMRange::createInstance(currentRange));
COMPtr<IDOMRange> proposedIDOMRange(AdoptCOM, DOMRange::createInstance(proposedRange));
BOOL shouldChange = FALSE;
if (FAILED(ed->shouldChangeSelectedDOMRange(m_webView, currentIDOMRange.get(), proposedIDOMRange.get(), static_cast<WebSelectionAffinity>(selectionAffinity), flag, &shouldChange)))
return true;
return shouldChange;
}
void TestRunner::keepWebHistory()
{
COMPtr<IWebHistory> history;
if (FAILED(WebKitCreateInstance(CLSID_WebHistory, 0, __uuidof(history), reinterpret_cast<void**>(&history))))
return;
COMPtr<IWebHistory> sharedHistory;
if (SUCCEEDED(history->optionalSharedHistory(&sharedHistory)) && sharedHistory)
return;
if (FAILED(WebKitCreateInstance(CLSID_WebHistory, 0, __uuidof(sharedHistory), reinterpret_cast<void**>(&sharedHistory))))
return;
history->setOptionalSharedHistory(sharedHistory.get());
}
void WebFrameLoaderClient::didRunInsecureContent(SecurityOrigin* origin)
{
COMPtr<IWebSecurityOrigin> webSecurityOrigin = WebSecurityOrigin::createInstance(origin);
WebView* webView = m_webFrame->webView();
COMPtr<IWebFrameLoadDelegatePrivate> frameLoadDelegatePriv;
if (FAILED(webView->frameLoadDelegatePrivate(&frameLoadDelegatePriv)) || !frameLoadDelegatePriv)
return;
COMPtr<IWebFrameLoadDelegatePrivate2> frameLoadDelegatePriv2(Query, frameLoadDelegatePriv);
if (!frameLoadDelegatePriv2)
return;
frameLoadDelegatePriv2->didRunInsecureContent(webView, webSecurityOrigin.get());
}
void WebContextMenuClient::downloadURL(const KURL& url)
{
COMPtr<IWebDownloadDelegate> downloadDelegate;
if (FAILED(m_webView->downloadDelegate(&downloadDelegate))) {
// If the WebView doesn't successfully provide a download delegate we'll pass a null one
// into the WebDownload - which may or may not decide to use a DefaultDownloadDelegate
LOG_ERROR("Failed to get downloadDelegate from WebView");
downloadDelegate = 0;
}
// Its the delegate's job to ref the WebDownload to keep it alive - otherwise it will be destroyed
// when this method returns
COMPtr<WebDownload> download;
download.adoptRef(WebDownload::createInstance(url, downloadDelegate.get()));
download->start();
}
HRESULT WebNotificationCenter::postNotification(_In_opt_ IWebNotification* notification)
{
BString name;
HRESULT hr = notification->name(&name);
if (FAILED(hr))
return hr;
COMPtr<IUnknown> obj;
hr = notification->getObject(&obj);
if (FAILED(hr))
return hr;
postNotificationInternal(notification, name, obj.get());
return hr;
}
void TestRunner::clearApplicationCacheForOrigin(JSStringRef origin)
{
COMPtr<IWebSecurityOrigin2> securityOrigin;
if (FAILED(WebKitCreateInstance(CLSID_WebSecurityOrigin, 0, IID_IWebSecurityOrigin2, reinterpret_cast<void**>(&securityOrigin))))
return;
_bstr_t originBstr(JSStringCopyBSTR(origin), false);
if (FAILED(securityOrigin->initWithURL(originBstr.GetBSTR())))
return;
COMPtr<IWebApplicationCache> applicationCache;
if (FAILED(WebKitCreateInstance(CLSID_WebApplicationCache, 0, IID_IWebApplicationCache, reinterpret_cast<void**>(&applicationCache))))
return;
applicationCache->deleteCacheForOrigin(securityOrigin.get());
}
void WebEditorClient::updateSpellingUIWithGrammarString(const String& string, const WebCore::GrammarDetail& detail)
{
COMPtr<IWebEditingDelegate> ed;
if (FAILED(m_webView->editingDelegate(&ed)) || !ed.get())
return;
Vector<BSTR> guessesBSTRs;
for (unsigned i = 0; i < detail.guesses.size(); i++) {
BString guess(detail.guesses[i]);
guessesBSTRs.append(guess.release());
}
BString userDescriptionBSTR(detail.userDescription);
ed->updateSpellingUIWithGrammarString(BString(string), detail.location, detail.length, userDescriptionBSTR, guessesBSTRs.data(), (int)guessesBSTRs.size());
for (unsigned i = 0; i < guessesBSTRs.size(); i++)
SysFreeString(guessesBSTRs[i]);
}
bool MediaPlayerPrivateMediaFoundation::createOutputNode(COMPtr<IMFStreamDescriptor> sourceSD, COMPtr<IMFTopologyNode>& node)
{
if (!MFCreateTopologyNodePtr() || !MFCreateAudioRendererActivatePtr() || !MFCreateVideoRendererActivatePtr())
return false;
if (!sourceSD)
return false;
#ifndef NDEBUG
// Get the stream ID.
DWORD streamID = 0;
sourceSD->GetStreamIdentifier(&streamID); // Just for debugging, ignore any failures.
#endif
COMPtr<IMFMediaTypeHandler> handler;
if (FAILED(sourceSD->GetMediaTypeHandler(&handler)))
return false;
GUID guidMajorType = GUID_NULL;
if (FAILED(handler->GetMajorType(&guidMajorType)))
return false;
// Create a downstream node.
if (FAILED(MFCreateTopologyNodePtr()(MF_TOPOLOGY_OUTPUT_NODE, &node)))
return false;
// Create an IMFActivate object for the renderer, based on the media type.
COMPtr<IMFActivate> rendererActivate;
if (MFMediaType_Audio == guidMajorType) {
// Create the audio renderer.
if (FAILED(MFCreateAudioRendererActivatePtr()(&rendererActivate)))
return false;
m_hasAudio = true;
} else if (MFMediaType_Video == guidMajorType) {
// Create the video renderer.
if (FAILED(MFCreateVideoRendererActivatePtr()(m_hwndVideo, &rendererActivate)))
return false;
m_hasVideo = true;
} else
return false;
// Set the IActivate object on the output node.
if (FAILED(node->SetObject(rendererActivate.get())))
return false;
return true;
}
PassRefPtr<Widget> WebFrameLoaderClient::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
WebView* webView = m_webFrame->webView();
COMPtr<IWebUIDelegate> ui;
if (SUCCEEDED(webView->uiDelegate(&ui)) && ui) {
COMPtr<IWebUIDelegatePrivate> uiPrivate(Query, ui);
if (uiPrivate) {
// Assemble the view arguments in a property bag.
HashMap<String, String> viewArguments;
for (unsigned i = 0; i < paramNames.size(); i++)
viewArguments.set(paramNames[i], paramValues[i]);
COMPtr<IPropertyBag> viewArgumentsBag(AdoptCOM, COMPropertyBag<String>::adopt(viewArguments));
COMPtr<IDOMElement> containingElement(AdoptCOM, DOMElement::createInstance(element));
HashMap<String, COMVariant> arguments;
arguments.set(WebEmbeddedViewAttributesKey, viewArgumentsBag);
arguments.set(WebEmbeddedViewBaseURLKey, url.string());
arguments.set(WebEmbeddedViewContainingElementKey, containingElement);
arguments.set(WebEmbeddedViewMIMETypeKey, mimeType);
COMPtr<IPropertyBag> argumentsBag(AdoptCOM, COMPropertyBag<COMVariant>::adopt(arguments));
COMPtr<IWebEmbeddedView> view;
HRESULT result = uiPrivate->embeddedViewWithArguments(webView, m_webFrame, argumentsBag.get(), &view);
if (SUCCEEDED(result)) {
HWND parentWindow;
HRESULT hr = webView->viewWindow((OLE_HANDLE*)&parentWindow);
ASSERT(SUCCEEDED(hr));
return EmbeddedWidget::create(view.get(), element, parentWindow, pluginSize);
}
}
}
Frame* frame = core(m_webFrame);
RefPtr<PluginView> pluginView = PluginView::create(frame, pluginSize, element, url, paramNames, paramValues, mimeType, loadManually);
if (pluginView->status() == PluginStatusLoadedSuccessfully)
return pluginView;
dispatchDidFailToStartPlugin(pluginView.get());
return 0;
}