[import] Cleanup: get rid of ad-hoc state machine.

Source/core/html/HTMLImportChild.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 22 matching lines @@
 
 #include "core/dom/Document.h"
 #include "core/dom/custom/CustomElement.h"
 #include "core/dom/custom/CustomElementMicrotaskImportStep.h"
 #include "core/html/HTMLImportChildClient.h"
 #include "core/html/HTMLImportLoader.h"
 
 namespace WebCore {
 
 HTMLImportChild::HTMLImportChild(const KURL& url, bool createdByParser)
-    : HTMLImport(WaitingLoaderOrChildren, createdByParser)
+    : HTMLImport(createdByParser)
     , m_url(url)
     , m_customElementMicrotaskStep(0)
     , m_client(0)
 {
 }
 
 HTMLImportChild::~HTMLImportChild()
 {
     // importDestroyed() should be called before the destruction.
     ASSERT(!m_loader);
 
     if (m_customElementMicrotaskStep) {
         // if Custom Elements were blocked, must unblock them before death
         m_customElementMicrotaskStep->importDidFinish();
         m_customElementMicrotaskStep = 0;
     }
 
     if (m_client)
         m_client->importChildWasDestroyed(this);
 }
 
 void HTMLImportChild::wasAlreadyLoaded()
 {
     ASSERT(!m_loader);
     ASSERT(m_client);
-
-    ensureLoader();
-    loaderWasResolved();
+    stateWillChange();
 }
 
 void HTMLImportChild::startLoading(const ResourcePtr<RawResource>& resource)
 {
     ASSERT(!hasResource());
     ASSERT(!m_loader);
 
     if (isCreatedByParser()) {
         ASSERT(!m_customElementMicrotaskStep);
         m_customElementMicrotaskStep = CustomElement::didCreateImport(this);
     }
 
     HTMLImportResourceOwner::setResource(resource);
 
     // If the node is "document blocked", it cannot create HTMLImportLoader
     // even if there is no sharable one found, as there is possibility that
     // preceding imports load the sharable imports.
     // In that case preceding one should win because it comes first in the tree order.
     // See also didUnblockFromCreatingDocument().
-    if (isBlockedFromCreatingDocument())
+    if (isStateBlockedFromCreatingDocument())
         return;
 
     ensureLoader();
 }
 
 void HTMLImportChild::didFinish()
 {
     if (m_client)
         m_client->didFinish();
 
     if (m_customElementMicrotaskStep) {
         m_customElementMicrotaskStep->importDidFinish();
         m_customElementMicrotaskStep = 0;
     }
 }
 
 void HTMLImportChild::didFinishLoading()
 {
     clearResource();
-    loaderDidFinish();
+    stateWillChange();
 }
 
 Document* HTMLImportChild::importedDocument() const
 {
     if (!m_loader)
         return 0;
     return m_loader->importedDocument();
 }
 
 void HTMLImportChild::importDestroyed()
@@ skipping 22 matching lines @@
     // cleared before Document is destroyed by HTMLImportChild::importDestroyed().
     ASSERT_NOT_REACHED();
 }
 
 void HTMLImportChild::didFinishParsing()
 {
     ASSERT(m_loader->isOwnedBy(this));
     m_loader->didFinishParsing();
 }
 
-// Once all preceding imports are loaded and "document blocking" ends,
-// HTMLImportChild can decide whether it should load the import by itself
-// or it can share existing one.
-void HTMLImportChild::didUnblockFromCreatingDocument()
+void HTMLImportChild::stateDidChange()
 {
-    HTMLImport::didUnblockFromCreatingDocument();
-    ensureLoader();
-}
+    HTMLImport::stateDidChange();
 
-void HTMLImportChild::didBecomeReady()
-{
-    HTMLImport::didBecomeReady();
-    didFinish();
+    // Once all preceding imports are loaded,
+    // HTMLImportChild can decide whether it should load the import by itself
+    // or it can share existing one.
+    if (!isStateBlockedFromCreatingDocument())
+        ensureLoader();
+    if (isStateReady())
+        didFinish();
 }
 
 void HTMLImportChild::ensureLoader()
 {
     if (m_loader)
         return;
 
     if (HTMLImportChild* found = root()->findLinkFor(m_url, this))
         shareLoader(found);
     else
         createLoader();
 }
 
 void HTMLImportChild::createLoader()
 {
-    ASSERT(!isBlockedFromCreatingDocument());
+    ASSERT(!isStateBlockedFromCreatingDocument());
     ASSERT(!m_loader);
     m_loader = HTMLImportLoader::create(this, parent()->document()->fetcher());
     m_loader->addClient(this);
     m_loader->startLoading(resource());
 }
 
 void HTMLImportChild::shareLoader(HTMLImportChild* loader)
 {
     ASSERT(!m_loader);
     m_loader = loader->m_loader;
     m_loader->addClient(this);
-    root()->blockerGone();
+    stateWillChange();
 }
 
 bool HTMLImportChild::isDone() const
 {
     return m_loader && m_loader->isDone();
 }
 
 bool HTMLImportChild::hasLoader() const
 {
     return m_loader;
@@ skipping 17 matching lines @@
     m_client = client;
 }
 
 void HTMLImportChild::clearClient()
 {
     // Doesn't check m_client nullity because we allow
     // clearClient() to reenter.
     m_client = 0;
 }
 
+
+#if !defined(NDEBUG)
+void HTMLImportChild::showThis()
+{
+    HTMLImport::showThis();
+    fprintf(stderr, " loader=%p own=%s async=%s url=%s",
+        m_loader.get(),
+        hasLoader() && ownsLoader() ? "Y" : "N",
+        isCreatedByParser() ? "Y" : "N",
+        url().string().utf8().data());
+}
+#endif
+
 } // namespace WebCore