void DocumentLoader::mainReceivedError(const ResourceError& error) { ASSERT(!error.isNull()); m_applicationCacheHost->failedLoadingMainResource(); if (!frameLoader()) return; setMainDocumentError(error); clearMainResourceLoader(); frameLoader()->receivedMainResourceError(error); }
void DocumentLoader::mainReceivedError(const ResourceError& error) { ASSERT(!error.isNull()); ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading() || InspectorInstrumentation::isDebuggerPaused(m_frame)); m_applicationCacheHost->failedLoadingMainResource(); if (!frameLoader()) return; setMainDocumentError(error); clearMainResourceLoader(); frameLoader()->receivedMainResourceError(error); clearMainResourceHandle(); }
// Cancels the data source's pending loads. Conceptually, a data source only loads // one document at a time, but one document may have many related resources. // stopLoading will stop all loads initiated by the data source, // but not loads initiated by child frames' data sources -- that's the WebFrame's job. void DocumentLoader::stopLoading(DatabasePolicy databasePolicy) { // In some rare cases, calling FrameLoader::stopLoading could set m_loading to false. // (This can happen when there's a single XMLHttpRequest currently loading and stopLoading causes it // to stop loading. Because of this, we need to save it so we don't return early. bool loading = m_loading; if (m_committed) { // Attempt to stop the frame if the document loader is loading, or if it is done loading but // still parsing. Failure to do so can cause a world leak. Document* doc = m_frame->document(); if (loading || doc->parsing()) m_frame->loader()->stopLoading(UnloadEventPolicyNone, databasePolicy); } // Always cancel multipart loaders cancelAll(m_multipartSubresourceLoaders); // Appcache uses ResourceHandle directly, DocumentLoader doesn't count these loads. #if ENABLE(OFFLINE_WEB_APPLICATIONS) m_applicationCacheHost->stopLoadingInFrame(m_frame); #endif if (!loading) return; RefPtr<Frame> protectFrame(m_frame); RefPtr<DocumentLoader> protectLoader(this); m_isStopping = true; FrameLoader* frameLoader = DocumentLoader::frameLoader(); if (m_mainResourceLoader) // Stop the main resource loader and let it send the cancelled message. m_mainResourceLoader->cancel(); else if (!m_subresourceLoaders.isEmpty()) // The main resource loader already finished loading. Set the cancelled error on the // document and let the subresourceLoaders send individual cancelled messages below. setMainDocumentError(frameLoader->cancelledError(m_request)); else // If there are no resource loaders, we need to manufacture a cancelled message. // (A back/forward navigation has no resource loaders because its resources are cached.) mainReceivedError(frameLoader->cancelledError(m_request), true); stopLoadingSubresources(); stopLoadingPlugIns(); m_isStopping = false; }
void DocumentLoader::mainReceivedError(const ResourceError& error, bool isComplete) { ASSERT(!error.isNull()); #if ENABLE(OFFLINE_WEB_APPLICATIONS) m_applicationCacheHost->failedLoadingMainResource(); #endif if (!frameLoader()) return; setMainDocumentError(error); if (isComplete) frameLoader()->mainReceivedCompleteError(this, error); }
void DocumentLoader::mainReceivedError(const ResourceError& error, bool isComplete) { #if ENABLE(OFFLINE_WEB_APPLICATIONS) ApplicationCacheGroup* group = m_candidateApplicationCacheGroup; if (!group && m_applicationCache && !mainResourceApplicationCache()) group = m_applicationCache->group(); if (group) group->failedLoadingMainResource(this); #endif if (!frameLoader()) return; setMainDocumentError(error); if (isComplete) frameLoader()->mainReceivedCompleteError(this, error); }
void DocumentLoader::mainReceivedError(const ResourceError& error) { ASSERT(!error.isNull()); if (m_identifierForLoadWithoutResourceLoader) { ASSERT(!mainResourceLoader()); frameLoader()->client()->dispatchDidFailLoading(this, m_identifierForLoadWithoutResourceLoader, error); } ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading()); m_applicationCacheHost->failedLoadingMainResource(); if (!frameLoader()) return; setMainDocumentError(error); clearMainResourceLoader(); frameLoader()->receivedMainResourceError(error); clearMainResourceHandle(); }
void DocumentLoader::mainReceivedError(const ResourceError& error, bool isComplete) { ASSERT(!error.isNull()); #if ENABLE(OFFLINE_WEB_APPLICATIONS) ApplicationCacheGroup* group = m_candidateApplicationCacheGroup; if (!group && m_applicationCache) { ASSERT(!mainResourceApplicationCache()); // If the main resource were loaded from a cache, it wouldn't fail. group = m_applicationCache->group(); } if (group) group->failedLoadingMainResource(this); #endif if (!frameLoader()) return; setMainDocumentError(error); if (isComplete) frameLoader()->mainReceivedCompleteError(this, error); }
// Cancels the data source's pending loads. Conceptually, a data source only loads // one document at a time, but one document may have many related resources. // stopLoading will stop all loads initiated by the data source, // but not loads initiated by child frames' data sources -- that's the WebFrame's job. void DocumentLoader::stopLoading() { RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame); RefPtr<DocumentLoader> protectLoader(this); // In some rare cases, calling FrameLoader::stopLoading could cause isLoading() to return false. // (This can happen when there's a single XMLHttpRequest currently loading and stopLoading causes it // to stop loading. Because of this, we need to save it so we don't return early. bool loading = isLoading(); if (m_committed) { // Attempt to stop the frame if the document loader is loading, or if it is done loading but // still parsing. Failure to do so can cause a world leak. Document* doc = m_frame->document(); if (loading || doc->parsing()) m_frame->loader().stopLoading(); } if (!loading) { m_fetcher->stopFetching(); return; } if (m_loadingMainResource) { // Stop the main resource loader and let it send the cancelled message. cancelMainResourceLoad(ResourceError::cancelledError(m_request.url())); } else if (m_fetcher->isFetching()) { // The main resource loader already finished loading. Set the cancelled error on the // document and let the resourceLoaders send individual cancelled messages below. setMainDocumentError(ResourceError::cancelledError(m_request.url())); } else { // If there are no resource loaders, we need to manufacture a cancelled message. // (A back/forward navigation has no resource loaders because its resources are cached.) mainReceivedError(ResourceError::cancelledError(m_request.url())); } m_fetcher->stopFetching(); }
// Cancels the data source's pending loads. Conceptually, a data source only loads // one document at a time, but one document may have many related resources. // stopLoading will stop all loads initiated by the data source, // but not loads initiated by child frames' data sources -- that's the WebFrame's job. void DocumentLoader::stopLoading() { RefPtr<Frame> protectFrame(m_frame); RefPtr<DocumentLoader> protectLoader(this); // In some rare cases, calling FrameLoader::stopLoading could cause isLoading() to return false. // (This can happen when there's a single XMLHttpRequest currently loading and stopLoading causes it // to stop loading. Because of this, we need to save it so we don't return early. bool loading = isLoading(); if (m_committed) { // Attempt to stop the frame if the document loader is loading, or if it is done loading but // still parsing. Failure to do so can cause a world leak. Document* doc = m_frame->document(); if (loading || doc->parsing()) m_frame->loader()->stopLoading(UnloadEventPolicyNone); } // Always cancel multipart loaders cancelAll(m_multipartSubresourceLoaders); // Appcache uses ResourceHandle directly, DocumentLoader doesn't count these loads. m_applicationCacheHost->stopLoadingInFrame(m_frame); #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML) clearArchiveResources(); #endif if (!loading) { // If something above restarted loading we might run into mysterious crashes like // https://bugs.webkit.org/show_bug.cgi?id=62764 and <rdar://problem/9328684> ASSERT(!isLoading()); return; } // We might run in to infinite recursion if we're stopping loading as the result of // detaching from the frame, so break out of that recursion here. // See <rdar://problem/9673866> for more details. if (m_isStopping) return; m_isStopping = true; FrameLoader* frameLoader = DocumentLoader::frameLoader(); if (m_mainResourceLoader) // Stop the main resource loader and let it send the cancelled message. m_mainResourceLoader->cancel(); else if (!m_subresourceLoaders.isEmpty()) // The main resource loader already finished loading. Set the cancelled error on the // document and let the subresourceLoaders send individual cancelled messages below. setMainDocumentError(frameLoader->cancelledError(m_request)); else // If there are no resource loaders, we need to manufacture a cancelled message. // (A back/forward navigation has no resource loaders because its resources are cached.) mainReceivedError(frameLoader->cancelledError(m_request)); stopLoadingSubresources(); stopLoadingPlugIns(); m_isStopping = false; }