diff --git a/ci/licenses_golden/licenses_flutter b/ci/licenses_golden/licenses_flutter
index b238e78..8e2f603 100755
--- a/ci/licenses_golden/licenses_flutter
+++ b/ci/licenses_golden/licenses_flutter
@@ -1754,7 +1754,9 @@
 FILE: ../../../flutter/shell/platform/windows/system_utils_unittests.cc
 FILE: ../../../flutter/shell/platform/windows/system_utils_win32.cc
 FILE: ../../../flutter/shell/platform/windows/system_utils_winuwp.cc
+FILE: ../../../flutter/shell/platform/windows/task_runner.cc
 FILE: ../../../flutter/shell/platform/windows/task_runner.h
+FILE: ../../../flutter/shell/platform/windows/task_runner_unittests.cc
 FILE: ../../../flutter/shell/platform/windows/task_runner_win32.cc
 FILE: ../../../flutter/shell/platform/windows/task_runner_win32.h
 FILE: ../../../flutter/shell/platform/windows/task_runner_win32_window.cc
diff --git a/shell/platform/windows/BUILD.gn b/shell/platform/windows/BUILD.gn
index 525e852..029305e 100644
--- a/shell/platform/windows/BUILD.gn
+++ b/shell/platform/windows/BUILD.gn
@@ -77,6 +77,7 @@
     "sequential_id_generator.cc",
     "sequential_id_generator.h",
     "system_utils.h",
+    "task_runner.cc",
     "task_runner.h",
     "text_input_plugin.cc",
     "text_input_plugin.h",
@@ -226,6 +227,7 @@
     "sequential_id_generator_unittests.cc",
     "string_conversion_unittests.cc",
     "system_utils_unittests.cc",
+    "task_runner_unittests.cc",
     "testing/engine_modifier.h",
     "testing/mock_gl_functions.h",
   ]
diff --git a/shell/platform/windows/flutter_windows_engine.cc b/shell/platform/windows/flutter_windows_engine.cc
index b6fb9f4..bb020d5 100644
--- a/shell/platform/windows/flutter_windows_engine.cc
+++ b/shell/platform/windows/flutter_windows_engine.cc
@@ -143,8 +143,7 @@
   FlutterEngineGetProcAddresses(&embedder_api_);
 
   task_runner_ = TaskRunner::Create(
-      GetCurrentThreadId(), embedder_api_.GetCurrentTime,
-      [this](const auto* task) {
+      embedder_api_.GetCurrentTime, [this](const auto* task) {
         if (!engine_) {
           std::cerr << "Cannot post an engine task when engine is not running."
                     << std::endl;
diff --git a/shell/platform/windows/task_runner.cc b/shell/platform/windows/task_runner.cc
new file mode 100644
index 0000000..fa8b134
--- /dev/null
+++ b/shell/platform/windows/task_runner.cc
@@ -0,0 +1,104 @@
+// Copyright 2013 The Flutter 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 "flutter/shell/platform/windows/task_runner.h"
+
+#include <atomic>
+#include <utility>
+
+namespace flutter {
+
+TaskRunner::TaskRunner(CurrentTimeProc get_current_time,
+                       const TaskExpiredCallback& on_task_expired)
+    : get_current_time_(get_current_time),
+      on_task_expired_(std::move(on_task_expired)) {}
+
+std::chrono::nanoseconds TaskRunner::ProcessTasks() {
+  const TaskTimePoint now = TaskTimePoint::clock::now();
+
+  std::vector<Task> expired_tasks;
+
+  // Process expired tasks.
+  {
+    std::lock_guard<std::mutex> lock(task_queue_mutex_);
+    while (!task_queue_.empty()) {
+      const auto& top = task_queue_.top();
+      // If this task (and all tasks after this) has not yet expired, there is
+      // nothing more to do. Quit iterating.
+      if (top.fire_time > now) {
+        break;
+      }
+
+      // Make a record of the expired task. Do NOT service the task here
+      // because we are still holding onto the task queue mutex. We don't want
+      // other threads to block on posting tasks onto this thread till we are
+      // done processing expired tasks.
+      expired_tasks.push_back(task_queue_.top());
+
+      // Remove the tasks from the delayed tasks queue.
+      task_queue_.pop();
+    }
+  }
+
+  // Fire expired tasks.
+  {
+    // Flushing tasks here without holing onto the task queue mutex.
+    for (const auto& task : expired_tasks) {
+      if (auto flutter_task = std::get_if<FlutterTask>(&task.variant)) {
+        on_task_expired_(flutter_task);
+      } else if (auto closure = std::get_if<TaskClosure>(&task.variant))
+        (*closure)();
+    }
+  }
+
+  // Calculate duration to sleep for on next iteration.
+  {
+    std::lock_guard<std::mutex> lock(task_queue_mutex_);
+    const auto next_wake = task_queue_.empty() ? TaskTimePoint::max()
+                                               : task_queue_.top().fire_time;
+
+    return std::min(next_wake - now, std::chrono::nanoseconds::max());
+  }
+}
+
+TaskRunner::TaskTimePoint TaskRunner::TimePointFromFlutterTime(
+    uint64_t flutter_target_time_nanos) const {
+  const auto now = TaskTimePoint::clock::now();
+  const auto flutter_duration = flutter_target_time_nanos - get_current_time_();
+  return now + std::chrono::nanoseconds(flutter_duration);
+}
+
+void TaskRunner::PostFlutterTask(FlutterTask flutter_task,
+                                 uint64_t flutter_target_time_nanos) {
+  Task task;
+  task.fire_time = TimePointFromFlutterTime(flutter_target_time_nanos);
+  task.variant = flutter_task;
+  EnqueueTask(std::move(task));
+}
+
+void TaskRunner::PostTask(TaskClosure closure) {
+  Task task;
+  task.fire_time = TaskTimePoint::clock::now();
+  task.variant = std::move(closure);
+  EnqueueTask(std::move(task));
+}
+
+void TaskRunner::EnqueueTask(Task task) {
+  static std::atomic_uint64_t sGlobalTaskOrder(0);
+
+  task.order = ++sGlobalTaskOrder;
+  {
+    std::lock_guard<std::mutex> lock(task_queue_mutex_);
+    task_queue_.push(task);
+
+    // Make sure the queue mutex is unlocked before waking up the loop. In case
+    // the wake causes this thread to be descheduled for the primary thread to
+    // process tasks, the acquisition of the lock on that thread while holding
+    // the lock here momentarily till the end of the scope is a pessimization.
+  }
+
+  WakeUp();
+}
+
+}  // namespace flutter
diff --git a/shell/platform/windows/task_runner.h b/shell/platform/windows/task_runner.h
index 0e3d444..7f181d0 100644
--- a/shell/platform/windows/task_runner.h
+++ b/shell/platform/windows/task_runner.h
@@ -5,10 +5,13 @@
 #ifndef FLUTTER_SHELL_PLATFORM_WINDOWS_TASK_RUNNER_H_
 #define FLUTTER_SHELL_PLATFORM_WINDOWS_TASK_RUNNER_H_
 
-#include <windows.h>
-
 #include <chrono>
+#include <deque>
+#include <functional>
 #include <memory>
+#include <mutex>
+#include <queue>
+#include <variant>
 
 #include "flutter/shell/platform/embedder/embedder.h"
 
@@ -16,7 +19,6 @@
 
 typedef uint64_t (*CurrentTimeProc)();
 
-// Abstract custom task runner for scheduling custom tasks.
 class TaskRunner {
  public:
   using TaskTimePoint = std::chrono::steady_clock::time_point;
@@ -25,18 +27,18 @@
 
   virtual ~TaskRunner() = default;
 
-  // Returns if the current thread is the UI thread.
+  // Returns `true` if the current thread is this runner's thread.
   virtual bool RunsTasksOnCurrentThread() const = 0;
 
   // Post a Flutter engine task to the event loop for delayed execution.
-  virtual void PostFlutterTask(FlutterTask flutter_task,
-                               uint64_t flutter_target_time_nanos) = 0;
+  void PostFlutterTask(FlutterTask flutter_task,
+                       uint64_t flutter_target_time_nanos);
 
   // Post a task to the event loop.
-  virtual void PostTask(TaskClosure task) = 0;
+  void PostTask(TaskClosure task);
 
   // Post a task to the event loop or run it immediately if this is being called
-  // from the main thread.
+  // from the runner's thread.
   void RunNowOrPostTask(TaskClosure task) {
     if (RunsTasksOnCurrentThread()) {
       task();
@@ -45,12 +47,57 @@
     }
   }
 
-  // Creates a new task runner with the given main thread ID, current time
+  // Creates a new task runner with the current thread, current time
   // provider, and callback for tasks that are ready to be run.
   static std::unique_ptr<TaskRunner> Create(
-      DWORD main_thread_id,
       CurrentTimeProc get_current_time,
       const TaskExpiredCallback& on_task_expired);
+
+ protected:
+  TaskRunner(CurrentTimeProc get_current_time,
+             const TaskExpiredCallback& on_task_expired);
+
+  // Schedules timers to call `ProcessTasks()` at the runner's thread.
+  virtual void WakeUp() = 0;
+
+  // Executes expired task, and returns the duration until the next task
+  // deadline if exists, otherwise returns `std::chrono::nanoseconds::max()`.
+  //
+  // Each platform implementations must call this to schedule the tasks.
+  std::chrono::nanoseconds ProcessTasks();
+
+ private:
+  typedef std::variant<FlutterTask, TaskClosure> TaskVariant;
+
+  struct Task {
+    uint64_t order;
+    TaskTimePoint fire_time;
+    TaskVariant variant;
+
+    struct Comparer {
+      bool operator()(const Task& a, const Task& b) {
+        if (a.fire_time == b.fire_time) {
+          return a.order > b.order;
+        }
+        return a.fire_time > b.fire_time;
+      }
+    };
+  };
+
+  // Enqueues the given task.
+  void EnqueueTask(Task task);
+
+  // Returns a TaskTimePoint computed from the given target time from Flutter.
+  TaskTimePoint TimePointFromFlutterTime(
+      uint64_t flutter_target_time_nanos) const;
+
+  CurrentTimeProc get_current_time_;
+  TaskExpiredCallback on_task_expired_;
+  std::mutex task_queue_mutex_;
+  std::priority_queue<Task, std::deque<Task>, Task::Comparer> task_queue_;
+
+  TaskRunner(const TaskRunner&) = delete;
+  TaskRunner& operator=(const TaskRunner&) = delete;
 };
 
 }  // namespace flutter
diff --git a/shell/platform/windows/task_runner_unittests.cc b/shell/platform/windows/task_runner_unittests.cc
new file mode 100644
index 0000000..713474d
--- /dev/null
+++ b/shell/platform/windows/task_runner_unittests.cc
@@ -0,0 +1,89 @@
+// Copyright 2013 The Flutter 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 <chrono>
+
+#include "flutter/fml/time/time_point.h"
+
+#include "flutter/shell/platform/windows/task_runner.h"
+
+#include "gtest/gtest.h"
+
+namespace flutter {
+namespace testing {
+
+namespace {
+class MockTaskRunner : public TaskRunner {
+ public:
+  MockTaskRunner(CurrentTimeProc get_current_time,
+                 const TaskExpiredCallback& on_task_expired)
+      : TaskRunner(get_current_time, on_task_expired) {}
+
+  virtual bool RunsTasksOnCurrentThread() const override { return true; }
+
+  void SimulateTimerAwake() { ProcessTasks(); }
+
+ protected:
+  virtual void WakeUp() override {
+    // Do nothing to avoid processing tasks immediately after the tasks is
+    // posted.
+  }
+};
+
+uint64_t MockGetCurrentTime() {
+  return static_cast<uint64_t>(
+      fml::TimePoint::Now().ToEpochDelta().ToNanoseconds());
+}
+}  // namespace
+
+TEST(TaskRunnerTest, MaybeExecuteTaskWithExactOrder) {
+  std::vector<uint64_t> executed_task_order;
+  auto runner =
+      MockTaskRunner(MockGetCurrentTime,
+                     [&executed_task_order](const FlutterTask* expired_task) {
+                       executed_task_order.push_back(expired_task->task);
+                     });
+
+  uint64_t time_now = MockGetCurrentTime();
+
+  runner.PostFlutterTask(FlutterTask{nullptr, 1}, time_now);
+  runner.PostFlutterTask(FlutterTask{nullptr, 2}, time_now);
+  runner.PostTask(
+      [&executed_task_order]() { executed_task_order.push_back(3); });
+  runner.PostTask(
+      [&executed_task_order]() { executed_task_order.push_back(4); });
+
+  runner.SimulateTimerAwake();
+
+  std::vector<uint64_t> posted_task_order{1, 2, 3, 4};
+  EXPECT_EQ(executed_task_order, posted_task_order);
+}
+
+TEST(TaskRunnerTest, MaybeExecuteTaskOnlyExpired) {
+  std::set<uint64_t> executed_task;
+  auto runner = MockTaskRunner(
+      MockGetCurrentTime, [&executed_task](const FlutterTask* expired_task) {
+        executed_task.insert(expired_task->task);
+      });
+
+  uint64_t time_now = MockGetCurrentTime();
+
+  uint64_t task_expired_before_now = 1;
+  uint64_t time_before_now = time_now - 10000;
+  runner.PostFlutterTask(FlutterTask{nullptr, task_expired_before_now},
+                         time_before_now);
+
+  uint64_t task_expired_after_now = 2;
+  uint64_t time_after_now = time_now + 10000;
+  runner.PostFlutterTask(FlutterTask{nullptr, task_expired_after_now},
+                         time_after_now);
+
+  runner.SimulateTimerAwake();
+
+  std::set<uint64_t> only_task_expired_before_now{task_expired_before_now};
+  EXPECT_EQ(executed_task, only_task_expired_before_now);
+}
+
+}  // namespace testing
+}  // namespace flutter
diff --git a/shell/platform/windows/task_runner_win32.cc b/shell/platform/windows/task_runner_win32.cc
index 62de4a1..01c7179 100644
--- a/shell/platform/windows/task_runner_win32.cc
+++ b/shell/platform/windows/task_runner_win32.cc
@@ -4,27 +4,19 @@
 
 #include "flutter/shell/platform/windows/task_runner_win32.h"
 
-#include <atomic>
-#include <iostream>
-#include <utility>
-
 namespace flutter {
 
 // static
 std::unique_ptr<TaskRunner> TaskRunner::Create(
-    DWORD main_thread_id,
     CurrentTimeProc get_current_time,
     const TaskExpiredCallback& on_task_expired) {
-  return std::make_unique<TaskRunnerWin32>(main_thread_id, get_current_time,
-                                           on_task_expired);
+  return std::make_unique<TaskRunnerWin32>(get_current_time, on_task_expired);
 }
 
-TaskRunnerWin32::TaskRunnerWin32(DWORD main_thread_id,
-                                 CurrentTimeProc get_current_time,
+TaskRunnerWin32::TaskRunnerWin32(CurrentTimeProc get_current_time,
                                  const TaskExpiredCallback& on_task_expired)
-    : main_thread_id_(main_thread_id),
-      get_current_time_(get_current_time),
-      on_task_expired_(std::move(on_task_expired)) {
+    : TaskRunner(get_current_time, on_task_expired) {
+  main_thread_id_ = GetCurrentThreadId();
   task_runner_window_ = TaskRunnerWin32Window::GetSharedInstance();
   task_runner_window_->AddDelegate(this);
 }
@@ -38,89 +30,10 @@
 }
 
 std::chrono::nanoseconds TaskRunnerWin32::ProcessTasks() {
-  const TaskTimePoint now = TaskTimePoint::clock::now();
-
-  std::vector<Task> expired_tasks;
-
-  // Process expired tasks.
-  {
-    std::lock_guard<std::mutex> lock(task_queue_mutex_);
-    while (!task_queue_.empty()) {
-      const auto& top = task_queue_.top();
-      // If this task (and all tasks after this) has not yet expired, there is
-      // nothing more to do. Quit iterating.
-      if (top.fire_time > now) {
-        break;
-      }
-
-      // Make a record of the expired task. Do NOT service the task here
-      // because we are still holding onto the task queue mutex. We don't want
-      // other threads to block on posting tasks onto this thread till we are
-      // done processing expired tasks.
-      expired_tasks.push_back(task_queue_.top());
-
-      // Remove the tasks from the delayed tasks queue.
-      task_queue_.pop();
-    }
-  }
-
-  // Fire expired tasks.
-  {
-    // Flushing tasks here without holing onto the task queue mutex.
-    for (const auto& task : expired_tasks) {
-      if (auto flutter_task = std::get_if<FlutterTask>(&task.variant)) {
-        on_task_expired_(flutter_task);
-      } else if (auto closure = std::get_if<TaskClosure>(&task.variant))
-        (*closure)();
-    }
-  }
-
-  // Calculate duration to sleep for on next iteration.
-  {
-    std::lock_guard<std::mutex> lock(task_queue_mutex_);
-    const auto next_wake = task_queue_.empty() ? TaskTimePoint::max()
-                                               : task_queue_.top().fire_time;
-
-    return std::min(next_wake - now, std::chrono::nanoseconds::max());
-  }
+  return TaskRunner::ProcessTasks();
 }
 
-TaskRunnerWin32::TaskTimePoint TaskRunnerWin32::TimePointFromFlutterTime(
-    uint64_t flutter_target_time_nanos) const {
-  const auto now = TaskTimePoint::clock::now();
-  const auto flutter_duration = flutter_target_time_nanos - get_current_time_();
-  return now + std::chrono::nanoseconds(flutter_duration);
-}
-
-void TaskRunnerWin32::PostFlutterTask(FlutterTask flutter_task,
-                                      uint64_t flutter_target_time_nanos) {
-  Task task;
-  task.fire_time = TimePointFromFlutterTime(flutter_target_time_nanos);
-  task.variant = flutter_task;
-  EnqueueTask(std::move(task));
-}
-
-void TaskRunnerWin32::PostTask(TaskClosure closure) {
-  Task task;
-  task.fire_time = TaskTimePoint::clock::now();
-  task.variant = std::move(closure);
-  EnqueueTask(std::move(task));
-}
-
-void TaskRunnerWin32::EnqueueTask(Task task) {
-  static std::atomic_uint64_t sGlobalTaskOrder(0);
-
-  task.order = ++sGlobalTaskOrder;
-  {
-    std::lock_guard<std::mutex> lock(task_queue_mutex_);
-    task_queue_.push(task);
-
-    // Make sure the queue mutex is unlocked before waking up the loop. In case
-    // the wake causes this thread to be descheduled for the primary thread to
-    // process tasks, the acquisition of the lock on that thread while holding
-    // the lock here momentarily till the end of the scope is a pessimization.
-  }
-
+void TaskRunnerWin32::WakeUp() {
   task_runner_window_->WakeUp();
 }
 
diff --git a/shell/platform/windows/task_runner_win32.h b/shell/platform/windows/task_runner_win32.h
index 149e9ac..6e3ceb8 100644
--- a/shell/platform/windows/task_runner_win32.h
+++ b/shell/platform/windows/task_runner_win32.h
@@ -7,14 +7,6 @@
 
 #include <windows.h>
 
-#include <chrono>
-#include <deque>
-#include <functional>
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <variant>
-
 #include "flutter/shell/platform/embedder/embedder.h"
 #include "flutter/shell/platform/windows/task_runner.h"
 #include "flutter/shell/platform/windows/task_runner_win32_window.h"
@@ -27,61 +19,25 @@
 class TaskRunnerWin32 : public TaskRunner,
                         public TaskRunnerWin32Window::Delegate {
  public:
-  // Creates a new task runner with the given main thread ID, current time
-  // provider, and callback for tasks that are ready to be run.
-  TaskRunnerWin32(DWORD main_thread_id,
-                  CurrentTimeProc get_current_time,
+  TaskRunnerWin32(CurrentTimeProc get_current_time,
                   const TaskExpiredCallback& on_task_expired);
-
   virtual ~TaskRunnerWin32();
 
   // |TaskRunner|
   bool RunsTasksOnCurrentThread() const override;
 
-  // |TaskRunner|
-  void PostFlutterTask(FlutterTask flutter_task,
-                       uint64_t flutter_target_time_nanos) override;
-
-  // |TaskRunner|
-  void PostTask(TaskClosure task) override;
-
   // |TaskRunnerWin32Window::Delegate|
   std::chrono::nanoseconds ProcessTasks() override;
 
+ protected:
+  // |TaskRunner|
+  void WakeUp() override;
+
  private:
-  typedef std::variant<FlutterTask, TaskClosure> TaskVariant;
-
-  struct Task {
-    uint64_t order;
-    TaskTimePoint fire_time;
-    TaskVariant variant;
-
-    struct Comparer {
-      bool operator()(const Task& a, const Task& b) {
-        if (a.fire_time == b.fire_time) {
-          return a.order > b.order;
-        }
-        return a.fire_time > b.fire_time;
-      }
-    };
-  };
-
-  // Enqueues the given task.
-  void EnqueueTask(Task task);
-
-  // Returns a TaskTimePoint computed from the given target time from Flutter.
-  TaskTimePoint TimePointFromFlutterTime(
-      uint64_t flutter_target_time_nanos) const;
-
   DWORD main_thread_id_;
-  CurrentTimeProc get_current_time_;
-  TaskExpiredCallback on_task_expired_;
-  std::mutex task_queue_mutex_;
-  std::priority_queue<Task, std::deque<Task>, Task::Comparer> task_queue_;
   std::shared_ptr<TaskRunnerWin32Window> task_runner_window_;
 
   TaskRunnerWin32(const TaskRunnerWin32&) = delete;
-
   TaskRunnerWin32& operator=(const TaskRunnerWin32&) = delete;
 };
 
diff --git a/shell/platform/windows/task_runner_winuwp.cc b/shell/platform/windows/task_runner_winuwp.cc
index 9f8ebaf..8bba42e 100644
--- a/shell/platform/windows/task_runner_winuwp.cc
+++ b/shell/platform/windows/task_runner_winuwp.cc
@@ -4,48 +4,50 @@
 
 #include "flutter/shell/platform/windows/task_runner_winuwp.h"
 
-#include <atomic>
-#include <utility>
-
 namespace flutter {
 
 // static
 std::unique_ptr<TaskRunner> TaskRunner::Create(
-    DWORD main_thread_id,
     CurrentTimeProc get_current_time,
     const TaskExpiredCallback& on_task_expired) {
-  return std::make_unique<TaskRunnerWinUwp>(main_thread_id, on_task_expired);
+  return std::make_unique<TaskRunnerWinUwp>(get_current_time, on_task_expired);
 }
 
-TaskRunnerWinUwp::TaskRunnerWinUwp(DWORD main_thread_id,
+TaskRunnerWinUwp::TaskRunnerWinUwp(CurrentTimeProc get_current_time,
                                    const TaskExpiredCallback& on_task_expired)
-    : main_thread_id_(main_thread_id),
-      on_task_expired_(std::move(on_task_expired)) {
-  dispatcher_ =
-      winrt::Windows::UI::Core::CoreWindow::GetForCurrentThread().Dispatcher();
+    : TaskRunner(get_current_time, on_task_expired) {
+  dispatcher_queue_ =
+      winrt::Windows::System::DispatcherQueue::GetForCurrentThread();
+  dispatcher_queue_timer_ = dispatcher_queue_.CreateTimer();
+  dispatcher_queue_timer_.Tick({this, &TaskRunnerWinUwp::OnTick});
 }
 
 TaskRunnerWinUwp::~TaskRunnerWinUwp() = default;
 
 bool TaskRunnerWinUwp::RunsTasksOnCurrentThread() const {
-  return GetCurrentThreadId() == main_thread_id_;
+  return dispatcher_queue_.HasThreadAccess();
 }
 
-void TaskRunnerWinUwp::PostFlutterTask(FlutterTask flutter_task,
-                                       uint64_t flutter_target_time_nanos) {
-  // TODO: Handle the target time. See
-  // https://github.com/flutter/flutter/issues/70890.
-
-  dispatcher_.RunAsync(
-      winrt::Windows::UI::Core::CoreDispatcherPriority::Normal,
-      [this, flutter_task]() { on_task_expired_(&flutter_task); });
+void TaskRunnerWinUwp::WakeUp() {
+  dispatcher_queue_.TryEnqueue([this]() { ProcessTasksAndScheduleNext(); });
 }
 
-void TaskRunnerWinUwp::PostTask(TaskClosure task) {
-  // TODO: Handle the target time. See PostFlutterTask()
+void TaskRunnerWinUwp::OnTick(
+    winrt::Windows::System::DispatcherQueueTimer const&,
+    winrt::Windows::Foundation::IInspectable const&) {
+  ProcessTasks();
+}
 
-  dispatcher_.RunAsync(winrt::Windows::UI::Core::CoreDispatcherPriority::Normal,
-                       [task]() { task(); });
+void TaskRunnerWinUwp::ProcessTasksAndScheduleNext() {
+  auto next = ProcessTasks();
+
+  if (next == std::chrono::nanoseconds::max()) {
+    dispatcher_queue_timer_.Stop();
+  } else {
+    dispatcher_queue_timer_.Interval(
+        std::chrono::duration_cast<winrt::Windows::Foundation::TimeSpan>(next));
+    dispatcher_queue_timer_.Start();
+  }
 }
 
 }  // namespace flutter
diff --git a/shell/platform/windows/task_runner_winuwp.h b/shell/platform/windows/task_runner_winuwp.h
index 7ee6d19..d92ce80a 100644
--- a/shell/platform/windows/task_runner_winuwp.h
+++ b/shell/platform/windows/task_runner_winuwp.h
@@ -2,51 +2,44 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef FLUTTER_SHELL_PLATFORM_WINDOWS_WINRT_TASK_RUNNER_H_
-#define FLUTTER_SHELL_PLATFORM_WINDOWS_WINRT_TASK_RUNNER_H_
+#ifndef FLUTTER_SHELL_PLATFORM_WINDOWS_TASK_RUNNER_WINUWP_H_
+#define FLUTTER_SHELL_PLATFORM_WINDOWS_TASK_RUNNER_WINUWP_H_
 
-#include <windows.h>
-
-#include <third_party/cppwinrt/generated/winrt/Windows.UI.Core.h>
-
-#include <chrono>
-#include <functional>
-#include <thread>
+#include <third_party/cppwinrt/generated/winrt/Windows.Foundation.h>
+#include <third_party/cppwinrt/generated/winrt/Windows.System.h>
 
 #include "flutter/shell/platform/embedder/embedder.h"
 #include "flutter/shell/platform/windows/task_runner.h"
 
 namespace flutter {
 
-// A custom task runner that uses a CoreDispatcher to schedule
-// flutter tasks.
+// A custom task runner that uses a DispatcherQueue.
 class TaskRunnerWinUwp : public TaskRunner {
  public:
-  TaskRunnerWinUwp(DWORD main_thread_id,
+  TaskRunnerWinUwp(CurrentTimeProc get_current_time,
                    const TaskExpiredCallback& on_task_expired);
-
-  ~TaskRunnerWinUwp();
-
-  TaskRunnerWinUwp(const TaskRunnerWinUwp&) = delete;
-  TaskRunnerWinUwp& operator=(const TaskRunnerWinUwp&) = delete;
+  virtual ~TaskRunnerWinUwp();
 
   // |TaskRunner|
   bool RunsTasksOnCurrentThread() const override;
 
+ protected:
   // |TaskRunner|
-  void PostFlutterTask(FlutterTask flutter_task,
-                       uint64_t flutter_target_time_nanos) override;
-
-  // |TaskRunner|
-  void PostTask(TaskClosure task) override;
+  void WakeUp() override;
 
  private:
-  DWORD main_thread_id_;
-  TaskExpiredCallback on_task_expired_;
+  void OnTick(winrt::Windows::System::DispatcherQueueTimer const&,
+              winrt::Windows::Foundation::IInspectable const&);
 
-  winrt::Windows::UI::Core::CoreDispatcher dispatcher_{nullptr};
+  void ProcessTasksAndScheduleNext();
+
+  winrt::Windows::System::DispatcherQueue dispatcher_queue_{nullptr};
+  winrt::Windows::System::DispatcherQueueTimer dispatcher_queue_timer_{nullptr};
+
+  TaskRunnerWinUwp(const TaskRunnerWinUwp&) = delete;
+  TaskRunnerWinUwp& operator=(const TaskRunnerWinUwp&) = delete;
 };
 
 }  // namespace flutter
 
-#endif  // FLUTTER_SHELL_PLATFORM_WINDOWS_WINRT_TASK_RUNNER_H_
+#endif  // FLUTTER_SHELL_PLATFORM_WINDOWS_TASK_RUNNER_WINUWP_H_