Refactoring: Simplify DocumentWriter by reorganizing its lifetime.

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 12 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/loader/DocumentLoader.h"
 
-#include <wtf/Assertions.h>
-#include <wtf/MemoryInstrumentationHashMap.h>
-#include <wtf/MemoryInstrumentationHashSet.h>
-#include <wtf/MemoryInstrumentationVector.h>
-#include <wtf/text/CString.h>
-#include <wtf/text/WTFString.h>
-#include <wtf/unicode/Unicode.h>
+#include "core/dom/DOMImplementation.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentParser.h"
 #include "core/dom/Event.h"
 #include "core/dom/WebCoreMemoryInstrumentation.h"
 #include "core/history/HistoryItem.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/DocumentWriter.h"
 #include "core/loader/FormState.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/ResourceLoader.h"
+#include "core/loader/SinkDocument.h"
 #include "core/loader/TextResourceDecoder.h"
 #include "core/loader/UniqueIdentifier.h"
 #include "core/loader/appcache/ApplicationCacheHost.h"
 #include "core/loader/archive/ArchiveResourceCollection.h"
 #include "core/loader/archive/MHTMLArchive.h"
 #include "core/loader/cache/CachedResourceLoader.h"
 #include "core/loader/cache/CachedResourceRequestInitiators.h"
 #include "core/loader/cache/MemoryCache.h"
 #include "core/page/DOMWindow.h"
 #include "core/page/Frame.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/Settings.h"
 #include "core/platform/Logging.h"
 #include "weborigin/SchemeRegistry.h"
 #include "weborigin/SecurityPolicy.h"
+#include "wtf/Assertions.h"
+#include "wtf/MemoryInstrumentationHashMap.h"
+#include "wtf/MemoryInstrumentationHashSet.h"
+#include "wtf/MemoryInstrumentationVector.h"
+#include "wtf/text/CString.h"
+#include "wtf/text/WTFString.h"
+#include "wtf/unicode/Unicode.h"
 
 namespace WebCore {
 
 static void cancelAll(const ResourceLoaderSet& loaders)
 {
     Vector<RefPtr<ResourceLoader> > loadersCopy;
     copyToVector(loaders, loadersCopy);
     size_t size = loadersCopy.size();
     for (size_t i = 0; i < size; ++i)
         loadersCopy[i]->cancel();
@@ skipping 10 matching lines @@
 
 static bool isArchiveMIMEType(const String& mimeType)
 {
     return mimeType == "multipart/related";
 }
 
 DocumentLoader::DocumentLoader(const ResourceRequest& req, const SubstituteData& substituteData)
     : m_deferMainResourceDataLoad(true)
     , m_frame(0)
     , m_cachedResourceLoader(CachedResourceLoader::create(this))
-    , m_writer(m_frame)
     , m_originalRequest(req)
     , m_substituteData(substituteData)
     , m_originalRequestCopy(req)
     , m_request(req)
     , m_committed(false)
     , m_isStopping(false)
-    , m_gotFirstByte(false)
     , m_isClientRedirect(false)
     , m_wasOnloadHandled(false)
     , m_loadingMainResource(false)
     , m_timeOfLastDataReceived(0.0)
     , m_identifierForLoadWithoutResourceLoader(0)
     , m_dataLoadTimer(this, &DocumentLoader::handleSubstituteDataLoadNow)
     , m_applicationCacheHost(adoptPtr(new ApplicationCacheHost(this)))
 {
 }
 
@@ skipping 174 matching lines @@
     stopLoadingSubresources();
     
     m_isStopping = false;
 }
 
 void DocumentLoader::commitIfReady()
 {
     if (!m_committed) {
         m_committed = true;
         frameLoader()->commitProvisionalLoad();
-        m_writer.setMIMEType(m_response.mimeType());
     }
 }
 
 bool DocumentLoader::isLoading() const
 {
     if (document() && document()->hasActiveParser())
         return true;
 
     return isLoadingMainResource() || !m_resourceLoaders.isEmpty();
 }
@@ skipping 25 matching lines @@
     if (!responseEndTime)
         responseEndTime = m_timeOfLastDataReceived;
     if (!responseEndTime)
         responseEndTime = monotonicallyIncreasingTime();
     timing()->setResponseEnd(responseEndTime);
 
     commitIfReady();
     if (!frameLoader())
         return;
 
-    if (!maybeCreateArchive()) {
+    if (isArchiveMIMEType(m_response.mimeType())) {
+        createArchive();
+    } else {
         // If this is an empty document, it will not have actually been created yet. Commit dummy data so that
         // DocumentWriter::begin() gets called and creates the Document.
-        if (!m_gotFirstByte)
+        if (!m_writer)
             commitData(0, 0);
+
         frameLoader()->client()->finishedLoading(this);
     }
 
-    m_writer.end();
+    endWriting(m_writer.get());
+
     if (!m_mainDocumentError.isNull())
         return;
     clearMainResourceLoader();
     if (!frameLoader()->stateMachine()->creatingInitialEmptyDocument())
         frameLoader()->checkLoadComplete();
 
     // If the document specified an application cache manifest, it violates the author's intent if we store it in the memory cache
     // and deny the appcache the chance to intercept it in the future, so remove from the memory cache.
     if (m_frame) {
         if (m_mainResource && m_frame->document()->hasManifest())
@@ skipping 256 matching lines @@
     return frameLoader()->client()->interruptedForPolicyChangeError(request());
 }
 
 void DocumentLoader::stopLoadingForPolicyChange()
 {
     ResourceError error = interruptedForPolicyChangeError();
     error.setIsCancellation(true);
     cancelMainResourceLoad(error);
 }
 
+void DocumentLoader::ensureWriter()
+{
+    ensureWriter(m_response.mimeType());
+}
+
+void DocumentLoader::ensureWriter(const String& mimeType)
+{
+    if (m_writer)
+        return;

[abarth-chromium, 2013/06/26 03:04:08]

Should we ASSERT that the mimeTypes match?

[Hajime Morrita, 2013/06/26 04:24:39]

We should. Will do.

+
+    String encoding = overrideEncoding().isNull() ? response().textEncodingName().impl() : overrideEncoding();
+    bool userChosen = !overrideEncoding().isNull();
+    m_writer = createWriterFor(m_frame, 0, documentURL(), mimeType, encoding, false, true);
+    m_writer->setDocumentWasLoadedAsPartOfNavigation();
+
+    if (frameLoader()->stateMachine()->creatingInitialEmptyDocument())
+        return;
+        
+    // Call receivedFirstData() exactly once per load.
+    frameLoader()->receivedFirstData();
+}
+
 void DocumentLoader::commitData(const char* bytes, size_t length)
 {
-    if (!m_gotFirstByte) {
-        m_gotFirstByte = true;
-        m_writer.begin(documentURL(), false);
-        m_writer.setDocumentWasLoadedAsPartOfNavigation();
-
-        if (frameLoader()->stateMachine()->creatingInitialEmptyDocument())
-            return;
-        
-        // 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.
-        if (m_archive)
-            m_frame->document()->setBaseURLOverride(m_archive->mainResource()->url());
-
-        // Call receivedFirstData() exactly once per load.
-        frameLoader()->receivedFirstData();
-
-        bool userChosen = true;
-        String encoding = overrideEncoding();
-        if (encoding.isNull()) {
-            userChosen = false;
-            encoding = response().textEncodingName();
-        }
-        m_writer.setEncoding(encoding, userChosen);
-    }
+    ensureWriter();
     ASSERT(m_frame->document()->parsing());
-    m_writer.addData(bytes, length);
+    m_writer->addData(bytes, length);
 }
 
 void DocumentLoader::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::Loader);
     info.addMember(m_frame, "frame");
     info.addMember(m_cachedResourceLoader, "cachedResourceLoader");
     info.addMember(m_mainResource, "mainResource");
     info.addMember(m_resourceLoaders, "resourceLoaders");
     info.addMember(m_multipartResourceLoaders, "multipartResourceLoaders");
@@ skipping 34 matching lines @@
     // See https://bugs.webkit.org/show_bug.cgi?id=110937
     // ASSERT(this == frameLoader()->activeDocumentLoader())
     m_frame->document()->domWindow()->finishedLoading();
 }
 
 void DocumentLoader::setFrame(Frame* frame)
 {
     if (m_frame == frame)
         return;
     ASSERT(frame && !m_frame);
+    ASSERT(!m_writer);
     m_frame = frame;
-    m_writer.setFrame(frame);
 }
 
 void DocumentLoader::detachFromFrame()
 {
     ASSERT(m_frame);
     RefPtr<Frame> protectFrame(m_frame);
     RefPtr<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.
@@ skipping 30 matching lines @@
         if (m_cachedResourceLoader->requestCount())
             return true;
         if (doc->processingLoadEvent())
             return true;
         if (doc->hasActiveParser())
             return true;
     }
     return frameLoader()->subframeIsLoading();
 }
 
-bool DocumentLoader::maybeCreateArchive()
+void DocumentLoader::createArchive()
 {
-    // Give the archive machinery a crack at this document. If the MIME type is not an archive type, it will return 0.
-    if (!isArchiveMIMEType(m_response.mimeType()))
-        return false;
-
     m_archive = MHTMLArchive::create(m_response.url(), mainResourceData().get());
     ASSERT(m_archive);
     
     addAllArchiveResources(m_archive.get());
     ArchiveResource* mainResource = m_archive->mainResource();
-    m_writer.setMIMEType(mainResource->mimeType());
-    
-    ASSERT(m_frame->document());
+
+    ensureWriter(mainResource->mimeType());
+
+    // 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.
+    m_frame->document()->setBaseURLOverride(m_archive->mainResource()->url());
+
     commitData(mainResource->data()->data(), mainResource->data()->size());
-    return true;
 }
 
 void DocumentLoader::addAllArchiveResources(MHTMLArchive* archive)
 {
     ASSERT(archive);
     if (!m_archiveResourceCollection)
         m_archiveResourceCollection = adoptPtr(new ArchiveResourceCollection);
     m_archiveResourceCollection->addAllResources(archive);
 }
 
@@ skipping 102 matching lines @@
 void DocumentLoader::stopLoadingSubresources()
 {
     cancelAll(m_resourceLoaders);
 }
 
 void DocumentLoader::addResourceLoader(ResourceLoader* loader)
 {
     // The main resource's underlying ResourceLoader will ask to be added here.
     // It is much simpler to handle special casing of main resource loads if we don't
     // let it be added. In the main resource load case, mainResourceLoader()
-    // will still be null at this point, but m_gotFirstByte should be false here if and only
+    // will still be null at this point, but document() should be null here if and only

[abarth-chromium, 2013/06/26 03:04:08]

null -> zero

[Hajime Morrita, 2013/06/26 04:24:39]

Done.

     // if we are just starting the main resource load.
-    if (!m_gotFirstByte)
+    if (!document())
         return;
     ASSERT(!m_resourceLoaders.contains(loader));
     ASSERT(!mainResourceLoader() || mainResourceLoader() != loader);
     m_resourceLoaders.add(loader);
 }
 
 void DocumentLoader::removeResourceLoader(ResourceLoader* loader)
 {
     if (!m_resourceLoaders.contains(loader))
         return;
@@ skipping 95 matching lines @@
 }
 
 void DocumentLoader::handledOnloadEvents()
 {
     m_wasOnloadHandled = true;
     applicationCacheHost()->stopDeferringEvents();
 }
 
 DocumentWriter* DocumentLoader::beginWriting(const String& mimeType, const String& encoding, const KURL& url)
 {
-    m_writer.setMIMEType(mimeType);
-    m_writer.setEncoding(encoding, false);
-    m_writer.begin(url);
-    return &m_writer;
+    m_writer = createWriterFor(m_frame, 0, url, mimeType, encoding, false, true);
+    return m_writer.get();
+}
+
+void DocumentLoader::endWriting(DocumentWriter* writer)
+{
+    ASSERT_UNUSED(writer, m_writer == writer);
+    m_writer->end();
+    m_writer.clear();
+}
+
+
+PassOwnPtr<DocumentWriter> DocumentLoader::createWriterFor(Frame* frame, const Document* ownerDocument, const KURL& url, const String& mimeType, const String& encoding, bool userChosen, bool dispatch)
+{
+    // Create a new document before clearing the frame, because it may need to
+    // inherit an aliased security context.
+    RefPtr<Document> document = DOMImplementation::createDocument(mimeType, frame, url, frame->inViewSourceMode());
+    if (document->isPluginDocument() && document->isSandboxed(SandboxPlugins))
+        document = SinkDocument::create(frame, url);
+    bool shouldReuseDefaultView = frame->loader()->stateMachine()->isDisplayingInitialEmptyDocument() && frame->document()->isSecureTransitionTo(url);
+
+    RefPtr<DOMWindow> originalDOMWindow;
+    if (shouldReuseDefaultView)
+        originalDOMWindow = frame->domWindow();
+    frame->loader()->clear(!shouldReuseDefaultView, !shouldReuseDefaultView);
+
+    if (!shouldReuseDefaultView) {
+        frame->setDOMWindow(DOMWindow::create(frame));
+    } else {
+        // Note that the old Document is still attached to the DOMWindow; the
+        // setDocument() call below will detach the old Document.
+        ASSERT(originalDOMWindow);
+        frame->setDOMWindow(originalDOMWindow);
+    }
+
+    frame->loader()->setOutgoingReferrer(url);
+    frame->domWindow()->setDocument(document);
+
+    if (ownerDocument) {
+        document->setCookieURL(ownerDocument->cookieURL());
+        document->setSecurityOrigin(ownerDocument->securityOrigin());
+    }
+
+    frame->loader()->didBeginDocument(dispatch);
+
+    return DocumentWriter::create(document.get(), mimeType, encoding, userChosen);
 }
 
 String DocumentLoader::mimeType() const
 {
-    return m_writer.mimeType();
+    return m_writer ? m_writer->mimeType() : m_response.mimeType().impl();

[abarth-chromium, 2013/06/26 03:04:08]

impl()   ?

[Hajime Morrita, 2013/06/26 04:24:39]

I shouldn't have used the ternary operator :-|

 }
 
+// This is only called by ScriptController::executeScriptIfJavaScriptURL
+// and always contains the result of evaluating a javascript: url.
+// This is the <iframe src="javascript:'html'"> case.
 void DocumentLoader::replaceDocument(const String& source, Document* ownerDocument)
 {
-    m_writer.replaceDocument(source, ownerDocument);
+    m_writer = createWriterFor(m_frame, ownerDocument, m_frame->document()->url(), "", "", false, true);
+    if (!source.isNull())
+        m_writer->appendReplacingData(source);
+    endWriting(m_writer.get());
 }
 
 } // namespace WebCore