Script remove more DISALLOW_COPY_AND_ASSIGNs

This applies a script previously used for large directories on all
remaining (smaller) directories as a single chunk.

This replaces DISALLOW_COPY_AND_ASSIGN with explicit constructor deletes
where a local script is able to detect its insertion place (~Foo() is
public => insert before this line).

This is incomplete as not all classes have a public ~Foo() declared, so
not all DISALLOW_COPY_AND_ASSIGN occurrences are replaced.

IWYU cleanup is left as a separate pass that is easier when these macros
go away.

Bug: 1010217
Change-Id: I572936462f763e1dd15dd88cdcf451ee14b34dd1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3182480
Reviewed-by: Lei Zhang <thestig@chromium.org>
Owners-Override: Lei Zhang <thestig@chromium.org>
Commit-Queue: Peter Boström <pbos@chromium.org>
Cr-Commit-Position: refs/heads/main@{#925533}

diff --git a/courgette/adjustment_method.cc b/courgette/adjustment_method.cc
index 939d02e..cdcd77d 100644
--- a/courgette/adjustment_method.cc
+++ b/courgette/adjustment_method.cc

@@ -214,6 +214,9 @@
         m_root_(nullptr),
         p_root_(nullptr) {}
 
+  AssignmentProblem(const AssignmentProblem&) = delete;
+  AssignmentProblem& operator=(const AssignmentProblem&) = delete;
+
   ~AssignmentProblem() {
     for (size_t i = 0;  i < all_nodes_.size();  ++i)
       delete all_nodes_[i];
@@ -562,14 +565,16 @@
   NodeQueue unsolved_;
 
   std::vector<Node*> all_nodes_;
-
-  DISALLOW_COPY_AND_ASSIGN(AssignmentProblem);
 };
 
 class GraphAdjuster : public AdjustmentMethod {
  public:
   GraphAdjuster()
       : prog_(nullptr), model_(nullptr), debug_label_index_gen_(0) {}
+
+  GraphAdjuster(const GraphAdjuster&) = delete;
+  GraphAdjuster& operator=(const GraphAdjuster&) = delete;
+
   ~GraphAdjuster() = default;
 
   bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {
@@ -659,9 +664,6 @@
   // Note LabelInfo is allocated inside map, so the LabelInfo lifetimes are
   // managed by the map.
   std::map<Label*, LabelInfo> label_infos_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(GraphAdjuster);
 };
 
 

diff --git a/courgette/adjustment_method_2.cc b/courgette/adjustment_method_2.cc
index 467e79a2..e7569f5 100644
--- a/courgette/adjustment_method_2.cc
+++ b/courgette/adjustment_method_2.cc

@@ -1228,6 +1228,10 @@
 class Adjuster : public AdjustmentMethod {
  public:
   Adjuster() : prog_(nullptr), model_(nullptr) {}
+
+  Adjuster(const Adjuster&) = delete;
+  Adjuster& operator=(const Adjuster&) = delete;
+
   ~Adjuster() = default;
 
   bool Adjust(const AssemblyProgram& model, AssemblyProgram* program) {
@@ -1285,9 +1289,6 @@
   const AssemblyProgram* model_;  // Program to be mimicked, owned by caller.
 
   LabelInfoMaker label_info_maker_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Adjuster);
 };
 
 ////////////////////////////////////////////////////////////////////////////////

diff --git a/courgette/assembly_program.cc b/courgette/assembly_program.cc
index 4a3a76c..6293bd0 100644
--- a/courgette/assembly_program.cc
+++ b/courgette/assembly_program.cc

@@ -22,6 +22,10 @@
   using VECTOR = CONTAINER<Label*>;
 
   LabelReceptor() = default;
+
+  LabelReceptor(const LabelReceptor&) = delete;
+  LabelReceptor& operator=(const LabelReceptor&) = delete;
+
   ~LabelReceptor() override = default;
 
   VECTOR* mutable_abs32_vector() { return &abs32_vector_; }
@@ -51,8 +55,6 @@
  private:
   VECTOR abs32_vector_;
   VECTOR rel32_vector_;
-
-  DISALLOW_COPY_AND_ASSIGN(LabelReceptor);
 };
 
 }  // namespace

diff --git a/courgette/assembly_program.h b/courgette/assembly_program.h
index 8f87f3e..22d3f2ee7 100644
--- a/courgette/assembly_program.h
+++ b/courgette/assembly_program.h

@@ -42,6 +42,10 @@
 class AssemblyProgram {
  public:
   AssemblyProgram(ExecutableType kind, uint64_t image_base);
+
+  AssemblyProgram(const AssemblyProgram&) = delete;
+  AssemblyProgram& operator=(const AssemblyProgram&) = delete;
+
   ~AssemblyProgram();
 
   ExecutableType kind() const { return kind_; }
@@ -89,8 +93,6 @@
   // These are used by Label adjustment during patch generation.
   std::vector<Label*> abs32_label_annotations_;
   std::vector<Label*> rel32_label_annotations_;
-
-  DISALLOW_COPY_AND_ASSIGN(AssemblyProgram);
 };
 
 }  // namespace courgette

diff --git a/courgette/courgette_flow.h b/courgette/courgette_flow.h
index 8329742..b849e7c 100644
--- a/courgette/courgette_flow.h
+++ b/courgette/courgette_flow.h

@@ -23,6 +23,10 @@
 class RegionBuffer : public BasicBuffer {
  public:
   explicit RegionBuffer(const Region& region) : region_(region) {}
+
+  RegionBuffer(const RegionBuffer&) = delete;
+  RegionBuffer& operator=(const RegionBuffer&) = delete;
+
   ~RegionBuffer() override {}
 
   // BasicBuffer:
@@ -31,8 +35,6 @@
 
  private:
   Region region_;
-
-  DISALLOW_COPY_AND_ASSIGN(RegionBuffer);
 };
 
 // CourgetteFlow stores Courgette data arranged into groups, and exposes
@@ -63,6 +65,10 @@
   };
 
   CourgetteFlow();
+
+  CourgetteFlow(const CourgetteFlow&) = delete;
+  CourgetteFlow& operator=(const CourgetteFlow&) = delete;
+
   ~CourgetteFlow();
 
   static const char* name(Group group);
@@ -141,8 +147,6 @@
   Data data_only_;
   Data data_old_;
   Data data_new_;
-
-  DISALLOW_COPY_AND_ASSIGN(CourgetteFlow);
 };
 
 }  // namespace courgette

diff --git a/courgette/courgette_tool.cc b/courgette/courgette_tool.cc
index 9d904a5..ce43de4 100644
--- a/courgette/courgette_tool.cc
+++ b/courgette/courgette_tool.cc

@@ -83,6 +83,10 @@
     if (!buffer_.Initialize(file_name))
       Problem("Can't read %s file.", kind);
   }
+
+  BufferedFileReader(const BufferedFileReader&) = delete;
+  BufferedFileReader& operator=(const BufferedFileReader&) = delete;
+
   ~BufferedFileReader() override = default;
 
   // courgette::BasicBuffer:
@@ -91,8 +95,6 @@
 
  private:
   base::MemoryMappedFile buffer_;
-
-  DISALLOW_COPY_AND_ASSIGN(BufferedFileReader);
 };
 
 /******** Various helpers ********/

diff --git a/courgette/difference_estimator.h b/courgette/difference_estimator.h
index 690c8404..b43d5f7c 100644
--- a/courgette/difference_estimator.h
+++ b/courgette/difference_estimator.h

@@ -34,6 +34,10 @@
 class DifferenceEstimator {
  public:
   DifferenceEstimator();
+
+  DifferenceEstimator(const DifferenceEstimator&) = delete;
+  DifferenceEstimator& operator=(const DifferenceEstimator&) = delete;
+
   ~DifferenceEstimator();
 
   class Base;
@@ -53,7 +57,6 @@
  private:
   std::vector<Base*> owned_bases_;
   std::vector<Subject*> owned_subjects_;
-  DISALLOW_COPY_AND_ASSIGN(DifferenceEstimator);
 };
 
 }  // namespace

diff --git a/courgette/disassembler.h b/courgette/disassembler.h
index 78a4005f..f3eb88e3 100644
--- a/courgette/disassembler.h
+++ b/courgette/disassembler.h

@@ -27,6 +27,10 @@
    public:
     RvaVisitor_Abs32(const std::vector<RVA>& rva_locations,
                      const AddressTranslator& translator);
+
+    RvaVisitor_Abs32(const RvaVisitor_Abs32&) = delete;
+    RvaVisitor_Abs32& operator=(const RvaVisitor_Abs32&) = delete;
+
     ~RvaVisitor_Abs32() override { }
 
     // VectorRvaVisitor<RVA> interfaces.
@@ -34,8 +38,6 @@
 
    private:
     const AddressTranslator& translator_;
-
-    DISALLOW_COPY_AND_ASSIGN(RvaVisitor_Abs32);
   };
 
   // Visitor/adaptor to translate RVA to target RVA for rel32.
@@ -43,6 +45,10 @@
    public:
     RvaVisitor_Rel32(const std::vector<RVA>& rva_locations,
                      const AddressTranslator& translator);
+
+    RvaVisitor_Rel32(const RvaVisitor_Rel32&) = delete;
+    RvaVisitor_Rel32& operator=(const RvaVisitor_Rel32&) = delete;
+
     ~RvaVisitor_Rel32() override { }
 
     // VectorRvaVisitor<RVA> interfaces.
@@ -50,8 +56,6 @@
 
    private:
     const AddressTranslator& translator_;
-
-    DISALLOW_COPY_AND_ASSIGN(RvaVisitor_Rel32);
   };
 
   virtual ~Disassembler();

diff --git a/courgette/disassembler_elf_32.h b/courgette/disassembler_elf_32.h
index fba67f1..a32b8e2 100644
--- a/courgette/disassembler_elf_32.h
+++ b/courgette/disassembler_elf_32.h

@@ -85,18 +85,22 @@
    public:
     Elf32RvaVisitor_Rel32(
         const std::vector<std::unique_ptr<TypedRVA>>& rva_locations);
+
+    Elf32RvaVisitor_Rel32(const Elf32RvaVisitor_Rel32&) = delete;
+    Elf32RvaVisitor_Rel32& operator=(const Elf32RvaVisitor_Rel32&) = delete;
+
     ~Elf32RvaVisitor_Rel32() override { }
 
     // VectorRvaVisitor<TypedRVA*> interfaces.
     RVA Get() const override;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(Elf32RvaVisitor_Rel32);
   };
 
  public:
   DisassemblerElf32(const uint8_t* start, size_t length);
 
+  DisassemblerElf32(const DisassemblerElf32&) = delete;
+  DisassemblerElf32& operator=(const DisassemblerElf32&) = delete;
+
   ~DisassemblerElf32() override { }
 
   // Disassembler interfaces.
@@ -240,9 +244,6 @@
   // Sorted rel32 RVAs. This is mutable because ParseFile() temporarily sorts
   // these by file offsets.
   mutable std::vector<std::unique_ptr<TypedRVA>> rel32_locations_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DisassemblerElf32);
 };
 
 }  // namespace courgette

diff --git a/courgette/disassembler_elf_32_x86.h b/courgette/disassembler_elf_32_x86.h
index 71e61ab..ad39307 100644
--- a/courgette/disassembler_elf_32_x86.h
+++ b/courgette/disassembler_elf_32_x86.h

@@ -39,6 +39,9 @@
 
   DisassemblerElf32X86(const uint8_t* start, size_t length);
 
+  DisassemblerElf32X86(const DisassemblerElf32X86&) = delete;
+  DisassemblerElf32X86& operator=(const DisassemblerElf32X86&) = delete;
+
   ~DisassemblerElf32X86() override { }
 
   // DisassemblerElf32 interfaces.
@@ -58,9 +61,6 @@
 #if COURGETTE_HISTOGRAM_TARGETS
   std::map<RVA, int> rel32_target_rvas_;
 #endif
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DisassemblerElf32X86);
 };
 
 }  // namespace courgette

diff --git a/courgette/disassembler_win32.h b/courgette/disassembler_win32.h
index da6a16d..c9b357c 100644
--- a/courgette/disassembler_win32.h
+++ b/courgette/disassembler_win32.h

@@ -25,6 +25,9 @@
 
 class DisassemblerWin32 : public Disassembler {
  public:
+  DisassemblerWin32(const DisassemblerWin32&) = delete;
+  DisassemblerWin32& operator=(const DisassemblerWin32&) = delete;
+
   virtual ~DisassemblerWin32() = default;
 
   // Disassembler interfaces.
@@ -153,9 +156,6 @@
   std::map<RVA, int> abs32_target_rvas_;
   std::map<RVA, int> rel32_target_rvas_;
 #endif
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DisassemblerWin32);
 };
 
 }  // namespace courgette

diff --git a/courgette/disassembler_win32_x64.h b/courgette/disassembler_win32_x64.h
index 837c745..c4d071e0 100644
--- a/courgette/disassembler_win32_x64.h
+++ b/courgette/disassembler_win32_x64.h

@@ -26,6 +26,10 @@
   }
 
   DisassemblerWin32X64(const uint8_t* start, size_t length);
+
+  DisassemblerWin32X64(const DisassemblerWin32X64&) = delete;
+  DisassemblerWin32X64& operator=(const DisassemblerWin32X64&) = delete;
+
   ~DisassemblerWin32X64() override = default;
 
   // Disassembler interfaces.
@@ -47,9 +51,6 @@
   uint16_t RelativeOffsetOfDataDirectories() const override {
     return kOffsetOfDataDirectoryFromImageOptionalHeader64;
   }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DisassemblerWin32X64);
 };
 
 }  // namespace courgette

diff --git a/courgette/disassembler_win32_x86.h b/courgette/disassembler_win32_x86.h
index 84813e6..67a46279 100644
--- a/courgette/disassembler_win32_x86.h
+++ b/courgette/disassembler_win32_x86.h

@@ -26,6 +26,10 @@
   }
 
   DisassemblerWin32X86(const uint8_t* start, size_t length);
+
+  DisassemblerWin32X86(const DisassemblerWin32X86&) = delete;
+  DisassemblerWin32X86& operator=(const DisassemblerWin32X86&) = delete;
+
   ~DisassemblerWin32X86() override = default;
 
   // Disassembler interfaces.
@@ -47,9 +51,6 @@
   uint16_t RelativeOffsetOfDataDirectories() const override {
     return kOffsetOfDataDirectoryFromImageOptionalHeader32;
   }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DisassemblerWin32X86);
 };
 
 }  // namespace courgette

diff --git a/courgette/encoded_program.h b/courgette/encoded_program.h
index b814cbb..3558039 100644
--- a/courgette/encoded_program.h
+++ b/courgette/encoded_program.h

@@ -44,6 +44,10 @@
 class EncodedProgram {
  public:
   EncodedProgram();
+
+  EncodedProgram(const EncodedProgram&) = delete;
+  EncodedProgram& operator=(const EncodedProgram&) = delete;
+
   ~EncodedProgram();
 
   // Generating an EncodedProgram:
@@ -138,8 +142,6 @@
   // Table of the addresses containing abs32 relocations; computed during
   // assembly, used to generate base relocation table.
   UInt32Vector abs32_relocs_;
-
-  DISALLOW_COPY_AND_ASSIGN(EncodedProgram);
 };
 
 // Deserializes program from a stream set to |*output|. Returns C_OK if

diff --git a/courgette/ensemble.h b/courgette/ensemble.h
index adb4b079..8597901 100644
--- a/courgette/ensemble.h
+++ b/courgette/ensemble.h

@@ -41,6 +41,9 @@
           Ensemble* ensemble,
           const Region& region);
 
+  Element(const Element&) = delete;
+  Element& operator=(const Element&) = delete;
+
   virtual ~Element();
 
   ExecutableType kind() const { return kind_; }
@@ -57,8 +60,6 @@
   ExecutableType kind_;
   Ensemble* ensemble_;
   Region region_;
-
-  DISALLOW_COPY_AND_ASSIGN(Element);
 };
 
 
@@ -66,6 +67,10 @@
  public:
   Ensemble(const Region& region, const char* name)
       : region_(region), name_(name) {}
+
+  Ensemble(const Ensemble&) = delete;
+  Ensemble& operator=(const Ensemble&) = delete;
+
   ~Ensemble();
 
   const Region& region() const { return region_; }
@@ -85,8 +90,6 @@
 
   std::vector<Element*> elements_;        // Embedded elements discovered.
   std::vector<Element*> owned_elements_;  // For deallocation.
-
-  DISALLOW_COPY_AND_ASSIGN(Ensemble);
 };
 
 inline size_t Element::offset_in_ensemble() const {

diff --git a/courgette/ensemble_apply.cc b/courgette/ensemble_apply.cc
index 54fccb5d..0711670 100644
--- a/courgette/ensemble_apply.cc
+++ b/courgette/ensemble_apply.cc

@@ -30,6 +30,10 @@
 class EnsemblePatchApplication {
  public:
   EnsemblePatchApplication();
+
+  EnsemblePatchApplication(const EnsemblePatchApplication&) = delete;
+  EnsemblePatchApplication& operator=(const EnsemblePatchApplication&) = delete;
+
   ~EnsemblePatchApplication() = default;
 
   Status ReadHeader(SourceStream* header_stream);
@@ -76,8 +80,6 @@
 
   SinkStream corrected_parameters_storage_;
   SinkStream corrected_elements_storage_;
-
-  DISALLOW_COPY_AND_ASSIGN(EnsemblePatchApplication);
 };
 
 EnsemblePatchApplication::EnsemblePatchApplication()

diff --git a/courgette/instruction_utils.h b/courgette/instruction_utils.h
index 9b201dce7..31aa4e8 100644
--- a/courgette/instruction_utils.h
+++ b/courgette/instruction_utils.h

@@ -18,6 +18,10 @@
 class InstructionReceptor {
  public:
   InstructionReceptor() = default;
+
+  InstructionReceptor(const InstructionReceptor&) = delete;
+  InstructionReceptor& operator=(const InstructionReceptor&) = delete;
+
   virtual ~InstructionReceptor() = default;
 
   // Generates an entire base relocation table.
@@ -43,9 +47,6 @@
 
   // Generates an 8-byte absolute reference to address of 'label'.
   virtual CheckBool EmitAbs64(Label* label) = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(InstructionReceptor);
 };
 
 // A rerunable callback that emit instructions to a provided receptor. Returns

diff --git a/courgette/label_manager.h b/courgette/label_manager.h
index 4b252405..dc0e2ac 100644
--- a/courgette/label_manager.h
+++ b/courgette/label_manager.h

@@ -50,6 +50,10 @@
   class SimpleIndexAssigner {
    public:
     explicit SimpleIndexAssigner(LabelVector* labels);
+
+    SimpleIndexAssigner(const SimpleIndexAssigner&) = delete;
+    SimpleIndexAssigner& operator=(const SimpleIndexAssigner&) = delete;
+
     ~SimpleIndexAssigner();
 
     // Scans forward to assign successive indexes to Labels, using existing
@@ -73,8 +77,6 @@
 
     // Tracker for index usage to ensure uniqueness of indexes.
     std::vector<bool> available_;
-
-    DISALLOW_COPY_AND_ASSIGN(SimpleIndexAssigner);
   };
 
   LabelManager();

diff --git a/courgette/streams.h b/courgette/streams.h
index a0de9e6..60f5d607 100644
--- a/courgette/streams.h
+++ b/courgette/streams.h

@@ -129,6 +129,10 @@
 class SinkStream {
  public:
   SinkStream() {}
+
+  SinkStream(const SinkStream&) = delete;
+  SinkStream& operator=(const SinkStream&) = delete;
+
   ~SinkStream() {}
 
   // Appends |byte_count| bytes from |data| to the stream.
@@ -169,14 +173,16 @@
 
  private:
   NoThrowBuffer<char> buffer_;
-
-  DISALLOW_COPY_AND_ASSIGN(SinkStream);
 };
 
 // A SourceStreamSet is a set of SourceStreams.
 class SourceStreamSet {
  public:
   SourceStreamSet();
+
+  SourceStreamSet(const SourceStreamSet&) = delete;
+  SourceStreamSet& operator=(const SourceStreamSet&) = delete;
+
   ~SourceStreamSet();
 
   // Initializes the SourceStreamSet with the stream data in memory at |source|.
@@ -205,8 +211,6 @@
  private:
   size_t count_;
   SourceStream streams_[kMaxStreams];
-
-  DISALLOW_COPY_AND_ASSIGN(SourceStreamSet);
 };
 
 // A SinkStreamSet is a set of SinkStreams.  Data is collected by writing to the
@@ -217,6 +221,10 @@
 class SinkStreamSet {
  public:
   SinkStreamSet();
+
+  SinkStreamSet(const SinkStreamSet&) = delete;
+  SinkStreamSet& operator=(const SinkStreamSet&) = delete;
+
   ~SinkStreamSet();
 
   // Initializes the SinkStreamSet to have |stream_index_limit| streams.  Must
@@ -243,8 +251,6 @@
 
   size_t count_;
   SinkStream streams_[kMaxStreams];
-
-  DISALLOW_COPY_AND_ASSIGN(SinkStreamSet);
 };
 
 }  // namespace courgette