[cleanup] Remove uses of DISALLOW_COPY_AND_ASSIGN

Also remove a comment referring to using the macro.

Bug: v8:11074
Change-Id: Ib56a0360b28812833b372738f4956ef41c59a97b
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2557058Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Commit-Queue: Zhi An Ng <zhin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#71388}

src/logging/code-events.h

@@ -115,6 +115,8 @@ class CodeEventDispatcher : public CodeEventListener {
   using LogEventsAndTags = CodeEventListener::LogEventsAndTags;
 
   CodeEventDispatcher() = default;
+  CodeEventDispatcher(const CodeEventDispatcher&) = delete;
+  CodeEventDispatcher& operator=(const CodeEventDispatcher&) = delete;
 
   bool AddListener(CodeEventListener* listener) {
     base::MutexGuard guard(&mutex_);
@@ -231,8 +233,6 @@ class CodeEventDispatcher : public CodeEventListener {
  private:
   std::unordered_set<CodeEventListener*> listeners_;
   base::Mutex mutex_;
-
-  DISALLOW_COPY_AND_ASSIGN(CodeEventDispatcher);
 };
 
 }  // namespace internal

src/logging/counters.h

@@ -36,6 +36,9 @@ class Counters;
 
 class StatsTable {
  public:
+  StatsTable(const StatsTable&) = delete;
+  StatsTable& operator=(const StatsTable&) = delete;
+
   // Register an application-defined function for recording
   // subsequent counter statistics.
   void SetCounterFunction(CounterLookupCallback f);
@@ -90,8 +93,6 @@ class StatsTable {
   CounterLookupCallback lookup_function_;
   CreateHistogramCallback create_histogram_function_;
   AddHistogramSampleCallback add_histogram_sample_function_;
-
-  DISALLOW_COPY_AND_ASSIGN(StatsTable);
 };
 
 // Base class for stats counters.
@@ -1288,11 +1289,12 @@ class RuntimeCallTimerScope {
     }
   }
 
+  RuntimeCallTimerScope(const RuntimeCallTimerScope&) = delete;
+  RuntimeCallTimerScope& operator=(const RuntimeCallTimerScope&) = delete;
+
  private:
   RuntimeCallStats* stats_ = nullptr;
   RuntimeCallTimer timer_;
-
-  DISALLOW_COPY_AND_ASSIGN(RuntimeCallTimerScope);
 };
 
 // This file contains all the v8 counters that are in use.

src/numbers/bignum.h

@@ -18,6 +18,8 @@ class V8_EXPORT_PRIVATE Bignum {
   static const int kMaxSignificantBits = 3584;
 
   Bignum();
+  Bignum(const Bignum&) = delete;
+  Bignum& operator=(const Bignum&) = delete;
   void AssignUInt16(uint16_t value);
   void AssignUInt64(uint64_t value);
   void AssignBignum(const Bignum& other);
@@ -111,8 +113,6 @@ class V8_EXPORT_PRIVATE Bignum {
   int used_digits_;
   // The Bignum's value equals value(bigits_) * 2^(exponent_ * kBigitSize).
   int exponent_;
-
-  DISALLOW_COPY_AND_ASSIGN(Bignum);
 };
 
 }  // namespace internal

src/runtime/runtime.h

@@ -779,6 +779,8 @@ class Runtime : public AllStatic {
 
 class RuntimeState {
  public:
+  RuntimeState(const RuntimeState&) = delete;
+  RuntimeState& operator=(const RuntimeState&) = delete;
 #ifndef V8_INTL_SUPPORT
   unibrow::Mapping<unibrow::ToUppercase, 128>* to_upper_mapping() {
     return &to_upper_mapping_;
@@ -808,8 +810,6 @@ class RuntimeState {
 
   friend class Isolate;
   friend class Runtime;
-
-  DISALLOW_COPY_AND_ASSIGN(RuntimeState);
 };
 
 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, Runtime::FunctionId);

src/strings/string-stream.h

@@ -47,6 +47,8 @@ class FixedStringAllocator final : public StringAllocator {
   FixedStringAllocator(char* buffer, unsigned length)
       : buffer_(buffer), length_(length) {}
   ~FixedStringAllocator() override = default;
+  FixedStringAllocator(const FixedStringAllocator&) = delete;
+  FixedStringAllocator& operator=(const FixedStringAllocator&) = delete;
 
   char* allocate(unsigned bytes) override;
   char* grow(unsigned* bytes) override;
@@ -54,7 +56,6 @@ class FixedStringAllocator final : public StringAllocator {
  private:
   char* buffer_;
   unsigned length_;
-  DISALLOW_COPY_AND_ASSIGN(FixedStringAllocator);
 };
 
 template <std::size_t kInlineSize>

src/tasks/cancelable-task.h

@@ -37,6 +37,8 @@ class V8_EXPORT_PRIVATE CancelableTaskManager {
   CancelableTaskManager();
 
   ~CancelableTaskManager();
+  CancelableTaskManager(const CancelableTaskManager&) = delete;
+  CancelableTaskManager& operator=(const CancelableTaskManager&) = delete;
 
   // Registers a new cancelable {task}. Returns the unique {id} of the task that
   // can be used to try to abort a task by calling {Abort}.
@@ -87,8 +89,6 @@ class V8_EXPORT_PRIVATE CancelableTaskManager {
   bool canceled_;
 
   friend class Cancelable;
-
-  DISALLOW_COPY_AND_ASSIGN(CancelableTaskManager);
 };
 
 class V8_EXPORT_PRIVATE Cancelable {
@@ -97,6 +97,8 @@ class V8_EXPORT_PRIVATE Cancelable {
       : parent_(parent), id_(parent->Register(this)) {}
 
   virtual ~Cancelable();
+  Cancelable(const Cancelable&) = delete;
+  Cancelable& operator=(const Cancelable&) = delete;
 
   // Never invoke after handing over the task to the platform! The reason is
   // that {Cancelable} is used in combination with {v8::Task} and handed to
@@ -137,8 +139,6 @@ class V8_EXPORT_PRIVATE Cancelable {
   CancelableTaskManager* const parent_;
   std::atomic<Status> status_{kWaiting};
   const CancelableTaskManager::Id id_;
-
-  DISALLOW_COPY_AND_ASSIGN(Cancelable);
 };
 
 // Multiple inheritance can be used because Task is a pure interface.
@@ -147,6 +147,8 @@ class V8_EXPORT_PRIVATE CancelableTask : public Cancelable,
  public:
   explicit CancelableTask(Isolate* isolate);
   explicit CancelableTask(CancelableTaskManager* manager);
+  CancelableTask(const CancelableTask&) = delete;
+  CancelableTask& operator=(const CancelableTask&) = delete;
 
   // Task overrides.
   void Run() final {
@@ -156,9 +158,6 @@ class V8_EXPORT_PRIVATE CancelableTask : public Cancelable,
   }
 
   virtual void RunInternal() = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CancelableTask);
 };
 
 // Multiple inheritance can be used because IdleTask is a pure interface.
@@ -166,6 +165,8 @@ class CancelableIdleTask : public Cancelable, public IdleTask {
  public:
   explicit CancelableIdleTask(Isolate* isolate);
   explicit CancelableIdleTask(CancelableTaskManager* manager);
+  CancelableIdleTask(const CancelableIdleTask&) = delete;
+  CancelableIdleTask& operator=(const CancelableIdleTask&) = delete;
 
   // IdleTask overrides.
   void Run(double deadline_in_seconds) final {
@@ -175,9 +176,6 @@ class CancelableIdleTask : public Cancelable, public IdleTask {
   }
 
   virtual void RunInternal(double deadline_in_seconds) = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CancelableIdleTask);
 };
 
 }  // namespace internal

src/tracing/traced-value.h

@@ -25,6 +25,8 @@ class V8_EXPORT_PRIVATE TracedValue : public ConvertableToTraceFormat
 {
  public:
   ~TracedValue() override;
+  TracedValue(const TracedValue&) = delete;
+  TracedValue& operator=(const TracedValue&) = delete;
 
   static std::unique_ptr<TracedValue> Create();
 
@@ -78,8 +80,6 @@ class V8_EXPORT_PRIVATE TracedValue : public ConvertableToTraceFormat
 
   std::string data_;
   bool first_item_;
-
-  DISALLOW_COPY_AND_ASSIGN(TracedValue);
 };
 
 }  // namespace tracing

src/trap-handler/handler-inside-posix.cc

@@ -60,8 +60,6 @@ class SigUnmaskStack {
     pthread_sigmask(SIG_UNBLOCK, &sigs, &old_mask_);
   }
 
-  // We'd normally use DISALLOW_COPY_AND_ASSIGN, but we're avoiding a dependency
-  // on base/macros.h
   SigUnmaskStack(const SigUnmaskStack&) = delete;
   void operator=(const SigUnmaskStack&) = delete;
 

src/trap-handler/trap-handler-internal.h

@@ -35,8 +35,6 @@ class MetadataLock {
   MetadataLock();
   ~MetadataLock();
 
-  // We'd normally use DISALLOW_COPY_AND_ASSIGN, but we're avoiding a dependency
-  // on base/macros.h
   MetadataLock(const MetadataLock&) = delete;
   void operator=(const MetadataLock&) = delete;
 };