diff --git a/base/task/sequence_manager/sequence_manager.h b/base/task/sequence_manager/sequence_manager.h
index 0be32d2c7fb82..6d1ce01c20a9c 100644
--- a/base/task/sequence_manager/sequence_manager.h
+++ b/base/task/sequence_manager/sequence_manager.h
@@ -28,6 +28,9 @@ class MessagePump;
 class TaskObserver;
 
 namespace sequence_manager {
+namespace internal {
+class TestTaskQueue;
+}  // namespace internal
 
 class TimeDomain;
 
@@ -283,17 +286,6 @@ class BASE_EXPORT SequenceManager {
 
   virtual TaskQueue::QueuePriority GetPriorityCount() const = 0;
 
-  // Creates a task queue with the given type, `spec` and args.
-  // Must be called on the main thread.
-  // TODO(scheduler-dev): SequenceManager should not create TaskQueues.
-  template <typename TaskQueueType, typename... Args>
-  scoped_refptr<TaskQueueType> CreateTaskQueueWithType(
-      const TaskQueue::Spec& spec,
-      Args&&... args) {
-    return WrapRefCounted(new TaskQueueType(CreateTaskQueueImpl(spec), spec,
-                                            std::forward<Args>(args)...));
-  }
-
   // Creates a vanilla TaskQueue rather than a user type derived from it. This
   // should be used if you don't wish to sub class TaskQueue.
   // Must be called on the main thread.
@@ -328,6 +320,8 @@ class BASE_EXPORT SequenceManager {
   virtual void RemoveTaskObserver(TaskObserver* task_observer) = 0;
 
  protected:
+  friend class internal::TestTaskQueue;  // For CreateTaskQueueImpl().
+
   virtual std::unique_ptr<internal::TaskQueueImpl> CreateTaskQueueImpl(
       const TaskQueue::Spec& spec) = 0;
 };
diff --git a/base/task/sequence_manager/sequence_manager_impl_unittest.cc b/base/task/sequence_manager/sequence_manager_impl_unittest.cc
index 5a17f99d19838..2cddd4fc56db6 100644
--- a/base/task/sequence_manager/sequence_manager_impl_unittest.cc
+++ b/base/task/sequence_manager/sequence_manager_impl_unittest.cc
@@ -37,7 +37,6 @@
 #include "base/task/sequence_manager/test/mock_time_domain.h"
 #include "base/task/sequence_manager/test/mock_time_message_pump.h"
 #include "base/task/sequence_manager/test/sequence_manager_for_test.h"
-#include "base/task/sequence_manager/test/test_task_queue.h"
 #include "base/task/sequence_manager/test/test_task_time_observer.h"
 #include "base/task/sequence_manager/thread_controller_with_message_pump_impl.h"
 #include "base/task/sequence_manager/work_queue.h"
@@ -82,6 +81,22 @@ namespace base {
 namespace sequence_manager {
 namespace internal {
 
+class TestTaskQueue : public TaskQueue {
+ public:
+  TestTaskQueue(SequenceManager& sequence_manager, const TaskQueue::Spec& spec)
+      : TaskQueue(sequence_manager.CreateTaskQueueImpl(spec), spec) {}
+
+  using TaskQueue::GetTaskQueueImpl;
+
+  WeakPtr<TestTaskQueue> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
+
+ private:
+  ~TestTaskQueue() override = default;  // Ref-counted.
+
+  // Used to ensure that task queue is deleted in tests.
+  WeakPtrFactory<TestTaskQueue> weak_factory_{this};
+};
+
 namespace {
 
 enum class RunnerType {
@@ -398,7 +413,7 @@ class SequenceManagerTest
 
   scoped_refptr<TestTaskQueue> CreateTaskQueue(
       TaskQueue::Spec spec = TaskQueue::Spec(QueueName::TEST_TQ)) {
-    return sequence_manager()->CreateTaskQueueWithType<TestTaskQueue>(spec);
+    return MakeRefCounted<TestTaskQueue>(*sequence_manager(), spec);
   }
 
   std::vector<scoped_refptr<TestTaskQueue>> CreateTaskQueues(
diff --git a/base/task/sequence_manager/sequence_manager_perftest.cc b/base/task/sequence_manager/sequence_manager_perftest.cc
index af5369c663121..8c9ddbbb6cfc8 100644
--- a/base/task/sequence_manager/sequence_manager_perftest.cc
+++ b/base/task/sequence_manager/sequence_manager_perftest.cc
@@ -15,10 +15,9 @@
 #include "base/run_loop.h"
 #include "base/sequence_checker.h"
 #include "base/synchronization/condition_variable.h"
-#include "base/task/sequence_manager/task_queue_impl.h"
+#include "base/task/sequence_manager/task_queue.h"
 #include "base/task/sequence_manager/test/mock_time_domain.h"
 #include "base/task/sequence_manager/test/sequence_manager_for_test.h"
-#include "base/task/sequence_manager/test/test_task_queue.h"
 #include "base/task/sequence_manager/test/test_task_time_observer.h"
 #include "base/task/sequence_manager/thread_controller_with_message_pump_impl.h"
 #include "base/task/single_thread_task_runner.h"
@@ -111,9 +110,8 @@ class BaseSequenceManagerPerfTestDelegate : public PerfTestDelegate {
   bool MultipleQueuesSupported() const override { return true; }
 
   scoped_refptr<TaskRunner> CreateTaskRunner() override {
-    scoped_refptr<TestTaskQueue> task_queue =
-        manager_->CreateTaskQueueWithType<TestTaskQueue>(
-            TaskQueue::Spec(QueueName::TEST_TQ));
+    scoped_refptr<TaskQueue> task_queue =
+        manager_->CreateTaskQueue(TaskQueue::Spec(QueueName::TEST_TQ));
     owned_task_queues_.push_back(task_queue);
     return task_queue->task_runner();
   }
@@ -143,7 +141,7 @@ class BaseSequenceManagerPerfTestDelegate : public PerfTestDelegate {
   std::unique_ptr<SequenceManager> manager_;
   std::unique_ptr<TimeDomain> time_domain_;
   std::unique_ptr<RunLoop> run_loop_;
-  std::vector<scoped_refptr<TestTaskQueue>> owned_task_queues_;
+  std::vector<scoped_refptr<TaskQueue>> owned_task_queues_;
 };
 
 class SequenceManagerWithMessagePumpPerfTestDelegate
@@ -166,8 +164,7 @@ class SequenceManagerWithMessagePumpPerfTestDelegate
     // ThreadControllerWithMessagePumpImpl doesn't provide a default task
     // runner.
     scoped_refptr<TaskQueue> default_task_queue =
-        GetManager()->template CreateTaskQueueWithType<TestTaskQueue>(
-            TaskQueue::Spec(QueueName::DEFAULT_TQ));
+        GetManager()->CreateTaskQueue(TaskQueue::Spec(QueueName::DEFAULT_TQ));
     GetManager()->SetDefaultTaskRunner(default_task_queue->task_runner());
   }
 
diff --git a/base/task/sequence_manager/task_queue.cc b/base/task/sequence_manager/task_queue.cc
index 4785350ac8707..15a61047f7225 100644
--- a/base/task/sequence_manager/task_queue.cc
+++ b/base/task/sequence_manager/task_queue.cc
@@ -20,42 +20,6 @@
 namespace base {
 namespace sequence_manager {
 
-namespace {
-
-class NullTaskRunner final : public SingleThreadTaskRunner {
- public:
-  NullTaskRunner() {}
-
-  bool PostDelayedTask(const Location& location,
-                       OnceClosure callback,
-                       TimeDelta delay) override {
-    return false;
-  }
-
-  bool PostNonNestableDelayedTask(const Location& location,
-                                  OnceClosure callback,
-                                  TimeDelta delay) override {
-    return false;
-  }
-
-  bool RunsTasksInCurrentSequence() const override {
-    return thread_checker_.CalledOnValidThread();
-  }
-
- private:
-  // Ref-counted
-  ~NullTaskRunner() override = default;
-
-  ThreadCheckerImpl thread_checker_;
-};
-
-// TODO(kraynov): Move NullTaskRunner from //base/test to //base.
-scoped_refptr<SingleThreadTaskRunner> CreateNullTaskRunner() {
-  return MakeRefCounted<NullTaskRunner>();
-}
-
-}  // namespace
-
 TaskQueue::QueueEnabledVoter::QueueEnabledVoter(
     scoped_refptr<TaskQueue> task_queue)
     : task_queue_(std::move(task_queue)), enabled_(true) {
@@ -125,13 +89,12 @@ void TaskQueue::OnQueueEnabledVoteChanged(bool enabled) {
 TaskQueue::TaskQueue(std::unique_ptr<internal::TaskQueueImpl> impl,
                      const TaskQueue::Spec& spec)
     : impl_(std::move(impl)),
-      sequence_manager_(impl_ ? impl_->GetSequenceManagerWeakPtr() : nullptr),
-      associated_thread_((impl_ && impl_->sequence_manager())
+      sequence_manager_(impl_->GetSequenceManagerWeakPtr()),
+      associated_thread_((impl_->sequence_manager())
                              ? impl_->sequence_manager()->associated_thread()
                              : MakeRefCounted<internal::AssociatedThreadId>()),
-      default_task_runner_(impl_ ? impl_->CreateTaskRunner(kTaskTypeNone)
-                                 : CreateNullTaskRunner()),
-      name_(impl_ ? impl_->GetProtoName() : QueueName::UNKNOWN_TQ) {}
+      default_task_runner_(impl_->CreateTaskRunner(kTaskTypeNone)),
+      name_(impl_->GetProtoName()) {}
 
 TaskQueue::~TaskQueue() {
   ShutdownTaskQueueGracefully();
diff --git a/base/task/sequence_manager/test/test_task_queue.cc b/base/task/sequence_manager/test/test_task_queue.cc
deleted file mode 100644
index bf1a302ef2e66..0000000000000
--- a/base/task/sequence_manager/test/test_task_queue.cc
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2018 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/task/sequence_manager/test/test_task_queue.h"
-
-#include "base/task/sequence_manager/task_queue_impl.h"
-
-namespace base {
-namespace sequence_manager {
-
-TestTaskQueue::TestTaskQueue(std::unique_ptr<internal::TaskQueueImpl> impl,
-                             const TaskQueue::Spec& spec)
-    : TaskQueue(std::move(impl), spec) {}
-
-TestTaskQueue::~TestTaskQueue() = default;
-
-WeakPtr<TestTaskQueue> TestTaskQueue::GetWeakPtr() {
-  return weak_factory_.GetWeakPtr();
-}
-
-}  // namespace sequence_manager
-}  // namespace base
diff --git a/base/task/sequence_manager/test/test_task_queue.h b/base/task/sequence_manager/test/test_task_queue.h
deleted file mode 100644
index 4a7bdbeda17a8..0000000000000
--- a/base/task/sequence_manager/test/test_task_queue.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2018 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TASK_SEQUENCE_MANAGER_TEST_TEST_TASK_QUEUE_H_
-#define BASE_TASK_SEQUENCE_MANAGER_TEST_TEST_TASK_QUEUE_H_
-
-#include "base/memory/weak_ptr.h"
-#include "base/task/sequence_manager/task_queue.h"
-
-namespace base {
-namespace sequence_manager {
-
-class TestTaskQueue : public TaskQueue {
- public:
-  explicit TestTaskQueue(std::unique_ptr<internal::TaskQueueImpl> impl,
-                         const TaskQueue::Spec& spec);
-
-  using TaskQueue::GetTaskQueueImpl;
-
-  WeakPtr<TestTaskQueue> GetWeakPtr();
-
- private:
-  ~TestTaskQueue() override;  // Ref-counted.
-
-  // Used to ensure that task queue is deleted in tests.
-  WeakPtrFactory<TestTaskQueue> weak_factory_{this};
-};
-
-}  // namespace sequence_manager
-}  // namespace base
-
-#endif  // BASE_TASK_SEQUENCE_MANAGER_TEST_TEST_TASK_QUEUE_H_
diff --git a/base/test/BUILD.gn b/base/test/BUILD.gn
index 5e26fbe476146..f03e4ccdf6fbd 100644
--- a/base/test/BUILD.gn
+++ b/base/test/BUILD.gn
@@ -39,8 +39,6 @@ static_library("test_support") {
     "../task/sequence_manager/test/mock_time_message_pump.h",
     "../task/sequence_manager/test/sequence_manager_for_test.cc",
     "../task/sequence_manager/test/sequence_manager_for_test.h",
-    "../task/sequence_manager/test/test_task_queue.cc",
-    "../task/sequence_manager/test/test_task_queue.h",
     "../task/sequence_manager/test/test_task_time_observer.h",
     "../timer/mock_timer.cc",
     "../timer/mock_timer.h",
diff --git a/base/threading/thread_unittest.cc b/base/threading/thread_unittest.cc
index 01a9141091140..33a5521a6c4e9 100644
--- a/base/threading/thread_unittest.cc
+++ b/base/threading/thread_unittest.cc
@@ -564,7 +564,7 @@ class SequenceManagerThreadDelegate : public Thread::Delegate {
   SequenceManagerThreadDelegate()
       : sequence_manager_(
             base::sequence_manager::CreateUnboundSequenceManager()),
-        task_queue_(sequence_manager_->CreateTaskQueueWithType<TaskQueue>(
+        task_queue_(sequence_manager_->CreateTaskQueue(
             TaskQueue::Spec(base::sequence_manager::QueueName::DEFAULT_TQ))) {
     sequence_manager_->SetDefaultTaskRunner(GetDefaultTaskRunner());
   }
diff --git a/codelabs/threading_and_scheduling/04-multiple-threads.cc b/codelabs/threading_and_scheduling/04-multiple-threads.cc
index 7ea9b73e4da91..dec0880d7b723 100644
--- a/codelabs/threading_and_scheduling/04-multiple-threads.cc
+++ b/codelabs/threading_and_scheduling/04-multiple-threads.cc
@@ -87,11 +87,9 @@ int main() {
 
   // Create a default TaskQueue that feeds into the SequenceManager.
   scoped_refptr<base::sequence_manager::TaskQueue> main_task_queue =
-      sequence_manager
-          ->CreateTaskQueueWithType<base::sequence_manager::TaskQueue>(
-              base::sequence_manager::TaskQueue::Spec(
-                  base::sequence_manager::TaskQueue::Spec(
-                      base::sequence_manager::QueueName::DEFAULT_TQ)));
+      sequence_manager->CreateTaskQueue(base::sequence_manager::TaskQueue::Spec(
+          base::sequence_manager::TaskQueue::Spec(
+              base::sequence_manager::QueueName::DEFAULT_TQ)));
 
   // Get a default TaskRunner for the main (UI) thread.
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner =
diff --git a/third_party/blink/renderer/platform/scheduler/common/auto_advancing_virtual_time_domain_unittest.cc b/third_party/blink/renderer/platform/scheduler/common/auto_advancing_virtual_time_domain_unittest.cc
index 532528c48b516..35f1ac0ca8bf8 100644
--- a/third_party/blink/renderer/platform/scheduler/common/auto_advancing_virtual_time_domain_unittest.cc
+++ b/third_party/blink/renderer/platform/scheduler/common/auto_advancing_virtual_time_domain_unittest.cc
@@ -10,7 +10,6 @@
 #include "base/message_loop/message_pump.h"
 #include "base/run_loop.h"
 #include "base/task/sequence_manager/sequence_manager.h"
-#include "base/task/sequence_manager/test/test_task_queue.h"
 #include "base/task/sequence_manager/test/test_task_time_observer.h"
 #include "base/time/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/idle_time_estimator_unittest.cc b/third_party/blink/renderer/platform/scheduler/main_thread/idle_time_estimator_unittest.cc
index 7d32a6abf1ed0..cea24b8a12d47 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/idle_time_estimator_unittest.cc
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/idle_time_estimator_unittest.cc
@@ -9,8 +9,8 @@
 #include "base/functional/callback.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/task/sequence_manager/sequence_manager.h"
+#include "base/task/sequence_manager/task_queue.h"
 #include "base/task/sequence_manager/test/sequence_manager_for_test.h"
-#include "base/task/sequence_manager/test/test_task_queue.h"
 #include "base/task/sequence_manager/test/test_task_time_observer.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/test/task_environment.h"
@@ -53,7 +53,8 @@ class IdleTimeEstimatorTest : public testing::Test {
   }
 
   scoped_refptr<MainThreadTaskQueue> NewTaskQueue() {
-    return manager_->CreateTaskQueueWithType<MainThreadTaskQueue>(
+    return base::MakeRefCounted<MainThreadTaskQueue>(
+        *manager_.get(),
         base::sequence_manager::TaskQueue::Spec(
             base::sequence_manager::QueueName::TEST_TQ),
         MainThreadTaskQueue::QueueCreationParams(
diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_helper.cc b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_helper.cc
index 7f633a2a75ca5..fa6161b9a8498 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_helper.cc
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_helper.cc
@@ -62,10 +62,8 @@ MainThreadSchedulerHelper::DeprecatedDefaultTaskRunner() {
 
 scoped_refptr<MainThreadTaskQueue> MainThreadSchedulerHelper::NewTaskQueue(
     const MainThreadTaskQueue::QueueCreationParams& params) {
-  scoped_refptr<MainThreadTaskQueue> task_queue =
-      sequence_manager_->CreateTaskQueueWithType<MainThreadTaskQueue>(
-          params.spec, params, main_thread_scheduler_);
-  return task_queue;
+  return base::MakeRefCounted<MainThreadTaskQueue>(
+      *sequence_manager_, params.spec, params, main_thread_scheduler_);
 }
 
 void MainThreadSchedulerHelper::ShutdownAllQueues() {
diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc
index 7a00a3c4fd2ad..e4c7978132d40 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc
@@ -112,18 +112,18 @@ bool MainThreadTaskQueue::IsPerFrameTaskQueue(
 }
 
 MainThreadTaskQueue::MainThreadTaskQueue(
-    std::unique_ptr<base::sequence_manager::internal::TaskQueueImpl> impl,
+    base::sequence_manager::SequenceManager& sequence_manager,
     const TaskQueue::Spec& spec,
     const QueueCreationParams& params,
     MainThreadSchedulerImpl* main_thread_scheduler)
-    : queue_type_(params.queue_type),
+    : task_queue_(sequence_manager.CreateTaskQueue(spec)),
+      queue_type_(params.queue_type),
       queue_traits_(params.queue_traits),
       web_scheduling_queue_type_(params.web_scheduling_queue_type),
       web_scheduling_priority_(params.web_scheduling_priority),
       main_thread_scheduler_(main_thread_scheduler),
       agent_group_scheduler_(params.agent_group_scheduler),
       frame_scheduler_(params.frame_scheduler) {
-  task_queue_ = base::MakeRefCounted<TaskQueue>(std::move(impl), spec);
   task_runner_with_default_task_type_ =
       base::FeatureList::IsEnabled(
           features::kUseBlinkSchedulerTaskRunnerWithCustomDeleter)
@@ -141,7 +141,6 @@ MainThreadTaskQueue::MainThreadTaskQueue(
       throttler_.emplace(task_queue_.get(),
                          main_thread_scheduler_->GetTickClock());
     }
-    // TaskQueueImpl may be null for tests.
     // TODO(scheduler-dev): Consider mapping directly to
     // MainThreadSchedulerImpl::OnTaskStarted/Completed. At the moment this
     // is not possible due to task queue being created inside
diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h
index 601d2c7ae7454..2cdc5f9ab0089 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h
@@ -383,6 +383,11 @@ class PLATFORM_EXPORT MainThreadTaskQueue
     }
   };
 
+  MainThreadTaskQueue(base::sequence_manager::SequenceManager& sequence_manager,
+                      const TaskQueue::Spec& spec,
+                      const QueueCreationParams& params,
+                      MainThreadSchedulerImpl* main_thread_scheduler);
+
   QueueType queue_type() const { return queue_type_; }
 
   bool CanBeDeferred() const { return queue_traits_.can_be_deferred; }
@@ -528,14 +533,6 @@ class PLATFORM_EXPORT MainThreadTaskQueue
  protected:
   void SetFrameSchedulerForTest(FrameSchedulerImpl* frame_scheduler);
 
-  // TODO(crbug.com/1143007): Remove references to TaskQueueImpl once
-  // TaskQueueImpl inherits from TaskQueue.
-  MainThreadTaskQueue(
-      std::unique_ptr<base::sequence_manager::internal::TaskQueueImpl> impl,
-      const TaskQueue::Spec& spec,
-      const QueueCreationParams& params,
-      MainThreadSchedulerImpl* main_thread_scheduler);
-
   MainThreadTaskQueue(const MainThreadTaskQueue&) = delete;
   MainThreadTaskQueue& operator=(const MainThreadTaskQueue&) = delete;
 
@@ -543,7 +540,6 @@ class PLATFORM_EXPORT MainThreadTaskQueue
 
  private:
   friend class base::RefCountedThreadSafe<MainThreadTaskQueue>;
-  friend class base::sequence_manager::SequenceManager;
   friend class blink::scheduler::main_thread_scheduler_impl_unittest::
       MainThreadSchedulerImplTest;
 
diff --git a/third_party/blink/renderer/platform/scheduler/test/fake_frame_scheduler.h b/third_party/blink/renderer/platform/scheduler/test/fake_frame_scheduler.h
index 0070ec7819450..b1ebd4f462c0b 100644
--- a/third_party/blink/renderer/platform/scheduler/test/fake_frame_scheduler.h
+++ b/third_party/blink/renderer/platform/scheduler/test/fake_frame_scheduler.h
@@ -15,30 +15,6 @@
 namespace blink {
 namespace scheduler {
 
-class MainThreadTaskQueueForTest : public MainThreadTaskQueue {
- public:
-  using MainThreadTaskQueue::SetFrameSchedulerForTest;
-
-  explicit MainThreadTaskQueueForTest(
-      QueueTraits::PrioritisationType prioritisation_type)
-      : MainThreadTaskQueue(
-            nullptr,
-            base::sequence_manager::TaskQueue::Spec(
-                MainThreadTaskQueue::NameForQueueType(
-                    MainThreadTaskQueue::QueueType::kTest)),
-            QueueCreationParams(MainThreadTaskQueue::QueueType::kTest)
-                .SetQueueTraits(
-                    QueueTraits().SetPrioritisationType(prioritisation_type)),
-            nullptr) {}
-  explicit MainThreadTaskQueueForTest(QueueType queue_type)
-      : MainThreadTaskQueue(nullptr,
-                            base::sequence_manager::TaskQueue::Spec(
-                                MainThreadTaskQueue::NameForQueueType(
-                                    MainThreadTaskQueue::QueueType::kTest)),
-                            QueueCreationParams(queue_type),
-                            nullptr) {}
-};
-
 // A dummy FrameScheduler for tests.
 class FakeFrameScheduler : public FrameSchedulerImpl {
  public:
diff --git a/third_party/blink/renderer/platform/scheduler/test/fuzzer/task_queue_with_voters.h b/third_party/blink/renderer/platform/scheduler/test/fuzzer/task_queue_with_voters.h
index 97d3d19e16fab..609862754ae4c 100644
--- a/third_party/blink/renderer/platform/scheduler/test/fuzzer/task_queue_with_voters.h
+++ b/third_party/blink/renderer/platform/scheduler/test/fuzzer/task_queue_with_voters.h
@@ -6,7 +6,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_TEST_FUZZER_TASK_QUEUE_WITH_VOTERS_H_
 
 #include "base/memory/scoped_refptr.h"
-#include "base/task/sequence_manager/test/test_task_queue.h"
+#include "base/task/sequence_manager/task_queue.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
 
@@ -15,10 +15,10 @@ namespace sequence_manager {
 
 struct PLATFORM_EXPORT TaskQueueWithVoters
     : public RefCountedThreadSafe<TaskQueueWithVoters> {
-  explicit TaskQueueWithVoters(scoped_refptr<TestTaskQueue> task_queue)
+  explicit TaskQueueWithVoters(scoped_refptr<TaskQueue> task_queue)
       : queue(std::move(task_queue)) {}
 
-  scoped_refptr<TestTaskQueue> queue;
+  scoped_refptr<TaskQueue> queue;
   Vector<std::unique_ptr<TaskQueue::QueueEnabledVoter>> voters;
 };
 
diff --git a/third_party/blink/renderer/platform/scheduler/test/fuzzer/thread_manager.cc b/third_party/blink/renderer/platform/scheduler/test/fuzzer/thread_manager.cc
index 604bf6625f430..3eb7add3fc64e 100644
--- a/third_party/blink/renderer/platform/scheduler/test/fuzzer/thread_manager.cc
+++ b/third_party/blink/renderer/platform/scheduler/test/fuzzer/thread_manager.cc
@@ -2,7 +2,7 @@
 
 #include <algorithm>
 
-#include "base/task/sequence_manager/test/test_task_queue.h"
+#include "base/task/sequence_manager/task_queue.h"
 #include "base/task/single_thread_task_runner.h"
 #include "third_party/blink/renderer/platform/scheduler/common/task_priority.h"
 #include "third_party/blink/renderer/platform/scheduler/test/fuzzer/thread_pool_manager.h"
@@ -70,8 +70,8 @@ ThreadManager::ThreadManager(base::TimeTicks initial_time,
           .Build());
 
   TaskQueue::Spec spec = TaskQueue::Spec(QueueName::DEFAULT_TQ);
-  task_queues_.emplace_back(MakeRefCounted<TaskQueueWithVoters>(
-      manager_->CreateTaskQueueWithType<TestTaskQueue>(spec)));
+  task_queues_.emplace_back(
+      MakeRefCounted<TaskQueueWithVoters>(manager_->CreateTaskQueue(spec)));
 }
 
 ThreadManager::~ThreadManager() = default;
@@ -166,11 +166,11 @@ void ThreadManager::ExecuteCreateTaskQueueAction(
 
   TaskQueue::Spec spec = TaskQueue::Spec(QueueName::TEST_TQ);
 
-  TestTaskQueue* chosen_task_queue;
+  TaskQueue* chosen_task_queue;
   {
     AutoLock lock(lock_);
-    task_queues_.emplace_back(MakeRefCounted<TaskQueueWithVoters>(
-        manager_->CreateTaskQueueWithType<TestTaskQueue>(spec)));
+    task_queues_.emplace_back(
+        MakeRefCounted<TaskQueueWithVoters>(manager_->CreateTaskQueue(spec)));
     chosen_task_queue = task_queues_.back()->queue.get();
   }
   chosen_task_queue->SetQueuePriority(
@@ -209,10 +209,10 @@ void ThreadManager::PostDelayedTask(
     uint64_t task_queue_id,
     uint32_t delay_ms,
     const SequenceManagerTestDescription::Task& task) {
-  // PostDelayedTask could be called cross-thread - therefore we need a
-  // refptr to the TestTaskQueue which could potentially be deleted by the
-  // thread on which ThreadManager lives.
-  scoped_refptr<TestTaskQueue> chosen_task_queue =
+  // PostDelayedTask could be called cross-thread - therefore we need a refptr
+  // to the TaskQueue which could potentially be deleted by the thread on which
+  // ThreadManager lives.
+  scoped_refptr<TaskQueue> chosen_task_queue =
       GetTaskQueueFor(task_queue_id)->queue.get();
 
   std::unique_ptr<Task> pending_task = std::make_unique<Task>(this);
@@ -241,7 +241,7 @@ void ThreadManager::ExecuteSetQueuePriorityAction(
                                   ActionForTest::ActionType::kSetQueuePriority,
                                   NowTicks());
 
-  TestTaskQueue* chosen_task_queue =
+  TaskQueue* chosen_task_queue =
       GetTaskQueueFor(action.task_queue_id())->queue.get();
   chosen_task_queue->SetQueuePriority(ToTaskQueuePriority(action.priority()));
 }
@@ -291,7 +291,7 @@ void ThreadManager::ExecuteShutdownTaskQueueAction(
                                   ActionForTest::ActionType::kShutdownTaskQueue,
                                   NowTicks());
 
-  TestTaskQueue* chosen_task_queue = nullptr;
+  TaskQueue* chosen_task_queue = nullptr;
   wtf_size_t queue_index;
   {
     AutoLock lock(lock_);
@@ -341,7 +341,7 @@ void ThreadManager::ExecuteInsertFenceAction(
                                   ActionForTest::ActionType::kInsertFence,
                                   NowTicks());
 
-  scoped_refptr<TestTaskQueue> chosen_task_queue =
+  scoped_refptr<TaskQueue> chosen_task_queue =
       GetTaskQueueFor(action.task_queue_id())->queue.get();
 
   if (action.position() ==
@@ -362,7 +362,7 @@ void ThreadManager::ExecuteRemoveFenceAction(
                                   ActionForTest::ActionType::kRemoveFence,
                                   NowTicks());
 
-  scoped_refptr<TestTaskQueue> chosen_task_queue =
+  scoped_refptr<TaskQueue> chosen_task_queue =
       GetTaskQueueFor(action.task_queue_id())->queue.get();
   chosen_task_queue->RemoveFence();
 }
diff --git a/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler_helper.cc b/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler_helper.cc
index de834be7dfb0b..b056a3773d382 100644
--- a/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler_helper.cc
+++ b/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler_helper.cc
@@ -66,8 +66,8 @@ NonMainThreadSchedulerHelper::NewTaskQueue(
     const TaskQueue::Spec& spec,
     NonMainThreadTaskQueue::QueueCreationParams params) {
   DCHECK(default_task_queue_);
-  return sequence_manager_->CreateTaskQueueWithType<NonMainThreadTaskQueue>(
-      spec, non_main_thread_scheduler_, params,
+  return base::MakeRefCounted<NonMainThreadTaskQueue>(
+      *sequence_manager_, spec, non_main_thread_scheduler_, params,
       default_task_queue_->GetTaskRunnerWithDefaultTaskType());
 }
 
@@ -75,8 +75,8 @@ scoped_refptr<NonMainThreadTaskQueue>
 NonMainThreadSchedulerHelper::NewTaskQueueInternal(
     const TaskQueue::Spec& spec,
     NonMainThreadTaskQueue::QueueCreationParams params) {
-  return sequence_manager_->CreateTaskQueueWithType<NonMainThreadTaskQueue>(
-      spec, non_main_thread_scheduler_, params, nullptr);
+  return base::MakeRefCounted<NonMainThreadTaskQueue>(
+      *sequence_manager_, spec, non_main_thread_scheduler_, params, nullptr);
 }
 
 void NonMainThreadSchedulerHelper::ShutdownAllQueues() {
diff --git a/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_task_queue.cc b/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_task_queue.cc
index 0eb1b7125332d..fac6a19c9f91e 100644
--- a/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_task_queue.cc
+++ b/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_task_queue.cc
@@ -7,6 +7,7 @@
 #include "base/feature_list.h"
 #include "base/functional/bind.h"
 #include "base/memory/scoped_refptr.h"
+#include "base/task/sequence_manager/sequence_manager.h"
 #include "base/task/single_thread_task_runner.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/renderer/platform/scheduler/common/blink_scheduler_single_thread_task_runner.h"
@@ -20,12 +21,12 @@ namespace scheduler {
 using base::sequence_manager::TaskQueue;
 
 NonMainThreadTaskQueue::NonMainThreadTaskQueue(
-    std::unique_ptr<base::sequence_manager::internal::TaskQueueImpl> impl,
+    base::sequence_manager::SequenceManager& sequence_manager,
     const TaskQueue::Spec& spec,
     NonMainThreadSchedulerBase* non_main_thread_scheduler,
     QueueCreationParams params,
     scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner)
-    : task_queue_(base::MakeRefCounted<TaskQueue>(std::move(impl), spec)),
+    : task_queue_(sequence_manager.CreateTaskQueue(spec)),
       non_main_thread_scheduler_(non_main_thread_scheduler),
       web_scheduling_queue_type_(params.web_scheduling_queue_type),
       web_scheduling_priority_(params.web_scheduling_priority),
diff --git a/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_task_queue.h b/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_task_queue.h
index 675b490c83e2c..9cc91b81e2108 100644
--- a/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_task_queue.h
+++ b/third_party/blink/renderer/platform/scheduler/worker/non_main_thread_task_queue.h
@@ -18,8 +18,11 @@
 #include "third_party/blink/renderer/platform/scheduler/public/web_scheduling_priority.h"
 #include "third_party/blink/renderer/platform/scheduler/public/web_scheduling_queue_type.h"
 
-namespace blink {
-namespace scheduler {
+namespace base::sequence_manager {
+class SequenceManager;
+}  // namespace base::sequence_manager
+
+namespace blink::scheduler {
 
 using TaskQueue = base::sequence_manager::TaskQueue;
 
@@ -53,9 +56,8 @@ class PLATFORM_EXPORT NonMainThreadTaskQueue
     absl::optional<WebSchedulingPriority> web_scheduling_priority;
   };
 
-  // TODO(kraynov): Consider options to remove TaskQueueImpl reference here.
   NonMainThreadTaskQueue(
-      std::unique_ptr<base::sequence_manager::internal::TaskQueueImpl> impl,
+      base::sequence_manager::SequenceManager& sequence_manager,
       const TaskQueue::Spec& spec,
       NonMainThreadSchedulerBase* non_main_thread_scheduler,
       QueueCreationParams params,
@@ -146,7 +148,6 @@ class PLATFORM_EXPORT NonMainThreadTaskQueue
       task_runner_with_default_task_type_;
 };
 
-}  // namespace scheduler
-}  // namespace blink
+}  // namespace blink::scheduler
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_SCHEDULER_WORKER_NON_MAIN_THREAD_TASK_QUEUE_H_