[HTML Import] Respect Content Security Policy Model

Source/core/html/HTMLImportsController.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 20 matching lines @@
 #include "config.h"
 #include "core/html/HTMLImportsController.h"
 
 #include "core/dom/Document.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/HTMLLinkElement.h"
 #include "core/loader/CrossOriginAccessControl.h"
 #include "core/loader/DocumentWriter.h"
 #include "core/loader/cache/CachedScript.h"
 #include "core/loader/cache/ResourceFetcher.h"
+#include "core/page/ContentSecurityPolicy.h"
 #include "weborigin/SecurityOrigin.h"
 
 namespace WebCore {
 
 PassRefPtr<LinkImport> LinkImport::create(HTMLLinkElement* owner)
 {
     return adoptRef(new LinkImport(owner));
 }
 
 LinkImport::LinkImport(HTMLLinkElement* owner)
@@ skipping 24 matching lines @@
 
     LinkRequestBuilder builder(m_owner);
     if (!builder.isValid())
         return;
 
     if (!m_owner->document()->import()) {
         ASSERT(m_owner->document()->frame()); // The document should be the master.
         HTMLImportsController::provideTo(m_owner->document());
     }
 
-    HTMLImportsController* controller = m_owner->document()->import()->controller();
+    HTMLImport* parent = m_owner->document()->import();
+    HTMLImportsController* controller = parent->controller();
     if (RefPtr<HTMLImportLoader> found = controller->findLinkFor(builder.url())) {
         m_loader = found;
         return;
     }
 
     FetchRequest request = builder.build(true);
     request.setPotentiallyCrossOriginEnabled(controller->securityOrigin(), DoNotAllowStoredCredentials);
-    CachedResourceHandle<CachedRawResource> resource = controller->fetcher()->requestRawResource(request);
+    CachedResourceHandle<CachedRawResource> resource = m_owner->document()->fetcher()->requestImport(request);
     if (!resource)
         return;
 
-    m_loader = HTMLImportLoader::create(controller, builder.url(), resource);
+    m_loader = HTMLImportLoader::create(parent, builder.url(), resource);
 }
 
 void LinkImport::ownerRemoved()
 {
     m_owner = 0;
     m_loader.clear();
 }
 
 
 PassRefPtr<HTMLImportLoader> HTMLImportLoader::create(HTMLImport* parent, const KURL& url, const CachedResourceHandle<CachedScript>& resource)
@@ skipping 16 matching lines @@
 {
     // importDestroyed() should be called before the destruction.
     ASSERT(!m_parent);
     ASSERT(!m_importedDocument);
     if (m_resource)
         m_resource->removeClient(this);
 }
 
 void HTMLImportLoader::responseReceived(CachedResource*, const ResourceResponse& response)
 {
-    setState(startParsing(response));
+    setState(startWritingAndParsing(response));
 }
 
 void HTMLImportLoader::dataReceived(CachedResource*, const char* data, int length)
 {
     RefPtr<DocumentWriter> protectingWriter(m_writer);
     m_writer->addData(data, length);
 }
 
 void HTMLImportLoader::notifyFinished(CachedResource*)
 {
-    setState(finish());
+    setState(finishWriting());
 }
 
 void HTMLImportLoader::setState(State state)
 {
     if (m_state == state)
         return;
 
     m_state = state;
 
+    if (m_state == StateReady || m_state == StateError || m_state == StateWritten) {
+        if (RefPtr<DocumentWriter> writer = m_writer.release())
+            writer->end();
+    }
+
     if (m_state == StateReady || m_state == StateError)
         dispose();
 }
 
 void HTMLImportLoader::dispose()
 {
-    if (m_writer) {
-        m_writer->end();
-        m_writer.clear();
-    }
-
     if (m_resource) {
         m_resource->removeClient(this);
         m_resource = 0;
     }
 
-
     if (HTMLImportsController* controller = this->controller())
         controller->didLoad(this);
 }
 
-HTMLImportLoader::State HTMLImportLoader::startParsing(const ResourceResponse& response)
+HTMLImportLoader::State HTMLImportLoader::startWritingAndParsing(const ResourceResponse& response)
 {
     // Current canAccess() implementation isn't sufficient for catching cross-domain redirects: http://crbug.com/256976
-    if (!controller()->fetcher()->canAccess(m_resource.get()))
+    if (!m_parent->document()->fetcher()->canAccess(m_resource.get()))
         return StateError;
 
     m_importedDocument = HTMLDocument::create(DocumentInit(response.url(), 0, this));
+    m_importedDocument->initContentSecurityPolicy(ContentSecurityPolicyResponseHeaders(response));
     m_writer = DocumentWriter::create(m_importedDocument.get(), response.mimeType(), response.textEncodingName());
 
     return StateLoading;
 }
 
-HTMLImportLoader::State HTMLImportLoader::finish()
+HTMLImportLoader::State HTMLImportLoader::finishWriting()
 {
     if (!m_parent)
         return StateError;
     // The writer instance indicates that a part of the document can be already loaded.
     // We don't take such a case as an error because the partially-loaded document has been visible from script at this point.
     if (m_resource->loadFailedOrCanceled() && !m_writer)
         return StateError;
+
+    return StateWritten;
+}
+
+HTMLImportLoader::State HTMLImportLoader::finishParsing()
+{
+    if (!m_parent)
+        return StateError;
     return StateReady;
 }
 
 Document* HTMLImportLoader::importedDocument() const
 {
     if (m_state != StateReady)
         return 0;
     return m_importedDocument.get();
 }
 
@@ skipping 19 matching lines @@
     return m_importedDocument.get();
 }
 
 void HTMLImportLoader::wasDetachedFromDocument()
 {
     // For imported documens this shouldn't be called because Document::m_import is
     // cleared before Document is destroyed by HTMLImportLoader::importDestroyed().
     ASSERT_NOT_REACHED();
 }
 
+void HTMLImportLoader::didFinishParsing()
+{
+    setState(finishParsing());
+}
+
+
 void HTMLImportsController::provideTo(Document* master)
 {
     DEFINE_STATIC_LOCAL(const char*, name, ("HTMLImportsController"));
     OwnPtr<HTMLImportsController> controller = adoptPtr(new HTMLImportsController(master));
     master->setImport(controller.get());
     Supplement<ScriptExecutionContext>::provideTo(master, name, controller.release());
 }
 
 HTMLImportsController::HTMLImportsController(Document* master)
     : m_master(master)
@@ skipping 49 matching lines @@
 }
 
 ResourceFetcher* HTMLImportsController::fetcher() const
 {
     return m_master->fetcher();
 }
 
 bool HTMLImportsController::haveChildrenLoaded(HTMLImport* parent) const
 {
     for (size_t i = 0; i < m_imports.size(); ++i) {
-        if (!m_imports[i]->isDone() && m_imports[i]->parent() == parent)
-            return false;
+        if (!m_imports[i]->isDone()) {
+            for (HTMLImport* ancestor = m_imports[i]->parent(); ancestor; ancestor = ancestor->parent()) {
+                if (ancestor == parent)
+                    return false;
+            }
+        }
     }
 
     return true;
 }
 
 HTMLImportsController* HTMLImportsController::controller()
 {
     return this;
 }
 
 HTMLImport* HTMLImportsController::parent()
 {
     return 0;
 }
 
 Document* HTMLImportsController::document()
 {
     return m_master;
 }
 
 void HTMLImportsController::wasDetachedFromDocument()
 {
     clear();
 }
 
+void HTMLImportsController::didFinishParsing()
+{
+}
+
 } // namespace WebCore