[HTML Imports] Make HTMLLinkElement.import a Document.

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 14 matching lines @@
  * 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/html/HTMLImportsController.h"
 
 #include "core/dom/Document.h"
-#include "core/dom/DocumentFragment.h"
 #include "core/dom/DocumentType.h"
 #include "core/dom/Range.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/HTMLLinkElement.h"
 #include "core/loader/cache/CachedResourceLoader.h"
 #include "core/loader/cache/CachedScript.h"
 #include "weborigin/SecurityOrigin.h"
 
 namespace WebCore {
 
@@ skipping 25 matching lines @@
         return StateError;
 
     String error;
     if (!m_controller->securityOrigin()->canRequest(m_resource->response().url())
         && !m_resource->passesAccessControlCheck(m_controller->securityOrigin(), error)) {
         m_controller->showSecurityErrorMessage("Import from origin '" + SecurityOrigin::create(m_resource->response().url())->toString() + "' has been blocked from loading by Cross-Origin Resource Sharing policy: " + error);
         return StateError;
     }
 
     // FIXME(morrita): This should be done in incremental way.
-    RefPtr<Document> parsingPlaceholder = HTMLDocument::create(0, KURL());
-    parsingPlaceholder->setContent(m_resource->script());
-
-    // Doctypes cannot be moved between documents. So we remove it before the migration.
-    if (RefPtr<Node> doctype = parsingPlaceholder->doctype())
-        parsingPlaceholder->removeChild(doctype.get());
-    m_importedFragment->takeAllChildrenFrom(parsingPlaceholder.get());
+    m_importedDocument = HTMLDocument::create(0, m_resource->response().url());
+    m_importedDocument->setContent(m_resource->script());
 
     return StateReady;
 }
 
 void LinkImport::notifyFinished(CachedResource*)
 {
     setState(finish());
 }
 
 void LinkImport::setState(State state)
@@ skipping 27 matching lines @@
     }
 
     CachedResourceRequest request = builder.build(true);
     m_resource = m_owner->document()->cachedResourceLoader()->requestScript(request);
     if (!m_resource)
         return StateError;
 
     m_resource->addClient(this);
     m_url = builder.url();
     m_controller->addImport(this);
-    m_importedFragment = m_controller->createDocumentFragment();
 
     return StateStarted;
 }
 
-DocumentFragment* LinkImport::importedFragment() const
+Document* LinkImport::importedDocument() const
 {
     if (!m_owner)
         return 0;
     if (m_state != StateReady)
         return 0;
 
     if (m_ofSameLocation) {
-        ASSERT(!m_importedFragment);
-        return m_ofSameLocation->importedFragment();
+        ASSERT(!m_importedDocument);
+        return m_ofSameLocation->importedDocument();
     }
 
-    return m_importedFragment.get();
+    return m_importedDocument.get();
 }
 
 void LinkImport::process()
 {
     if (StatePreparing != m_state)
         return;
     setState(startRequest());
 }
 
 void LinkImport::ownerRemoved()
 {
     m_owner = 0;
 }
 
 void LinkImport::importDestroyed()
 {
     m_controller = 0;
-    m_importedFragment.clear();
+    m_importedDocument.clear();
 }
 
 PassOwnPtr<HTMLImportsController> HTMLImportsController::create(Document* master)
 {
     return adoptPtr(new HTMLImportsController(master));
 }
 
 HTMLImportsController::HTMLImportsController(Document* master)
     : m_master(master)
-    , m_importedFragmentOwner(HTMLDocument::create(0, KURL()))
 {
 }
 
 HTMLImportsController::~HTMLImportsController()
 {
     for (size_t i = 0; i < m_imports.size(); ++i)
         m_imports[i]->importDestroyed();
 }
 
 void HTMLImportsController::addImport(PassRefPtr<LinkImport> link)
 {
     ASSERT(!link->url().isEmpty() && link->url().isValid());
     m_imports.append(link);
 }
 
 void HTMLImportsController::showSecurityErrorMessage(const String& message)
 {
     m_master->addConsoleMessage(JSMessageSource, ErrorMessageLevel, message);
 }
 
 void HTMLImportsController::didLoad()
 {
     if (haveLoaded())
         m_master->didLoadAllImports();
 }
 
-PassRefPtr<DocumentFragment> HTMLImportsController::createDocumentFragment() const
-{
-    return m_importedFragmentOwner->createDocumentFragment();
-}
-
 PassRefPtr<LinkImport> HTMLImportsController::findLinkFor(const KURL& url) const
 {
     for (size_t i = 0; i < m_imports.size(); ++i) {
         if (m_imports[i]->url() == url)
             return m_imports[i];
     }
 
     return 0;
 }
 
 SecurityOrigin* HTMLImportsController::securityOrigin() const
 {
     return m_master->securityOrigin();
 }
 
 bool HTMLImportsController::haveLoaded() const
 {
     for (size_t i = 0; i < m_imports.size(); ++i) {
         if (!m_imports[i]->isDone())
             return false;
     }
 
     return true;
 }
 
 } // namespace WebCore