Introduce EventQueueProcessor

Summary:
Changelog: [internal]

Pulling out event queue processing to its separate class. We will be adding more logic there so it makes sense to separate it for simplicity and testability purposes.

Alternative names that came to mind: `EventsProcessor`, `EventsDispatcher`.

Reviewed By: JoshuaGross

Differential Revision: D28572283

fbshipit-source-id: 1cb2459f616b9995f66da80d50c401e68002da7f

Author: sammy-SC

ReactCommon/react/renderer/core/BatchedEventQueue.cpp

@@ -11,10 +11,9 @@ namespace facebook {
 namespace react {
 
 BatchedEventQueue::BatchedEventQueue(
-    EventPipe eventPipe,
-    StatePipe statePipe,
+    EventQueueProcessor eventProcessor,
     std::unique_ptr<EventBeat> eventBeat)
-    : EventQueue(eventPipe, statePipe, std::move(eventBeat)) {}
+    : EventQueue(std::move(eventProcessor), std::move(eventBeat)) {}
 
 void BatchedEventQueue::onEnqueue() const {
   eventBeat_->request();

ReactCommon/react/renderer/core/BatchedEventQueue.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <react/renderer/core/EventQueue.h>
+#include <react/renderer/core/EventQueueProcessor.h>
 
 namespace facebook {
 namespace react {
@@ -19,8 +20,7 @@ namespace react {
 class BatchedEventQueue final : public EventQueue {
  public:
   BatchedEventQueue(
-      EventPipe eventPipe,
-      StatePipe statePipe,
+      EventQueueProcessor eventProcessor,
       std::unique_ptr<EventBeat> eventBeat);
 
   void onEnqueue() const override;

ReactCommon/react/renderer/core/EventDispatcher.cpp

@@ -17,27 +17,22 @@ namespace facebook {
 namespace react {
 
 EventDispatcher::EventDispatcher(
-    EventPipe const &eventPipe,
-    StatePipe const &statePipe,
+    EventQueueProcessor eventProcessor,
     EventBeat::Factory const &synchonousEventBeatFactory,
     EventBeat::Factory const &asynchonousEventBeatFactory,
     EventBeat::SharedOwnerBox const &ownerBox,
     bool unbatchedQueuesOnly)
     : synchronousUnbatchedQueue_(std::make_unique<UnbatchedEventQueue>(
-          eventPipe,
-          statePipe,
+          eventProcessor,
           synchonousEventBeatFactory(ownerBox))),
       synchronousBatchedQueue_(std::make_unique<BatchedEventQueue>(
-          eventPipe,
-          statePipe,
+          eventProcessor,
           synchonousEventBeatFactory(ownerBox))),
       asynchronousUnbatchedQueue_(std::make_unique<UnbatchedEventQueue>(
-          eventPipe,
-          statePipe,
+          eventProcessor,
           asynchonousEventBeatFactory(ownerBox))),
       asynchronousBatchedQueue_(std::make_unique<BatchedEventQueue>(
-          eventPipe,
-          statePipe,
+          eventProcessor,
           asynchonousEventBeatFactory(ownerBox))),
       unbatchedQueuesOnly_(unbatchedQueuesOnly) {}
 

ReactCommon/react/renderer/core/EventDispatcher.h

@@ -7,14 +7,10 @@
 
 #pragma once
 
-#include <array>
-#include <memory>
-
 #include <react/renderer/core/BatchedEventQueue.h>
 #include <react/renderer/core/EventBeat.h>
-#include <react/renderer/core/EventPipe.h>
 #include <react/renderer/core/EventPriority.h>
-#include <react/renderer/core/StatePipe.h>
+#include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/StateUpdate.h>
 #include <react/renderer/core/UnbatchedEventQueue.h>
 
@@ -33,8 +29,7 @@ class EventDispatcher {
   using Weak = std::weak_ptr<EventDispatcher const>;
 
   EventDispatcher(
-      EventPipe const &eventPipe,
-      StatePipe const &statePipe,
+      EventQueueProcessor eventProcessor,
       EventBeat::Factory const &synchonousEventBeatFactory,
       EventBeat::Factory const &asynchonousEventBeatFactory,
       EventBeat::SharedOwnerBox const &ownerBox,

ReactCommon/react/renderer/core/EventQueue.cpp

@@ -14,11 +14,9 @@ namespace facebook {
 namespace react {
 
 EventQueue::EventQueue(
-    EventPipe eventPipe,
-    StatePipe statePipe,
+    EventQueueProcessor eventProcessor,
     std::unique_ptr<EventBeat> eventBeat)
-    : eventPipe_(std::move(eventPipe)),
-      statePipe_(std::move(statePipe)),
+    : eventProcessor_(std::move(eventProcessor)),
       eventBeat_(std::move(eventBeat)) {
   eventBeat_->setBeatCallback(
       std::bind(&EventQueue::onBeat, this, std::placeholders::_1));
@@ -97,30 +95,7 @@ void EventQueue::flushEvents(jsi::Runtime &runtime) const {
     eventQueue_.clear();
   }
 
-  {
-    std::lock_guard<std::mutex> lock(EventEmitter::DispatchMutex());
-
-    for (const auto &event : queue) {
-      if (event.eventTarget) {
-        event.eventTarget->retain(runtime);
-      }
-    }
-  }
-
-  for (const auto &event : queue) {
-    eventPipe_(
-        runtime, event.eventTarget.get(), event.type, event.payloadFactory);
-  }
-
-  // No need to lock `EventEmitter::DispatchMutex()` here.
-  // The mutex protects from a situation when the `instanceHandle` can be
-  // deallocated during accessing, but that's impossible at this point because
-  // we have a strong pointer to it.
-  for (const auto &event : queue) {
-    if (event.eventTarget) {
-      event.eventTarget->release(runtime);
-    }
-  }
+  eventProcessor_.flushEvents(runtime, std::move(queue));
 }
 
 void EventQueue::flushStateUpdates() const {
@@ -137,9 +112,7 @@ void EventQueue::flushStateUpdates() const {
     stateUpdateQueue_.clear();
   }
 
-  for (const auto &stateUpdate : stateUpdateQueue) {
-    statePipe_(stateUpdate);
-  }
+  eventProcessor_.flushStateUpdates(std::move(stateUpdateQueue));
 }
 
 } // namespace react

ReactCommon/react/renderer/core/EventQueue.h

@@ -13,9 +13,8 @@
 
 #include <jsi/jsi.h>
 #include <react/renderer/core/EventBeat.h>
-#include <react/renderer/core/EventPipe.h>
+#include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/RawEvent.h>
-#include <react/renderer/core/StatePipe.h>
 #include <react/renderer/core/StateUpdate.h>
 
 namespace facebook {
@@ -28,8 +27,7 @@ namespace react {
 class EventQueue {
  public:
   EventQueue(
-      EventPipe eventPipe,
-      StatePipe statePipe,
+      EventQueueProcessor eventProcessor,
       std::unique_ptr<EventBeat> eventBeat);
   virtual ~EventQueue() = default;
 
@@ -64,8 +62,8 @@ class EventQueue {
   void flushEvents(jsi::Runtime &runtime) const;
   void flushStateUpdates() const;
 
-  const EventPipe eventPipe_;
-  const StatePipe statePipe_;
+  EventQueueProcessor eventProcessor_;
+
   const std::unique_ptr<EventBeat> eventBeat_;
   // Thread-safe, protected by `queueMutex_`.
   mutable std::vector<RawEvent> eventQueue_;

ReactCommon/react/renderer/core/EventQueueProcessor.cpp

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "EventQueue.h"
+
+#include "EventEmitter.h"
+#include "ShadowNodeFamily.h"
+
+namespace facebook {
+namespace react {
+
+EventQueueProcessor::EventQueueProcessor(
+    EventPipe eventPipe,
+    StatePipe statePipe)
+    : eventPipe_(std::move(eventPipe)), statePipe_(std::move(statePipe)) {}
+
+void EventQueueProcessor::flushEvents(
+    jsi::Runtime &runtime,
+    std::vector<RawEvent> &&events) const {
+  {
+    std::lock_guard<std::mutex> lock(EventEmitter::DispatchMutex());
+
+    for (const auto &event : events) {
+      if (event.eventTarget) {
+        event.eventTarget->retain(runtime);
+      }
+    }
+  }
+
+  for (const auto &event : events) {
+    eventPipe_(
+        runtime, event.eventTarget.get(), event.type, event.payloadFactory);
+  }
+
+  // No need to lock `EventEmitter::DispatchMutex()` here.
+  // The mutex protects from a situation when the `instanceHandle` can be
+  // deallocated during accessing, but that's impossible at this point because
+  // we have a strong pointer to it.
+  for (const auto &event : events) {
+    if (event.eventTarget) {
+      event.eventTarget->release(runtime);
+    }
+  }
+}
+
+void EventQueueProcessor::flushStateUpdates(
+    std::vector<StateUpdate> &&states) const {
+  for (const auto &stateUpdate : states) {
+    statePipe_(stateUpdate);
+  }
+}
+
+} // namespace react
+} // namespace facebook

ReactCommon/react/renderer/core/EventQueueProcessor.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <vector>
+
+#include <jsi/jsi.h>
+#include <react/renderer/core/EventPipe.h>
+#include <react/renderer/core/RawEvent.h>
+#include <react/renderer/core/StatePipe.h>
+#include <react/renderer/core/StateUpdate.h>
+
+namespace facebook {
+namespace react {
+
+class EventQueueProcessor {
+ public:
+  EventQueueProcessor(EventPipe eventPipe, StatePipe statePipe);
+
+  void flushEvents(jsi::Runtime &runtime, std::vector<RawEvent> &&events) const;
+  void flushStateUpdates(std::vector<StateUpdate> &&states) const;
+
+ private:
+  EventPipe const eventPipe_;
+  StatePipe const statePipe_;
+};
+
+} // namespace react
+} // namespace facebook

ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -13,6 +13,7 @@
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/componentregistry/ComponentDescriptorRegistry.h>
 #include <react/renderer/core/Constants.h>
+#include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
@@ -77,8 +78,7 @@ Scheduler::Scheduler(
   // Creating an `EventDispatcher` instance inside the already allocated
   // container (inside the optional).
   eventDispatcher_->emplace(
-      eventPipe,
-      statePipe,
+      EventQueueProcessor(eventPipe, statePipe),
       schedulerToolbox.synchronousEventBeatFactory,
       schedulerToolbox.asynchronousEventBeatFactory,
       eventOwnerBox,

packages/rn-tester/Podfile.lock

@@ -862,7 +862,7 @@ SPEC CHECKSUMS:
   RCTTypeSafety: f5405e0143bb2addae97ce33e4c87d9284a48fe2
   React: f64c9f6db5428717922a3292ba6a448615a2e143
   React-callinvoker: c5d61e29df57793f0dc10ec2bc01c846f863e51f
-  React-Core: 6ac4e2647cebffffe6e24137682fb2a325dc43be
+  React-Core: f5b65410a2ecdbb4560f23dc4525588390b0b3b1
   React-CoreModules: 818e75a3eb8f431be8fc3d8c8eb15206b3f52e81
   React-cxxreact: fa0884110d142f7e1600a86ae769d5fd43ec8a69
   React-Fabric: ee21f85af985320ca427353e95821a5b4d6f4f46