REGRESSION(r171966): Custom elements in async imports don't get upgrade.

Source/core/dom/custom/CustomElementMicrotaskImportStep.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:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 15 matching lines @@
  * 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/dom/custom/CustomElementMicrotaskImportStep.h"
 
 #include "core/dom/custom/CustomElementMicrotaskDispatcher.h"
 #include "core/dom/custom/CustomElementMicrotaskQueue.h"
+#include "core/html/imports/HTMLImportChild.h"
 
 namespace WebCore {
 
-PassOwnPtr<CustomElementMicrotaskImportStep> CustomElementMicrotaskImportStep::create(PassRefPtr<CustomElementMicrotaskQueue> queue)
+PassOwnPtr<CustomElementMicrotaskImportStep> CustomElementMicrotaskImportStep::create(PassRefPtr<CustomElementMicrotaskQueue> queue, bool shouldStopProcessing)
 {
-    return adoptPtr(new CustomElementMicrotaskImportStep(queue));
+    return adoptPtr(new CustomElementMicrotaskImportStep(queue, shouldStopProcessing));
 }
 
-CustomElementMicrotaskImportStep::CustomElementMicrotaskImportStep(PassRefPtr<CustomElementMicrotaskQueue> queue)
-    : m_importFinished(false)
+CustomElementMicrotaskImportStep::CustomElementMicrotaskImportStep(PassRefPtr<CustomElementMicrotaskQueue> queue, bool shouldStopProcessing)
+    : m_shouldStopProcessing(shouldStopProcessing)
+    , m_importWaitingFinish(0)
     , m_queue(queue)
 {
 }
 
 CustomElementMicrotaskImportStep::~CustomElementMicrotaskImportStep()
 {
 }
 
-void CustomElementMicrotaskImportStep::importDidFinish()
+void CustomElementMicrotaskImportStep::importWasDestroyed()
 {
-    // imports should only "finish" once
-    ASSERT(!m_importFinished);
-    m_importFinished = true;
+    m_importWaitingFinish = 0;
+    m_queue.clear();
+}
+
+void CustomElementMicrotaskImportStep::importDidLoad(HTMLImportChild* importWaitingFinish)
+{
+    ASSERT(!m_importWaitingFinish);
+    m_importWaitingFinish = importWaitingFinish;
     CustomElementMicrotaskDispatcher::instance().importDidFinish(this);
 }
 
 CustomElementMicrotaskStep::Result CustomElementMicrotaskImportStep::process()
 {
+    if (!m_queue)
+        return Continue;
+
     Result result = m_queue->dispatch();
-    if (!m_importFinished)
+
+    if (m_importWaitingFinish) {
+        if (m_queue->isEmpty()) {
+            ASSERT(result == Continue);
+            m_importWaitingFinish->didFinishMicrotask();
+            m_importWaitingFinish = 0;
+            m_queue.clear();
+        }
+
+        return result;
+    }
+
+    result = Result(result | ShouldRemain);

[dominicc (has gone to gerrit), 2014/04/30 23:57:20]

It seems bad to have a microtask queue whose import is destroyed before the
import finishes loading "remain" indefinitely. Can we make this "fail safe"?

+    if (m_shouldStopProcessing)
         result = Result(result | ShouldStop);
+
     return result;
 }
 
+#if !defined(NDEBUG)
+
+void CustomElementMicrotaskImportStep::show(unsigned indent)
+{
+    for (unsigned i = 0; i < indent; ++i)
+        fprintf(stderr, " ");
+    fprintf(stderr, "Import(stop=%d, finish=%p): \n", m_shouldStopProcessing, m_importWaitingFinish);
+    m_queue->show(indent + 1);
+}
+
+#endif
+
 } // namespace WebCore