[Courgette] Refactor: Manage AssemblyProgram and EncodedProgram with scoped_ptr.

courgette/encoded_program_fuzz_unittest.cc

Index: courgette/encoded_program_fuzz_unittest.cc
diff --git a/courgette/encoded_program_fuzz_unittest.cc b/courgette/encoded_program_fuzz_unittest.cc
index b755f857c897b4cb49d45f611c2130b7fb46e452..ed301f11a0e882f63f77e8b9434165028db5492d 100644
--- a/courgette/encoded_program_fuzz_unittest.cc
+++ b/courgette/encoded_program_fuzz_unittest.cc
@@ -10,13 +10,16 @@
 //
 // We try a lot of arbitrary modifications to the serialized form and make sure
 // that the outcome is not a crash.
-
-#include "base/test/test_suite.h"
+#include "courgette/encoded_program.h"
 
 #include <stddef.h>
 
+#include "base/memory/scoped_ptr.h"
+#include "base/test/test_suite.h"
+#include "courgette/assembly_program.h"
 #include "courgette/base_test_unittest.h"
 #include "courgette/courgette.h"
+#include "courgette/program_detector.h"
 #include "courgette/streams.h"
 
 class DecodeFuzzTest : public BaseTest {
@@ -40,24 +43,24 @@ void DecodeFuzzTest::FuzzExe(const char* file_name) const {
   const void* original_buffer = file1.c_str();
   size_t original_length = file1.length();
 
-  courgette::AssemblyProgram* program = NULL;
+  scoped_ptr<courgette::AssemblyProgram> program;
   const courgette::Status parse_status =
       courgette::ParseDetectedExecutable(original_buffer, original_length,
                                          &program);
   EXPECT_EQ(courgette::C_OK, parse_status);
 
-  courgette::EncodedProgram* encoded = NULL;
-
-  const courgette::Status encode_status = Encode(program, &encoded);
+  scoped_ptr<courgette::EncodedProgram> encoded;
+  const courgette::Status encode_status = Encode(*program, &encoded);
   EXPECT_EQ(courgette::C_OK, encode_status);
 
-  DeleteAssemblyProgram(program);
+  program.reset();
 
   courgette::SinkStreamSet sinks;
-  const courgette::Status write_status = WriteEncodedProgram(encoded, &sinks);
+  const courgette::Status write_status =
+      WriteEncodedProgram(encoded.get(), &sinks);
   EXPECT_EQ(courgette::C_OK, write_status);
 
-  DeleteEncodedProgram(encoded);
+  encoded.reset();
 
   courgette::SinkStream sink;
   bool can_collect = sinks.CopyTo(&sink);
@@ -170,7 +173,7 @@ void DecodeFuzzTest::FuzzBits(const std::string& base_buffer,
 
 bool DecodeFuzzTest::TryAssemble(const std::string& buffer,
                                  std::string* output) const {
-  courgette::EncodedProgram *encoded = NULL;
+  scoped_ptr<courgette::EncodedProgram> encoded;
   bool result = false;
 
   courgette::SourceStreamSet sources;
@@ -180,7 +183,8 @@ bool DecodeFuzzTest::TryAssemble(const std::string& buffer,
         ReadEncodedProgram(&sources, &encoded);
     if (read_status == courgette::C_OK) {
       courgette::SinkStream assembled;
-      const courgette::Status assemble_status = Assemble(encoded, &assembled);
+      const courgette::Status assemble_status =
+          Assemble(encoded.get(), &assembled);
 
       if (assemble_status == courgette::C_OK) {
         const void* assembled_buffer = assembled.Buffer();
@@ -194,8 +198,6 @@ bool DecodeFuzzTest::TryAssemble(const std::string& buffer,
     }
   }
 
-  DeleteEncodedProgram(encoded);
-
   return result;
 }