Remove WebWorker support from Timers

Reviewed By: AaaChiuuu

Differential Revision: D4929245

fbshipit-source-id: 6eae128756a31f6063bf8fe39f0573c1c07ca8bb

ReactAndroid/src/main/java/com/facebook/react/modules/core/JSTimersExecution.java

@@ -10,10 +10,8 @@
 package com.facebook.react.modules.core;
 
 import com.facebook.react.bridge.JavaScriptModule;
-import com.facebook.react.bridge.SupportsWebWorkers;
 import com.facebook.react.bridge.WritableArray;
 
-@SupportsWebWorkers
 public interface JSTimersExecution extends JavaScriptModule {
   void callTimers(WritableArray timerIDs);
   void callIdleCallbacks(double frameTime);

ReactAndroid/src/main/java/com/facebook/react/modules/core/Timing.java

@@ -11,22 +11,14 @@ package com.facebook.react.modules.core;
 
 import javax.annotation.Nullable;
 
-import java.util.ArrayList;
 import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
 import java.util.PriorityQueue;
-import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import android.util.SparseArray;
 
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.ExecutorToken;
 import com.facebook.react.bridge.LifecycleEventListener;
-import com.facebook.react.bridge.OnExecutorUnregisteredListener;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
@@ -41,9 +33,9 @@ import com.facebook.react.module.annotations.ReactModule;
 /**
  * Native module for JS timer execution. Timers fire on frame boundaries.
  */
-@ReactModule(name = Timing.NAME, supportsWebWorkers = true)
+@ReactModule(name = Timing.NAME)
 public final class Timing extends ReactContextBaseJavaModule implements LifecycleEventListener,
-  OnExecutorUnregisteredListener, HeadlessJsTaskEventListener {
+  HeadlessJsTaskEventListener {
 
   protected static final String NAME = "Timing";
 
@@ -58,20 +50,16 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
   private final DevSupportManager mDevSupportManager;
 
   private static class Timer {
-
-    private final ExecutorToken mExecutorToken;
     private final int mCallbackID;
     private final boolean mRepeat;
     private final int mInterval;
     private long mTargetTime;
 
     private Timer(
-        ExecutorToken executorToken,
         int callbackID,
         long initialTargetTime,
         int duration,
         boolean repeat) {
-      mExecutorToken = executorToken;
       mCallbackID = callbackID;
       mTargetTime = initialTargetTime;
       mInterval = duration;
@@ -81,8 +69,8 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
 
   private class TimerFrameCallback extends ChoreographerCompat.FrameCallback {
 
-    // Temporary map for constructing the individual arrays of timers per ExecutorToken
-    private final HashMap<ExecutorToken, WritableArray> mTimersToCall = new HashMap<>();
+    // Temporary map for constructing the individual arrays of timers to call
+    private @Nullable WritableArray mTimersToCall = null;
 
     /**
      * Calls all timers that have expired since the last time this frame callback was called.
@@ -97,32 +85,23 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
       synchronized (mTimerGuard) {
         while (!mTimers.isEmpty() && mTimers.peek().mTargetTime < frameTimeMillis) {
           Timer timer = mTimers.poll();
-          WritableArray timersForContext = mTimersToCall.get(timer.mExecutorToken);
-          if (timersForContext == null) {
-            timersForContext = Arguments.createArray();
-            mTimersToCall.put(timer.mExecutorToken, timersForContext);
+          if (mTimersToCall == null) {
+            mTimersToCall = Arguments.createArray();
           }
-          timersForContext.pushInt(timer.mCallbackID);
+          mTimersToCall.pushInt(timer.mCallbackID);
           if (timer.mRepeat) {
             timer.mTargetTime = frameTimeMillis + timer.mInterval;
             mTimers.add(timer);
           } else {
-            SparseArray<Timer> timers = mTimerIdsToTimers.get(timer.mExecutorToken);
-            if (timers != null) {
-              timers.remove(timer.mCallbackID);
-              if (timers.size() == 0) {
-                mTimerIdsToTimers.remove(timer.mExecutorToken);
-              }
-            }
+            mTimerIdsToTimers.remove(timer.mCallbackID);
           }
         }
       }
 
-      for (Map.Entry<ExecutorToken, WritableArray> entry : mTimersToCall.entrySet()) {
-        getReactApplicationContext().getJSModule(entry.getKey(), JSTimersExecution.class)
-            .callTimers(entry.getValue());
+      if (mTimersToCall != null) {
+        getReactApplicationContext().getJSModule(JSTimersExecution.class).callTimers(mTimersToCall);
+        mTimersToCall = null;
       }
-      mTimersToCall.clear();
 
       mReactChoreographer.postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, this);
     }
@@ -172,13 +151,13 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
         return;
       }
 
-      mIdleCallbackContextsToCall.clear();
+      boolean sendIdleEvents;
       synchronized (mIdleCallbackGuard) {
-        mIdleCallbackContextsToCall.addAll(mSendIdleEventsExecutorTokens);
+        sendIdleEvents = mSendIdleEvents;
       }
 
-      for (ExecutorToken context : mIdleCallbackContextsToCall) {
-        getReactApplicationContext().getJSModule(context, JSTimersExecution.class)
+      if (sendIdleEvents) {
+        getReactApplicationContext().getJSModule(JSTimersExecution.class)
             .callIdleCallbacks(absoluteFrameStartTime);
       }
 
@@ -193,7 +172,7 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
   private final Object mTimerGuard = new Object();
   private final Object mIdleCallbackGuard = new Object();
   private final PriorityQueue<Timer> mTimers;
-  private final Map<ExecutorToken, SparseArray<Timer>> mTimerIdsToTimers;
+  private final SparseArray<Timer> mTimerIdsToTimers;
   private final AtomicBoolean isPaused = new AtomicBoolean(true);
   private final AtomicBoolean isRunningTasks = new AtomicBoolean(false);
   private final TimerFrameCallback mTimerFrameCallback = new TimerFrameCallback();
@@ -202,9 +181,7 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
   private @Nullable IdleCallbackRunnable mCurrentIdleCallbackRunnable;
   private boolean mFrameCallbackPosted = false;
   private boolean mFrameIdleCallbackPosted = false;
-  private final Set<ExecutorToken> mSendIdleEventsExecutorTokens;
-  // Temporary array used to dipatch idle callbacks on the JS thread.
-  private final List<ExecutorToken> mIdleCallbackContextsToCall;
+  private boolean mSendIdleEvents = false;
 
   public Timing(ReactApplicationContext reactContext, DevSupportManager devSupportManager) {
     super(reactContext);
@@ -225,9 +202,7 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
             }
           }
         });
-    mTimerIdsToTimers = new HashMap<>();
-    mSendIdleEventsExecutorTokens = new HashSet<>();
-    mIdleCallbackContextsToCall = new ArrayList<>();
+    mTimerIdsToTimers = new SparseArray<>();
     mReactChoreographer = ReactChoreographer.getInstance();
   }
 
@@ -291,7 +266,7 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
 
   private void maybeSetChoreographerIdleCallback() {
     synchronized (mIdleCallbackGuard) {
-      if (mSendIdleEventsExecutorTokens.size() > 0) {
+      if (mSendIdleEvents) {
         setChoreographerIdleCallback();
       }
     }
@@ -347,32 +322,8 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
     return NAME;
   }
 
-  @Override
-  public boolean supportsWebWorkers() {
-    return true;
-  }
-
-  @Override
-  public void onExecutorDestroyed(ExecutorToken executorToken) {
-    synchronized (mTimerGuard) {
-      SparseArray<Timer> timersForContext = mTimerIdsToTimers.remove(executorToken);
-      if (timersForContext == null) {
-        return;
-      }
-      for (int i = 0; i < timersForContext.size(); i++) {
-        Timer timer = timersForContext.get(timersForContext.keyAt(i));
-        mTimers.remove(timer);
-      }
-    }
-
-    synchronized (mIdleCallbackGuard) {
-      mSendIdleEventsExecutorTokens.remove(executorToken);
-    }
-  }
-
   @ReactMethod
   public void createTimer(
-      ExecutorToken executorToken,
       final int callbackID,
       final int duration,
       final double jsSchedulingTime,
@@ -386,7 +337,7 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
     if (mDevSupportManager.getDevSupportEnabled()) {
       long driftTime = Math.abs(remoteTime - deviceTime);
       if (driftTime > 60000) {
-        getReactApplicationContext().getJSModule(executorToken, JSTimersExecution.class)
+        getReactApplicationContext().getJSModule(JSTimersExecution.class)
           .emitTimeDriftWarning(
             "Debugger and device times have drifted by more than 60s. Please correct this by " +
             "running adb shell \"date `date +%m%d%H%M%Y.%S`\" on your debugger machine.");
@@ -398,59 +349,42 @@ public final class Timing extends ReactContextBaseJavaModule implements Lifecycl
     if (duration == 0 && !repeat) {
       WritableArray timerToCall = Arguments.createArray();
       timerToCall.pushInt(callbackID);
-      getReactApplicationContext().getJSModule(executorToken, JSTimersExecution.class)
+      getReactApplicationContext().getJSModule(JSTimersExecution.class)
         .callTimers(timerToCall);
       return;
     }
 
     long initialTargetTime = SystemClock.nanoTime() / 1000000 + adjustedDuration;
-    Timer timer = new Timer(executorToken, callbackID, initialTargetTime, duration, repeat);
+    Timer timer = new Timer(callbackID, initialTargetTime, duration, repeat);
     synchronized (mTimerGuard) {
       mTimers.add(timer);
-      SparseArray<Timer> timersForContext = mTimerIdsToTimers.get(executorToken);
-      if (timersForContext == null) {
-        timersForContext = new SparseArray<>();
-        mTimerIdsToTimers.put(executorToken, timersForContext);
-      }
-      timersForContext.put(callbackID, timer);
+      mTimerIdsToTimers.put(callbackID, timer);
     }
   }
 
   @ReactMethod
-  public void deleteTimer(ExecutorToken executorToken, int timerId) {
+  public void deleteTimer(int timerId) {
     synchronized (mTimerGuard) {
-      SparseArray<Timer> timersForContext = mTimerIdsToTimers.get(executorToken);
-      if (timersForContext == null) {
-        return;
-      }
-      Timer timer = timersForContext.get(timerId);
+      Timer timer = mTimerIdsToTimers.get(timerId);
       if (timer == null) {
         return;
       }
-      // We may have already called/removed it
-      timersForContext.remove(timerId);
-      if (timersForContext.size() == 0) {
-        mTimerIdsToTimers.remove(executorToken);
-      }
+      mTimerIdsToTimers.remove(timerId);
       mTimers.remove(timer);
     }
   }
 
   @ReactMethod
-  public void setSendIdleEvents(ExecutorToken executorToken, boolean sendIdleEvents) {
+  public void setSendIdleEvents(final boolean sendIdleEvents) {
     synchronized (mIdleCallbackGuard) {
-      if (sendIdleEvents) {
-        mSendIdleEventsExecutorTokens.add(executorToken);
-      } else {
-        mSendIdleEventsExecutorTokens.remove(executorToken);
-      }
+      mSendIdleEvents = sendIdleEvents;
     }
 
     UiThreadUtil.runOnUiThread(new Runnable() {
       @Override
       public void run() {
         synchronized (mIdleCallbackGuard) {
-          if (mSendIdleEventsExecutorTokens.size() > 0) {
+          if (sendIdleEvents) {
             setChoreographerIdleCallback();
           } else {
             clearChoreographerIdleCallback();