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()); }