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

courgette/patch_generator_x86_32.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.
 
 // This is the transformation and adjustment for all executables.
 // The executable type is determined by ParseDetectedExecutable function.
 
 #ifndef COURGETTE_WIN32_X86_GENERATOR_H_
 #define COURGETTE_WIN32_X86_GENERATOR_H_
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "courgette/assembly_program.h"
 #include "courgette/ensemble.h"
-#include "courgette/program_detector.h"
 
 namespace courgette {
 
 class PatchGeneratorX86_32 : public TransformationPatchGenerator {
  public:
   PatchGeneratorX86_32(Element* old_element,
                        Element* new_element,
                        PatcherX86_32* patcher,
                        ExecutableType kind)
       : TransformationPatchGenerator(old_element, new_element, patcher),
@@ skipping 28 matching lines @@
   // serializing them.
   Status Transform(SourceStreamSet* corrected_parameters,
                    SinkStreamSet* old_transformed_element,
                    SinkStreamSet* new_transformed_element) {
     // Don't expect any corrected parameters.
     if (!corrected_parameters->Empty())
       return C_GENERAL_ERROR;
 
     // Generate old version of program using |corrected_parameters|.
     // TODO(sra): refactor to use same code from patcher_.
-    scoped_ptr<AssemblyProgram> old_program;
+    AssemblyProgram* old_program = NULL;
     Status old_parse_status =
         ParseDetectedExecutable(old_element_->region().start(),
                                 old_element_->region().length(),
                                 &old_program);
     if (old_parse_status != C_OK) {
       LOG(ERROR) << "Cannot parse an executable " << old_element_->Name();
       return old_parse_status;
     }
 
-    // TODO(huangs): Move the block below to right before |new_program| gets
-    // used, so we can reduce Courgette-gen peak memory.
-    scoped_ptr<AssemblyProgram> new_program;
+    AssemblyProgram* new_program = NULL;
     Status new_parse_status =
         ParseDetectedExecutable(new_element_->region().start(),
                                 new_element_->region().length(),
                                 &new_program);
     if (new_parse_status != C_OK) {
+      DeleteAssemblyProgram(old_program);
       LOG(ERROR) << "Cannot parse an executable " << new_element_->Name();
       return new_parse_status;
     }
 
-    scoped_ptr<EncodedProgram> old_encoded;
-    Status old_encode_status = Encode(*old_program, &old_encoded);
-    if (old_encode_status != C_OK)
+    EncodedProgram* old_encoded = NULL;
+    Status old_encode_status = Encode(old_program, &old_encoded);
+    if (old_encode_status != C_OK) {
+      DeleteAssemblyProgram(old_program);
       return old_encode_status;
+    }
 
     Status old_write_status =
-        WriteEncodedProgram(old_encoded.get(), old_transformed_element);
+        WriteEncodedProgram(old_encoded, old_transformed_element);
+    DeleteEncodedProgram(old_encoded);
+    if (old_write_status != C_OK) {
+      DeleteAssemblyProgram(old_program);
+      return old_write_status;
+    }
 
-    old_encoded.reset();
+    Status adjust_status = Adjust(*old_program, new_program);
+    DeleteAssemblyProgram(old_program);
+    if (adjust_status != C_OK) {
+      DeleteAssemblyProgram(new_program);
+      return adjust_status;
+    }
 
-    if (old_write_status != C_OK)
-      return old_write_status;
-
-    Status adjust_status = Adjust(*old_program, new_program.get());
-    old_program.reset();
-    if (adjust_status != C_OK)
-      return adjust_status;
-
-    scoped_ptr<EncodedProgram> new_encoded;
-    Status new_encode_status = Encode(*new_program, &new_encoded);
+    EncodedProgram* new_encoded = NULL;
+    Status new_encode_status = Encode(new_program, &new_encoded);
+    DeleteAssemblyProgram(new_program);
     if (new_encode_status != C_OK)
       return new_encode_status;
 
-    new_program.reset();
+    Status new_write_status =
+        WriteEncodedProgram(new_encoded, new_transformed_element);
+    DeleteEncodedProgram(new_encoded);
+    if (new_write_status != C_OK)
+      return new_write_status;
 
-    Status new_write_status =
-        WriteEncodedProgram(new_encoded.get(), new_transformed_element);
-    return new_write_status;
+    return C_OK;
   }
 
   Status Reform(SourceStreamSet* transformed_element,
                 SinkStream* reformed_element) {
     return TransformationPatchGenerator::Reform(transformed_element,
                                                 reformed_element);
   }
 
  private:
   virtual ~PatchGeneratorX86_32() { }
 
   ExecutableType kind_;
 
   DISALLOW_COPY_AND_ASSIGN(PatchGeneratorX86_32);
 };
 
 }  // namespace courgette
-
 #endif  // COURGETTE_WIN32_X86_GENERATOR_H_