Unified usage of vector<unique_ptr<T>>

courgette/ensemble_apply.cc

 // 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 file contains the code to apply a Courgette patch.
 
 #include "courgette/ensemble.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+#include <utility>
+
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "courgette/crc.h"
 #include "courgette/patcher_x86_32.h"
 #include "courgette/region.h"
 #include "courgette/simple_delta.h"
 #include "courgette/streams.h"
 
 namespace courgette {
 
 // EnsemblePatchApplication is all the logic and data required to apply the
 // multi-stage patch.
 class EnsemblePatchApplication {
  public:
   EnsemblePatchApplication();
-  ~EnsemblePatchApplication();
+  ~EnsemblePatchApplication() = default;
 
   Status ReadHeader(SourceStream* header_stream);
 
   Status InitBase(const Region& region);
 
   Status ValidateBase();
 
   Status ReadInitialParameters(SourceStream* initial_parameters);
 
   Status PredictTransformParameters(SinkStreamSet* predicted_parameters);
@@ skipping 21 matching lines @@
                             SourceStream* correction,
                             SourceStreamSet* corrected_items,
                             SinkStream* corrected_items_storage);
 
   Region base_region_;       // Location of in-memory copy of 'old' version.
 
   uint32_t source_checksum_;
   uint32_t target_checksum_;
   uint32_t final_patch_input_size_prediction_;
 
-  std::vector<TransformationPatcher*> patchers_;
+  std::vector<std::unique_ptr<TransformationPatcher>> patchers_;
 
   SinkStream corrected_parameters_storage_;
   SinkStream corrected_elements_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(EnsemblePatchApplication);
 };
 
 EnsemblePatchApplication::EnsemblePatchApplication()
     : source_checksum_(0), target_checksum_(0),
       final_patch_input_size_prediction_(0) {
 }
 
-EnsemblePatchApplication::~EnsemblePatchApplication() {
-  for (size_t i = 0;  i < patchers_.size();  ++i) {
-    delete patchers_[i];
-  }
-}
-
 Status EnsemblePatchApplication::ReadHeader(SourceStream* header_stream) {
   uint32_t magic;
   if (!header_stream->ReadVarint32(&magic))
     return C_BAD_ENSEMBLE_MAGIC;
 
   if (magic != CourgettePatchFile::kMagic)
     return C_BAD_ENSEMBLE_MAGIC;
 
   uint32_t version;
   if (!header_stream->ReadVarint32(&version))
@@ skipping 31 matching lines @@
     SourceStream* transformation_parameters) {
   uint32_t number_of_transformations = 0;
   if (!transformation_parameters->ReadVarint32(&number_of_transformations))
     return C_BAD_ENSEMBLE_HEADER;
 
   for (size_t i = 0;  i < number_of_transformations;  ++i) {
     uint32_t kind;
     if (!transformation_parameters->ReadVarint32(&kind))
       return C_BAD_ENSEMBLE_HEADER;
 
-    TransformationPatcher* patcher = NULL;
+    std::unique_ptr<TransformationPatcher> patcher;
 
-    switch (kind)
-    {
-      case EXE_WIN_32_X86:
-        patcher = new PatcherX86_32(base_region_);
+    switch (kind) {
+      case EXE_WIN_32_X86:  // Fall through.
+      case EXE_ELF_32_X86:
+      case EXE_ELF_32_ARM:
+      case EXE_WIN_32_X64:
+        patcher.reset(new PatcherX86_32(base_region_));
         break;
-      case EXE_ELF_32_X86:
-        patcher = new PatcherX86_32(base_region_);
-        break;
-      case EXE_ELF_32_ARM:
-        patcher = new PatcherX86_32(base_region_);
-        break;
-      case EXE_WIN_32_X64:
-        patcher = new PatcherX86_32(base_region_);
-        break;
+      default:
+        return C_BAD_ENSEMBLE_HEADER;
     }
 
-    if (patcher)
-      patchers_.push_back(patcher);
-    else
-      return C_BAD_ENSEMBLE_HEADER;
+    DCHECK(patcher);
+    patchers_.push_back(std::move(patcher));
   }
 
   for (size_t i = 0;  i < patchers_.size();  ++i) {
     Status status = patchers_[i]->Init(transformation_parameters);
     if (status != C_OK)
       return status;
   }
 
   // All transformation_parameters should have been consumed by the above loop.
   if (!transformation_parameters->Empty())
@@ skipping 250 matching lines @@
           static_cast<int>(new_sink_stream.Length()));
   if (written == -1)
     return C_WRITE_OPEN_ERROR;
   if (static_cast<size_t>(written) != new_sink_stream.Length())
     return C_WRITE_ERROR;
 
   return C_OK;
 }
 
 }  // namespace