react-native-tvos 0.74.3-0 → 0.75.2-0

package/ReactAndroid/src/main/java/com/facebook/react/runtime/internal/bolts/Task.java

@@ -10,18 +10,11 @@ package com.facebook.react.runtime.internal.bolts;
 import androidx.annotation.Nullable;
 import com.facebook.react.interfaces.TaskInterface;
 import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.Executor;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * Represents the result of an asynchronous operation.
@@ -29,18 +22,15 @@ import java.util.concurrent.atomic.AtomicInteger;
  * @param <TResult> The type of the result of the task.
  */
 public class Task<TResult> implements TaskInterface<TResult> {
-  /** An {@link java.util.concurrent.Executor} that executes tasks in parallel. */
-  public static final ExecutorService BACKGROUND_EXECUTOR = BoltsExecutors.background();
-
   /**
    * An {@link java.util.concurrent.Executor} that executes tasks in the current thread unless the
    * stack runs too deep, at which point it will delegate to {@link Task#BACKGROUND_EXECUTOR} in
    * order to trim the stack.
    */
-  private static final Executor IMMEDIATE_EXECUTOR = BoltsExecutors.immediate();
+  public static final Executor IMMEDIATE_EXECUTOR = Executors.IMMEDIATE;
 
   /** An {@link java.util.concurrent.Executor} that executes tasks on the UI thread. */
-  public static final Executor UI_THREAD_EXECUTOR = AndroidExecutors.uiThread();
+  public static final Executor UI_THREAD_EXECUTOR = Executors.UI_THREAD;
 
   /**
    * Interface for handlers invoked when a failed {@code Task} is about to be finalized, but the
@@ -121,7 +111,9 @@ public class Task<TResult> implements TaskInterface<TResult> {
     }
   }
 
-  /** @return {@code true} if the task was cancelled, {@code false} otherwise. */
+  /**
+   * @return {@code true} if the task was cancelled, {@code false} otherwise.
+   */
   @Override
   public boolean isCancelled() {
     synchronized (lock) {
@@ -129,7 +121,9 @@ public class Task<TResult> implements TaskInterface<TResult> {
     }
   }
 
-  /** @return {@code true} if the task has an error, {@code false} otherwise. */
+  /**
+   * @return {@code true} if the task has an error, {@code false} otherwise.
+   */
   @Override
   public boolean isFaulted() {
     synchronized (lock) {
@@ -137,7 +131,9 @@ public class Task<TResult> implements TaskInterface<TResult> {
     }
   }
 
-  /** @return The result of the task, if set. {@code null} otherwise. */
+  /**
+   * @return The result of the task, if set. {@code null} otherwise.
+   */
   @Override
   public TResult getResult() {
     synchronized (lock) {
@@ -145,7 +141,9 @@ public class Task<TResult> implements TaskInterface<TResult> {
     }
   }
 
-  /** @return The error for the task, if set. {@code null} otherwise. */
+  /**
+   * @return The error for the task, if set. {@code null} otherwise.
+   */
   @Override
   public Exception getError() {
     synchronized (lock) {
@@ -213,74 +211,6 @@ public class Task<TResult> implements TaskInterface<TResult> {
     return (Task<TResult>) TASK_CANCELLED;
   }
 
-  /**
-   * Creates a task that completes after a time delay.
-   *
-   * @param delay The number of milliseconds to wait before completing the returned task. Zero and
-   *     negative values are treated as requests for immediate execution.
-   */
-  public static Task<Void> delay(long delay) {
-    return delay(delay, BoltsExecutors.scheduled(), null);
-  }
-
-  /**
-   * Creates a task that completes after a time delay.
-   *
-   * @param delay The number of milliseconds to wait before completing the returned task. Zero and
-   *     negative values are treated as requests for immediate execution.
-   * @param cancellationToken The optional cancellation token that will be checked prior to
-   *     completing the returned task.
-   */
-  public static Task<Void> delay(long delay, CancellationToken cancellationToken) {
-    return delay(delay, BoltsExecutors.scheduled(), cancellationToken);
-  }
-
-  /* package */ static Task<Void> delay(
-      long delay, ScheduledExecutorService executor, final CancellationToken cancellationToken) {
-    if (cancellationToken != null && cancellationToken.isCancellationRequested()) {
-      return Task.cancelled();
-    }
-
-    if (delay <= 0) {
-      return Task.forResult(null);
-    }
-
-    final TaskCompletionSource<Void> tcs = new TaskCompletionSource<>();
-    final ScheduledFuture<?> scheduled =
-        executor.schedule(
-            new Runnable() {
-              @Override
-              public void run() {
-                tcs.trySetResult(null);
-              }
-            },
-            delay,
-            TimeUnit.MILLISECONDS);
-
-    if (cancellationToken != null) {
-      cancellationToken.register(
-          new Runnable() {
-            @Override
-            public void run() {
-              scheduled.cancel(true);
-              tcs.trySetCancelled();
-            }
-          });
-    }
-
-    return tcs.getTask();
-  }
-
-  /**
-   * Makes a fluent cast of a Task's result possible, avoiding an extra continuation just to cast
-   * the type of the result.
-   */
-  public <TOut> Task<TOut> cast() {
-    @SuppressWarnings("unchecked")
-    Task<TOut> task = (Task<TOut>) this;
-    return task;
-  }
-
   /** Turns a Task<T> into a Task<Void>, dropping any result. */
   public Task<Void> makeVoid() {
     return this.continueWithTask(
@@ -298,46 +228,14 @@ public class Task<TResult> implements TaskInterface<TResult> {
         });
   }
 
-  /**
-   * Invokes the callable on a background thread, returning a Task to represent the operation.
-   *
-   * <p>If you want to cancel the resulting Task throw a {@link
-   * java.util.concurrent.CancellationException} from the callable.
-   */
-  public static <TResult> Task<TResult> callInBackground(Callable<TResult> callable) {
-    return call(callable, BACKGROUND_EXECUTOR, null);
-  }
-
-  /** Invokes the callable on a background thread, returning a Task to represent the operation. */
-  public static <TResult> Task<TResult> callInBackground(
-      Callable<TResult> callable, CancellationToken ct) {
-    return call(callable, BACKGROUND_EXECUTOR, ct);
-  }
-
-  /**
-   * Invokes the callable using the given executor, returning a Task to represent the operation.
-   *
-   * <p>If you want to cancel the resulting Task throw a {@link
-   * java.util.concurrent.CancellationException} from the callable.
-   */
-  public static <TResult> Task<TResult> call(final Callable<TResult> callable, Executor executor) {
-    return call(callable, executor, null);
-  }
-
   /** Invokes the callable using the given executor, returning a Task to represent the operation. */
-  public static <TResult> Task<TResult> call(
-      final Callable<TResult> callable, Executor executor, final CancellationToken ct) {
+  public static <TResult> Task<TResult> call(final Callable<TResult> callable, Executor executor) {
     final TaskCompletionSource<TResult> tcs = new TaskCompletionSource<>();
     try {
       executor.execute(
           new Runnable() {
             @Override
             public void run() {
-              if (ct != null && ct.isCancellationRequested()) {
-                tcs.setCancelled();
-                return;
-              }
-
               try {
                 tcs.setResult(callable.call());
               } catch (CancellationException e) {
@@ -361,266 +259,7 @@ public class Task<TResult> implements TaskInterface<TResult> {
    * java.util.concurrent.CancellationException} from the callable.
    */
   public static <TResult> Task<TResult> call(final Callable<TResult> callable) {
-    return call(callable, IMMEDIATE_EXECUTOR, null);
-  }
-
-  /** Invokes the callable on the current thread, producing a Task. */
-  public static <TResult> Task<TResult> call(
-      final Callable<TResult> callable, CancellationToken ct) {
-    return call(callable, IMMEDIATE_EXECUTOR, ct);
-  }
-
-  /**
-   * Creates a task that will complete when any of the supplied tasks have completed.
-   *
-   * <p>The returned task will complete when any of the supplied tasks has completed. The returned
-   * task will always end in the completed state with its result set to the first task to complete.
-   * This is true even if the first task to complete ended in the canceled or faulted state.
-   *
-   * @param tasks The tasks to wait on for completion.
-   * @return A task that represents the completion of one of the supplied tasks. The return task's
-   *     result is the task that completed.
-   */
-  public static <TResult> Task<Task<TResult>> whenAnyResult(
-      Collection<? extends Task<TResult>> tasks) {
-    if (tasks.size() == 0) {
-      return Task.forResult(null);
-    }
-
-    final TaskCompletionSource<Task<TResult>> firstCompleted = new TaskCompletionSource<>();
-    final AtomicBoolean isAnyTaskComplete = new AtomicBoolean(false);
-
-    for (Task<TResult> task : tasks) {
-      task.continueWith(
-          new Continuation<TResult, Void>() {
-            @Override
-            public Void then(Task<TResult> task) {
-              if (isAnyTaskComplete.compareAndSet(false, true)) {
-                firstCompleted.setResult(task);
-              } else {
-                Throwable ensureObserved = task.getError();
-              }
-              return null;
-            }
-          });
-    }
-    return firstCompleted.getTask();
-  }
-
-  /**
-   * Creates a task that will complete when any of the supplied tasks have completed.
-   *
-   * <p>The returned task will complete when any of the supplied tasks has completed. The returned
-   * task will always end in the completed state with its result set to the first task to complete.
-   * This is true even if the first task to complete ended in the canceled or faulted state.
-   *
-   * @param tasks The tasks to wait on for completion.
-   * @return A task that represents the completion of one of the supplied tasks. The return task's
-   *     Result is the task that completed.
-   */
-  @SuppressWarnings("unchecked")
-  public static Task<Task<?>> whenAny(Collection<? extends Task<?>> tasks) {
-    if (tasks.size() == 0) {
-      return Task.forResult(null);
-    }
-
-    final TaskCompletionSource<Task<?>> firstCompleted = new TaskCompletionSource<>();
-    final AtomicBoolean isAnyTaskComplete = new AtomicBoolean(false);
-
-    for (Task<?> task : tasks) {
-      ((Task<Object>) task)
-          .continueWith(
-              new Continuation<Object, Void>() {
-                @Override
-                public Void then(Task<Object> task) {
-                  if (isAnyTaskComplete.compareAndSet(false, true)) {
-                    firstCompleted.setResult(task);
-                  } else {
-                    Throwable ensureObserved = task.getError();
-                  }
-                  return null;
-                }
-              });
-    }
-    return firstCompleted.getTask();
-  }
-
-  /**
-   * Creates a task that completes when all of the provided tasks are complete.
-   *
-   * <p>If any of the supplied tasks completes in a faulted state, the returned task will also
-   * complete in a faulted state, where its exception will resolve to that {@link
-   * java.lang.Exception} if a single task fails or an {@link AggregateException} of all the {@link
-   * java.lang.Exception}s if multiple tasks fail.
-   *
-   * <p>If none of the supplied tasks faulted but at least one of them was cancelled, the returned
-   * task will end as cancelled.
-   *
-   * <p>If none of the tasks faulted and none of the tasks were cancelled, the resulting task will
-   * end completed. The result of the returned task will be set to a list containing all of the
-   * results of the supplied tasks in the same order as they were provided (e.g. if the input tasks
-   * collection contained t1, t2, t3, the output task's result will return an {@code
-   * List&lt;TResult&gt;} where {@code list.get(0) == t1.getResult(), list.get(1) == t2.getResult(),
-   * and list.get(2) == t3.getResult()}).
-   *
-   * <p>If the supplied collection contains no tasks, the returned task will immediately transition
-   * to a completed state before it's returned to the caller. The returned {@code
-   * List&lt;TResult&gt;} will contain 0 elements.
-   *
-   * @param tasks The tasks that the return value will wait for before completing.
-   * @return A Task that will resolve to {@code List&lt;TResult&gt;} when all the tasks are
-   *     resolved.
-   */
-  public static <TResult> Task<List<TResult>> whenAllResult(
-      final Collection<? extends Task<TResult>> tasks) {
-    return whenAll(tasks)
-        .onSuccess(
-            new Continuation<Void, List<TResult>>() {
-              @Override
-              public List<TResult> then(Task<Void> task) throws Exception {
-                if (tasks.size() == 0) {
-                  return Collections.emptyList();
-                }
-
-                List<TResult> results = new ArrayList<>();
-                for (Task<TResult> individualTask : tasks) {
-                  results.add(individualTask.getResult());
-                }
-                return results;
-              }
-            });
-  }
-
-  /**
-   * Creates a task that completes when all of the provided tasks are complete.
-   *
-   * <p>If any of the supplied tasks completes in a faulted state, the returned task will also
-   * complete in a faulted state, where its exception will resolve to that {@link
-   * java.lang.Exception} if a single task fails or an {@link AggregateException} of all the {@link
-   * java.lang.Exception}s if multiple tasks fail.
-   *
-   * <p>If none of the supplied tasks faulted but at least one of them was cancelled, the returned
-   * task will end as cancelled.
-   *
-   * <p>If none of the tasks faulted and none of the tasks were canceled, the resulting task will
-   * end in the completed state.
-   *
-   * <p>If the supplied collection contains no tasks, the returned task will immediately transition
-   * to a completed state before it's returned to the caller.
-   *
-   * @param tasks The tasks that the return value will wait for before completing.
-   * @return A Task that will resolve to {@code Void} when all the tasks are resolved.
-   */
-  public static Task<Void> whenAll(Collection<? extends Task<?>> tasks) {
-    if (tasks.size() == 0) {
-      return Task.forResult(null);
-    }
-
-    final TaskCompletionSource<Void> allFinished = new TaskCompletionSource<>();
-    final ArrayList<Exception> causes = new ArrayList<>();
-    final Object errorLock = new Object();
-    final AtomicInteger count = new AtomicInteger(tasks.size());
-    final AtomicBoolean isCancelled = new AtomicBoolean(false);
-
-    for (Task<?> task : tasks) {
-      @SuppressWarnings("unchecked")
-      Task<Object> t = (Task<Object>) task;
-      t.continueWith(
-          new Continuation<Object, Void>() {
-            @Override
-            public Void then(Task<Object> task) {
-              if (task.isFaulted()) {
-                synchronized (errorLock) {
-                  causes.add(task.getError());
-                }
-              }
-
-              if (task.isCancelled()) {
-                isCancelled.set(true);
-              }
-
-              if (count.decrementAndGet() == 0) {
-                if (causes.size() != 0) {
-                  if (causes.size() == 1) {
-                    allFinished.setError(causes.get(0));
-                  } else {
-                    Exception error =
-                        new AggregateException(
-                            String.format("There were %d exceptions.", causes.size()), causes);
-                    allFinished.setError(error);
-                  }
-                } else if (isCancelled.get()) {
-                  allFinished.setCancelled();
-                } else {
-                  allFinished.setResult(null);
-                }
-              }
-              return null;
-            }
-          });
-    }
-
-    return allFinished.getTask();
-  }
-
-  /**
-   * Continues a task with the equivalent of a Task-based while loop, where the body of the loop is
-   * a task continuation.
-   */
-  public Task<Void> continueWhile(
-      Callable<Boolean> predicate, Continuation<Void, Task<Void>> continuation) {
-    return continueWhile(predicate, continuation, IMMEDIATE_EXECUTOR, null);
-  }
-
-  /**
-   * Continues a task with the equivalent of a Task-based while loop, where the body of the loop is
-   * a task continuation.
-   */
-  public Task<Void> continueWhile(
-      Callable<Boolean> predicate,
-      Continuation<Void, Task<Void>> continuation,
-      CancellationToken ct) {
-    return continueWhile(predicate, continuation, IMMEDIATE_EXECUTOR, ct);
-  }
-
-  /**
-   * Continues a task with the equivalent of a Task-based while loop, where the body of the loop is
-   * a task continuation.
-   */
-  public Task<Void> continueWhile(
-      final Callable<Boolean> predicate,
-      final Continuation<Void, Task<Void>> continuation,
-      final Executor executor) {
-    return continueWhile(predicate, continuation, executor, null);
-  }
-
-  /**
-   * Continues a task with the equivalent of a Task-based while loop, where the body of the loop is
-   * a task continuation.
-   */
-  public Task<Void> continueWhile(
-      final Callable<Boolean> predicate,
-      final Continuation<Void, Task<Void>> continuation,
-      final Executor executor,
-      final CancellationToken ct) {
-    final Capture<Continuation<Void, Task<Void>>> predicateContinuation = new Capture<>();
-    predicateContinuation.set(
-        new Continuation<Void, Task<Void>>() {
-          @Override
-          public Task<Void> then(Task<Void> task) throws Exception {
-            if (ct != null && ct.isCancellationRequested()) {
-              return Task.cancelled();
-            }
-
-            if (predicate.call()) {
-              return Task.<Void>forResult(null)
-                  .onSuccessTask(continuation, executor)
-                  .onSuccessTask(predicateContinuation.get(), executor);
-            }
-            return Task.forResult(null);
-          }
-        });
-    return makeVoid().continueWithTask(predicateContinuation.get(), executor);
+    return call(callable, IMMEDIATE_EXECUTOR);
   }
 
   /**
@@ -630,18 +269,6 @@ public class Task<TResult> implements TaskInterface<TResult> {
    */
   public <TContinuationResult> Task<TContinuationResult> continueWith(
       final Continuation<TResult, TContinuationResult> continuation, final Executor executor) {
-    return continueWith(continuation, executor, null);
-  }
-
-  /**
-   * Adds a continuation that will be scheduled using the executor, returning a new task that
-   * completes after the continuation has finished running. This allows the continuation to be
-   * scheduled on different thread.
-   */
-  public <TContinuationResult> Task<TContinuationResult> continueWith(
-      final Continuation<TResult, TContinuationResult> continuation,
-      final Executor executor,
-      final CancellationToken ct) {
     boolean completed;
     final TaskCompletionSource<TContinuationResult> tcs = new TaskCompletionSource<>();
     synchronized (lock) {
@@ -651,14 +278,14 @@ public class Task<TResult> implements TaskInterface<TResult> {
             new Continuation<TResult, Void>() {
               @Override
               public Void then(Task<TResult> task) {
-                completeImmediately(tcs, continuation, task, executor, ct);
+                completeImmediately(tcs, continuation, task, executor);
                 return null;
               }
             });
       }
     }
     if (completed) {
-      completeImmediately(tcs, continuation, this, executor, ct);
+      completeImmediately(tcs, continuation, this, executor);
     }
     return tcs.getTask();
   }
@@ -669,16 +296,7 @@ public class Task<TResult> implements TaskInterface<TResult> {
    */
   public <TContinuationResult> Task<TContinuationResult> continueWith(
       Continuation<TResult, TContinuationResult> continuation) {
-    return continueWith(continuation, IMMEDIATE_EXECUTOR, null);
-  }
-
-  /**
-   * Adds a synchronous continuation to this task, returning a new task that completes after the
-   * continuation has finished running.
-   */
-  public <TContinuationResult> Task<TContinuationResult> continueWith(
-      Continuation<TResult, TContinuationResult> continuation, CancellationToken ct) {
-    return continueWith(continuation, IMMEDIATE_EXECUTOR, ct);
+    return continueWith(continuation, IMMEDIATE_EXECUTOR);
   }
 
   /**
@@ -688,17 +306,6 @@ public class Task<TResult> implements TaskInterface<TResult> {
   public <TContinuationResult> Task<TContinuationResult> continueWithTask(
       final Continuation<TResult, Task<TContinuationResult>> continuation,
       final Executor executor) {
-    return continueWithTask(continuation, executor, null);
-  }
-
-  /**
-   * Adds an Task-based continuation to this task that will be scheduled using the executor,
-   * returning a new task that completes after the task returned by the continuation has completed.
-   */
-  public <TContinuationResult> Task<TContinuationResult> continueWithTask(
-      final Continuation<TResult, Task<TContinuationResult>> continuation,
-      final Executor executor,
-      final CancellationToken ct) {
     boolean completed;
     final TaskCompletionSource<TContinuationResult> tcs = new TaskCompletionSource<>();
     synchronized (lock) {
@@ -708,14 +315,14 @@ public class Task<TResult> implements TaskInterface<TResult> {
             new Continuation<TResult, Void>() {
               @Override
               public Void then(Task<TResult> task) {
-                completeAfterTask(tcs, continuation, task, executor, ct);
+                completeAfterTask(tcs, continuation, task, executor);
                 return null;
               }
             });
       }
     }
     if (completed) {
-      completeAfterTask(tcs, continuation, this, executor, ct);
+      completeAfterTask(tcs, continuation, this, executor);
     }
     return tcs.getTask();
   }
@@ -726,16 +333,7 @@ public class Task<TResult> implements TaskInterface<TResult> {
    */
   public <TContinuationResult> Task<TContinuationResult> continueWithTask(
       Continuation<TResult, Task<TContinuationResult>> continuation) {
-    return continueWithTask(continuation, IMMEDIATE_EXECUTOR, null);
-  }
-
-  /**
-   * Adds an asynchronous continuation to this task, returning a new task that completes after the
-   * task returned by the continuation has completed.
-   */
-  public <TContinuationResult> Task<TContinuationResult> continueWithTask(
-      Continuation<TResult, Task<TContinuationResult>> continuation, CancellationToken ct) {
-    return continueWithTask(continuation, IMMEDIATE_EXECUTOR, ct);
+    return continueWithTask(continuation, IMMEDIATE_EXECUTOR);
   }
 
   /**
@@ -744,25 +342,10 @@ public class Task<TResult> implements TaskInterface<TResult> {
    */
   public <TContinuationResult> Task<TContinuationResult> onSuccess(
       final Continuation<TResult, TContinuationResult> continuation, Executor executor) {
-    return onSuccess(continuation, executor, null);
-  }
-
-  /**
-   * Runs a continuation when a task completes successfully, forwarding along {@link
-   * java.lang.Exception} or cancellation.
-   */
-  public <TContinuationResult> Task<TContinuationResult> onSuccess(
-      final Continuation<TResult, TContinuationResult> continuation,
-      Executor executor,
-      final CancellationToken ct) {
     return continueWithTask(
         new Continuation<TResult, Task<TContinuationResult>>() {
           @Override
           public Task<TContinuationResult> then(Task<TResult> task) {
-            if (ct != null && ct.isCancellationRequested()) {
-              return Task.cancelled();
-            }
-
             if (task.isFaulted()) {
               return Task.forError(task.getError());
             } else if (task.isCancelled()) {
@@ -781,16 +364,7 @@ public class Task<TResult> implements TaskInterface<TResult> {
    */
   public <TContinuationResult> Task<TContinuationResult> onSuccess(
       final Continuation<TResult, TContinuationResult> continuation) {
-    return onSuccess(continuation, IMMEDIATE_EXECUTOR, null);
-  }
-
-  /**
-   * Runs a continuation when a task completes successfully, forwarding along {@link
-   * java.lang.Exception}s or cancellation.
-   */
-  public <TContinuationResult> Task<TContinuationResult> onSuccess(
-      final Continuation<TResult, TContinuationResult> continuation, CancellationToken ct) {
-    return onSuccess(continuation, IMMEDIATE_EXECUTOR, ct);
+    return onSuccess(continuation, IMMEDIATE_EXECUTOR);
   }
 
   /**
@@ -799,25 +373,10 @@ public class Task<TResult> implements TaskInterface<TResult> {
    */
   public <TContinuationResult> Task<TContinuationResult> onSuccessTask(
       final Continuation<TResult, Task<TContinuationResult>> continuation, Executor executor) {
-    return onSuccessTask(continuation, executor, null);
-  }
-
-  /**
-   * Runs a continuation when a task completes successfully, forwarding along {@link
-   * java.lang.Exception}s or cancellation.
-   */
-  public <TContinuationResult> Task<TContinuationResult> onSuccessTask(
-      final Continuation<TResult, Task<TContinuationResult>> continuation,
-      Executor executor,
-      final CancellationToken ct) {
     return continueWithTask(
         new Continuation<TResult, Task<TContinuationResult>>() {
           @Override
           public Task<TContinuationResult> then(Task<TResult> task) {
-            if (ct != null && ct.isCancellationRequested()) {
-              return Task.cancelled();
-            }
-
             if (task.isFaulted()) {
               return Task.forError(task.getError());
             } else if (task.isCancelled()) {
@@ -839,15 +398,6 @@ public class Task<TResult> implements TaskInterface<TResult> {
     return onSuccessTask(continuation, IMMEDIATE_EXECUTOR);
   }
 
-  /**
-   * Runs a continuation when a task completes successfully, forwarding along {@link
-   * java.lang.Exception}s or cancellation.
-   */
-  public <TContinuationResult> Task<TContinuationResult> onSuccessTask(
-      final Continuation<TResult, Task<TContinuationResult>> continuation, CancellationToken ct) {
-    return onSuccessTask(continuation, IMMEDIATE_EXECUTOR, ct);
-  }
-
   /**
    * Handles the non-async (i.e. the continuation doesn't return a Task) continuation case, passing
    * the results of the given Task through to the given continuation and using the results of that
@@ -863,18 +413,12 @@ public class Task<TResult> implements TaskInterface<TResult> {
       final TaskCompletionSource<TContinuationResult> tcs,
       final Continuation<TResult, TContinuationResult> continuation,
       final Task<TResult> task,
-      Executor executor,
-      final CancellationToken ct) {
+      Executor executor) {
     try {
       executor.execute(
           new Runnable() {
             @Override
             public void run() {
-              if (ct != null && ct.isCancellationRequested()) {
-                tcs.setCancelled();
-                return;
-              }
-
               try {
                 TContinuationResult result = continuation.then(task);
                 tcs.setResult(result);
@@ -906,18 +450,12 @@ public class Task<TResult> implements TaskInterface<TResult> {
       final TaskCompletionSource<TContinuationResult> tcs,
       final Continuation<TResult, Task<TContinuationResult>> continuation,
       final Task<TResult> task,
-      final Executor executor,
-      final CancellationToken ct) {
+      final Executor executor) {
     try {
       executor.execute(
           new Runnable() {
             @Override
             public void run() {
-              if (ct != null && ct.isCancellationRequested()) {
-                tcs.setCancelled();
-                return;
-              }
-
               try {
                 Task<TContinuationResult> result = continuation.then(task);
                 if (result == null) {
@@ -927,11 +465,6 @@ public class Task<TResult> implements TaskInterface<TResult> {
                       new Continuation<TContinuationResult, Void>() {
                         @Override
                         public Void then(Task<TContinuationResult> task) {
-                          if (ct != null && ct.isCancellationRequested()) {
-                            tcs.setCancelled();
-                            return null;
-                          }
-
                           if (task.isCancelled()) {
                             tcs.setCancelled();
                           } else if (task.isFaulted()) {