diff --git a/lib/deprecated_loop/BUILD.gn b/lib/deprecated_loop/BUILD.gn
deleted file mode 100644
index 3889254..0000000
--- a/lib/deprecated_loop/BUILD.gn
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright 2018 The Fuchsia Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-import("//build/package.gni")
-import("//build/testing/environments.gni")
-
-source_set("deprecated_loop") {
-  sources = [
-    "incoming_task_queue.cc",
-    "incoming_task_queue.h",
-    "message_loop.cc",
-    "message_loop.h",
-    "thread.cc",
-    "thread.h",
-  ]
-  public_deps = [
-    "//garnet/public/lib/fxl",
-    "//zircon/public/lib/async-default",
-    "//zircon/public/lib/async-loop-cpp",
-    "//zircon/public/lib/async-testutils",
-    "//zircon/public/lib/fdio",
-    "//zircon/public/lib/zx",
-  ]
-}
-
-executable("deprecated_loop_unittests") {
-  testonly = true
-  sources = [
-    "message_loop_unittest.cc",
-    "thread_unittest.cc",
-  ]
-
-  deps = [
-    ":deprecated_loop",
-    "//garnet/public/lib/fsl",
-    "//garnet/public/lib/fxl/test:gtest_main",
-    "//third_party/googletest:gtest",
-  ]
-}
-
-package("deprecated_loop_tests") {
-  testonly = true
-  deps = [
-    ":deprecated_loop_unittests",
-  ]
-
-  tests = [
-    {
-      name = "deprecated_loop_unittests"
-      environments = basic_envs
-    },
-  ]
-}
diff --git a/lib/deprecated_loop/incoming_task_queue.cc b/lib/deprecated_loop/incoming_task_queue.cc
deleted file mode 100644
index 20a5910..0000000
--- a/lib/deprecated_loop/incoming_task_queue.cc
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2016 The Fuchsia 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 "topaz/lib/deprecated_loop/incoming_task_queue.h"
-
-namespace deprecated_loop {
-namespace internal {
-
-TaskQueueDelegate::~TaskQueueDelegate() {}
-
-IncomingTaskQueue::IncomingTaskQueue() {}
-
-IncomingTaskQueue::~IncomingTaskQueue() {}
-
-void IncomingTaskQueue::PostTask(fxl::Closure task) {
-  AddTask(std::move(task), fxl::TimePoint());
-}
-
-void IncomingTaskQueue::PostTaskForTime(fxl::Closure task,
-                                        fxl::TimePoint target_time) {
-  AddTask(std::move(task), target_time);
-}
-
-void IncomingTaskQueue::PostDelayedTask(fxl::Closure task,
-                                        fxl::TimeDelta delay) {
-  AddTask(std::move(task), delay > fxl::TimeDelta::Zero()
-                               ? fxl::TimePoint::Now() + delay
-                               : fxl::TimePoint());
-}
-
-void IncomingTaskQueue::AddTask(fxl::Closure task, fxl::TimePoint target_time) {
-  std::lock_guard<std::mutex> locker(mutex_);
-
-  if (drop_incoming_tasks_)
-    return;
-  if (delegate_) {
-    delegate_->PostTask(std::move(task), target_time);
-  } else {
-    incoming_queue_.emplace_back(std::move(task), target_time);
-  }
-}
-
-bool IncomingTaskQueue::RunsTasksOnCurrentThread() {
-  std::lock_guard<std::mutex> locker(mutex_);
-  return delegate_ && delegate_->RunsTasksOnCurrentThread();
-}
-
-void IncomingTaskQueue::InitDelegate(TaskQueueDelegate* delegate) {
-  FXL_DCHECK(delegate);
-
-  std::lock_guard<std::mutex> locker(mutex_);
-  FXL_DCHECK(!drop_incoming_tasks_);
-
-  delegate_ = delegate;
-  for (auto& task : incoming_queue_)
-    delegate_->PostTask(std::move(task.first), task.second);
-  incoming_queue_.clear();
-}
-
-void IncomingTaskQueue::ClearDelegate() {
-  std::lock_guard<std::mutex> locker(mutex_);
-
-  FXL_DCHECK(!drop_incoming_tasks_);
-  drop_incoming_tasks_ = true;
-  delegate_ = nullptr;
-}
-
-}  // namespace internal
-}  // namespace deprecated_loop
diff --git a/lib/deprecated_loop/incoming_task_queue.h b/lib/deprecated_loop/incoming_task_queue.h
deleted file mode 100644
index 0264a5d..0000000
--- a/lib/deprecated_loop/incoming_task_queue.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright 2018 The Fuchsia Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef LIB_DEPRECATED_LOOP_INCOMING_TASK_QUEUE_H_
-#define LIB_DEPRECATED_LOOP_INCOMING_TASK_QUEUE_H_
-
-#include <mutex>
-#include <utility>
-#include <vector>
-
-#include "lib/fxl/functional/closure.h"
-#include "lib/fxl/fxl_export.h"
-#include "lib/fxl/macros.h"
-#include "lib/fxl/memory/ref_counted.h"
-#include "lib/fxl/synchronization/thread_annotations.h"
-#include "lib/fxl/tasks/task_runner.h"
-#include "lib/fxl/time/time_point.h"
-
-namespace deprecated_loop {
-namespace internal {
-
-class FXL_EXPORT TaskQueueDelegate {
- public:
-  virtual void PostTask(fxl::Closure task, fxl::TimePoint target_time) = 0;
-  virtual bool RunsTasksOnCurrentThread() = 0;
-
- protected:
-  virtual ~TaskQueueDelegate();
-};
-
-// Receives tasks from multiple threads and buffers them until a delegate
-// is ready to receive them.
-//
-// This object is threadsafe.
-class FXL_EXPORT IncomingTaskQueue : public fxl::TaskRunner {
- public:
-  IncomingTaskQueue();
-  ~IncomingTaskQueue() override;
-
-  // |TaskRunner| implementation:
-  void PostTask(fxl::Closure task) override;
-  void PostTaskForTime(fxl::Closure task, fxl::TimePoint target_time) override;
-  void PostDelayedTask(fxl::Closure task, fxl::TimeDelta delay) override;
-  bool RunsTasksOnCurrentThread() override;
-
-  // Sets the delegate and schedules all pending tasks with it.
-  void InitDelegate(TaskQueueDelegate* delegate);
-
-  // Clears the delegate and drops all later incoming tasks.
-  void ClearDelegate();
-
- private:
-  void AddTask(fxl::Closure task, fxl::TimePoint target_time);
-
-  using Task = std::pair<fxl::Closure, fxl::TimePoint>;
-
-  std::mutex mutex_;
-  std::vector<Task> incoming_queue_ FXL_GUARDED_BY(mutex_);
-  TaskQueueDelegate* delegate_ FXL_GUARDED_BY(mutex_) = nullptr;
-  bool drop_incoming_tasks_ FXL_GUARDED_BY(mutex_) = false;
-
-  FXL_DISALLOW_COPY_AND_ASSIGN(IncomingTaskQueue);
-};
-
-}  // namespace internal
-}  // namespace deprecated_loop
-
-#endif  // LIB_DEPRECATED_LOOP_INCOMING_TASK_QUEUE_H_
diff --git a/lib/deprecated_loop/message_loop.cc b/lib/deprecated_loop/message_loop.cc
deleted file mode 100644
index 633987f..0000000
--- a/lib/deprecated_loop/message_loop.cc
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2016 The Fuchsia 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 "topaz/lib/deprecated_loop/message_loop.h"
-
-#include <utility>
-
-#include <lib/async/cpp/task.h>
-#include <zircon/syscalls.h>
-
-#include "lib/fxl/logging.h"
-
-namespace deprecated_loop {
-namespace {
-
-thread_local MessageLoop* g_current;
-
-}  // namespace
-
-MessageLoop::MessageLoop()
-    : MessageLoop(fxl::MakeRefCounted<internal::IncomingTaskQueue>()) {}
-
-MessageLoop::MessageLoop(
-    fxl::RefPtr<internal::IncomingTaskQueue> incoming_tasks)
-    : loop_config_{.make_default_for_current_thread = true,
-                   .epilogue = &MessageLoop::Epilogue,
-                   .data = this},
-      loop_(&loop_config_),
-      task_runner_(std::move(incoming_tasks)) {
-  FXL_DCHECK(!g_current) << "At most one message loop per thread.";
-  g_current = this;
-
-  MessageLoop::incoming_tasks()->InitDelegate(this);
-}
-
-MessageLoop::~MessageLoop() {
-  FXL_DCHECK(g_current == this)
-      << "Message loops must be destroyed on their own threads.";
-
-  loop_.Shutdown();
-
-  incoming_tasks()->ClearDelegate();
-
-  g_current = nullptr;
-}
-
-MessageLoop* MessageLoop::GetCurrent() { return g_current; }
-
-void MessageLoop::PostTask(fxl::Closure task, fxl::TimePoint target_time) {
-  zx_status_t status = async::PostTaskForTime(
-      loop_.dispatcher(), [task = std::move(task)] { task(); },
-      zx::time(target_time.ToEpochDelta().ToNanoseconds()));
-  FXL_CHECK(status == ZX_OK || status == ZX_ERR_BAD_STATE)
-      << "Failed to post task: status=" << status;
-}
-
-void MessageLoop::Run(bool until_idle) {
-  FXL_DCHECK(g_current == this);
-
-  FXL_CHECK(!is_running_) << "Cannot run a nested message loop.";
-  is_running_ = true;
-
-  zx_status_t status = until_idle ? loop_.RunUntilIdle() : loop_.Run();
-  FXL_CHECK(status == ZX_OK || status == ZX_ERR_CANCELED)
-      << "Loop stopped abnormally: status=" << status;
-
-  status = loop_.ResetQuit();
-  FXL_DCHECK(status == ZX_OK)
-      << "Failed to reset quit state: status=" << status;
-
-  FXL_DCHECK(is_running_);
-  is_running_ = false;
-}
-
-void MessageLoop::Run() { Run(false); }
-
-void MessageLoop::RunUntilIdle() { Run(true); }
-
-void MessageLoop::QuitNow() {
-  FXL_DCHECK(g_current == this);
-
-  if (is_running_)
-    loop_.Quit();
-}
-
-void MessageLoop::PostQuitTask() {
-  task_runner()->PostTask([this]() { QuitNow(); });
-}
-
-bool MessageLoop::RunsTasksOnCurrentThread() { return g_current == this; }
-
-void MessageLoop::SetAfterTaskCallback(fxl::Closure callback) {
-  FXL_DCHECK(g_current == this);
-
-  after_task_callback_ = std::move(callback);
-}
-
-void MessageLoop::ClearAfterTaskCallback() {
-  FXL_DCHECK(g_current == this);
-
-  after_task_callback_ = fxl::Closure();
-}
-
-void MessageLoop::Epilogue(async_loop_t*, void* data) {
-  auto loop = static_cast<MessageLoop*>(data);
-  if (loop->after_task_callback_)
-    loop->after_task_callback_();
-}
-
-}  // namespace deprecated_loop
diff --git a/lib/deprecated_loop/message_loop.h b/lib/deprecated_loop/message_loop.h
deleted file mode 100644
index 697410d..0000000
--- a/lib/deprecated_loop/message_loop.h
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2016 The Fuchsia Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef LIB_DEPRECATED_LOOP_MESSAGE_LOOP_H_
-#define LIB_DEPRECATED_LOOP_MESSAGE_LOOP_H_
-
-#include <map>
-
-#include <lib/async-loop/cpp/loop.h>
-
-#include "lib/fxl/fxl_export.h"
-#include "lib/fxl/macros.h"
-#include "lib/fxl/memory/ref_ptr.h"
-#include "lib/fxl/tasks/task_runner.h"
-#include "topaz/lib/deprecated_loop/incoming_task_queue.h"
-
-namespace deprecated_loop {
-
-// DEPRECATED: please use async::Loop instead.
-class FXL_EXPORT MessageLoop : private internal::TaskQueueDelegate {
- public:
-  using HandlerKey = uint64_t;
-
-  // Constructs a message loop with an empty task queue. The message loop is
-  // bound to the current thread.
-  MessageLoop();
-
-  // Constructs a message loop that will begin by draining the tasks already
-  // present in the |incoming_tasks| queue. The message loop is bound to the
-  // current thread.
-  explicit MessageLoop(fxl::RefPtr<internal::IncomingTaskQueue> incoming_tasks);
-
-  ~MessageLoop() override;
-
-  // Returns the message loop associated with the current thread, if any.
-  static MessageLoop* GetCurrent();
-
-  // Gets the underlying libasync dispatcher.
-  // See <async/dispatcher.h> for details on how to use this.
-  async_dispatcher_t* dispatcher() const { return loop_.dispatcher(); }
-
-  // Return an interface for posting tasks to this message loop.
-  const fxl::RefPtr<fxl::TaskRunner>& task_runner() const {
-    return task_runner_;
-  }
-
-  // The message loop will call |callback| after each task that execute and
-  // after each time it signals a handler. If the message loop already has an
-  // after task callback set, this function will replace it with this one.
-  void SetAfterTaskCallback(fxl::Closure callback);
-
-  // The message loop will no longer call the registered after task callback, if
-  // any.
-  void ClearAfterTaskCallback();
-
-  // Causes the message loop to run tasks until |QuitNow| is called. If no tasks
-  // are available, the message loop with block and wait for tasks to be posted
-  // via the |task_runner|.
-  void Run();
-
-  // Runs until there are no tasks to run and no runnable handlers. This is
-  // useful for unit testing, because the behavior doesn't depend on time.
-  void RunUntilIdle();
-
-  // Prevents further tasks from running and returns from |Run|. Must be called
-  // while |Run| is on the stack.
-  void QuitNow();
-
-  // Posts a task to the queue that calls |QuitNow|. Useful for gracefully
-  // ending the message loop. Can be called whether or not |Run| is on the
-  // stack.
-  void PostQuitTask();
-
- private:
-  // |internal::TaskQueueDelegate| implementation:
-  void PostTask(fxl::Closure task, fxl::TimePoint target_time) override;
-  bool RunsTasksOnCurrentThread() override;
-
-  void Run(bool until_idle);
-
-  static void Epilogue(async_loop_t* loop, void* data);
-
-  internal::IncomingTaskQueue* incoming_tasks() {
-    return static_cast<internal::IncomingTaskQueue*>(task_runner_.get());
-  }
-
-  async_loop_config_t loop_config_;
-  async::Loop loop_;
-
-  fxl::RefPtr<fxl::TaskRunner> task_runner_;
-  fxl::Closure after_task_callback_;
-  bool is_running_ = false;
-
-  FXL_DISALLOW_COPY_AND_ASSIGN(MessageLoop);
-};
-
-}  // namespace deprecated_loop
-
-#endif  // LIB_DEPRECATED_LOOP_MESSAGE_LOOP_H_
diff --git a/lib/deprecated_loop/message_loop_unittest.cc b/lib/deprecated_loop/message_loop_unittest.cc
deleted file mode 100644
index f58dfb1..0000000
--- a/lib/deprecated_loop/message_loop_unittest.cc
+++ /dev/null
@@ -1,248 +0,0 @@
-// Copyright 2016 The Fuchsia 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 "topaz/lib/deprecated_loop/message_loop.h"
-
-#include <lib/fdio/io.h>
-#include <lib/zx/channel.h>
-#include <lib/zx/event.h>
-
-#include <poll.h>
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "lib/fsl/tasks/fd_waiter.h"
-#include "src/lib/files/unique_fd.h"
-#include "lib/fxl/functional/closure.h"
-#include "lib/fxl/macros.h"
-
-namespace deprecated_loop {
-namespace {
-
-TEST(MessageLoop, Current) {
-  EXPECT_TRUE(MessageLoop::GetCurrent() == nullptr);
-  {
-    MessageLoop message_loop;
-    EXPECT_EQ(&message_loop, MessageLoop::GetCurrent());
-  }
-  EXPECT_TRUE(MessageLoop::GetCurrent() == nullptr);
-}
-
-TEST(MessageLoop, RunsTasksOnCurrentThread) {
-  fxl::RefPtr<fxl::TaskRunner> task_runner;
-
-  {
-    MessageLoop loop;
-    task_runner = loop.task_runner();
-    EXPECT_TRUE(task_runner->RunsTasksOnCurrentThread());
-    bool run_on_other_thread;
-    std::thread t([task_runner, &run_on_other_thread]() {
-      run_on_other_thread = task_runner->RunsTasksOnCurrentThread();
-    });
-    t.join();
-    EXPECT_FALSE(run_on_other_thread);
-  }
-
-  EXPECT_FALSE(task_runner->RunsTasksOnCurrentThread());
-}
-
-TEST(MessageLoop, CanRunTasks) {
-  bool did_run = false;
-  MessageLoop loop;
-  loop.task_runner()->PostTask([&did_run, &loop]() {
-    EXPECT_FALSE(did_run);
-    did_run = true;
-  });
-  loop.RunUntilIdle();
-  EXPECT_TRUE(did_run);
-}
-
-TEST(MessageLoop, CanPostTasksFromTasks) {
-  bool did_run = false;
-  MessageLoop loop;
-  fxl::Closure nested_task = [&did_run, &loop]() {
-    EXPECT_FALSE(did_run);
-    did_run = true;
-  };
-  loop.task_runner()->PostTask([&nested_task, &loop]() {
-    loop.task_runner()->PostTask(std::move(nested_task));
-  });
-  loop.RunUntilIdle();
-  EXPECT_TRUE(did_run);
-}
-
-TEST(MessageLoop, TriplyNestedTasks) {
-  std::vector<std::string> tasks;
-  MessageLoop loop;
-  loop.task_runner()->PostTask([&tasks, &loop]() {
-    tasks.push_back("one");
-    loop.task_runner()->PostTask([&tasks, &loop]() {
-      tasks.push_back("two");
-      loop.task_runner()->PostTask(
-          [&tasks, &loop]() { tasks.push_back("three"); });
-    });
-  });
-  loop.RunUntilIdle();
-  EXPECT_EQ(3u, tasks.size());
-  EXPECT_EQ("one", tasks[0]);
-  EXPECT_EQ("two", tasks[1]);
-  EXPECT_EQ("three", tasks[2]);
-}
-
-TEST(MessageLoop, CanRunTasksInOrder) {
-  std::vector<std::string> tasks;
-  MessageLoop loop;
-  loop.task_runner()->PostTask([&tasks]() { tasks.push_back("0"); });
-  loop.task_runner()->PostTask([&tasks]() { tasks.push_back("1"); });
-  loop.PostQuitTask();
-  loop.task_runner()->PostTask([&tasks]() { tasks.push_back("2"); });
-  loop.RunUntilIdle();
-  EXPECT_EQ(2u, tasks.size());
-  EXPECT_EQ("0", tasks[0]);
-  EXPECT_EQ("1", tasks[1]);
-}
-
-TEST(MessageLoop, CanPreloadTasks) {
-  auto incoming_queue = fxl::MakeRefCounted<internal::IncomingTaskQueue>();
-
-  bool did_run = false;
-  MessageLoop* loop_ptr = nullptr;
-  incoming_queue->PostTask([&did_run, &loop_ptr]() {
-    EXPECT_FALSE(did_run);
-    did_run = true;
-  });
-
-  MessageLoop loop(std::move(incoming_queue));
-  loop_ptr = &loop;
-  loop.RunUntilIdle();
-  EXPECT_TRUE(did_run);
-}
-
-TEST(MessageLoop, AfterTaskCallbacks) {
-  std::vector<std::string> tasks;
-  MessageLoop loop;
-  loop.SetAfterTaskCallback([&tasks] { tasks.push_back("callback"); });
-  loop.task_runner()->PostTask([&tasks] { tasks.push_back("0"); });
-  loop.task_runner()->PostTask([&tasks] { tasks.push_back("1"); });
-  loop.PostQuitTask();
-  loop.task_runner()->PostTask([&tasks] { tasks.push_back("2"); });
-  loop.RunUntilIdle();
-  EXPECT_EQ(5u, tasks.size());
-  EXPECT_EQ("0", tasks[0]);
-  EXPECT_EQ("callback", tasks[1]);
-  EXPECT_EQ("1", tasks[2]);
-  EXPECT_EQ("callback", tasks[3]);
-}
-
-TEST(MessageLoop, RemoveAfterTaskCallbacksDuringCallback) {
-  std::vector<std::string> tasks;
-  MessageLoop loop;
-
-  loop.SetAfterTaskCallback([&tasks, &loop]() {
-    tasks.push_back("callback");
-    loop.ClearAfterTaskCallback();
-  });
-  loop.task_runner()->PostTask([&tasks] { tasks.push_back("0"); });
-  loop.task_runner()->PostTask([&tasks] { tasks.push_back("1"); });
-  loop.RunUntilIdle();
-  EXPECT_EQ(3u, tasks.size());
-  EXPECT_EQ("0", tasks[0]);
-  EXPECT_EQ("callback", tasks[1]);
-  EXPECT_EQ("1", tasks[2]);
-}
-
-class DestructorObserver {
- public:
-  DestructorObserver(fxl::Closure callback) : callback_(std::move(callback)) {}
-  ~DestructorObserver() { callback_(); }
-
- private:
-  fxl::Closure callback_;
-};
-
-TEST(MessageLoop, TaskDestructionTime) {
-  bool destructed = false;
-  fxl::RefPtr<fxl::TaskRunner> task_runner;
-
-  {
-    MessageLoop loop;
-    task_runner = fxl::RefPtr<fxl::TaskRunner>(loop.task_runner());
-    loop.RunUntilIdle();
-    auto observer1 = std::make_unique<DestructorObserver>(
-        [&destructed] { destructed = true; });
-    task_runner->PostTask([p = std::move(observer1)]() {});
-    EXPECT_FALSE(destructed);
-  }
-  EXPECT_TRUE(destructed);
-
-  destructed = false;
-  auto observer2 = std::make_unique<DestructorObserver>(
-      [&destructed] { destructed = true; });
-  task_runner->PostTask([p = std::move(observer2)]() {});
-  EXPECT_TRUE(destructed);
-}
-
-TEST(MessageLoop, CanQuitCurrent) {
-  int count = 0;
-  MessageLoop loop;
-  loop.task_runner()->PostTask([&count]() {
-    count++;
-    MessageLoop::GetCurrent()->QuitNow();
-  });
-  loop.task_runner()->PostTask([&count]() { count++; });
-  loop.RunUntilIdle();
-  EXPECT_EQ(1, count);
-}
-
-TEST(MessageLoop, CanQuitManyTimes) {
-  MessageLoop loop;
-  loop.QuitNow();
-  loop.QuitNow();
-  loop.PostQuitTask();
-  loop.RunUntilIdle();
-  loop.QuitNow();
-  loop.QuitNow();
-}
-
-// Tests that waiting on files in a MessageLoop works.
-TEST(MessageLoop, FDWaiter) {
-  // Create an event and an FD that reflects that event. The fd
-  // shares ownership of the event.
-  zx::event fdevent;
-  EXPECT_EQ(zx::event::create(0u, &fdevent), ZX_OK);
-  fxl::UniqueFD fd(
-      fdio_handle_fd(fdevent.get(), ZX_USER_SIGNAL_0, 0, /*shared=*/true));
-  EXPECT_TRUE(fd.is_valid());
-
-  bool callback_ran = false;
-  {
-    MessageLoop message_loop;
-    fsl::FDWaiter waiter;
-
-    std::thread thread([&fdevent]() {
-      // Poke the fdevent, which pokes the fd.
-      EXPECT_EQ(fdevent.signal(0u, ZX_USER_SIGNAL_0), ZX_OK);
-    });
-    auto callback = [&callback_ran, &message_loop](zx_status_t success,
-                                                   uint32_t events) {
-      EXPECT_EQ(success, ZX_OK);
-      EXPECT_EQ(events, static_cast<uint32_t>(POLLIN));
-      callback_ran = true;
-      message_loop.QuitNow();
-    };
-    EXPECT_TRUE(waiter.Wait(callback, fd.get(), POLLIN));
-    message_loop.Run();
-    thread.join();
-  }
-
-  EXPECT_TRUE(callback_ran);
-}
-
-}  // namespace
-}  // namespace deprecated_loop
diff --git a/lib/deprecated_loop/thread.cc b/lib/deprecated_loop/thread.cc
deleted file mode 100644
index 6696732..0000000
--- a/lib/deprecated_loop/thread.cc
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2017 The Fuchsia 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 "topaz/lib/deprecated_loop/thread.h"
-
-#include "topaz/lib/deprecated_loop/incoming_task_queue.h"
-#include "topaz/lib/deprecated_loop/message_loop.h"
-
-namespace deprecated_loop {
-
-Thread::Thread()
-    : thread_([this] { Main(); }),
-      task_runner_(fxl::MakeRefCounted<internal::IncomingTaskQueue>()) {}
-
-Thread::~Thread() {}
-
-bool Thread::Run(size_t stack_size) { return thread_.Run(stack_size); }
-
-bool Thread::IsRunning() const { return thread_.IsRunning(); }
-
-fxl::RefPtr<fxl::TaskRunner> Thread::TaskRunner() const { return task_runner_; }
-
-void Thread::Main(void) {
-  MessageLoop message_loop(task_runner_);
-  message_loop.Run();
-}
-
-bool Thread::Join() { return thread_.Join(); }
-
-}  // namespace deprecated_loop
diff --git a/lib/deprecated_loop/thread.h b/lib/deprecated_loop/thread.h
deleted file mode 100644
index f5fd8a0..0000000
--- a/lib/deprecated_loop/thread.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2017 The Fuchsia Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef LIB_DEPRECATED_LOOP_THREAD_H_
-#define LIB_DEPRECATED_LOOP_THREAD_H_
-
-#include "lib/fxl/fxl_export.h"
-#include "lib/fxl/macros.h"
-#include "lib/fxl/memory/ref_ptr.h"
-#include "lib/fxl/tasks/task_runner.h"
-#include "lib/fxl/threading/thread.h"
-#include "topaz/lib/deprecated_loop/incoming_task_queue.h"
-
-namespace deprecated_loop {
-
-namespace internal {
-class IncomingTaskQueue;
-}  // namespace internal
-
-// DEPRECATED
-class FXL_EXPORT Thread {
- public:
-  static constexpr size_t default_stack_size = 1 * 1024 * 1024;
-
-  Thread();
-  ~Thread();
-  bool Run(size_t stack_size = default_stack_size);
-  bool IsRunning() const;
-  bool Join();
-  fxl::RefPtr<fxl::TaskRunner> TaskRunner() const;
-
- private:
-  void Main();
-
-  fxl::Thread thread_;
-  fxl::RefPtr<internal::IncomingTaskQueue> task_runner_;
-
-  FXL_DISALLOW_COPY_AND_ASSIGN(Thread);
-};
-
-}  // namespace deprecated_loop
-
-#endif  // LIB_DEPRECATED_LOOP_THREAD_H_
diff --git a/lib/deprecated_loop/thread_unittest.cc b/lib/deprecated_loop/thread_unittest.cc
deleted file mode 100644
index faac0ee..0000000
--- a/lib/deprecated_loop/thread_unittest.cc
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2018 The Fuchsia 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 "topaz/lib/deprecated_loop/thread.h"
-
-#include "gtest/gtest.h"
-#include "topaz/lib/deprecated_loop/message_loop.h"
-
-namespace deprecated_loop {
-namespace {
-
-TEST(Thread, Control) {
-  Thread thread;
-  EXPECT_FALSE(thread.IsRunning());
-  EXPECT_TRUE(thread.Run());
-  EXPECT_TRUE(thread.IsRunning());
-  thread.TaskRunner()->PostTask(
-      [] { MessageLoop::GetCurrent()->QuitNow(); });
-  EXPECT_TRUE(thread.Join());
-}
-
-}  // namespace
-}  // namespace deprecated_loop
diff --git a/packages/tests/all b/packages/tests/all
index 35f3d89..2a3ee09 100644
--- a/packages/tests/all
+++ b/packages/tests/all
@@ -9,7 +9,6 @@
         "topaz/packages/tests/dart_target_unittests",
         "topaz/packages/tests/dart_target_integration_tests",
         "topaz/packages/tests/dart_unittests",
-        "topaz/packages/tests/deprecated_loop",
         "topaz/packages/tests/fidl_changes",
         "topaz/packages/tests/fidl_compatibility_test",
         "topaz/packages/tests/fidl_compatibility_test_server_dart",
diff --git a/packages/tests/deprecated_loop b/packages/tests/deprecated_loop
deleted file mode 100644
index 197acea..0000000
--- a/packages/tests/deprecated_loop
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-    "packages": [
-        "//topaz/lib/deprecated_loop:deprecated_loop_tests"
-    ]
-}