[HTML Imports] Make import loading in order.

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 92 matching lines @@
 {
     m_owner = 0;
     m_loader.clear();
 }
 
 
 PassRefPtr<HTMLImportLoader> HTMLImportLoader::create(HTMLImport* parent, const KURL& url, const ResourcePtr<CachedScript>& resource)
 {
     RefPtr<HTMLImportLoader> loader = adoptRef(new HTMLImportLoader(parent, url, resource));
     loader->controller()->addImport(loader);
+    parent->appendChild(loader.get());
     return loader.release();
 }
 
 HTMLImportLoader::HTMLImportLoader(HTMLImport* parent, const KURL& url, const ResourcePtr<CachedScript>& resource)
     : m_parent(parent)
     , m_state(StateLoading)
     , m_resource(resource)
     , m_url(url)
 {
     m_resource->addClient(this);
@@ skipping 40 matching lines @@
         dispose();
 }
 
 void HTMLImportLoader::dispose()
 {
     if (m_resource) {
         m_resource->removeClient(this);
         m_resource = 0;
     }
 
-    if (HTMLImportsController* controller = this->controller())
-        controller->didLoad(this);
+    ASSERT(!document() || !document()->parsing());
+    controller()->scheduleUnblock();
 }
 
 HTMLImportLoader::State HTMLImportLoader::startWritingAndParsing(const ResourceResponse& response)
 {
     // Current canAccess() implementation isn't sufficient for catching cross-domain redirects: http://crbug.com/256976
     if (!m_parent->document()->fetcher()->canAccess(m_resource.get()))
         return StateError;
 
     m_importedDocument = HTMLDocument::create(DocumentInit(response.url(), 0, this).withRegistrationContext(controller()->document()->registrationContext()));
     m_importedDocument->initContentSecurityPolicy(ContentSecurityPolicyResponseHeaders(response));
@@ skipping 33 matching lines @@
     m_parent = 0;
     if (RefPtr<Document> document = m_importedDocument.release())
         document->setImport(0);
 }
 
 HTMLImportsController* HTMLImportLoader::controller()
 {
     return m_parent ? m_parent->controller() : 0;
 }
 
-HTMLImport* HTMLImportLoader::parent()
+HTMLImport* HTMLImportLoader::parent() const
 {
     return m_parent;
 }
 
-Document* HTMLImportLoader::document()
+Document* HTMLImportLoader::document() const
 {
     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());
 }
 
+bool HTMLImportLoader::isProcessing() const
+{
+    if (!m_importedDocument)
+        return !isDone();
+    return m_importedDocument->parsing();
+}
 
 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)
+    , m_unblockTimer(this, &HTMLImportsController::unblockTimerFired)
 {
 }
 
 HTMLImportsController::~HTMLImportsController()
 {
     ASSERT(!m_master);
 }
 
 void HTMLImportsController::clear()
 {
     for (size_t i = 0; i < m_imports.size(); ++i)
         m_imports[i]->importDestroyed();
     if (m_master)
         m_master->setImport(0);
     m_master = 0;
 }
 
 void HTMLImportsController::addImport(PassRefPtr<HTMLImportLoader> 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(HTMLImportLoader* loadedImport)
-{
-    for (HTMLImport* ancestorToNotify = loadedImport->parent(); ancestorToNotify; ancestorToNotify = ancestorToNotify->parent()) {
-        if (haveChildrenLoaded(ancestorToNotify))
-            ancestorToNotify->document()->didLoadAllImports();
-    }
-}
-
 PassRefPtr<HTMLImportLoader> HTMLImportsController::findLinkFor(const KURL& url) const
 {
     for (size_t i = 0; i < m_imports.size(); ++i) {
         if (equalIgnoringFragmentIdentifier(m_imports[i]->url(), url))
             return m_imports[i];
     }
 
     return 0;
 }
 
 SecurityOrigin* HTMLImportsController::securityOrigin() const
 {
     return m_master->securityOrigin();
 }
 
 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()) {
-            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()
+HTMLImport* HTMLImportsController::parent() const
 {
     return 0;
 }
 
-Document* HTMLImportsController::document()
+Document* HTMLImportsController::document() const
 {
     return m_master;
 }
 
 void HTMLImportsController::wasDetachedFromDocument()
 {
     clear();
 }
 
 void HTMLImportsController::didFinishParsing()
 {
 }
 
+bool HTMLImportsController::isProcessing() const
+{
+    return m_master->parsing();
+}
+
+void HTMLImportsController::scheduleUnblock()
+{
+    if (m_unblockTimer.isActive())
+        return;
+    m_unblockTimer.startOneShot(0);
+}
+
+void HTMLImportsController::unblockTimerFired(Timer<HTMLImportsController>*)
+{
+    do {
+        m_unblockTimer.stop();
+        HTMLImport::unblock(this);
+    } while (m_unblockTimer.isActive());
+}
+
 } // namespace WebCore