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>

[huangs, 2016/05/11 04:49:23]

NIT: new line to separate C-style and C++-style.

Add

#include <utility>

if you adopt the std::move() suggestion below.

[etiennep, 2016/05/11 18:19:14]

Done.

 
 #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;

[huangs, 2016/05/11 04:49:24]

std::unique_ptr<TransformationPatcher> patcher;

[etiennep, 2016/05/11 18:19:13]

Done.

 
     switch (kind)

[huangs, 2016/05/11 04:49:24]

Unwrap.

[etiennep, 2016/05/11 18:19:14]

Done.

     {
       case EXE_WIN_32_X86:
         patcher = new PatcherX86_32(base_region_);

[huangs, 2016/05/11 04:49:23]

patcher.reset(...);
...

[etiennep, 2016/05/11 18:19:13]

Done.

         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;
     }

[huangs, 2016/05/11 04:49:23]

    default:
      return C_BAD_ENSEMBLE_HEADER;

[etiennep, 2016/05/11 18:19:13]

Done.

 
     if (patcher)

[huangs, 2016/05/11 04:49:23]

Can do:

  DCHECK(patcher);
  patchers_.push_back(std::move(patcher));

remove the else.

[etiennep, 2016/05/11 18:19:14]

Done.

-      patchers_.push_back(patcher);
+      patchers_.emplace_back(patcher);
     else
       return C_BAD_ENSEMBLE_HEADER;
   }
 
   for (size_t i = 0;  i < patchers_.size();  ++i) {
     Status status = patchers_[i]->Init(transformation_parameters);
     if (status != C_OK)
       return status;
   }
 
@@ skipping 252 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