convert //courgette to std::unique_ptr

courgette/assembly_program.h

 // Copyright (c) 2011 The Chromium 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 COURGETTE_ASSEMBLY_PROGRAM_H_
 #define COURGETTE_ASSEMBLY_PROGRAM_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
-#include "base/memory/scoped_ptr.h"
 #include "courgette/courgette.h"
 #include "courgette/image_utils.h"
 #include "courgette/label_manager.h"
 #include "courgette/memory_allocator.h"
 
 namespace courgette {
 
 class EncodedProgram;
 
 // Opcodes of simple assembly language
@@ skipping 98 matching lines @@
   // Looks up a label or creates a new one.  Might return NULL.
   Label* FindOrMakeAbs32Label(RVA rva);
 
   // Looks up a label or creates a new one.  Might return NULL.
   Label* FindOrMakeRel32Label(RVA rva);
 
   void DefaultAssignIndexes();
   void UnassignIndexes();
   void AssignRemainingIndexes();
 
-  scoped_ptr<EncodedProgram> Encode() const;
+  std::unique_ptr<EncodedProgram> Encode() const;
 
   // Accessor for instruction list.
   const InstructionVector& instructions() const {
     return instructions_;
   }
 
   // Returns the label if the instruction contains an absolute 32-bit address,
   // otherwise returns NULL.
   Label* InstructionAbs32Label(const Instruction* instruction) const;
 
   // Returns the label if the instruction contains an absolute 64-bit address,
   // otherwise returns NULL.
   Label* InstructionAbs64Label(const Instruction* instruction) const;
 
   // Returns the label if the instruction contains a rel32 offset,
   // otherwise returns NULL.
   Label* InstructionRel32Label(const Instruction* instruction) const;
 
   // Removes underused Labels. Thresholds used (may be 0, i.e., no trimming) is
   // dependent on architecture. Returns true on success, and false otherwise.
   CheckBool TrimLabels();
 
  private:
   using ScopedInstruction =
-      scoped_ptr<Instruction, UncheckedDeleter<Instruction>>;
+      std::unique_ptr<Instruction, UncheckedDeleter<Instruction>>;
 
   ExecutableType kind_;
 
   CheckBool Emit(ScopedInstruction instruction) WARN_UNUSED_RESULT;
   CheckBool EmitShared(Instruction* instruction) WARN_UNUSED_RESULT;
 
   static const int kLabelLowerLimit;
 
   // Looks up a label or creates a new one.  Might return NULL.
   Label* FindLabel(RVA rva, RVAToLabel* labels);
 
   // Helper methods for the public versions.
   static void UnassignIndexes(RVAToLabel* labels);
   static void DefaultAssignIndexes(RVAToLabel* labels);
   static void AssignRemainingIndexes(RVAToLabel* labels);
 
   // Sharing instructions that emit a single byte saves a lot of space.
   Instruction* GetByteInstruction(uint8_t byte);
-  scoped_ptr<Instruction* [], base::FreeDeleter> byte_instruction_cache_;
+  std::unique_ptr<Instruction* [], base::FreeDeleter> byte_instruction_cache_;
 
   uint64_t image_base_;  // Desired or mandated base address of image.
 
   InstructionVector instructions_;  // All the instructions in program.
 
   // These are lookup maps to find the label associated with a given address.
   // We have separate label spaces for addresses referenced by rel32 labels and
   // abs32 labels.  This is somewhat arbitrary.
   RVAToLabel rel32_labels_;
   RVAToLabel abs32_labels_;
 
   DISALLOW_COPY_AND_ASSIGN(AssemblyProgram);
 };
 
 // Converts |program| into encoded form, returning it as |*output|.
 // Returns C_OK if succeeded, otherwise returns an error status and sets
 // |*output| to null.
 Status Encode(const AssemblyProgram& program,
-              scoped_ptr<EncodedProgram>* output);
+              std::unique_ptr<EncodedProgram>* output);
 
 }  // namespace courgette
 
 #endif  // COURGETTE_ASSEMBLY_PROGRAM_H_