void WebChromeClient::runOpenPanel(Frame* frame, PassRefPtr<FileChooser> prpFileChooser)
{
if (m_page->activeOpenPanelResultListener())
return;
RefPtr<FileChooser> fileChooser = prpFileChooser;
m_page->setActiveOpenPanelResultListener(WebOpenPanelResultListener::create(m_page, fileChooser.get()));
WebFrameLoaderClient* webFrameLoaderClient = toWebFrameLoaderClient(frame->loader()->client());
WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : 0;
ASSERT(webFrame);
m_page->send(Messages::WebPageProxy::RunOpenPanel(webFrame->frameID(), fileChooser->settings()));
}
void TextInputController::setMarkedText(const CppArgumentList& arguments, CppVariant* result)
{
result->setNull();
WebFrame* mainFrame = getMainFrame();
if (!mainFrame)
return;
if (arguments.size() >= 3 && arguments[0].isString()
&& arguments[1].isNumber() && arguments[2].isNumber()) {
mainFrame->setMarkedText(WebString::fromUTF8(arguments[0].toString()),
arguments[1].toInt32(),
arguments[2].toInt32());
}
}
bool LayoutTestController::pauseTransitionAtTimeOnElementWithId(const WebString& propertyName, double time, const WebString& elementId)
{
WebFrame* webFrame = m_shell->webView()->mainFrame();
if (!webFrame)
return false;
WebAnimationController* controller = webFrame->animationController();
if (!controller)
return false;
WebElement element = webFrame->document().getElementById(elementId);
if (element.isNull())
return false;
return controller->pauseTransitionAtTime(element, propertyName, time);
}
void WebChromeClient::exceededDatabaseQuota(Frame* frame, const String& databaseName)
{
WebFrame* webFrame = static_cast<WebFrameLoaderClient*>(frame->loader()->client())->webFrame();
SecurityOrigin* origin = frame->document()->securityOrigin();
DatabaseDetails details = DatabaseTracker::tracker().detailsForNameAndOrigin(databaseName, origin);
uint64_t currentQuota = DatabaseTracker::tracker().quotaForOrigin(origin);
uint64_t currentOriginUsage = DatabaseTracker::tracker().usageForOrigin(origin);
uint64_t newQuota = 0;
WebProcess::shared().connection()->sendSync(
Messages::WebPageProxy::ExceededDatabaseQuota(webFrame->frameID(), origin->databaseIdentifier(), databaseName, details.displayName(), currentQuota, currentOriginUsage, details.currentUsage(), details.expectedUsage()),
Messages::WebPageProxy::ExceededDatabaseQuota::Reply(newQuota), m_page->pageID());
DatabaseTracker::tracker().setQuota(origin, newQuota);
}
// WebCore::UserMessageHandlerDescriptor
void didPostMessage(WebCore::UserMessageHandler& handler, WebCore::SerializedScriptValue* value) override
{
WebCore::Frame* frame = handler.frame();
if (!frame)
return;
WebFrame* webFrame = WebFrame::fromCoreFrame(*frame);
if (!webFrame)
return;
WebPage* webPage = webFrame->page();
if (!webPage)
return;
WebProcess::singleton().parentProcessConnection()->send(Messages::WebUserContentControllerProxy::DidPostMessage(webPage->pageID(), webFrame->frameID(), SecurityOriginData::fromFrame(frame), m_identifier, IPC::DataReference(value->data())), m_controller->identifier());
}
void WebChromeClient::focusedFrameChanged(Frame* frame)
{
WebFrameLoaderClient* webFrameLoaderClient = frame ? toWebFrameLoaderClient(frame->loader()->client()) : 0;
WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : 0;
WebProcess::shared().connection()->send(Messages::WebPageProxy::FocusedFrameChanged(webFrame ? webFrame->frameID() : 0), m_page->pageID());
}
Page* WebChromeClient::createWindow(Frame* frame, const FrameLoadRequest& request, const WindowFeatures& windowFeatures, const NavigationAction& navigationAction)
{
#if ENABLE(FULLSCREEN_API)
if (frame->document() && frame->document()->webkitCurrentFullScreenElement())
frame->document()->webkitCancelFullScreen();
#endif
auto& webProcess = WebProcess::singleton();
WebFrame* webFrame = WebFrame::fromCoreFrame(*frame);
NavigationActionData navigationActionData;
navigationActionData.navigationType = navigationAction.type();
navigationActionData.modifiers = InjectedBundleNavigationAction::modifiersForNavigationAction(navigationAction);
navigationActionData.mouseButton = InjectedBundleNavigationAction::mouseButtonForNavigationAction(navigationAction);
navigationActionData.syntheticClickType = InjectedBundleNavigationAction::syntheticClickTypeForNavigationAction(navigationAction);
navigationActionData.userGestureTokenIdentifier = webProcess.userGestureTokenIdentifier(navigationAction.userGestureToken());
navigationActionData.canHandleRequest = m_page->canHandleRequest(request.resourceRequest());
navigationActionData.shouldOpenExternalURLsPolicy = navigationAction.shouldOpenExternalURLsPolicy();
navigationActionData.downloadAttribute = navigationAction.downloadAttribute();
uint64_t newPageID = 0;
WebPageCreationParameters parameters;
if (!webProcess.parentProcessConnection()->sendSync(Messages::WebPageProxy::CreateNewPage(webFrame->frameID(), SecurityOriginData::fromFrame(frame), request.resourceRequest(), windowFeatures, navigationActionData), Messages::WebPageProxy::CreateNewPage::Reply(newPageID, parameters), m_page->pageID()))
return nullptr;
if (!newPageID)
return nullptr;
webProcess.createWebPage(newPageID, parameters);
return webProcess.webPage(newPageID)->corePage();
}
void WebChromeClient::contentsSizeChanged(Frame* frame, const IntSize& size) const
{
if (!m_page->corePage()->settings().frameFlatteningEnabled()) {
WebFrame* largestFrame = findLargestFrameInFrameSet(m_page);
if (largestFrame != m_cachedFrameSetLargestFrame.get()) {
m_cachedFrameSetLargestFrame = largestFrame;
m_page->send(Messages::WebPageProxy::FrameSetLargestFrameChanged(largestFrame ? largestFrame->frameID() : 0));
}
}
if (&frame->page()->mainFrame() != frame)
return;
m_page->send(Messages::WebPageProxy::DidChangeContentSize(size));
m_page->drawingArea()->mainFrameContentSizeChanged(size);
FrameView* frameView = frame->view();
if (frameView && !frameView->delegatesScrolling()) {
bool hasHorizontalScrollbar = frameView->horizontalScrollbar();
bool hasVerticalScrollbar = frameView->verticalScrollbar();
if (hasHorizontalScrollbar != m_cachedMainFrameHasHorizontalScrollbar || hasVerticalScrollbar != m_cachedMainFrameHasVerticalScrollbar) {
m_page->send(Messages::WebPageProxy::DidChangeScrollbarsForMainFrame(hasHorizontalScrollbar, hasVerticalScrollbar));
m_cachedMainFrameHasHorizontalScrollbar = hasHorizontalScrollbar;
m_cachedMainFrameHasVerticalScrollbar = hasVerticalScrollbar;
}
}
}
void TextInputController::insertText(const CppArgumentList& arguments, CppVariant* result)
{
result->setNull();
WebFrame* mainFrame = getMainFrame();
if (!mainFrame)
return;
if (arguments.size() < 1 || !arguments[0].isString())
return;
if (mainFrame->hasMarkedText()) {
mainFrame->unmarkText();
mainFrame->replaceSelection(WebString());
}
mainFrame->insertText(WebString::fromUTF8(arguments[0].toString()));
}
void LayoutTestController::numberOfPages(const CppArgumentList& arguments, CppVariant* result)
{
result->setNull();
float pageWidthInPixels = 0;
float pageHeightInPixels = 0;
if (!parsePageSizeParameters(arguments, 0, &pageWidthInPixels, &pageHeightInPixels))
return;
WebFrame* frame = m_shell->webView()->mainFrame();
if (!frame)
return;
WebSize size(pageWidthInPixels, pageHeightInPixels);
int numberOfPages = frame->printBegin(size);
frame->printEnd();
result->set(numberOfPages);
}
void LayoutTestController::pageNumberForElementById(const CppArgumentList& arguments, CppVariant* result)
{
result->setNull();
float pageWidthInPixels = 0;
float pageHeightInPixels = 0;
if (!parsePageSizeParameters(arguments, 1,
&pageWidthInPixels, &pageHeightInPixels))
return;
if (!arguments[0].isString())
return;
WebFrame* frame = m_shell->webView()->mainFrame();
if (!frame)
return;
result->set(frame->pageNumberForElementById(cppVariantToWebString(arguments[0]),
pageWidthInPixels, pageHeightInPixels));
}
Page* WebChromeClient::createWindow(Frame* frame, const FrameLoadRequest& request, const WindowFeatures& windowFeatures, const NavigationAction& navigationAction)
{
#if ENABLE(FULLSCREEN_API)
if (frame->document() && frame->document()->webkitCurrentFullScreenElement())
frame->document()->webkitCancelFullScreen();
#endif
WebFrame* webFrame = WebFrame::fromCoreFrame(*frame);
NavigationActionData navigationActionData;
navigationActionData.navigationType = navigationAction.type();
navigationActionData.modifiers = InjectedBundleNavigationAction::modifiersForNavigationAction(navigationAction);
navigationActionData.mouseButton = InjectedBundleNavigationAction::mouseButtonForNavigationAction(navigationAction);
navigationActionData.isProcessingUserGesture = navigationAction.processingUserGesture();
navigationActionData.canHandleRequest = m_page->canHandleRequest(request.resourceRequest());
uint64_t newPageID = 0;
WebPageCreationParameters parameters;
auto& webProcess = WebProcess::singleton();
if (!webProcess.parentProcessConnection()->sendSync(Messages::WebPageProxy::CreateNewPage(webFrame->frameID(), request.resourceRequest(), windowFeatures, navigationActionData), Messages::WebPageProxy::CreateNewPage::Reply(newPageID, parameters), m_page->pageID()))
return nullptr;
if (!newPageID)
return nullptr;
webProcess.createWebPage(newPageID, parameters);
return webProcess.webPage(newPageID)->corePage();
}
void TextInputController::selectedRange(const CppArgumentList&, CppVariant* result)
{
result->setNull();
WebFrame* mainFrame = m_webView->mainFrame();
if (!mainFrame)
return;
WebRange range = mainFrame->selectionRange();
vector<int> intArray(2);
intArray[0] = range.startOffset();
intArray[1] = range.endOffset();
NPObject* resultArray = WebBindings::makeIntArray(intArray);
result->set(resultArray);
WebBindings::releaseObject(resultArray);
}
void TouchActionTest::runIFrameTest(std::string file) {
TouchActionTrackingWebViewClient client;
WebView* webView = setupTest(file, client);
WebFrame* curFrame = webView->mainFrame()->firstChild();
ASSERT_TRUE(curFrame);
for (; curFrame; curFrame = curFrame->nextSibling()) {
// Oilpan: see runTouchActionTest() comment why these are persistent
// references.
Persistent<Document> contentDoc =
static_cast<Document*>(curFrame->document());
runTestOnTree(contentDoc.get(), webView, client);
}
// Explicitly reset to break dependency on locally scoped client.
m_webViewHelper.reset();
}
void WebChromeClient::runJavaScriptAlert(Frame* frame, const String& alertText)
{
WebFrame* webFrame = static_cast<WebFrameLoaderClient*>(frame->loader()->client())->webFrame();
// Notify the bundle client.
m_page->injectedBundleUIClient().willRunJavaScriptAlert(m_page, alertText, webFrame);
WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::RunJavaScriptAlert(webFrame->frameID(), alertText), Messages::WebPageProxy::RunJavaScriptAlert::Reply(), m_page->pageID());
}
string dumpFrameScrollPosition(WebFrame* frame, bool recursive)
{
string result;
WebSize offset = frame->scrollOffset();
if (offset.width > 0 || offset.height > 0) {
if (frame->parent())
result = string("frame '") + frame->uniqueName().utf8().data() + "' ";
char data[100];
snprintf(data, sizeof(data), "scrolled to %d,%d\n", offset.width, offset.height);
result += data;
}
if (!recursive)
return result;
for (WebFrame* child = frame->firstChild(); child; child = child->nextSibling())
result += dumpFrameScrollPosition(child, recursive);
return result;
}
Frame* WebFrameLoaderClient::dispatchCreatePage()
{
#if PLATFORM(AMIGAOS4)
extern BalWidget *createAmigaWindow(WebView *);
extern void closeAmigaWindow(BalWidget *);
WebView* newWebView = WebView::createInstance();
if (newWebView) {
BalWidget *newowbwindow = createAmigaWindow(newWebView);
if (newowbwindow) {
IntRect clientRect(0, 0, amigaConfig.width, amigaConfig.height);
newWebView->initWithFrame(clientRect, "", "");
newWebView->setViewWindow(newowbwindow);
WebFrame *mainFrame = newWebView->mainFrame();
if (mainFrame && mainFrame->impl())
return mainFrame->impl();
closeAmigaWindow(newowbwindow);
}
delete newWebView;
}
return 0;
#else
/*WebView* webView = m_webFrame->webView();
COMPtr<IWebUIDelegate> ui;
if (FAILED(webView->uiDelegate(&ui)))
return 0;
COMPtr<IWebView> newWebView;
if (FAILED(ui->createWebViewWithRequest(webView, 0, &newWebView)))
return 0;
COMPtr<IWebFrame> mainFrame;
if (FAILED(newWebView->mainFrame(&mainFrame)))
return 0;
COMPtr<WebFrame> mainFrameImpl(Query, mainFrame);
return core(mainFrameImpl.get());*/
return 0;
#endif
}
void WebChromeClient::runJavaScriptAlert(Frame* frame, const String& alertText)
{
WebFrame* webFrame = static_cast<WebFrameLoaderClient*>(frame->loader()->client())->webFrame();
// Notify the bundle client.
m_page->injectedBundleUIClient().willRunJavaScriptAlert(m_page, alertText, webFrame);
unsigned syncSendFlags = (WebCore::AXObjectCache::accessibilityEnabled()) ? CoreIPC::SpinRunLoopWhileWaitingForReply : 0;
WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::RunJavaScriptAlert(webFrame->frameID(), alertText), Messages::WebPageProxy::RunJavaScriptAlert::Reply(), m_page->pageID(), CoreIPC::Connection::DefaultTimeout, syncSendFlags);
}
bool WebChromeClient::runBeforeUnloadConfirmPanel(const String& message, Frame* frame)
{
WebFrame* webFrame = static_cast<WebFrameLoaderClient*>(frame->loader()->client())->webFrame();
bool shouldClose = false;
if (!WebProcess::shared().connection()->sendSync(Messages::WebPageProxy::RunBeforeUnloadConfirmPanel(message, webFrame->frameID()), Messages::WebPageProxy::RunBeforeUnloadConfirmPanel::Reply(shouldClose), m_page->pageID()))
return false;
return shouldClose;
}
bool LoadItem::invoke() const
{
char* targetString = JSStringCopyUTF8CString(m_target.get());
WebFrame* targetFrame;
if (!strlen(targetString))
targetFrame = getWebView()->mainFrame();
else
targetFrame = getWebView()->mainFrame()->findFrameNamed(targetString);
free(targetString);
char* urlString = JSStringCopyUTF8CString(m_url.get());
targetFrame->loadURL(urlString);
// WebKitNetworkRequest* request = webkit_network_request_new(urlString);
free(urlString);
// webkit_web_frame_load_request(targetFrame, request);
// g_object_unref(request);
return true;
}
void TextFinder::updateFindMatchRects() {
IntSize currentContentsSize = ownerFrame().contentsSize();
if (m_contentsSizeForCurrentFindMatchRects != currentContentsSize) {
m_contentsSizeForCurrentFindMatchRects = currentContentsSize;
m_findMatchRectsAreValid = false;
}
size_t deadMatches = 0;
for (FindMatch& match : m_findMatchesCache) {
if (!match.m_range->boundaryPointsValid() ||
!match.m_range->startContainer()->isConnected())
match.m_rect = FloatRect();
else if (!m_findMatchRectsAreValid)
match.m_rect = findInPageRectFromRange(match.m_range.get());
if (match.m_rect.isEmpty())
++deadMatches;
}
// Remove any invalid matches from the cache.
if (deadMatches) {
HeapVector<FindMatch> filteredMatches;
filteredMatches.reserveCapacity(m_findMatchesCache.size() - deadMatches);
for (const FindMatch& match : m_findMatchesCache) {
if (!match.m_rect.isEmpty())
filteredMatches.append(match);
}
m_findMatchesCache.swap(filteredMatches);
}
// Invalidate the rects in child frames. Will be updated later during
// traversal.
if (!m_findMatchRectsAreValid)
for (WebFrame* child = ownerFrame().firstChild(); child;
child = child->nextSibling())
toWebLocalFrameImpl(child)->ensureTextFinder().m_findMatchRectsAreValid =
false;
m_findMatchRectsAreValid = true;
}
static WebFrame* findLargestFrameInFrameSet(WebPage* page)
{
// Approximate what a user could consider a default target frame for application menu operations.
WebFrame* mainFrame = page->mainWebFrame();
if (!mainFrame->isFrameSet())
return 0;
WebFrame* largestSoFar = 0;
RefPtr<ImmutableArray> frameChildren = mainFrame->childFrames();
size_t count = frameChildren->size();
for (size_t i = 0; i < count; ++i) {
WebFrame* childFrame = frameChildren->at<WebFrame>(i);
if (!largestSoFar || area(childFrame) > area(largestSoFar))
largestSoFar = childFrame;
}
return largestSoFar;
}
void WebLoaderStrategy::createPingHandle(NetworkingContext* networkingContext, ResourceRequest& request, bool shouldUseCredentialStorage)
{
// It's possible that call to createPingHandle might be made during initial empty Document creation before a NetworkingContext exists.
// It is not clear that we should send ping loads during that process anyways.
if (!networkingContext)
return;
WebFrameNetworkingContext* webContext = static_cast<WebFrameNetworkingContext*>(networkingContext);
WebFrameLoaderClient* webFrameLoaderClient = webContext->webFrameLoaderClient();
WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
WebPage* webPage = webFrame ? webFrame->page() : nullptr;
NetworkResourceLoadParameters loadParameters;
loadParameters.request = request;
loadParameters.sessionID = webPage ? webPage->sessionID() : SessionID::defaultSessionID();
loadParameters.allowStoredCredentials = shouldUseCredentialStorage ? AllowStoredCredentials : DoNotAllowStoredCredentials;
loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = networkingContext->shouldClearReferrerOnHTTPSToHTTPRedirect();
WebProcess::singleton().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::LoadPing(loadParameters), 0);
}
void WebChromeClient::exceededDatabaseQuota(Frame* frame, const String& databaseName, DatabaseDetails details)
{
WebFrame* webFrame = static_cast<WebFrameLoaderClient*>(frame->loader()->client())->webFrame();
SecurityOrigin* origin = frame->document()->securityOrigin();
DatabaseManager& dbManager = DatabaseManager::manager();
uint64_t currentQuota = dbManager.quotaForOrigin(origin);
uint64_t currentOriginUsage = dbManager.usageForOrigin(origin);
uint64_t newQuota = 0;
RefPtr<WebSecurityOrigin> webSecurityOrigin = WebSecurityOrigin::createFromDatabaseIdentifier(origin->databaseIdentifier());
newQuota = m_page->injectedBundleUIClient().didExceedDatabaseQuota(m_page, webSecurityOrigin.get(), databaseName, details.displayName(), currentQuota, currentOriginUsage, details.currentUsage(), details.expectedUsage());
if (!newQuota) {
WebProcess::shared().connection()->sendSync(
Messages::WebPageProxy::ExceededDatabaseQuota(webFrame->frameID(), origin->databaseIdentifier(), databaseName, details.displayName(), currentQuota, currentOriginUsage, details.currentUsage(), details.expectedUsage()),
Messages::WebPageProxy::ExceededDatabaseQuota::Reply(newQuota), m_page->pageID());
}
dbManager.setQuota(origin, newQuota);
}
//-----------------------------------------------------------------------------
// WebPointerEventHandler::highlitableElement
//-----------------------------------------------------------------------------
TBrCtlDefs::TBrCtlElementType WebPointerEventHandler::highlitableElement()
{
TRect elRect;
TBrCtlDefs::TBrCtlElementType elType = TBrCtlDefs::EElementNone;
Frame* coreFrame = core(m_webview->mainFrame());
WebCursor* cursor = StaticObjectsContainer::instance()->webCursor();
TPointerEvent event;
TPoint pos = cursor->position();
WebFrame* wfrm = cursor->getFrameAtPoint(pos);
Frame* frm = core(wfrm);
TPoint pt(wfrm->frameView()->viewCoordsInFrameCoords(pos));
TPoint nodePoint;
Element* eventNode = frm->document()->elementFromPoint(pos.iX, pos.iY);
m_highlightedNode = NULL;
Node* retNode = 0;
frm->bridge()->getTypeFromElement(eventNode, elType, elRect, retNode);
if (elType == TBrCtlDefs::EElementNone) {
Node* n = wfrm->getClosestAnchorElement(cursor->position(), pos);
if (n) {
wfrm = cursor->getFrameAtPoint(pos);
frm = core(wfrm);
eventNode = frm->document()->elementFromPoint(pos.iX, pos.iY);
frm->bridge()->getTypeFromElement(eventNode, elType, elRect, retNode);
TPoint nodePoint = n->getRect().Rect().Center();
m_offset = (pt.iX- nodePoint.iX)*(pt.iX- nodePoint.iX) +
(pt.iY- nodePoint.iY)*(pt.iY- nodePoint.iY);
}
}
m_highlightedNode = eventNode;
if (m_highlightedNode) {
m_highlightPos = pos;
m_buttonDownEvent.iPosition = m_highlightPos;
}
m_webview->setFocusedElementType(elType);
return elType;
}
bool WebViewHost::navigate(const TestNavigationEntry& entry, bool reload)
{
// Get the right target frame for the entry.
WebFrame* frame = webView()->mainFrame();
if (!entry.targetFrame().isEmpty())
frame = webView()->findFrameByName(entry.targetFrame());
// TODO(mpcomplete): should we clear the target frame, or should
// back/forward navigations maintain the target frame?
// A navigation resulting from loading a javascript URL should not be
// treated as a browser initiated event. Instead, we want it to look as if
// the page initiated any load resulting from JS execution.
if (!GURL(entry.URL()).SchemeIs("javascript"))
setPendingExtraData(adoptPtr(new TestShellExtraData(entry.pageID())));
// If we are reloading, then WebKit will use the state of the current page.
// Otherwise, we give it the state to navigate to.
if (reload) {
frame->reload(false);
} else if (!entry.contentState().isNull()) {
ASSERT(entry.pageID() != -1);
frame->loadHistoryItem(entry.contentState());
} else {
ASSERT(entry.pageID() == -1);
frame->loadRequest(WebURLRequest(entry.URL()));
}
// In case LoadRequest failed before DidCreateDataSource was called.
setPendingExtraData(nullptr);
// Restore focus to the main frame prior to loading new request.
// This makes sure that we don't have a focused iframe. Otherwise, that
// iframe would keep focus when the SetFocus called immediately after
// LoadRequest, thus making some tests fail (see http://b/issue?id=845337
// for more details).
webView()->setFocusedFrame(frame);
m_shell->setFocus(webView(), true);
return true;
}
static string dumpFramesAsText(WebFrame* frame, bool recursive)
{
string result;
// Add header for all but the main frame. Skip empty frames.
if (frame->parent() && !frame->document().documentElement().isNull()) {
result.append("\n--------\nFrame: '");
result.append(frame->name().utf8().data());
result.append("'\n--------\n");
}
result.append(dumpDocumentText(frame));
result.append("\n");
if (recursive) {
for (WebFrame* child = frame->firstChild(); child; child = child->nextSibling())
result.append(dumpFramesAsText(child, recursive));
}
return result;
}
PassRefPtr<Frame> WebFrameLoaderClient::createFrame(const KURL& URL, const String& name, HTMLFrameOwnerElement* ownerElement, const String& referrer)
{
Frame* coreFrame = core(m_webFrame);
ASSERT(coreFrame);
WebFrame* webFrame = WebFrame::createInstance();
RefPtr<Frame> childFrame = webFrame->init(m_webFrame->webView(), coreFrame->page(), ownerElement);
coreFrame->tree()->appendChild(childFrame);
childFrame->tree()->setName(name);
childFrame->init();
loadURLIntoChild(URL, referrer, webFrame);
// The frame's onload handler may have removed it from the document.
if (!childFrame->tree()->parent())
return 0;
return childFrame.release();
}
TEST_F(WebFrameTest, IframeRedirect)
{
registerMockedHttpURLLoad("iframe_redirect.html");
registerMockedHttpURLLoad("visible_iframe.html");
WebView* webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "iframe_redirect.html", true);
webkit_support::RunAllPendingMessages(); // Queue the iframe.
webkit_support::ServeAsynchronousMockedRequests(); // Load the iframe.
WebFrame* iframe = webView->findFrameByName(WebString::fromUTF8("ifr"));
ASSERT_TRUE(iframe);
WebDataSource* iframeDataSource = iframe->dataSource();
ASSERT_TRUE(iframeDataSource);
WebVector<WebURL> redirects;
iframeDataSource->redirectChain(redirects);
ASSERT_EQ(2U, redirects.size());
EXPECT_EQ(toKURL("about:blank"), toKURL(redirects[0].spec().data()));
EXPECT_EQ(toKURL("http://www.test.com/visible_iframe.html"), toKURL(redirects[1].spec().data()));
webView->close();
}
void WebChromeClient::runJavaScriptAlert(Frame* frame, const String& alertText)
{
WebFrame* webFrame = WebFrame::fromCoreFrame(*frame);
ASSERT(webFrame);
// Notify the bundle client.
m_page->injectedBundleUIClient().willRunJavaScriptAlert(m_page, alertText, webFrame);
HangDetectionDisabler hangDetectionDisabler;
WebProcess::singleton().parentProcessConnection()->sendSync(Messages::WebPageProxy::RunJavaScriptAlert(webFrame->frameID(), SecurityOriginData::fromFrame(frame), alertText), Messages::WebPageProxy::RunJavaScriptAlert::Reply(), m_page->pageID(), std::chrono::milliseconds::max(), IPC::SendSyncOption::InformPlatformProcessWillSuspend);
}