Remove DISALLOW_COPY_AND_ASSIGN from base/task/sequence_manager

Also fixes a few cpp lint warnings. No functional changes.

Bug: 1010217
Change-Id: If2e666a7b57f92a0f8dce2c1b81957d89adc9122
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2416848Reviewed-by: Etienne Pierre-Doray <etiennep@chromium.org>
Reviewed-by: Sami Kyöstilä <skyostil@chromium.org>
Commit-Queue: David Bienvenu <davidbienvenu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#807989}

base/task/sequence_manager/atomic_flag_set.h

@@ -28,7 +28,8 @@ class BASE_EXPORT AtomicFlagSet {
 
  public:
   explicit AtomicFlagSet(scoped_refptr<AssociatedThreadId> associated_thread);
-
+  AtomicFlagSet(const AtomicFlagSet&) = delete;
+  AtomicFlagSet& operator=(const AtomicFlagSet&) = delete;
   // AtomicFlags need to be released (or deleted) before this can be deleted.
   ~AtomicFlagSet();
 
@@ -89,6 +90,8 @@ class BASE_EXPORT AtomicFlagSet {
   // AtomicFlag's with one bit per flag.
   struct BASE_EXPORT Group {
     Group();
+    Group(const Group&) = delete;
+    Group& operator=(const Group&) = delete;
     ~Group();
 
     static constexpr int kNumFlags = sizeof(size_t) * 8;
@@ -112,9 +115,6 @@ class BASE_EXPORT AtomicFlagSet {
     // Computes the index of the |flag_callbacks| based on the number of leading
     // zero bits in |flag|.
     static int IndexOfFirstFlagSet(size_t flag);
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(Group);
   };
 
  private:
@@ -131,8 +131,6 @@ class BASE_EXPORT AtomicFlagSet {
   scoped_refptr<AssociatedThreadId> associated_thread_;
   std::unique_ptr<Group> alloc_list_head_;
   Group* partially_free_list_head_ = nullptr;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomicFlagSet);
 };
 
 }  // namespace internal

base/task/sequence_manager/enqueue_order_generator.h

@@ -11,7 +11,6 @@
 #include <atomic>
 
 #include "base/base_export.h"
-#include "base/macros.h"
 #include "base/task/sequence_manager/enqueue_order.h"
 
 namespace base {
@@ -23,6 +22,8 @@ namespace internal {
 class BASE_EXPORT EnqueueOrderGenerator {
  public:
   EnqueueOrderGenerator();
+  EnqueueOrderGenerator(const EnqueueOrderGenerator&) = delete;
+  EnqueueOrderGenerator& operator=(const EnqueueOrderGenerator&) = delete;
   ~EnqueueOrderGenerator();
 
   // Can be called from any thread.
@@ -33,7 +34,6 @@ class BASE_EXPORT EnqueueOrderGenerator {
 
  private:
   std::atomic<uint64_t> counter_;
-  DISALLOW_COPY_AND_ASSIGN(EnqueueOrderGenerator);
 };
 
 }  // namespace internal

base/task/sequence_manager/lazily_deallocated_deque.h

@@ -8,12 +8,12 @@
 #include <algorithm>
 #include <cmath>
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "base/check_op.h"
 #include "base/debug/alias.h"
 #include "base/gtest_prod_util.h"
-#include "base/macros.h"
 #include "base/time/time.h"
 
 namespace base {
@@ -51,8 +51,9 @@ class LazilyDeallocatedDeque {
     kMinimumShrinkIntervalInSeconds = 5
   };
 
-  LazilyDeallocatedDeque() {}
-
+  LazilyDeallocatedDeque() = default;
+  LazilyDeallocatedDeque(const LazilyDeallocatedDeque&) = delete;
+  LazilyDeallocatedDeque& operator=(const LazilyDeallocatedDeque&) = delete;
   ~LazilyDeallocatedDeque() { clear(); }
 
   bool empty() const { return size_ == 0; }
@@ -237,7 +238,8 @@ class LazilyDeallocatedDeque {
           next_(nullptr) {
       DCHECK_GE(capacity_, kMinimumRingSize);
     }
-
+    Ring(const Ring&) = delete;
+    Ring& operator=(const Ring&) = delete;
     ~Ring() {
       while (!empty()) {
         pop_front();
@@ -313,8 +315,6 @@ class LazilyDeallocatedDeque {
     size_t back_index_;
     T* data_;
     std::unique_ptr<Ring> next_;
-
-    DISALLOW_COPY_AND_ASSIGN(Ring);
   };
 
  public:
@@ -370,8 +370,6 @@ class LazilyDeallocatedDeque {
   size_t size_ = 0;
   size_t max_size_ = 0;
   TimeTicks next_resize_time_;
-
-  DISALLOW_COPY_AND_ASSIGN(LazilyDeallocatedDeque);
 };
 
 }  // namespace internal

base/task/sequence_manager/lazy_now.h

@@ -6,7 +6,6 @@
 #define BASE_TASK_SEQUENCE_MANAGER_LAZY_NOW_H_
 
 #include "base/base_export.h"
-#include "base/macros.h"
 #include "base/optional.h"
 #include "base/time/time.h"
 
@@ -23,6 +22,8 @@ class BASE_EXPORT LazyNow {
  public:
   explicit LazyNow(TimeTicks now);
   explicit LazyNow(const TickClock* tick_clock);
+  LazyNow(const LazyNow&) = delete;
+  LazyNow& operator=(const LazyNow&) = delete;
 
   LazyNow(LazyNow&& move_from) noexcept;
 
@@ -34,8 +35,6 @@ class BASE_EXPORT LazyNow {
  private:
   const TickClock* tick_clock_;  // Not owned.
   Optional<TimeTicks> now_;
-
-  DISALLOW_COPY_AND_ASSIGN(LazyNow);
 };
 
 }  // namespace sequence_manager

base/task/sequence_manager/real_time_domain.cc

@@ -10,10 +10,6 @@ namespace base {
 namespace sequence_manager {
 namespace internal {
 
-RealTimeDomain::RealTimeDomain() {}
-
-RealTimeDomain::~RealTimeDomain() = default;
-
 void RealTimeDomain::OnRegisterWithSequenceManager(
     SequenceManagerImpl* sequence_manager) {
   TimeDomain::OnRegisterWithSequenceManager(sequence_manager);

base/task/sequence_manager/real_time_domain.h

@@ -6,7 +6,6 @@
 #define BASE_TASK_SEQUENCE_MANAGER_REAL_TIME_DOMAIN_H_
 
 #include "base/base_export.h"
-#include "base/macros.h"
 #include "base/task/sequence_manager/time_domain.h"
 
 namespace base {
@@ -15,8 +14,10 @@ namespace internal {
 
 class BASE_EXPORT RealTimeDomain : public TimeDomain {
  public:
-  RealTimeDomain();
-  ~RealTimeDomain() override;
+  RealTimeDomain() = default;
+  RealTimeDomain(const RealTimeDomain&) = delete;
+  RealTimeDomain& operator=(const RealTimeDomain&) = delete;
+  ~RealTimeDomain() override = default;
 
   // TimeDomain implementation:
   LazyNow CreateLazyNow() const override;
@@ -31,8 +32,6 @@ class BASE_EXPORT RealTimeDomain : public TimeDomain {
 
  private:
   const TickClock* tick_clock_ = nullptr;
-
-  DISALLOW_COPY_AND_ASSIGN(RealTimeDomain);
 };
 
 }  // namespace internal

base/task/sequence_manager/sequence_manager.h

@@ -6,9 +6,9 @@
 #define BASE_TASK_SEQUENCE_MANAGER_SEQUENCE_MANAGER_H_
 
 #include <memory>
+#include <string>
 #include <utility>
 
-#include "base/macros.h"
 #include "base/message_loop/message_pump_type.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/sequenced_task_runner.h"
@@ -56,7 +56,8 @@ class BASE_EXPORT SequenceManager {
   struct MetricRecordingSettings {
     // This parameter will be updated for consistency on creation (setting
     // value to 0 when ThreadTicks are not supported).
-    MetricRecordingSettings(double task_sampling_rate_for_recording_cpu_time);
+    explicit MetricRecordingSettings(
+        double task_sampling_rate_for_recording_cpu_time);
 
     // The proportion of the tasks for which the cpu time will be
     // sampled or 0 if this is not enabled.
@@ -81,6 +82,8 @@ class BASE_EXPORT SequenceManager {
     class Builder;
 
     Settings();
+    Settings(const Settings&) = delete;
+    Settings& operator=(const Settings&) = delete;
     // In the future MessagePump (which is move-only) will also be a setting,
     // so we are making Settings move-only in preparation.
     Settings(Settings&& move_from) noexcept;
@@ -131,8 +134,6 @@ class BASE_EXPORT SequenceManager {
     int random_task_selection_seed = 0;
 
 #endif  // DCHECK_IS_ON()
-
-    DISALLOW_COPY_AND_ASSIGN(Settings);
   };
 
   virtual ~SequenceManager() = default;

base/task/sequence_manager/sequence_manager_impl.h

@@ -11,6 +11,7 @@
 #include <memory>
 #include <random>
 #include <set>
+#include <string>
 #include <unordered_map>
 #include <utility>
 
@@ -18,7 +19,6 @@
 #include "base/cancelable_callback.h"
 #include "base/containers/circular_deque.h"
 #include "base/debug/crash_logging.h"
-#include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_pump_type.h"
@@ -80,6 +80,8 @@ class BASE_EXPORT SequenceManagerImpl
  public:
   using Observer = SequenceManager::Observer;
 
+  SequenceManagerImpl(const SequenceManagerImpl&) = delete;
+  SequenceManagerImpl& operator=(const SequenceManagerImpl&) = delete;
   ~SequenceManagerImpl() override;
 
   // Assume direct control over current thread and create a SequenceManager.
@@ -432,8 +434,6 @@ class BASE_EXPORT SequenceManagerImpl
   }
 
   WeakPtrFactory<SequenceManagerImpl> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(SequenceManagerImpl);
 };
 
 }  // namespace internal

base/task/sequence_manager/sequence_manager_perftest.cc

@@ -56,6 +56,8 @@ perf_test::PerfResultReporter SetUpReporter(const std::string& story_name) {
 class PerfTestTimeDomain : public MockTimeDomain {
  public:
   PerfTestTimeDomain() : MockTimeDomain(TimeTicks::Now()) {}
+  PerfTestTimeDomain(const PerfTestTimeDomain&) = delete;
+  PerfTestTimeDomain& operator=(const PerfTestTimeDomain&) = delete;
   ~PerfTestTimeDomain() override = default;
 
   Optional<TimeDelta> DelayTillNextTask(LazyNow* lazy_now) override {
@@ -72,9 +74,6 @@ class PerfTestTimeDomain : public MockTimeDomain {
     if (NumberOfScheduledWakeUps() == 1u)
       RequestDoWork();
   }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(PerfTestTimeDomain);
 };
 
 enum class PerfTestType {

base/task/sequence_manager/task_queue.h

@@ -7,7 +7,6 @@
 
 #include <memory>
 
-#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
 #include "base/single_thread_task_runner.h"
@@ -138,6 +137,8 @@ class BASE_EXPORT TaskQueue : public RefCountedThreadSafe<TaskQueue> {
   // TODO(altimin): Make this private after TaskQueue/TaskQueueImpl refactoring.
   TaskQueue(std::unique_ptr<internal::TaskQueueImpl> impl,
             const TaskQueue::Spec& spec);
+  TaskQueue(const TaskQueue&) = delete;
+  TaskQueue& operator=(const TaskQueue&) = delete;
 
   // Information about task execution.
   //
@@ -381,8 +382,6 @@ class BASE_EXPORT TaskQueue : public RefCountedThreadSafe<TaskQueue> {
   int enabled_voter_count_ = 0;
   int voter_count_ = 0;
   const char* name_;
-
-  DISALLOW_COPY_AND_ASSIGN(TaskQueue);
 };
 
 }  // namespace sequence_manager

base/task/sequence_manager/task_queue_impl.h

@@ -10,9 +10,9 @@
 #include <memory>
 #include <queue>
 #include <set>
+#include <utility>
 
 #include "base/callback.h"
-#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/pending_task.h"
@@ -74,6 +74,8 @@ class BASE_EXPORT TaskQueueImpl {
                 TimeDomain* time_domain,
                 const TaskQueue::Spec& spec);
 
+  TaskQueueImpl(const TaskQueueImpl&) = delete;
+  TaskQueueImpl& operator=(const TaskQueueImpl&) = delete;
   ~TaskQueueImpl();
 
   // Types of queues TaskQueueImpl is maintaining internally.
@@ -308,6 +310,8 @@ class BASE_EXPORT TaskQueueImpl {
   struct DelayedIncomingQueue {
    public:
     DelayedIncomingQueue();
+    DelayedIncomingQueue(const DelayedIncomingQueue&) = delete;
+    DelayedIncomingQueue& operator=(const DelayedIncomingQueue&) = delete;
     ~DelayedIncomingQueue();
 
     void push(Task&& task);
@@ -336,8 +340,6 @@ class BASE_EXPORT TaskQueueImpl {
 
     // Number of pending tasks in the queue that need high resolution timing.
     int pending_high_res_tasks_ = 0;
-
-    DISALLOW_COPY_AND_ASSIGN(DelayedIncomingQueue);
   };
 
   struct MainThreadOnly {
@@ -540,8 +542,6 @@ class BASE_EXPORT TaskQueueImpl {
   const bool should_monitor_quiescence_;
   const bool should_notify_observers_;
   const bool delayed_fence_allowed_;
-
-  DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
 };
 
 }  // namespace internal

base/task/sequence_manager/task_queue_selector.h

@@ -7,8 +7,9 @@
 
 #include <stddef.h>
 
+#include <vector>
+
 #include "base/base_export.h"
-#include "base/macros.h"
 #include "base/pending_task.h"
 #include "base/task/sequence_manager/sequence_manager.h"
 #include "base/task/sequence_manager/sequenced_task_source.h"
@@ -31,6 +32,8 @@ class BASE_EXPORT TaskQueueSelector : public WorkQueueSets::Observer {
   TaskQueueSelector(scoped_refptr<AssociatedThreadId> associated_thread,
                     const SequenceManager::Settings& settings);
 
+  TaskQueueSelector(const TaskQueueSelector&) = delete;
+  TaskQueueSelector& operator=(const TaskQueueSelector&) = delete;
   ~TaskQueueSelector() override;
 
   // Called to register a queue that can be selected. This function is called
@@ -253,7 +256,6 @@ class BASE_EXPORT TaskQueueSelector : public WorkQueueSets::Observer {
   size_t immediate_starvation_count_ = 0;
 
   Observer* task_queue_selector_observer_ = nullptr;  // Not owned.
-  DISALLOW_COPY_AND_ASSIGN(TaskQueueSelector);
 };
 
 }  // namespace internal

base/task/sequence_manager/task_queue_selector_unittest.cc

@@ -13,7 +13,6 @@
 #include <vector>
 
 #include "base/bind.h"
-#include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/pending_task.h"
 #include "base/task/sequence_manager/enqueue_order_generator.h"
@@ -37,12 +36,11 @@ namespace task_queue_selector_unittest {
 class MockObserver : public TaskQueueSelector::Observer {
  public:
   MockObserver() = default;
+  MockObserver(const MockObserver&) = delete;
+  MockObserver& operator=(const MockObserver&) = delete;
   ~MockObserver() override = default;
 
   MOCK_METHOD1(OnTaskQueueEnabled, void(internal::TaskQueueImpl*));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockObserver);
 };
 
 class TaskQueueSelectorForTest : public TaskQueueSelector {
@@ -54,13 +52,14 @@ class TaskQueueSelectorForTest : public TaskQueueSelector {
   using TaskQueueSelector::SetImmediateStarvationCountForTest;
   using TaskQueueSelector::SetOperationOldest;
 
-  TaskQueueSelectorForTest(scoped_refptr<AssociatedThreadId> associated_thread)
+  explicit TaskQueueSelectorForTest(
+      scoped_refptr<AssociatedThreadId> associated_thread)
       : TaskQueueSelector(associated_thread, SequenceManager::Settings()) {}
 };
 
 class TaskQueueSelectorTest : public testing::Test {
  public:
-  explicit TaskQueueSelectorTest()
+  TaskQueueSelectorTest()
       : test_closure_(BindRepeating(&TaskQueueSelectorTest::TestFunction)),
         associated_thread_(AssociatedThreadId::CreateBound()),
         selector_(associated_thread_) {}

base/task/sequence_manager/task_time_observer.h

@@ -5,7 +5,6 @@
 #ifndef BASE_TASK_SEQUENCE_MANAGER_TASK_TIME_OBSERVER_H_
 #define BASE_TASK_SEQUENCE_MANAGER_TASK_TIME_OBSERVER_H_
 
-#include "base/macros.h"
 #include "base/time/time.h"
 
 namespace base {
@@ -15,6 +14,8 @@ namespace sequence_manager {
 class TaskTimeObserver {
  public:
   TaskTimeObserver() = default;
+  TaskTimeObserver(const TaskTimeObserver&) = delete;
+  TaskTimeObserver& operator=(const TaskTimeObserver&) = delete;
   virtual ~TaskTimeObserver() = default;
 
   // To be called when task is about to start.
@@ -22,9 +23,6 @@ class TaskTimeObserver {
 
   // To be called when task is completed.
   virtual void DidProcessTask(TimeTicks start_time, TimeTicks end_time) = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TaskTimeObserver);
 };
 
 }  // namespace sequence_manager

base/task/sequence_manager/tasks.h

@@ -29,6 +29,8 @@ struct BASE_EXPORT PostedTask {
                       Nestable nestable = Nestable::kNestable,
                       TaskType task_type = kTaskTypeNone);
   PostedTask(PostedTask&& move_from) noexcept;
+  PostedTask(const PostedTask&) = delete;
+  PostedTask& operator=(const PostedTask&) = delete;
   ~PostedTask();
 
   OnceClosure callback;
@@ -41,8 +43,6 @@ struct BASE_EXPORT PostedTask {
   scoped_refptr<SequencedTaskRunner> task_runner;
   // The time at which the task was queued.
   TimeTicks queue_time;
-
-  DISALLOW_COPY_AND_ASSIGN(PostedTask);
 };
 
 // Represents a time at which a task wants to run. Tasks scheduled for the

base/task/sequence_manager/test/mock_time_domain.h

@@ -15,6 +15,8 @@ namespace sequence_manager {
 class MockTimeDomain : public TimeDomain {
  public:
   explicit MockTimeDomain(TimeTicks initial_now_ticks);
+  MockTimeDomain(const MockTimeDomain&) = delete;
+  MockTimeDomain& operator=(const MockTimeDomain&) = delete;
   ~MockTimeDomain() override;
 
   void SetNowTicks(TimeTicks now_ticks);
@@ -29,8 +31,6 @@ class MockTimeDomain : public TimeDomain {
 
  private:
   TimeTicks now_ticks_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockTimeDomain);
 };
 
 }  // namespace sequence_manager

base/task/sequence_manager/thread_controller_impl.h

@@ -8,7 +8,6 @@
 #include <memory>
 
 #include "base/cancelable_callback.h"
-#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/sequence_checker.h"
@@ -32,6 +31,8 @@ class SequenceManagerImpl;
 class BASE_EXPORT ThreadControllerImpl : public ThreadController,
                                          public RunLoop::NestingObserver {
  public:
+  ThreadControllerImpl(const ThreadControllerImpl&) = delete;
+  ThreadControllerImpl& operator=(const ThreadControllerImpl&) = delete;
   ~ThreadControllerImpl() override;
 
   // TODO(https://crbug.com/948051): replace |funneled_sequence_manager| with
@@ -127,8 +128,6 @@ class BASE_EXPORT ThreadControllerImpl : public ThreadController,
 #endif
 
   WeakPtrFactory<ThreadControllerImpl> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadControllerImpl);
 };
 
 }  // namespace internal

base/task/sequence_manager/thread_controller_with_message_pump_impl.h

@@ -40,6 +40,10 @@ class BASE_EXPORT ThreadControllerWithMessagePumpImpl
   ThreadControllerWithMessagePumpImpl(
       std::unique_ptr<MessagePump> message_pump,
       const SequenceManager::Settings& settings);
+  ThreadControllerWithMessagePumpImpl(
+      const ThreadControllerWithMessagePumpImpl&) = delete;
+  ThreadControllerWithMessagePumpImpl& operator=(
+      const ThreadControllerWithMessagePumpImpl&) = delete;
   ~ThreadControllerWithMessagePumpImpl() override;
 
   using ShouldScheduleWork = WorkDeduplicator::ShouldScheduleWork;
@@ -197,8 +201,6 @@ class BASE_EXPORT ThreadControllerWithMessagePumpImpl
   // Reset at the start of each unit of work to cover the work itself and then
   // transition to the next one.
   base::Optional<HangWatchScopeEnabled> hang_watch_scope_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadControllerWithMessagePumpImpl);
 };
 
 }  // namespace internal

base/task/sequence_manager/time_domain.h

@@ -9,7 +9,6 @@
 
 #include "base/callback.h"
 #include "base/check.h"
-#include "base/macros.h"
 #include "base/task/common/intrusive_heap.h"
 #include "base/task/sequence_manager/lazy_now.h"
 #include "base/task/sequence_manager/task_queue_impl.h"
@@ -36,6 +35,8 @@ class TaskQueueImpl;
 // into a global wake-up, which ultimately gets passed to the ThreadController.
 class BASE_EXPORT TimeDomain {
  public:
+  TimeDomain(const TimeDomain&) = delete;
+  TimeDomain& operator=(const TimeDomain&) = delete;
   virtual ~TimeDomain();
 
   // Returns LazyNow in TimeDomain's time.
@@ -152,7 +153,6 @@ class BASE_EXPORT TimeDomain {
   int pending_high_res_wake_up_count_ = 0;
 
   scoped_refptr<internal::AssociatedThreadId> associated_thread_;
-  DISALLOW_COPY_AND_ASSIGN(TimeDomain);
 };
 
 }  // namespace sequence_manager

base/task/sequence_manager/time_domain_unittest.cc

@@ -6,7 +6,6 @@
 
 #include <memory>
 
-#include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_pump.h"
 #include "base/message_loop/message_pump_type.h"
@@ -39,6 +38,8 @@ class TestTimeDomain : public TimeDomain {
  public:
   TestTimeDomain() : now_(TimeTicks() + TimeDelta::FromSeconds(1)) {}
 
+  TestTimeDomain(const TestTimeDomain&) = delete;
+  TestTimeDomain& operator=(const TestTimeDomain&) = delete;
   ~TestTimeDomain() override = default;
 
   using TimeDomain::MoveReadyDelayedTasksToWorkQueues;
@@ -72,8 +73,6 @@ class TestTimeDomain : public TimeDomain {
 
  private:
   TimeTicks now_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestTimeDomain);
 };
 
 class TimeDomainTest : public testing::Test {

base/task/sequence_manager/work_queue.h

@@ -33,6 +33,8 @@ class BASE_EXPORT WorkQueue {
 
   // Note |task_queue| can be null if queue_type is kNonNestable.
   WorkQueue(TaskQueueImpl* task_queue, const char* name, QueueType queue_type);
+  WorkQueue(const WorkQueue&) = delete;
+  WorkQueue& operator=(const WorkQueue&) = delete;
   ~WorkQueue();
 
   // Associates this work queue with the given work queue sets. This must be
@@ -180,8 +182,6 @@ class BASE_EXPORT WorkQueue {
   const char* const name_;
   EnqueueOrder fence_;
   const QueueType queue_type_;
-
-  DISALLOW_COPY_AND_ASSIGN(WorkQueue);
 };
 
 }  // namespace internal

base/task/sequence_manager/work_queue_sets.h

@@ -7,10 +7,10 @@
 
 #include <array>
 #include <map>
+#include <vector>
 
 #include "base/base_export.h"
 #include "base/check_op.h"
-#include "base/macros.h"
 #include "base/task/common/intrusive_heap.h"
 #include "base/task/sequence_manager/sequence_manager.h"
 #include "base/task/sequence_manager/task_queue_impl.h"
@@ -41,6 +41,8 @@ class BASE_EXPORT WorkQueueSets {
   WorkQueueSets(const char* name,
                 Observer* observer,
                 const SequenceManager::Settings& settings);
+  WorkQueueSets(const WorkQueueSets&) = delete;
+  WorkQueueSets& operator=(const WorkQueueSets&) = delete;
   ~WorkQueueSets();
 
   // O(log num queues)
@@ -151,8 +153,6 @@ class BASE_EXPORT WorkQueueSets {
 #endif
 
   Observer* const observer_;
-
-  DISALLOW_COPY_AND_ASSIGN(WorkQueueSets);
 };
 
 }  // namespace internal