[Oilpan] [Reland] Migrate classes under core/fetch to Oilpan heap

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 201 matching lines @@
 
 // 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);
 
-    m_fetcher->stopFetching();
+    if (m_fetcher)
+        m_fetcher->stopFetching();
     if (isLoading())
         cancelMainResourceLoad(ResourceError::cancelledError(m_request.url()));
 }
 
 void DocumentLoader::commitIfReady()
 {
     if (!m_committed) {
         m_committed = true;
         frameLoader()->commitProvisionalLoad();
     }
 }
 
 bool DocumentLoader::isLoading() const
 {
     if (document() && document()->hasActiveParser())
         return true;
 
-    return m_loadingMainResource || m_fetcher->isFetching();
+    return m_loadingMainResource || (m_fetcher && 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()) {
@@ skipping 343 matching lines @@
 
     // 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();
 
     // 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();
+    if (m_fetcher)
+        m_fetcher->clearContext();
+    m_fetcher.clear();
+
     m_applicationCacheHost->detachFromDocumentLoader();
     m_applicationCacheHost.clear();
     WeakIdentifierMap<DocumentLoader>::notifyObjectDestroyed(this);
     clearMainResourceHandle();
     m_frame = nullptr;
 }
 
 void DocumentLoader::clearMainResourceLoader()
 {
     m_loadingMainResource = false;
@@ skipping 18 matching lines @@
         return false;
 
     ASSERT(m_mainResource);
     m_archive = MHTMLArchive::create(m_response.url(), m_mainResource->resourceBuffer());
     // Invalid MHTML.
     if (!m_archive || !m_archive->mainResource()) {
         m_archive.clear();
         return false;
     }
 
-    m_fetcher->addAllArchiveResources(m_archive.get());
+    if (m_fetcher)

[sof, 2015/06/26 07:21:45]

Trying to understand; could you explain why the m_fetcher accesses are null
checked now?

[peria, 2015/06/26 07:31:43]

No theoretical backgroud. :(
I'm just looking if there can be other reasons to fail tests.

Because we introduced m_fetcher.clear() in detach(), some tests failed with
accessing nullptr'ed m_fetcher.

[sof, 2015/06/29 13:29:29]

I can't see much going wrong when I revert those changes locally. I think we do
need the one in Document::finishedParsing(), but that might be it?

fast/files/workers/worker-read-blob-async.html is failing though; but that's
also failing with the last trybot runs here.

[sof, 2015/06/29 15:00:47]

Having looked at that test failure some, I'm wondering if the extra clearing of
ResourceFetchers added here needs to be reconsidered. i.e., a detached Document
ends up being used by a Worker to initiate a load -- finding no ResourceFetcher
when doing so.

[peria, 2015/06/30 07:14:39]

Yes, we need this check in Document::finishedParsing().  It fixes a failure of
CrazyExtensionTest.Crazy.
I'm not sure if it is needed in other area, though.

+        m_fetcher->addAllArchiveResources(m_archive.get());
     ArchiveResource* mainResource = m_archive->mainResource();
 
     // 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(), m_archive->mainResource()->url());
 
     // The Document has now been created.
     document()->enforceSandboxFlags(SandboxAll);
 
     commitData(mainResource->data()->data(), mainResource->data()->size());
     return true;
 }
 
 void DocumentLoader::prepareSubframeArchiveLoadIfNeeded()
 {
     if (!m_frame->tree().parent() || !m_frame->tree().parent()->isLocalFrame())
         return;
 
     ArchiveResourceCollection* parentCollection = toLocalFrame(m_frame->tree().parent())->loader().documentLoader()->fetcher()->archiveResourceCollection();
     if (!parentCollection)
         return;
 
     m_archive = parentCollection->popSubframeArchive(m_frame->tree().uniqueName(), m_request.url());
 
     if (!m_archive)
         return;
-    m_fetcher->addAllArchiveResources(m_archive.get());
+    if (m_fetcher)
+        m_fetcher->addAllArchiveResources(m_archive.get());
 
     ArchiveResource* mainResource = m_archive->mainResource();
     m_substituteData = SubstituteData(mainResource->data(), mainResource->mimeType(), mainResource->textEncoding(), KURL());
 }
 
 const AtomicString& DocumentLoader::responseMIMEType() const
 {
     return m_response.mimeType();
 }
 
 const KURL& DocumentLoader::unreachableURL() const
 {
     return m_substituteData.failingURL();
 }
 
 void DocumentLoader::setDefersLoading(bool defers)
 {
     // Multiple frames may be loading the same main resource simultaneously. If deferral state changes,
     // each frame's DocumentLoader will try to send a setDefersLoading() to the same underlying ResourceLoader. Ensure only
     // the "owning" DocumentLoader does so, as setDefersLoading() is not resilient to setting the same value repeatedly.
     if (mainResourceLoader() && mainResourceLoader()->isLoadedBy(m_fetcher.get()))
         mainResourceLoader()->setDefersLoading(defers);
 
-    m_fetcher->setDefersLoading(defers);
+    if (m_fetcher)
+        m_fetcher->setDefersLoading(defers);
 }
 
 bool DocumentLoader::maybeLoadEmpty()
 {
     bool shouldLoadEmpty = !m_substituteData.isValid() && (m_request.url().isEmpty() || SchemeRegistry::shouldLoadURLSchemeAsEmptyDocument(m_request.url().protocol()));
     if (!shouldLoadEmpty)
         return false;
 
     if (m_request.url().isEmpty() && !frameLoader()->stateMachine()->creatingInitialEmptyDocument())
         m_request.setURL(blankURL());
@@ skipping 66 matching lines @@
 }
 
 void DocumentLoader::attachThreadedDataReceiver(PassRefPtrWillBeRawPtr<ThreadedDataReceiver> threadedDataReceiver)
 {
     if (mainResourceLoader())
         mainResourceLoader()->attachThreadedDataReceiver(threadedDataReceiver);
 }
 
 void DocumentLoader::acceptDataFromThreadedReceiver(const char* data, int dataLength, int encodedDataLength)
 {
-    m_fetcher->acceptDataFromThreadedReceiver(mainResourceIdentifier(), data, dataLength, encodedDataLength);
+    if (m_fetcher)
+        m_fetcher->acceptDataFromThreadedReceiver(mainResourceIdentifier(), data, dataLength, encodedDataLength);
 }
 
 void DocumentLoader::endWriting(DocumentWriter* writer)
 {
     ASSERT_UNUSED(writer, m_writer == writer);
     m_writer->end();
     m_writer.clear();
 }
 
 PassRefPtrWillBeRawPtr<DocumentWriter> DocumentLoader::createWriterFor(const Document* ownerDocument, const DocumentInit& init, const AtomicString& mimeType, const AtomicString& encoding, bool dispatch, ParserSynchronizationPolicy parsingPolicy)
@@ skipping 27 matching lines @@
 // This is only called by FrameLoader::replaceDocumentWhileExecutingJavaScriptURL()
 void DocumentLoader::replaceDocumentWhileExecutingJavaScriptURL(const DocumentInit& init, const String& source, Document* ownerDocument)
 {
     m_writer = createWriterFor(ownerDocument, init, mimeType(), m_writer ? m_writer->encoding() : emptyAtom, true, ForceSynchronousParsing);
     if (!source.isNull())
         m_writer->appendReplacingData(source);
     endWriting(m_writer.get());
 }
 
 } // namespace blink