Refactoring: Introduce HTMLImport interface to form import tree.

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 59 matching lines @@
     if (!m_owner)
         return;
 
     if (!m_owner->document()->frame() && !m_owner->document()->imports())
         return;
 
     LinkRequestBuilder builder(m_owner);
     if (!builder.isValid())
         return;
 
-    HTMLImportsController* controller = m_owner->document()->imports();
-    if (!controller) {
+    if (!m_owner->document()->imports()) {
         ASSERT(m_owner->document()->frame()); // The document should be the master.
-        m_owner->document()->setImports(HTMLImportsController::create(m_owner->document()));
-        controller = m_owner->document()->imports();
+        HTMLImportsController::provideTo(m_owner->document());
     }
 
+    HTMLImportsController* controller = m_owner->document()->imports()->controller();
     if (RefPtr<HTMLImportLoader> found = controller->findLinkFor(builder.url())) {
         m_loader = found;
         return;
     }
 
     CachedResourceRequest request = builder.build(true);
     request.setPotentiallyCrossOriginEnabled(controller->securityOrigin(), DoNotAllowStoredCredentials);
     CachedResourceHandle<CachedRawResource> resource = controller->cachedResourceLoader()->requestRawResource(request);
     if (!resource)
         return;
 
     m_loader = HTMLImportLoader::create(controller, builder.url(), resource);
 }
 
 void LinkImport::ownerRemoved()
 {
     m_owner = 0;
     m_loader.clear();
 }
 
 
-PassRefPtr<HTMLImportLoader> HTMLImportLoader::create(HTMLImportsController* controller, const KURL& url, const CachedResourceHandle<CachedScript>& resource)
+PassRefPtr<HTMLImportLoader> HTMLImportLoader::create(HTMLImport* parent, const KURL& url, const CachedResourceHandle<CachedScript>& resource)
 {
-    RefPtr<HTMLImportLoader> loader = adoptRef(new HTMLImportLoader(controller, url, resource));
-    controller->addImport(loader);
-    return loader;
+    RefPtr<HTMLImportLoader> loader = adoptRef(new HTMLImportLoader(parent, url, resource));
+    loader->controller()->addImport(loader);
+    return loader.release();
 }
 
-HTMLImportLoader::HTMLImportLoader(HTMLImportsController* controller, const KURL& url, const CachedResourceHandle<CachedScript>& resource)
-    : m_controller(controller)
+HTMLImportLoader::HTMLImportLoader(HTMLImport* parent, const KURL& url, const CachedResourceHandle<CachedScript>& resource)
+    : m_parent(parent)
     , m_state(StateLoading)
     , m_resource(resource)
     , m_url(url)
 {
     m_resource->addClient(this);
 }
 
 HTMLImportLoader::~HTMLImportLoader()
 {
+    ASSERT(!m_parent);
+    ASSERT(!m_importedDocument);
     if (m_resource)
         m_resource->removeClient(this);
 }
 
 void HTMLImportLoader::responseReceived(CachedResource*, const ResourceResponse& response)
 {
     setState(startParsing(response));
 }
 
 void HTMLImportLoader::dataReceived(CachedResource*, const char* data, int length)
@@ skipping 24 matching lines @@
         m_writer->end();
         m_writer.clear();
     }
 
     if (m_resource) {
         m_resource->removeClient(this);
         m_resource = 0;
     }
 
 
-    if (m_controller)
-        m_controller->didLoad();
+    if (HTMLImportsController* controller = this->controller())
+        controller->didLoad(this);
 }
 
 HTMLImportLoader::State HTMLImportLoader::startParsing(const ResourceResponse& response)
 {
     // Current canAccess() implementation isn't sufficient for catching cross-domain redirects: http://crbug.com/256976
-    if (!m_controller->cachedResourceLoader()->canAccess(m_resource.get()))
+    if (!controller()->cachedResourceLoader()->canAccess(m_resource.get()))
         return StateError;
 
     m_importedDocument = HTMLDocument::create(0, response.url());
-    m_importedDocument->setImports(m_controller);
+    m_importedDocument->setImports(this);
     m_writer = DocumentWriter::create(m_importedDocument.get(), response.mimeType(), response.textEncodingName());
 
     return StateLoading;
 }
 
 HTMLImportLoader::State HTMLImportLoader::finish()
 {
-    if (!m_controller)
+    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 StateReady;
 }
 
 Document* HTMLImportLoader::importedDocument() const
 {
     if (m_state != StateReady)
         return 0;
     return m_importedDocument.get();
 }
 
 void HTMLImportLoader::importDestroyed()
 {
-    m_controller = 0;
+    m_parent = 0;
+    m_importedDocument->setImports(0);
     m_importedDocument.clear();
 }
 
+HTMLImportsController* HTMLImportLoader::controller()
+{
+    return m_parent ? m_parent->controller() : 0;
+}
 
-PassRefPtr<HTMLImportsController> HTMLImportsController::create(Document* master)
+HTMLImport* HTMLImportLoader::parent()
 {
-    return adoptRef(new HTMLImportsController(master));
+    return m_parent;
+}
+
+Document* HTMLImportLoader::document()
+{
+    return m_importedDocument.get();
+}
+
+void HTMLImportsController::provideTo(Document* master)
+{
+    DEFINE_STATIC_LOCAL(const char*, name, ("HTMLImportsController"));
+    OwnPtr<HTMLImportsController> controller = adoptPtr(new HTMLImportsController(master));
+    master->setImports(controller.get());
+    Supplement<ScriptExecutionContext>::provideTo(master, name, controller.release());
 }
 
 HTMLImportsController::HTMLImportsController(Document* master)
     : m_master(master)
 {
 }
 
 HTMLImportsController::~HTMLImportsController()
 {
     for (size_t i = 0; i < m_imports.size(); ++i)
         m_imports[i]->importDestroyed();
+    m_master->setImports(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()
+void HTMLImportsController::didLoad(HTMLImportLoader* loadedImport)
 {
-    if (haveLoaded())
-        m_master->didLoadAllImports();
+    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();
 }
 
 CachedResourceLoader* HTMLImportsController::cachedResourceLoader() const
 {
     return m_master->cachedResourceLoader();
 }
 
-bool HTMLImportsController::haveLoaded() const
+bool HTMLImportsController::haveChildrenLoaded(HTMLImport* parent) const
 {
     for (size_t i = 0; i < m_imports.size(); ++i) {
-        if (!m_imports[i]->isDone())
+        if (!m_imports[i]->isDone() && m_imports[i]->parent() == parent)
             return false;
     }
 
     return true;
 }
 
+HTMLImportsController* HTMLImportsController::controller()
+{
+    return this;
+}
+
+HTMLImport* HTMLImportsController::parent()
+{
+    return 0;
+}
+
+Document* HTMLImportsController::document()
+{
+    return m_master;
+}
+
 } // namespace WebCore