NavigationPolicy FrameLoaderClientImpl::decidePolicyForNavigation(const ResourceRequest& request, DocumentLoader* loader, NavigationType type, NavigationPolicy policy, bool replacesCurrentHistoryItem)
{
if (!m_webFrame->client())
return NavigationPolicyIgnore;
if (policy == NavigationPolicyNewBackgroundTab && !allowCreatingBackgroundTabs() && !UIEventWithKeyState::newTabModifierSetFromIsolatedWorld())
policy = NavigationPolicyNewForegroundTab;
WebDataSourceImpl* ds = WebDataSourceImpl::fromDocumentLoader(loader);
// Newly created child frames may need to be navigated to a history item
// during a back/forward navigation. This will only happen when the parent
// is a LocalFrame doing a back/forward navigation that has not completed.
// (If the load has completed and the parent later adds a frame with script,
// we do not want to use a history item for it.)
bool isHistoryNavigationInNewChildFrame = m_webFrame->parent()
&& m_webFrame->parent()->isWebLocalFrame()
&& isBackForwardLoadType(toWebLocalFrameImpl(m_webFrame->parent())->frame()->loader().loadType())
&& !toWebLocalFrameImpl(m_webFrame->parent())->frame()->document()->loadEventFinished();
WrappedResourceRequest wrappedResourceRequest(request);
WebFrameClient::NavigationPolicyInfo navigationInfo(wrappedResourceRequest);
navigationInfo.navigationType = static_cast<WebNavigationType>(type);
navigationInfo.defaultPolicy = static_cast<WebNavigationPolicy>(policy);
navigationInfo.extraData = ds ? ds->extraData() : nullptr;
navigationInfo.replacesCurrentHistoryItem = replacesCurrentHistoryItem;
navigationInfo.isHistoryNavigationInNewChildFrame = isHistoryNavigationInNewChildFrame;
WebNavigationPolicy webPolicy = m_webFrame->client()->decidePolicyForNavigation(navigationInfo);
return static_cast<NavigationPolicy>(webPolicy);
}
WebDOMFileSystem WebDOMFileSystem::create(
WebLocalFrame* frame,
WebFileSystemType type,
const WebString& name,
const WebURL& rootURL,
SerializableType serializableType)
{
DCHECK(frame);
DCHECK(toWebLocalFrameImpl(frame)->frame());
DOMFileSystem* domFileSystem = DOMFileSystem::create(toWebLocalFrameImpl(frame)->frame()->document(), name, static_cast<FileSystemType>(type), rootURL);
if (serializableType == SerializableTypeSerializable)
domFileSystem->makeClonable();
return WebDOMFileSystem(domFileSystem);
}
WebDevToolsFrontend* WebDevToolsFrontend::create(
WebLocalFrame* frame,
WebDevToolsFrontendClient* client,
const WebString& applicationLocale)
{
return new WebDevToolsFrontendImpl(toWebLocalFrameImpl(frame), client);
}
WebHelperPlugin* WebHelperPlugin::create(const WebString& pluginType, WebLocalFrame* frame)
{
OwnPtr<WebHelperPlugin> plugin = adoptPtr<WebHelperPlugin>(new WebHelperPluginImpl());
if (!toWebHelperPluginImpl(plugin.get())->initialize(pluginType, toWebLocalFrameImpl(frame)))
return 0;
return plugin.leakPtr();
}
WebDevToolsFrontend* WebDevToolsFrontend::create(
WebView* view,
WebDevToolsFrontendClient* client,
const WebString& applicationLocale)
{
return new WebDevToolsFrontendImpl(toWebLocalFrameImpl(view->mainFrame()), client);
}
void FrameLoaderClientImpl::dispatchDidClearWindowObjectInMainWorld() {
if (m_webFrame->client()) {
m_webFrame->client()->didClearWindowObject(m_webFrame);
Document* document = m_webFrame->frame()->document();
if (document) {
DeviceMotionController::from(*document);
DeviceOrientationController::from(*document);
DeviceOrientationAbsoluteController::from(*document);
if (RuntimeEnabledFeatures::deviceLightEnabled())
DeviceLightController::from(*document);
NavigatorGamepad::from(*document);
NavigatorServiceWorker::from(*document);
DOMWindowStorageController::from(*document);
if (RuntimeEnabledFeatures::webVREnabled() ||
OriginTrials::webVREnabled(document->getExecutionContext()))
NavigatorVR::from(*document);
}
}
// FIXME: when extensions go out of process, this whole concept stops working.
WebDevToolsFrontendImpl* devToolsFrontend =
m_webFrame->top()->isWebLocalFrame()
? toWebLocalFrameImpl(m_webFrame->top())->devToolsFrontend()
: nullptr;
if (devToolsFrontend)
devToolsFrontend->didClearWindowObject(m_webFrame);
}
void WebSharedWorkerImpl::initializeLoader() {
// Create 'shadow page'. This page is never displayed, it is used to proxy the
// loading requests from the worker context to the rest of WebKit and Chromium
// infrastructure.
DCHECK(!m_webView);
m_webView = WebView::create(nullptr, WebPageVisibilityStateVisible);
// FIXME: http://crbug.com/363843. This needs to find a better way to
// not create graphics layers.
m_webView->settings()->setAcceleratedCompositingEnabled(false);
// FIXME: Settings information should be passed to the Worker process from
// Browser process when the worker is created (similar to
// RenderThread::OnCreateNewView).
m_mainFrame = toWebLocalFrameImpl(
WebLocalFrame::create(WebTreeScopeType::Document, this));
m_webView->setMainFrame(m_mainFrame.get());
m_mainFrame->setDevToolsAgentClient(this);
// If we were asked to pause worker context on start and wait for debugger
// then it is the good time to do that.
m_client->workerReadyForInspection();
if (m_pauseWorkerContextOnStart) {
m_isPausedOnStart = true;
return;
}
loadShadowPage();
}
void ChromeClientImpl::setScrollbarsVisible(bool value)
{
m_windowFeatures.scrollbarsVisible = value;
WebLocalFrameImpl* webFrame = toWebLocalFrameImpl(m_webView->mainFrame());
if (webFrame)
webFrame->setCanHaveScrollbars(value);
}
WebHelperPlugin* WebHelperPlugin::create(const WebString& pluginType, WebLocalFrame* frame)
{
WebHelperPluginUniquePtr plugin(new WebHelperPluginImpl());
if (!toWebHelperPluginImpl(plugin.get())->initialize(pluginType, toWebLocalFrameImpl(frame)))
return 0;
return plugin.release();
}
WebPageSerializerImpl::WebPageSerializerImpl(WebFrame* frame,
bool recursiveSerialization,
WebPageSerializerClient* client,
const WebVector<WebURL>& links,
const WebVector<WebString>& localPaths,
const WebString& localDirectoryName)
: m_client(client)
, m_recursiveSerialization(recursiveSerialization)
, m_framesCollected(false)
, m_localDirectoryName(localDirectoryName)
, m_htmlEntities(false)
, m_xmlEntities(true)
{
// Must specify available webframe.
ASSERT(frame);
m_specifiedWebLocalFrameImpl = toWebLocalFrameImpl(frame);
// Make sure we have non 0 client.
ASSERT(client);
// Build local resources map.
ASSERT(links.size() == localPaths.size());
for (size_t i = 0; i < links.size(); i++) {
KURL url = links[i];
ASSERT(!m_localLinks.contains(url.string()));
m_localLinks.set(url.string(), localPaths[i]);
}
ASSERT(m_dataBuffer.isEmpty());
}
WebString WebFrameContentDumper::dumpFrameTreeAsText(WebLocalFrame* frame, size_t maxChars)
{
if (!frame)
return WebString();
StringBuilder text;
frameContentAsPlainText(maxChars, toWebLocalFrameImpl(frame)->frame(), text);
return text.toString();
}
void TextFinder::findMatchRects(WebVector<WebFloatRect>& outputRects)
{
Vector<WebFloatRect> matchRects;
for (WebLocalFrameImpl* frame = &m_ownerFrame; frame; frame = toWebLocalFrameImpl(frame->traverseNext(false)))
frame->ensureTextFinder().appendFindMatchRects(matchRects);
outputRects = matchRects;
}
void WebRemoteFrameImpl::initializeFromFrame(WebLocalFrame* source) const
{
ASSERT(source);
WebLocalFrameImpl* localFrameImpl = toWebLocalFrameImpl(source);
client()->initializeChildFrame(
localFrameImpl->frame()->view()->frameRect(),
localFrameImpl->frame()->view()->visibleContentScaleFactor());
}
void WebRemoteFrameImpl::initializeFromFrame(WebLocalFrame* source) const
{
DCHECK(source);
WebLocalFrameImpl* localFrameImpl = toWebLocalFrameImpl(source);
client()->initializeChildFrame(
localFrameImpl->frame()->view()->frameRect(),
localFrameImpl->frame()->page()->deviceScaleFactor());
}
void WebRemoteFrameImpl::didStopLoading()
{
frame()->setIsLoading(false);
if (parent() && parent()->isWebLocalFrame()) {
WebLocalFrameImpl* parentFrame =
toWebLocalFrameImpl(parent()->toWebLocalFrame());
parentFrame->frame()->loader().checkCompleted();
}
}
ALWAYS_INLINE bool WebFrame::isFrameAlive(const WebFrame* frame) {
if (!frame)
return true;
if (frame->isWebLocalFrame())
return ThreadHeap::isHeapObjectAlive(toWebLocalFrameImpl(frame));
return ThreadHeap::isHeapObjectAlive(toWebRemoteFrameImpl(frame));
}
WebSharedWorkerImpl::~WebSharedWorkerImpl()
{
ASSERT(m_webView);
// Detach the client before closing the view to avoid getting called back.
toWebLocalFrameImpl(m_mainFrame)->setClient(0);
m_webView->close();
m_mainFrame->close();
}
// static
WebRange WebRange::fromDocumentRange(WebLocalFrame* frame, int start, int length)
{
LocalFrame* webFrame = toWebLocalFrameImpl(frame)->frame();
Element* selectionRoot = webFrame->selection().rootEditableElement();
ContainerNode* scope = selectionRoot ? selectionRoot : webFrame->document()->documentElement();
const EphemeralRange range = PlainTextRange(start, start + length).createRange(*scope);
if (range.isNull())
return WebRange();
return Range::create(range.document(), range.startPosition(), range.endPosition());
}
void WebSharedWorkerImpl::loadShadowPage()
{
WebLocalFrameImpl* webFrame = toWebLocalFrameImpl(m_webView->mainFrame());
// Construct substitute data source for the 'shadow page'. We only need it
// to have same origin as the worker so the loading checks work correctly.
CString content("");
RefPtr<SharedBuffer> buffer(SharedBuffer::create(content.data(), content.length()));
webFrame->frame()->loader().load(FrameLoadRequest(0, ResourceRequest(m_url), SubstituteData(buffer, "text/html", "UTF-8", KURL())));
}
ALWAYS_INLINE void WebFrame::traceFrameImpl(VisitorDispatcher visitor,
WebFrame* frame) {
if (!frame)
return;
if (frame->isWebLocalFrame())
visitor->trace(toWebLocalFrameImpl(frame));
else
visitor->trace(toWebRemoteFrameImpl(frame));
}
WebData WebFrameSerializer::generateMHTMLHeader(
const WebString& boundary, WebLocalFrame* frame)
{
Document* document = toWebLocalFrameImpl(frame)->frame()->document();
RefPtr<SharedBuffer> buffer = SharedBuffer::create();
MHTMLArchive::generateMHTMLHeader(
boundary, document->title(), document->suggestedMIMEType(),
*buffer);
return buffer.release();
}
void WebDOMMessageEvent::initMessageEvent(const WebString& type, bool canBubble, bool cancelable, const WebSerializedScriptValue& messageData, const WebString& origin, const WebFrame* sourceFrame, const WebString& lastEventId, const WebMessagePortChannelArray& webChannels)
{
ASSERT(m_private.get());
ASSERT(isMessageEvent());
LocalDOMWindow* window = 0;
if (sourceFrame)
window = toWebLocalFrameImpl(sourceFrame)->frame()->domWindow();
OwnPtr<MessagePortArray> ports;
if (sourceFrame)
ports = MessagePort::toMessagePortArray(window->document(), webChannels);
unwrap<MessageEvent>()->initMessageEvent(type, canBubble, cancelable, messageData, origin, lastEventId, window, ports.release());
}
void WebSharedWorkerImpl::didFinishDocumentLoad(WebLocalFrame* frame)
{
ASSERT(!m_loadingDocument);
ASSERT(!m_mainScriptLoader);
m_mainScriptLoader = Loader::create();
m_loadingDocument = toWebLocalFrameImpl(frame)->frame()->document();
m_mainScriptLoader->load(
m_loadingDocument.get(),
m_url,
bind(&WebSharedWorkerImpl::didReceiveScriptLoaderResponse, this),
bind(&WebSharedWorkerImpl::onScriptLoaderFinished, this));
}
void WebSharedWorkerImpl::didFinishDocumentLoad(WebLocalFrame* frame)
{
ASSERT(!m_loadingDocument);
ASSERT(!m_mainScriptLoader);
m_networkProvider = adoptPtr(client()->createServiceWorkerNetworkProvider(frame->dataSource()));
m_mainScriptLoader = Loader::create();
m_loadingDocument = toWebLocalFrameImpl(frame)->frame()->document();
m_mainScriptLoader->load(
m_loadingDocument.get(),
m_url,
bind(&WebSharedWorkerImpl::didReceiveScriptLoaderResponse, this),
bind(&WebSharedWorkerImpl::onScriptLoaderFinished, this));
}
int TextFinder::ordinalOfFirstMatchForFrame(WebLocalFrameImpl* frame) const
{
int ordinal = 0;
WebLocalFrameImpl* mainFrameImpl = m_ownerFrame.viewImpl()->mainFrameImpl();
// Iterate from the main frame up to (but not including) |frame| and
// add up the number of matches found so far.
for (WebLocalFrameImpl* it = mainFrameImpl; it != frame; it = toWebLocalFrameImpl(it->traverseNext(true))) {
TextFinder& finder = it->ensureTextFinder();
if (finder.m_lastMatchCount > 0)
ordinal += finder.m_lastMatchCount;
}
return ordinal;
}
void WebSurroundingText::initializeFromCurrentSelection(WebLocalFrame* frame,
size_t maxLength) {
LocalFrame* webFrame = toWebLocalFrameImpl(frame)->frame();
// TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
// needs to be audited. See http://crbug.com/590369 for more details.
webFrame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
if (Range* range = createRange(
webFrame->selection().selection().toNormalizedEphemeralRange())) {
// TODO(xiaochengh): The followinng SurroundingText can hold a null Range,
// in which case we should prevent it from being stored in |m_private|.
m_private.reset(new SurroundingText(*range, maxLength));
}
}
WebLocalFrame* WebRemoteFrameImpl::createLocalChild(WebTreeScopeType scope, const WebString& name, WebSandboxFlags sandboxFlags, WebFrameClient* client, WebFrame* previousSibling, const WebFrameOwnerProperties& frameOwnerProperties)
{
WebLocalFrameImpl* child = toWebLocalFrameImpl(WebLocalFrame::create(scope, client));
WillBeHeapHashMap<WebFrame*, OwnPtrWillBeMember<FrameOwner>>::AddResult result =
m_ownersForChildren.add(child, RemoteBridgeFrameOwner::create(child, static_cast<SandboxFlags>(sandboxFlags), frameOwnerProperties));
insertAfter(child, previousSibling);
// FIXME: currently this calls LocalFrame::init() on the created LocalFrame, which may
// result in the browser observing two navigations to about:blank (one from the initial
// frame creation, and one from swapping it into the remote process). FrameLoader might
// need a special initialization function for this case to avoid that duplicate navigation.
child->initializeCoreFrame(frame()->host(), result.storedValue->value.get(), name, nullAtom);
// Partially related with the above FIXME--the init() call may trigger JS dispatch. However,
// if the parent is remote, it should never be detached synchronously...
ASSERT(child->frame());
return child;
}
WebString WebFrameContentDumper::dumpLayoutTreeAsText(WebLocalFrame* frame, LayoutAsTextControls toShow)
{
if (!frame)
return WebString();
LayoutAsTextBehavior behavior = LayoutAsTextShowAllLayers;
if (toShow & LayoutAsTextWithLineTrees)
behavior |= LayoutAsTextShowLineTrees;
if (toShow & LayoutAsTextDebug)
behavior |= LayoutAsTextShowCompositedLayers | LayoutAsTextShowAddresses | LayoutAsTextShowIDAndClass | LayoutAsTextShowLayerNesting;
if (toShow & LayoutAsTextPrinting)
behavior |= LayoutAsTextPrintingMode;
return externalRepresentation(toWebLocalFrameImpl(frame)->frame(), behavior);
}
void WebSharedWorkerImpl::didFinishDocumentLoad(WebLocalFrame* frame, bool)
{
ASSERT(!m_loadingDocument);
ASSERT(!m_mainScriptLoader);
m_networkProvider = adoptPtr(m_client->createServiceWorkerNetworkProvider(frame->dataSource()));
m_mainScriptLoader = WorkerScriptLoader::create();
m_mainScriptLoader->setRequestContext(WebURLRequest::RequestContextSharedWorker);
m_loadingDocument = toWebLocalFrameImpl(frame)->frame()->document();
m_mainScriptLoader->loadAsynchronously(
*m_loadingDocument.get(),
m_url,
DenyCrossOriginRequests,
bind(&WebSharedWorkerImpl::didReceiveScriptLoaderResponse, this),
bind(&WebSharedWorkerImpl::onScriptLoaderFinished, this));
// Do nothing here since onScriptLoaderFinished() might have been already
// invoked and |this| might have been deleted at this point.
}
WebFrameSerializerImpl::WebFrameSerializerImpl(
WebLocalFrame* frame,
WebFrameSerializerClient* client,
WebFrameSerializer::LinkRewritingDelegate* delegate)
: m_client(client)
, m_delegate(delegate)
, m_htmlEntities(false)
, m_xmlEntities(true)
{
// Must specify available webframe.
DCHECK(frame);
m_specifiedWebLocalFrameImpl = toWebLocalFrameImpl(frame);
// Make sure we have non null client and delegate.
DCHECK(client);
DCHECK(delegate);
DCHECK(m_dataBuffer.isEmpty());
}
