Simplify parsing/loading state, attempt #2

third_party/WebKit/Source/core/loader/DocumentLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 110 matching lines @@
     return &m_frame->loader();
 }
 
 ResourceLoader* DocumentLoader::mainResourceLoader() const
 {
     return m_mainResource ? m_mainResource->loader() : nullptr;
 }
 
 DocumentLoader::~DocumentLoader()
 {
-    ASSERT(!m_frame || !isLoading());
+    ASSERT(!m_frame);
     ASSERT(!m_mainResource);
     ASSERT(!m_applicationCacheHost);
 }
 
 DEFINE_TRACE(DocumentLoader)
 {
     visitor->trace(m_frame);
     visitor->trace(m_fetcher);
     visitor->trace(m_mainResource);
     visitor->trace(m_writer);
     visitor->trace(m_documentLoadTiming);
     visitor->trace(m_applicationCacheHost);
     visitor->trace(m_contentSecurityPolicy);
 }
 
 unsigned long DocumentLoader::mainResourceIdentifier() const
 {
     return m_mainResource ? m_mainResource->identifier() : 0;
 }
 
-Document* DocumentLoader::document() const
-{
-    if (m_frame && m_frame->loader().documentLoader() == this)
-        return m_frame->document();
-    return nullptr;
-}
-
 const ResourceRequest& DocumentLoader::originalRequest() const
 {
     return m_originalRequest;
 }
 
 const ResourceRequest& DocumentLoader::request() const
 {
     return m_request;
 }
 
@@ skipping 61 matching lines @@
     if (m_isClientRedirect)
         appendRedirect(oldURL);
     appendRedirect(newURL);
 }
 
 const KURL& DocumentLoader::urlForHistory() const
 {
     return unreachableURL().isEmpty() ? url() : unreachableURL();
 }
 
-void DocumentLoader::mainReceivedError(const ResourceError& error)
-{
-    ASSERT(!error.isNull());
-    ASSERT(!m_frame || !m_frame->page()->defersLoading() || InspectorInstrumentation::isDebuggerPaused(m_frame));
-    if (m_applicationCacheHost)
-        m_applicationCacheHost->failedLoadingMainResource();
-    if (!frameLoader())
-        return;
-    m_state = MainResourceDone;
-    frameLoader()->receivedMainResourceError(this, 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()
-{
-    RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame.get());
-    RefPtrWillBeRawPtr<DocumentLoader> protectLoader(this);
-
-    if (isLoading())
-        cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
-    m_fetcher->stopFetching();
-}
-
 void DocumentLoader::commitIfReady()
 {
     if (m_state < Committed) {
         m_state = Committed;
         frameLoader()->commitProvisionalLoad();
     }
 }
 
-bool DocumentLoader::isLoading() const
-{
-    if (document() && document()->hasActiveParser())
-        return true;
-
-    return (m_state > NotStarted && m_state < MainResourceDone) || m_fetcher->isFetching();
-}
-
 void DocumentLoader::notifyFinished(Resource* resource)
 {
     ASSERT_UNUSED(resource, m_mainResource == resource);
     ASSERT(m_mainResource);
 
     RefPtrWillBeRawPtr<DocumentLoader> protect(this);
 
     if (!m_mainResource->errorOccurred() && !m_mainResource->wasCanceled()) {
         finishedLoading(m_mainResource->loadFinishTime());
         return;
     }
 
-    mainReceivedError(m_mainResource->resourceError());
+    if (m_applicationCacheHost)
+        m_applicationCacheHost->failedLoadingMainResource();
+    m_state = MainResourceDone;
+    frameLoader()->loadFailed(this, m_mainResource->resourceError());
+    clearMainResourceHandle();
 }
 
 void DocumentLoader::finishedLoading(double finishTime)
 {
     ASSERT(!m_frame->page()->defersLoading() || InspectorInstrumentation::isDebuggerPaused(m_frame));
 
     RefPtrWillBeRawPtr<DocumentLoader> protect(this);
 
     double responseEndTime = finishTime;
     if (!responseEndTime)
@@ skipping 28 matching lines @@
     ASSERT_UNUSED(resource, resource == m_mainResource);
     ASSERT(!redirectResponse.isNull());
     m_request = request;
 
     // If the redirecting url is not allowed to display content from the target origin,
     // then block the redirect.
     const KURL& requestURL = m_request.url();
     RefPtr<SecurityOrigin> redirectingOrigin = SecurityOrigin::create(redirectResponse.url());
     if (!redirectingOrigin->canDisplay(requestURL)) {
         FrameLoader::reportLocalLoadFailed(m_frame, requestURL.getString());
-        cancelMainResourceLoad(ResourceError::cancelledError(requestURL));
+        m_fetcher->stopFetching();
         return;
     }
     if (!frameLoader()->shouldContinueForNavigationPolicy(m_request, SubstituteData(), this, CheckContentSecurityPolicy, m_navigationType, NavigationPolicyCurrentTab, replacesCurrentHistoryItem(), isClientRedirect())) {
-        cancelMainResourceLoad(ResourceError::cancelledError(requestURL));
+        m_fetcher->stopFetching();
         return;
     }
 
     ASSERT(timing().fetchStart());
     timing().addRedirect(redirectResponse.url(), requestURL);
     appendRedirect(requestURL);
     frameLoader()->receivedMainResourceRedirect(requestURL);
 }
 
 static bool canShowMIMEType(const String& mimeType, Page* page)
@@ skipping 83 matching lines @@
 
     ASSERT(!m_frame->page()->defersLoading());
 
     m_response = response;
 
     if (isArchiveMIMEType(m_response.mimeType()) && m_mainResource->getDataBufferingPolicy() != BufferData)
         m_mainResource->setDataBufferingPolicy(BufferData);
 
     if (!shouldContinueForResponse()) {
         InspectorInstrumentation::continueWithPolicyIgnore(m_frame, this, m_mainResource->identifier(), m_response);
-        cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
+        m_fetcher->stopFetching();
         return;
     }
 
     if (m_response.isHTTP()) {
         int status = m_response.httpStatusCode();
         if ((status < 200 || status >= 300) && m_frame->owner())
             m_frame->owner()->renderFallbackContent();
     }
 }
 
@@ skipping 37 matching lines @@
     m_frame->document()->maybeHandleHttpRefresh(m_response.httpHeaderField(HTTPNames::Refresh), Document::HttpRefreshFromHeader);
 }
 
 void DocumentLoader::commitData(const char* bytes, size_t length)
 {
     ASSERT(m_state < MainResourceDone);
     ensureWriter(m_response.mimeType());
 
     // This can happen if document.close() is called by an event handler while
     // there's still pending incoming data.
-    if (m_frame && !m_frame->document()->parsing()) {
-        cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
+    if (m_frame && !m_frame->document()->parsing())
         return;
-    }
 
     if (length)
         m_state = DataReceived;
 
     m_writer->addData(bytes, length);
 }
 
 void DocumentLoader::dataReceived(Resource* resource, const char* data, size_t length)
 {
     ASSERT(data);
@@ skipping 43 matching lines @@
     if (isArchiveMIMEType(response().mimeType()))
         return;
     commitIfReady();
     if (!frameLoader())
         return;
     commitData(data, length);
 
     // If we are sending data to MediaDocument, we should stop here
     // and cancel the request.
     if (m_frame && m_frame->document()->isMediaDocument())
-        cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
+        m_fetcher->stopFetching();
 }
 
 void DocumentLoader::clearRedirectChain()
 {
     m_redirectChain.clear();
 }
 
 void DocumentLoader::appendRedirect(const KURL& url)
 {
     m_redirectChain.append(url);
 }
 
 void DocumentLoader::detachFromFrame()
 {
     ASSERT(m_frame);
     RefPtrWillBeRawPtr<LocalFrame> protectFrame(m_frame.get());
     RefPtrWillBeRawPtr<DocumentLoader> protectLoader(this);
 
     // It never makes sense to have a document loader that is detached from its
     // frame have any loads active, so go ahead and kill all the loads.
-    stopLoading();
+    m_fetcher->stopFetching();
 
     // If that load cancellation triggered another detach, leave.
     // (fast/frames/detach-frame-nested-no-crash.html is an example of this.)
     if (!m_frame)
         return;
 
     m_fetcher->clearContext();
-
     m_applicationCacheHost->detachFromDocumentLoader();
     m_applicationCacheHost.clear();
     WeakIdentifierMap<DocumentLoader>::notifyObjectDestroyed(this);
     clearMainResourceHandle();
     m_frame = nullptr;
 }
 
 void DocumentLoader::clearMainResourceHandle()
 {
     if (!m_mainResource)
@@ skipping 10 matching lines @@
 
     ASSERT(m_mainResource);
     ArchiveResource* mainResource = m_fetcher->createArchive(m_mainResource.get());
     if (!mainResource)
         return false;
     // The origin is the MHTML file, we need to set the base URL to the document encoded in the MHTML so
     // relative URLs are resolved properly.
     ensureWriter(mainResource->mimeType(), mainResource->url());
 
     // The Document has now been created.
-    document()->enforceSandboxFlags(SandboxAll);
+    m_frame->document()->enforceSandboxFlags(SandboxAll);
 
     commitData(mainResource->data()->data(), mainResource->data()->size());
     return true;
 }
 
 const AtomicString& DocumentLoader::responseMIMEType() const
 {
     return m_response.mimeType();
 }
 
@@ skipping 50 matching lines @@
     // A bunch of headers are set when the underlying ResourceLoader is created, and m_request needs to include those.
     // Even when using a cached resource, we may make some modification to the request, e.g. adding the referer header.
     m_request = mainResourceLoader() ? m_mainResource->resourceRequest() : fetchRequest.resourceRequest();
     // If there was a fragment identifier on m_request, the cache will have stripped it. m_request should include
     // the fragment identifier, so add that back in.
     if (equalIgnoringFragmentIdentifier(m_request.url(), fetchRequest.url()))
         m_request.setURL(fetchRequest.url());
     m_mainResource->addClient(this);
 }
 
-void DocumentLoader::cancelMainResourceLoad(const ResourceError& resourceError)
-{
-    RefPtrWillBeRawPtr<DocumentLoader> protect(this);
-    ResourceError error = resourceError.isNull() ? ResourceError::cancelledError(m_request.url()) : resourceError;
-
-    if (mainResourceLoader())
-        mainResourceLoader()->cancel(error);
-
-    mainReceivedError(error);
-}
-
 void DocumentLoader::endWriting(DocumentWriter* writer)
 {
     ASSERT_UNUSED(writer, m_writer == writer);
     m_writer->end();
     m_writer.clear();
 }
 
 PassRefPtrWillBeRawPtr<DocumentWriter> DocumentLoader::createWriterFor(const DocumentInit& init, const AtomicString& mimeType, const AtomicString& encoding, bool dispatch, ParserSynchronizationPolicy parsingPolicy)
 {
     LocalFrame* frame = init.frame();
@@ skipping 23 matching lines @@
 {
     m_writer = createWriterFor(init, mimeType(), m_writer ? m_writer->encoding() : emptyAtom, true, ForceSynchronousParsing);
     if (!source.isNull())
         m_writer->appendReplacingData(source);
     endWriting(m_writer.get());
 }
 
 DEFINE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 } // namespace blink