HTML Imports: Get rid of needsProcessOrStop() from dom/custom/

Source/core/dom/custom/CustomElementMicrotaskDispatcher.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/dom/custom/CustomElementMicrotaskDispatcher.h"
 
 #include "core/dom/Microtask.h"
+#include "core/dom/custom/CustomElementAsyncImportMicrotaskQueue.h"
 #include "core/dom/custom/CustomElementCallbackDispatcher.h"
 #include "core/dom/custom/CustomElementCallbackQueue.h"
 #include "core/dom/custom/CustomElementMicrotaskImportStep.h"
 #include "core/dom/custom/CustomElementMicrotaskQueue.h"
 #include "core/dom/custom/CustomElementScheduler.h"
 #include "core/html/imports/HTMLImportLoader.h"
 #include "wtf/MainThread.h"
 
 namespace WebCore {
 
 static const CustomElementCallbackQueue::ElementQueueId kMicrotaskQueueId = 0;
 
 CustomElementMicrotaskDispatcher::CustomElementMicrotaskDispatcher()
     : m_hasScheduledMicrotask(false)
     , m_phase(Quiescent)
     , m_resolutionAndImports(CustomElementMicrotaskQueue::create())
+    , m_asyncImports(CustomElementAsyncImportMicrotaskQueue::create())
 {
 }
 
+CustomElementMicrotaskDispatcher::~CustomElementMicrotaskDispatcher()
+{
+}
+
 CustomElementMicrotaskDispatcher& CustomElementMicrotaskDispatcher::instance()
 {
     DEFINE_STATIC_LOCAL(CustomElementMicrotaskDispatcher, instance, ());
     return instance;
 }
 
 void CustomElementMicrotaskDispatcher::enqueue(HTMLImportLoader* importLoader, PassOwnPtr<CustomElementMicrotaskStep> step)
 {
-    ASSERT(m_phase == Quiescent || m_phase == DispatchingCallbacks);
-    ensureMicrotaskScheduled();
+    willOrDidEnqueueStep();

[dominicc (has gone to gerrit), 2014/05/27 23:41:25]

Thanks for fighting duplication.

     if (importLoader)
         importLoader->microtaskQueue()->enqueue(step);
     else
         m_resolutionAndImports->enqueue(step);
 }
 
+void CustomElementMicrotaskDispatcher::enqueue(HTMLImportLoader* importLoader, PassOwnPtr<CustomElementMicrotaskImportStep> step)
+{
+    willOrDidEnqueueStep();
+    if (step->isSync())

[dominicc (has gone to gerrit), 2014/05/27 23:41:25]

Very neat; I love it.

+        enqueue(importLoader, PassOwnPtr<CustomElementMicrotaskStep>(step));
+    else
+        m_asyncImports->enqueue(step);
+}
+
 void CustomElementMicrotaskDispatcher::enqueue(CustomElementCallbackQueue* queue)
 {
     ASSERT(m_phase == Quiescent || m_phase == Resolving);
     ensureMicrotaskScheduled();
     queue->setOwner(kMicrotaskQueueId);
     m_elements.append(queue);
 }
 
 void CustomElementMicrotaskDispatcher::importDidFinish(CustomElementMicrotaskImportStep* step)
 {
+    willOrDidEnqueueStep();

[dominicc (has gone to gerrit), 2014/05/27 23:41:25]

Think willOrDidEnqueueStep is mis-named, because in this case the step was
enqueued a LOOOONG time ago.

[Hajime Morrita, 2014/05/28 00:41:37]

Agreed. I just did't came up with any better name...
What about ensureMicrotaskScheduledForMicrotaskStep() ?

[dominicc (has gone to gerrit), 2014/05/28 01:41:34]

OK. Can you extract the two lines from enqueue(CustomElementCallbackQueue*) and
call them ensureMicrotaskScheduledForElementQueue() and put it right next to
ensureMicrotaskScheduledForMicrotaskStep. That will explain what the methods are
by contrast. Then there should be no callers of ensureMicrotaskScheduled except
those two methods.

+}
+
+void CustomElementMicrotaskDispatcher::willOrDidEnqueueStep()
+{
     ASSERT(m_phase == Quiescent || m_phase == DispatchingCallbacks);
     ensureMicrotaskScheduled();
 }
 
 void CustomElementMicrotaskDispatcher::ensureMicrotaskScheduled()
 {
     if (!m_hasScheduledMicrotask) {
         Microtask::enqueueMicrotask(WTF::bind(&dispatch));
         m_hasScheduledMicrotask = true;
     }
@@ skipping 11 matching lines @@
     ASSERT(m_phase == Quiescent && m_hasScheduledMicrotask);
     m_hasScheduledMicrotask = false;
 
     // Finishing microtask work deletes all
     // CustomElementCallbackQueues. Being in a callback delivery scope
     // implies those queues could still be in use.
     ASSERT_WITH_SECURITY_IMPLICATION(!CustomElementCallbackDispatcher::inCallbackDeliveryScope());
 
     m_phase = Resolving;
     m_resolutionAndImports->dispatch();
+    if (m_resolutionAndImports->isEmpty())
+        m_asyncImports->dispatch();
 
     m_phase = DispatchingCallbacks;
     for (Vector<CustomElementCallbackQueue*>::iterator it = m_elements.begin();it != m_elements.end(); ++it) {
         // Created callback may enqueue an attached callback.
         CustomElementCallbackDispatcher::CallbackDeliveryScope scope;
         (*it)->processInElementQueue(kMicrotaskQueueId);
     }
 
     m_elements.clear();
     CustomElementScheduler::microtaskDispatcherDidFinish();
     m_phase = Quiescent;
 }
 
 #if !defined(NDEBUG)
 void CustomElementMicrotaskDispatcher::show()
 {
     fprintf(stderr, "Dispatcher:\n");
-    m_resolutionAndImports->show(1);
+    fprintf(stderr, "  Sync:\n");
+    m_resolutionAndImports->show(3);
+    fprintf(stderr, "  Async:\n");
+    m_asyncImports->show(3);
+
 }
 #endif
 
 } // namespace WebCore
 
 #if !defined(NDEBUG)
 void showCEMD()
 {
     WebCore::CustomElementMicrotaskDispatcher::instance().show();
 }
 #endif