convert //courgette to std::unique_ptr

courgette/encoded_program_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "courgette/encoded_program.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "courgette/image_utils.h"
 #include "courgette/label_manager.h"
 #include "courgette/streams.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace courgette {
 
 namespace {
 
 // Helper class to instantiate RVAToLabel while managing allocation.
@@ skipping 20 matching lines @@
 
   const std::vector<Label>& GetLabels() const { return labels_; }
 
  private:
   std::vector<Label> labels_;  // Stores all Labels.
   RVAToLabel label_map_;  // Has pointers to |labels_| elements.
 };
 
 // Creates a simple new program with given addresses. The orders of elements
 // in |abs32_specs| and |rel32_specs| are important.
-scoped_ptr<EncodedProgram> CreateTestProgram(RVAToLabelMaker* abs32_maker,
-                                             RVAToLabelMaker* rel32_maker) {
+std::unique_ptr<EncodedProgram> CreateTestProgram(
+    RVAToLabelMaker* abs32_maker,
+    RVAToLabelMaker* rel32_maker) {
   RVAToLabel* abs32_labels = abs32_maker->Make();
   RVAToLabel* rel32_labels = rel32_maker->Make();
 
-  scoped_ptr<EncodedProgram> program(new EncodedProgram());
+  std::unique_ptr<EncodedProgram> program(new EncodedProgram());
 
   uint32_t base = 0x00900000;
   program->set_image_base(base);
 
   EXPECT_TRUE(program->DefineLabels(*abs32_labels, *rel32_labels));
 
   EXPECT_TRUE(program->AddOrigin(0));  // Start at base.
 
   // Arbitrary: Add instructions in the order they're defined in |*_maker|.
   for (const Label& label : abs32_maker->GetLabels())
@@ skipping 19 matching lines @@
 // Create a simple program with a few addresses and references and
 // check that the bits produced are as expected.
 TEST(EncodedProgramTest, Test) {
   // ABS32 index 7 <-- base + 4.
   RVAToLabelMaker abs32_label_maker;
   abs32_label_maker.Add(7, 4);
   // REL32 index 5 <-- base + 0.
   RVAToLabelMaker rel32_label_maker;
   rel32_label_maker.Add(5, 0);
 
-  scoped_ptr<EncodedProgram> program(
+  std::unique_ptr<EncodedProgram> program(
       CreateTestProgram(&abs32_label_maker, &rel32_label_maker));
 
   // Serialize and deserialize.
   SinkStreamSet sinks;
   EXPECT_TRUE(program->WriteTo(&sinks));
   program.reset();
 
   SinkStream sink;
   bool can_collect = sinks.CopyTo(&sink);
   EXPECT_TRUE(can_collect);
 
   const void* buffer = sink.Buffer();
   size_t length = sink.Length();
 
   SourceStreamSet sources;
   bool can_get_source_streams = sources.Init(buffer, length);
   EXPECT_TRUE(can_get_source_streams);
 
-  scoped_ptr<EncodedProgram> encoded2(new EncodedProgram());
+  std::unique_ptr<EncodedProgram> encoded2(new EncodedProgram());
   bool can_read = encoded2->ReadFrom(&sources);
   EXPECT_TRUE(can_read);
 
   // Finally, try to assemble.
   SinkStream assembled;
   bool can_assemble = encoded2->AssembleTo(&assembled);
   EXPECT_TRUE(can_assemble);
   encoded2.reset();
 
   const uint8_t golden[] = {
@@ skipping 12 matching lines @@
   RVAToLabelMaker abs32_label_maker;
   abs32_label_maker.Add(7, 11);
   abs32_label_maker.Add(3, 2);
   abs32_label_maker.Add(5, 23);
   // Relative addresses by index: [16, 7, _, 32].
   RVAToLabelMaker rel32_label_maker;
   rel32_label_maker.Add(0, 16);
   rel32_label_maker.Add(3, 32);
   rel32_label_maker.Add(1, 7);
 
-  scoped_ptr<EncodedProgram> program(
+  std::unique_ptr<EncodedProgram> program(
       CreateTestProgram(&abs32_label_maker, &rel32_label_maker));
 
   SinkStreamSet sinks;
   EXPECT_TRUE(program->WriteTo(&sinks));
   program.reset();
 
   // Check indexes and addresses in sinks.
   const uint8_t golden_abs32_indexes[] = {
       0x03, 0x07, 0x03, 0x05  // 3 indexes: [7, 3, 5].
   };
@@ skipping 31 matching lines @@
   const uint8_t golden_rel32_addresses[] = {
       0x04,  // 4 address deltas.
       0x20, 0x11, 0x00, 0x32,
   };
   EXPECT_TRUE(CompareSink(golden_rel32_addresses,
                           arraysize(golden_rel32_addresses),
                           sinks.stream(kStreamRel32Addresses)));
 }
 
 }  // namespace courgette