rAF: Introduce FrameRequestCallbackCollection for managing rAF callbacks.

Source/core/dom/ScriptedAnimationController.cpp

 /*
  * Copyright (C) 2011 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 10 matching lines @@
  *  (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/ScriptedAnimationController.h"
 
 #include "core/css/MediaQueryListListener.h"
 #include "core/dom/Document.h"
-#include "core/dom/RequestAnimationFrameCallback.h"
+#include "core/dom/FrameRequestCallback.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/FrameView.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/loader/DocumentLoader.h"
 #include "platform/Logging.h"
 
 namespace blink {
 
 std::pair<EventTarget*, StringImpl*> eventTargetKey(const Event* event)
 {
     return std::make_pair(event->target(), event->type().impl());
 }
 
 ScriptedAnimationController::ScriptedAnimationController(Document* document)
     : m_document(document)
-    , m_nextCallbackId(0)
+    , m_callbackCollection(document)
     , m_suspendCount(0)
 {
 }
 
 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(ScriptedAnimationController);
 
 DEFINE_TRACE(ScriptedAnimationController)
 {
 #if ENABLE(OILPAN)
-    visitor->trace(m_callbacks);
-    visitor->trace(m_callbacksToInvoke);
     visitor->trace(m_document);
+    visitor->trace(m_callbackCollection);
     visitor->trace(m_eventQueue);
     visitor->trace(m_mediaQueryListListeners);
     visitor->trace(m_perFrameEvents);
 #endif
 }
 
 void ScriptedAnimationController::suspend()
 {
     ++m_suspendCount;
 }
 
 void ScriptedAnimationController::resume()
 {
     // It would be nice to put an ASSERT(m_suspendCount > 0) here, but in WK1 resume() can be called
     // even when suspend hasn't (if a tab was created in the background).
     if (m_suspendCount > 0)
         --m_suspendCount;
     scheduleAnimationIfNeeded();
 }
 
 void ScriptedAnimationController::dispatchEventsAndCallbacksForPrinting()
 {
     dispatchEvents(EventNames::MediaQueryListEvent);
     callMediaQueryListListeners();
 }
 
-ScriptedAnimationController::CallbackId ScriptedAnimationController::registerCallback(RequestAnimationFrameCallback* callback)
+ScriptedAnimationController::CallbackId ScriptedAnimationController::registerCallback(FrameRequestCallback* callback)
 {
-    ScriptedAnimationController::CallbackId id = ++m_nextCallbackId;
-    callback->m_cancelled = false;
-    callback->m_id = id;
-    m_callbacks.append(callback);
+    CallbackId id = m_callbackCollection.registerCallback(callback);
     scheduleAnimationIfNeeded();
-
-    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "RequestAnimationFrame", "data", InspectorAnimationFrameEvent::data(m_document, id));
-    InspectorInstrumentation::didRequestAnimationFrame(m_document, id);
-
     return id;
 }
 
 void ScriptedAnimationController::cancelCallback(CallbackId id)
 {
-    for (size_t i = 0; i < m_callbacks.size(); ++i) {
-        if (m_callbacks[i]->m_id == id) {
-            TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "CancelAnimationFrame", "data", InspectorAnimationFrameEvent::data(m_document, id));
-            InspectorInstrumentation::didCancelAnimationFrame(m_document, id);
-            m_callbacks.remove(i);
-            return;
-        }
-    }
-    for (size_t i = 0; i < m_callbacksToInvoke.size(); ++i) {
-        if (m_callbacksToInvoke[i]->m_id == id) {
-            TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "CancelAnimationFrame", "data", InspectorAnimationFrameEvent::data(m_document, id));
-            InspectorInstrumentation::didCancelAnimationFrame(m_document, id);
-            m_callbacksToInvoke[i]->m_cancelled = true;
-            // will be removed at the end of executeCallbacks()
-            return;
-        }
-    }
+    m_callbackCollection.cancelCallback(id);
 }
 
 void ScriptedAnimationController::dispatchEvents(const AtomicString& eventInterfaceFilter)
 {
     WillBeHeapVector<RefPtrWillBeMember<Event>> events;
     if (eventInterfaceFilter.isEmpty()) {
         events.swap(m_eventQueue);
         m_perFrameEvents.clear();
     } else {
         WillBeHeapVector<RefPtrWillBeMember<Event>> remaining;
@@ skipping 24 matching lines @@
 }
 
 void ScriptedAnimationController::executeCallbacks(double monotonicTimeNow)
 {
     // dispatchEvents() runs script which can cause the document to be destroyed.
     if (!m_document)
         return;
 
     double highResNowMs = 1000.0 * m_document->loader()->timing().monotonicTimeToZeroBasedDocumentTime(monotonicTimeNow);
     double legacyHighResNowMs = 1000.0 * m_document->loader()->timing().monotonicTimeToPseudoWallTime(monotonicTimeNow);
-
-    // First, generate a list of callbacks to consider.  Callbacks registered from this point
-    // on are considered only for the "next" frame, not this one.
-    ASSERT(m_callbacksToInvoke.isEmpty());
-    m_callbacksToInvoke.swap(m_callbacks);
-
-    for (size_t i = 0; i < m_callbacksToInvoke.size(); ++i) {
-        RequestAnimationFrameCallback* callback = m_callbacksToInvoke[i].get();
-        if (!callback->m_cancelled) {
-            TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "FireAnimationFrame", "data", InspectorAnimationFrameEvent::data(m_document, callback->m_id));
-            InspectorInstrumentationCookie cookie = InspectorInstrumentation::willFireAnimationFrame(m_document, callback->m_id);
-            if (callback->m_useLegacyTimeBase)
-                callback->handleEvent(legacyHighResNowMs);
-            else
-                callback->handleEvent(highResNowMs);
-            InspectorInstrumentation::didFireAnimationFrame(cookie);
-            TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", "data", InspectorUpdateCountersEvent::data());
-        }
-    }
-
-    m_callbacksToInvoke.clear();
+    m_callbackCollection.executeCallbacks(highResNowMs, legacyHighResNowMs);
 }
 
 void ScriptedAnimationController::callMediaQueryListListeners()
 {
     MediaQueryListListeners listeners;
     listeners.swap(m_mediaQueryListListeners);
 
     for (const auto& listener : listeners) {
         listener->notifyMediaQueryChanged();
     }
 }
 
 void ScriptedAnimationController::serviceScriptedAnimations(double monotonicTimeNow)
 {
-    if (!m_callbacks.size() && !m_eventQueue.size() && !m_mediaQueryListListeners.size())
+    if (m_callbackCollection.isEmpty() && !m_eventQueue.size() && !m_mediaQueryListListeners.size())
         return;
 
     if (m_suspendCount)
         return;
 
     RefPtrWillBeRawPtr<ScriptedAnimationController> protect(this);
 
     callMediaQueryListListeners();
     dispatchEvents();
     executeCallbacks(monotonicTimeNow);
@@ skipping 24 matching lines @@
 }
 
 void ScriptedAnimationController::scheduleAnimationIfNeeded()
 {
     if (!m_document)
         return;
 
     if (m_suspendCount)
         return;
 
-    if (!m_callbacks.size() && !m_eventQueue.size() && !m_mediaQueryListListeners.size())
+    if (m_callbackCollection.isEmpty() && !m_eventQueue.size() && !m_mediaQueryListListeners.size())
         return;
 
     if (FrameView* frameView = m_document->view())
         frameView->scheduleAnimation();
 }
 
 }