Use std::unique_ptr for Metalink objects

19 files changed, 302 insertions, 364 deletions

diff --git a/src/ChunkChecksum.cc b/src/ChunkChecksum.cc
index 44748c87..68e76b1e 100644
--- a/src/ChunkChecksum.cc
+++ b/src/ChunkChecksum.cc
@@ -80,9 +80,9 @@ void ChunkChecksum::setHashType(const std::string& hashType)
   hashType_ = hashType;
 }
 
-void ChunkChecksum::setPieceHashes(const std::vector<std::string>& pieceHashes)
+void ChunkChecksum::setPieceHashes(std::vector<std::string> pieceHashes)
 {
-  pieceHashes_ = pieceHashes;
+  pieceHashes_ = std::move(pieceHashes);
 }
 
 } // namespace aria2
diff --git a/src/ChunkChecksum.h b/src/ChunkChecksum.h
index f1c0580c..4d82528a 100644
--- a/src/ChunkChecksum.h
+++ b/src/ChunkChecksum.h
@@ -64,7 +64,7 @@ public:
 
   const std::string& getPieceHash(size_t index) const;
 
-  void setPieceHashes(const std::vector<std::string>& pieceHashes);
+  void setPieceHashes(std::vector<std::string> pieceHashes);
   const std::vector<std::string>& getPieceHashes() const
   {
     return pieceHashes_;
diff --git a/src/Context.cc b/src/Context.cc
index 1d1bb315..27ca9a3f 100644
--- a/src/Context.cc
+++ b/src/Context.cc
@@ -99,12 +99,10 @@ namespace {
 void showMetalinkFile
 (const std::string& uri, const std::shared_ptr<Option>& op)
 {
-  std::vector<std::shared_ptr<MetalinkEntry> > metalinkEntries;
-  metalink::parseAndQuery(metalinkEntries, uri, op.get(),
-                          op->get(PREF_METALINK_BASE_URI));
-  std::vector<std::shared_ptr<FileEntry> > fileEntries;
-  MetalinkEntry::toFileEntry(fileEntries, metalinkEntries);
-  util::toStream(fileEntries.begin(), fileEntries.end(), *global::cout());
+  auto fileEntries = MetalinkEntry::toFileEntry
+    (metalink::parseAndQuery(uri, op.get(), op->get(PREF_METALINK_BASE_URI)));
+  util::toStream(std::begin(fileEntries), std::end(fileEntries),
+                 *global::cout());
   global::cout()->write("\n");
   global::cout()->flush();
 }
diff --git a/src/DownloadContext.cc b/src/DownloadContext.cc
index 2c37e300..0dd274e1 100644
--- a/src/DownloadContext.cc
+++ b/src/DownloadContext.cc
@@ -276,9 +276,9 @@ void DownloadContext::setBasePath(const std::string& basePath)
   basePath_ = basePath;
 }
 
-void DownloadContext::setSignature(const std::shared_ptr<Signature>& signature)
+void DownloadContext::setSignature(std::unique_ptr<Signature> signature)
 {
-  signature_ = signature;
+  signature_ = std::move(signature);
 }
 
 void DownloadContext::updateDownloadLength(size_t bytes)
diff --git a/src/DownloadContext.h b/src/DownloadContext.h
index 89a8c8e7..fe1e665a 100644
--- a/src/DownloadContext.h
+++ b/src/DownloadContext.h
@@ -84,7 +84,7 @@ private:
 
   Timer downloadStopTime_;
 
-  std::shared_ptr<Signature> signature_;
+  std::unique_ptr<Signature> signature_;
   // This member variable is required to avoid to use parse Metalink
   // (including both Metalink XML and Metalink/HTTP) twice.
   bool acceptMetalink_;
@@ -169,9 +169,9 @@ public:
 
   void setBasePath(const std::string& basePath);
 
-  const std::shared_ptr<Signature>& getSignature() const { return signature_; }
+  const std::unique_ptr<Signature>& getSignature() const { return signature_; }
 
-  void setSignature(const std::shared_ptr<Signature>& signature);
+  void setSignature(std::unique_ptr<Signature> signature);
 
   RequestGroup* getOwnerRequestGroup() { return ownerRequestGroup_; }
 
diff --git a/src/Metalink2RequestGroup.cc b/src/Metalink2RequestGroup.cc
index 0dd594f9..2a856bb9 100644
--- a/src/Metalink2RequestGroup.cc
+++ b/src/Metalink2RequestGroup.cc
@@ -58,6 +58,7 @@
 #include "fmt.h"
 #include "SegList.h"
 #include "DownloadFailureException.h"
+#include "Signature.h"
 #ifdef ENABLE_BITTORRENT
 # include "BtDependency.h"
 # include "download_helper.h"
@@ -79,7 +80,7 @@ public:
   AccumulateNonP2PUri(std::vector<std::string>& urisPtr)
     :urisPtr(urisPtr) {}
 
-  void operator()(const std::shared_ptr<MetalinkResource>& resource) {
+  void operator()(const std::unique_ptr<MetalinkResource>& resource) {
     switch(resource->type) {
     case MetalinkResource::TYPE_HTTP:
     case MetalinkResource::TYPE_HTTPS:
@@ -110,47 +111,51 @@ public:
 
 void
 Metalink2RequestGroup::generate
-(std::vector<std::shared_ptr<RequestGroup> >& groups,
+(std::vector<std::shared_ptr<RequestGroup>>& groups,
  const std::string& metalinkFile,
  const std::shared_ptr<Option>& option,
  const std::string& baseUri)
 {
-  std::vector<std::shared_ptr<MetalinkEntry> > entries;
-  metalink::parseAndQuery(entries, metalinkFile, option.get(), baseUri);
-  std::vector<std::shared_ptr<RequestGroup> > tempgroups;
-  createRequestGroup(tempgroups, entries, option);
+  std::vector<std::shared_ptr<RequestGroup>> tempgroups;
+  createRequestGroup(tempgroups,
+                     metalink::parseAndQuery(metalinkFile, option.get(),
+                                             baseUri),
+                     option);
   std::shared_ptr<MetadataInfo> mi;
   if(metalinkFile == DEV_STDIN) {
-    mi.reset(new MetadataInfo());
+    mi = std::make_shared<MetadataInfo>();
   } else {
     // TODO Downloads from local metalink file does not save neither
     // its gid nor MetadataInfo's gid.
-    mi.reset(new MetadataInfo(GroupId::create(), metalinkFile));
+    mi = std::make_shared<MetadataInfo>(GroupId::create(), metalinkFile);
   }
-  setMetadataInfo(tempgroups.begin(), tempgroups.end(), mi);
-  groups.insert(groups.end(), tempgroups.begin(), tempgroups.end());
+  setMetadataInfo(std::begin(tempgroups), std::end(tempgroups), mi);
+  groups.insert(std::end(groups),
+                std::begin(tempgroups), std::end(tempgroups));
 }
 
 void
 Metalink2RequestGroup::generate
-(std::vector<std::shared_ptr<RequestGroup> >& groups,
+(std::vector<std::shared_ptr<RequestGroup>>& groups,
  const std::shared_ptr<BinaryStream>& binaryStream,
  const std::shared_ptr<Option>& option,
  const std::string& baseUri)
 {
-  std::vector<std::shared_ptr<MetalinkEntry> > entries;
-  metalink::parseAndQuery(entries, binaryStream.get(), option.get(), baseUri);
-  std::vector<std::shared_ptr<RequestGroup> > tempgroups;
-  createRequestGroup(tempgroups, entries, option);
-  std::shared_ptr<MetadataInfo> mi(new MetadataInfo());
-  setMetadataInfo(tempgroups.begin(), tempgroups.end(), mi);
-  groups.insert(groups.end(), tempgroups.begin(), tempgroups.end());
+  std::vector<std::shared_ptr<RequestGroup>> tempgroups;
+  createRequestGroup(tempgroups,
+                     metalink::parseAndQuery(binaryStream.get(), option.get(),
+                                             baseUri),
+                     option);
+  auto mi = std::make_shared<MetadataInfo>();
+  setMetadataInfo(std::begin(tempgroups), std::end(tempgroups), mi);
+  groups.insert(std::end(groups),
+                std::begin(tempgroups), std::end(tempgroups));
 }
 
 void
 Metalink2RequestGroup::createRequestGroup
-(std::vector<std::shared_ptr<RequestGroup> >& groups,
- const std::vector<std::shared_ptr<MetalinkEntry> >& entries,
+(std::vector<std::shared_ptr<RequestGroup>>& groups,
+ std::vector<std::unique_ptr<MetalinkEntry>> entries,
  const std::shared_ptr<Option>& optionTemplate)
 {
   if(entries.empty()) {
@@ -159,57 +164,52 @@ Metalink2RequestGroup::createRequestGroup
   }
   std::vector<std::string> locations;
   if(optionTemplate->defined(PREF_METALINK_LOCATION)) {
-    const std::string& loc = optionTemplate->get(PREF_METALINK_LOCATION);
-    util::split(loc.begin(), loc.end(),
+    auto& loc = optionTemplate->get(PREF_METALINK_LOCATION);
+    util::split(std::begin(loc), std::end(loc),
                 std::back_inserter(locations), ',', true);
-    for(std::vector<std::string>::iterator i = locations.begin(),
-          eoi = locations.end(); i != eoi; ++i) {
-      util::lowercase(*i);
+    for(auto& s : locations) {
+      util::lowercase(s);
     }
   }
   std::string preferredProtocol;
   if(optionTemplate->get(PREF_METALINK_PREFERRED_PROTOCOL) != V_NONE) {
     preferredProtocol = optionTemplate->get(PREF_METALINK_PREFERRED_PROTOCOL);
   }
-  for(std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator i =
-        entries.begin(), eoi = entries.end(); i != eoi; ++i) {
-    (*i)->dropUnsupportedResource();
-    if((*i)->resources.empty() && (*i)->metaurls.empty()) {
+  for(auto& entry : entries) {
+    entry->dropUnsupportedResource();
+    if(entry->resources.empty() && entry->metaurls.empty()) {
       continue;
     }
-    (*i)->setLocationPriority
+    entry->setLocationPriority
       (locations, -MetalinkResource::getLowestPriority());
     if(!preferredProtocol.empty()) {
-      (*i)->setProtocolPriority
+      entry->setProtocolPriority
         (preferredProtocol, -MetalinkResource::getLowestPriority());
     }
   }
-  std::vector<std::shared_ptr<MetalinkEntry> > selectedEntries;
   SegList<int> sgl;
   util::parseIntSegments(sgl, optionTemplate->get(PREF_SELECT_FILE));
   sgl.normalize();
-  if(!sgl.hasNext()) {
-    selectedEntries.assign(entries.begin(), entries.end());
-  } else {
-    selectedEntries.reserve(entries.size());
+  if(sgl.hasNext()) {
+    size_t inspoint = 0;
     for(size_t i = 0, len = entries.size(); i < len && sgl.hasNext(); ++i) {
-      size_t j = sgl.peek()-1;
+      size_t j = sgl.peek() - 1;
       if(i == j) {
-        selectedEntries.push_back(entries[i]);
+        if(inspoint != i) {
+          entries[inspoint] = std::move(entries[i]);
+        }
+        ++inspoint;
         sgl.next();
       }
     }
+    entries.resize(inspoint);
   }
-  std::for_each(selectedEntries.begin(), selectedEntries.end(),
+  std::for_each(std::begin(entries), std::end(entries),
                 std::mem_fn(&MetalinkEntry::reorderMetaurlsByPriority));
-  std::vector<std::pair<std::string,
-    std::vector<std::shared_ptr<MetalinkEntry> > > > entryGroups;
-  metalink::groupEntryByMetaurlName(entryGroups, selectedEntries);
-  for(std::vector<std::pair<std::string,
-        std::vector<std::shared_ptr<MetalinkEntry> > > >::const_iterator itr =
-        entryGroups.begin(), eoi = entryGroups.end(); itr != eoi; ++itr) {
-    const std::string& metaurl = (*itr).first;
-    const std::vector<std::shared_ptr<MetalinkEntry> >& mes = (*itr).second;
+  auto entryGroups = metalink::groupEntryByMetaurlName(entries);
+  for(auto& entryGroup : entryGroups) {
+    auto& metaurl = entryGroup.first;
+    auto& mes = entryGroup.second;
     A2_LOG_INFO(fmt("Processing metaurl group metaurl=%s", metaurl.c_str()));
 #ifdef ENABLE_BITTORRENT
     std::shared_ptr<RequestGroup> torrentRg;
@@ -217,7 +217,7 @@ Metalink2RequestGroup::createRequestGroup
       std::vector<std::string> uris;
       uris.push_back(metaurl);
       {
-        std::vector<std::shared_ptr<RequestGroup> > result;
+        std::vector<std::shared_ptr<RequestGroup>> result;
         createRequestGroupForUri(result, optionTemplate, uris,
                                  /* ignoreForceSequential = */true,
                                  /* ignoreLocalPath = */true);
@@ -233,26 +233,24 @@ Metalink2RequestGroup::createRequestGroup
         // tranparent metalink
         torrentRg->getDownloadContext()->setAcceptMetalink(false);
         // make it in-memory download
-        std::shared_ptr<PreDownloadHandler> preh
-          (new MemoryBufferPreDownloadHandler());
-        std::shared_ptr<RequestGroupCriteria> cri(new TrueRequestGroupCriteria());
-        preh->setCriteria(cri);
+        auto preh = std::make_shared<MemoryBufferPreDownloadHandler>();
+        preh->setCriteria(std::make_shared<TrueRequestGroupCriteria>());
         torrentRg->addPreDownloadHandler(preh);
         groups.push_back(torrentRg);
       }
     }
 #endif // ENABLE_BITTORRENT
-    std::shared_ptr<Option> option = util::copy(optionTemplate);
-    std::shared_ptr<RequestGroup> rg(new RequestGroup(GroupId::create(), option));
+    auto option = util::copy(optionTemplate);
+    auto rg = std::make_shared<RequestGroup>(GroupId::create(), option);
     std::shared_ptr<DownloadContext> dctx;
     int numSplit = option->getAsInt(PREF_SPLIT);
     int maxConn = option->getAsInt(PREF_MAX_CONNECTION_PER_SERVER);
     if(mes.size() == 1) {
-      std::shared_ptr<MetalinkEntry> entry = mes[0];
+      auto entry = mes[0];
       A2_LOG_INFO(fmt(MSG_METALINK_QUEUEING, entry->getPath().c_str()));
       entry->reorderResourcesByPriority();
       std::vector<std::string> uris;
-      std::for_each(entry->resources.begin(), entry->resources.end(),
+      std::for_each(std::begin(entry->resources), std::end(entry->resources),
                     AccumulateNonP2PUri(uris));
       // If piece hash is specified in the metalink,
       // make segment size equal to piece hash size.
@@ -266,11 +264,11 @@ Metalink2RequestGroup::createRequestGroup
 #else
       pieceLength = option->getAsInt(PREF_PIECE_LENGTH);
 #endif // ENABLE_MESSAGE_DIGEST
-      dctx.reset(new DownloadContext
-                 (pieceLength,
-                  entry->getLength(),
-                  util::applyDir(option->get(PREF_DIR),
-                                 entry->file->getPath())));
+      dctx = std::make_shared<DownloadContext>
+        (pieceLength,
+         entry->getLength(),
+         util::applyDir(option->get(PREF_DIR),
+                        entry->file->getPath()));
       dctx->getFirstFileEntry()->setUris(uris);
       dctx->getFirstFileEntry()->setMaxConnectionPerServer(maxConn);
       if(option->getAsBool(PREF_METALINK_ENABLE_UNIQUE_PROTOCOL)) {
@@ -282,47 +280,49 @@ Metalink2RequestGroup::createRequestGroup
                         entry->checksum->getDigest());
       }
       if(entry->chunkChecksum) {
-        dctx->setPieceHashes(entry->chunkChecksum->getHashType(),
-                             entry->chunkChecksum->getPieceHashes().begin(),
-                             entry->chunkChecksum->getPieceHashes().end());
+        dctx->setPieceHashes
+          (entry->chunkChecksum->getHashType(),
+           std::begin(entry->chunkChecksum->getPieceHashes()),
+           std::end(entry->chunkChecksum->getPieceHashes()));
       }
 #endif // ENABLE_MESSAGE_DIGEST
-      dctx->setSignature(entry->getSignature());
+      dctx->setSignature(entry->popSignature());
       rg->setNumConcurrentCommand
         (entry->maxConnections < 0 ?
          numSplit : std::min(numSplit, entry->maxConnections));
     } else {
-      dctx.reset(new DownloadContext());
+      dctx = std::make_shared<DownloadContext>();
       // piece length is overridden by the one in torrent file.
       dctx->setPieceLength(option->getAsInt(PREF_PIECE_LENGTH));
-      std::vector<std::shared_ptr<FileEntry> > fileEntries;
+      std::vector<std::shared_ptr<FileEntry>> fileEntries;
       int64_t offset = 0;
-      for(std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator i =
-            mes.begin(), eoi = mes.end(); i != eoi; ++i) {
+      for(auto entry : mes) {
         A2_LOG_INFO(fmt("Metalink: Queueing %s for download as a member.",
-                        (*i)->getPath().c_str()));
-        A2_LOG_DEBUG(fmt("originalName = %s", (*i)->metaurls[0]->name.c_str()));
-        (*i)->reorderResourcesByPriority();
+                        entry->getPath().c_str()));
+        A2_LOG_DEBUG(fmt("originalName = %s",
+                         entry->metaurls[0]->name.c_str()));
+        entry->reorderResourcesByPriority();
         std::vector<std::string> uris;
-        std::for_each((*i)->resources.begin(), (*i)->resources.end(),
+        std::for_each(std::begin(entry->resources),
+                      std::end(entry->resources),
                       AccumulateNonP2PUri(uris));
-        std::shared_ptr<FileEntry> fe
-          (new FileEntry
-           (util::applyDir(option->get(PREF_DIR), (*i)->file->getPath()),
-            (*i)->file->getLength(), offset, uris));
+        auto fe = std::make_shared<FileEntry>
+          (util::applyDir(option->get(PREF_DIR),
+                          entry->file->getPath()),
+           entry->file->getLength(), offset, uris);
         fe->setMaxConnectionPerServer(maxConn);
         if(option->getAsBool(PREF_METALINK_ENABLE_UNIQUE_PROTOCOL)) {
           fe->setUniqueProtocol(true);
         }
-        fe->setOriginalName((*i)->metaurls[0]->name);
+        fe->setOriginalName(entry->metaurls[0]->name);
         fileEntries.push_back(fe);
         if(offset >
-           std::numeric_limits<int64_t>::max() - (*i)->file->getLength()) {
+           std::numeric_limits<int64_t>::max() - entry->file->getLength()) {
           throw DOWNLOAD_FAILURE_EXCEPTION(fmt(EX_TOO_LARGE_FILE, offset));
         }
-        offset += (*i)->file->getLength();
+        offset += entry->file->getLength();
       }
-      dctx->setFileEntries(fileEntries.begin(), fileEntries.end());
+      dctx->setFileEntries(std::begin(fileEntries), std::end(fileEntries));
       rg->setNumConcurrentCommand(numSplit);
     }
     rg->setDownloadContext(dctx);
@@ -335,7 +335,7 @@ Metalink2RequestGroup::createRequestGroup
     // Inject depenency between rg and torrentRg here if
     // torrentRg is true
     if(torrentRg) {
-      std::shared_ptr<Dependency> dep(new BtDependency(rg.get(), torrentRg));
+      auto dep = std::make_shared<BtDependency>(rg.get(), torrentRg);
       rg->dependsOn(dep);
       torrentRg->belongsTo(rg->getGID());
       // metadata download may take very long time. If URIs are
@@ -344,15 +344,14 @@ Metalink2RequestGroup::createRequestGroup
       time_t currentBtStopTimeout =
         torrentRg->getOption()->getAsInt(PREF_BT_STOP_TIMEOUT);
       if(currentBtStopTimeout == 0 || currentBtStopTimeout > btStopTimeout) {
-        std::vector<std::shared_ptr<FileEntry> >::const_iterator i;
-        std::vector<std::shared_ptr<FileEntry> >::const_iterator eoi
-          = dctx->getFileEntries().end();
-        for(i = dctx->getFileEntries().begin(); i != eoi; ++i) {
-          if((*i)->getRemainingUris().empty()) {
+        bool allHaveUri = true;
+        for(auto& fe : dctx->getFileEntries()) {
+          if(fe->getRemainingUris().empty()) {
+            allHaveUri = false;
             break;
           }
         }
-        if(i == dctx->getFileEntries().end()) {
+        if(allHaveUri) {
           torrentRg->getOption()->put
             (PREF_BT_STOP_TIMEOUT, util::itos(btStopTimeout));
         }
diff --git a/src/Metalink2RequestGroup.h b/src/Metalink2RequestGroup.h
index 9b2574ac..a98e961f 100644
--- a/src/Metalink2RequestGroup.h
+++ b/src/Metalink2RequestGroup.h
@@ -52,18 +52,18 @@ class MetalinkEntry;
 class Metalink2RequestGroup {
 private:
   void
-  createRequestGroup(std::vector<std::shared_ptr<RequestGroup> >& groups,
-                     const std::vector<std::shared_ptr<MetalinkEntry> >& entries,
+  createRequestGroup(std::vector<std::shared_ptr<RequestGroup>>& groups,
+                     std::vector<std::unique_ptr<MetalinkEntry>> entries,
                      const std::shared_ptr<Option>& option);
 public:
   Metalink2RequestGroup();
 
-  void generate(std::vector<std::shared_ptr<RequestGroup> >& groups,
+  void generate(std::vector<std::shared_ptr<RequestGroup>>& groups,
                 const std::string& metalinkFile,
                 const std::shared_ptr<Option>& option,
                 const std::string& baseUri = A2STR::NIL);
 
-  void generate(std::vector<std::shared_ptr<RequestGroup> >& groups,
+  void generate(std::vector<std::shared_ptr<RequestGroup>>& groups,
                 const std::shared_ptr<BinaryStream>& binaryStream,
                 const std::shared_ptr<Option>& option,
                 const std::string& baseUri = A2STR::NIL);
diff --git a/src/MetalinkEntry.cc b/src/MetalinkEntry.cc
index 86e47344..8decf8c2 100644
--- a/src/MetalinkEntry.cc
+++ b/src/MetalinkEntry.cc
@@ -57,45 +57,6 @@ MetalinkEntry::MetalinkEntry():
 
 MetalinkEntry::~MetalinkEntry() {}
 
-namespace {
-class AddLocationPriority {
-private:
-  std::vector<std::string> locations_;
-  int priorityToAdd_;
-public:
-  AddLocationPriority
-  (const std::vector<std::string>& locations, int priorityToAdd):
-    locations_(locations), priorityToAdd_(priorityToAdd)
-  {
-    std::sort(locations_.begin(), locations_.end());
-  }
-
-  void operator()(std::shared_ptr<MetalinkResource>& res) {
-    if(std::binary_search
-       (locations_.begin(), locations_.end(), res->location)) {
-      res->priority += priorityToAdd_;
-    }
-  }
-};
-} // namespace
-
-MetalinkEntry& MetalinkEntry::operator=(const MetalinkEntry& metalinkEntry)
-{
-  if(this != &metalinkEntry) {
-    this->file = metalinkEntry.file;
-    this->version = metalinkEntry.version;
-    this->languages = metalinkEntry.languages;
-    this->oses = metalinkEntry.oses;
-    this->maxConnections = metalinkEntry.maxConnections;
-#ifdef ENABLE_MESSAGE_DIGEST
-    this->checksum = metalinkEntry.checksum;
-    this->chunkChecksum = metalinkEntry.chunkChecksum;
-#endif // ENABLE_MESSAGE_DIGEST
-    this->signature_ = metalinkEntry.signature_;
-  }
-  return *this;
-}
-
 const std::string& MetalinkEntry::getPath() const
 {
   return file->getPath();
@@ -109,41 +70,29 @@ int64_t MetalinkEntry::getLength() const
 void MetalinkEntry::setLocationPriority
 (const std::vector<std::string>& locations, int priorityToAdd)
 {
-  std::for_each(resources.begin(), resources.end(),
-                AddLocationPriority(locations, priorityToAdd));
-}
-
-namespace {
-class AddProtocolPriority {
-private:
-  std::string protocol_;
-  int priorityToAdd_;
-public:
-  AddProtocolPriority(const std::string& protocol, int prefToAdd):
-    protocol_(protocol), priorityToAdd_(prefToAdd) {}
-
-  void operator()(const std::shared_ptr<MetalinkResource>& res) const
-  {
-    if(protocol_ == MetalinkResource::getTypeString(res->type)) {
-      res->priority += priorityToAdd_;
+  for(auto& res : resources) {
+    if(std::find(std::begin(locations), std::end(locations), res->location)
+       != std::end(locations)) {
+      res->priority += priorityToAdd;
     }
   }
-};
-} // namespace
+}
 
 void MetalinkEntry::setProtocolPriority(const std::string& protocol,
-                                          int priorityToAdd)
+                                        int priorityToAdd)
 {
-  std::for_each(resources.begin(), resources.end(),
-                AddProtocolPriority(protocol, priorityToAdd));
+  for(auto& res : resources) {
+    if(protocol == MetalinkResource::getTypeString(res->type)) {
+      res->priority += priorityToAdd;
+    }
+  }
 }
 
 namespace {
 template<typename T>
 class PriorityHigher {
 public:
-  bool operator()(const std::shared_ptr<T>& res1,
-                  const std::shared_ptr<T>& res2)
+  bool operator()(const T& res1, const T& res2)
   {
     return res1->priority < res2->priority;
   }
@@ -151,15 +100,16 @@ public:
 } // namespace
 
 void MetalinkEntry::reorderResourcesByPriority() {
-  std::random_shuffle(resources.begin(), resources.end(),
+  std::random_shuffle(std::begin(resources), std::end(resources),
                       *SimpleRandomizer::getInstance());
-  std::sort(resources.begin(), resources.end(),
-            PriorityHigher<MetalinkResource>());
+  std::sort(std::begin(resources), std::end(resources),
+            PriorityHigher<std::unique_ptr<MetalinkResource>>{});
 }
 
 void MetalinkEntry::reorderMetaurlsByPriority()
 {
-  std::sort(metaurls.begin(), metaurls.end(),PriorityHigher<MetalinkMetaurl>());
+  std::sort(std::begin(metaurls), std::end(metaurls),
+            PriorityHigher<std::unique_ptr<MetalinkMetaurl>>{});
 }
 
 namespace {
@@ -184,24 +134,43 @@ public:
 };
 } // namespace
 
-void MetalinkEntry::dropUnsupportedResource() {
-  resources.erase(std::remove_if(resources.begin(), resources.end(),
-                                 std::not1(Supported())),
-                  resources.end());
+void MetalinkEntry::dropUnsupportedResource()
+{
+  resources.erase(std::remove_if
+                  (std::begin(resources), std::end(resources),
+                   [](const std::unique_ptr<MetalinkResource>& res)
+                   {
+                     switch(res->type) {
+                     case MetalinkResource::TYPE_FTP:
+                     case MetalinkResource::TYPE_HTTP:
+#ifdef ENABLE_SSL
+                     case MetalinkResource::TYPE_HTTPS:
+#endif // ENABLE_SSL
+#ifdef ENABLE_BITTORRENT
+                     case MetalinkResource::TYPE_BITTORRENT:
+#endif // ENABLE_BITTORRENT
+                       return false;
+                     default:
+                       return true;
+                     }
+                   }),
+                  std::end(resources));
 }
 
-void MetalinkEntry::toFileEntry
-(std::vector<std::shared_ptr<FileEntry> >& fileEntries,
- const std::vector<std::shared_ptr<MetalinkEntry> >& metalinkEntries)
+std::vector<std::unique_ptr<FileEntry>> MetalinkEntry::toFileEntry
+(std::vector<std::unique_ptr<MetalinkEntry>> metalinkEntries)
 {
-  std::transform(metalinkEntries.begin(), metalinkEntries.end(),
-                 std::back_inserter(fileEntries),
-                 std::mem_fn(&MetalinkEntry::getFile));
+  std::vector<std::unique_ptr<FileEntry>> res;
+  res.reserve(metalinkEntries.size());
+  for(auto& entry : metalinkEntries) {
+    res.push_back(entry->popFile());
+  }
+  return res;
 }
 
-void MetalinkEntry::setSignature(const std::shared_ptr<Signature>& signature)
+void MetalinkEntry::setSignature(std::unique_ptr<Signature> signature)
 {
-  signature_ = signature;
+  signature_ = std::move(signature);
 }
 
 bool MetalinkEntry::containsLanguage(const std::string& lang) const
@@ -214,4 +183,14 @@ bool MetalinkEntry::containsOS(const std::string& os) const
   return std::find(oses.begin(), oses.end(), os) != oses.end();
 }
 
+std::unique_ptr<Signature> MetalinkEntry::popSignature()
+{
+  return std::move(signature_);
+}
+
+std::unique_ptr<FileEntry> MetalinkEntry::popFile()
+{
+  return std::move(file);
+}
+
 } // namespace aria2
diff --git a/src/MetalinkEntry.h b/src/MetalinkEntry.h
index 475efe0d..8884ee7f 100644
--- a/src/MetalinkEntry.h
+++ b/src/MetalinkEntry.h
@@ -54,37 +54,37 @@ class Signature;
 
 class MetalinkEntry {
 public:
-  std::shared_ptr<FileEntry> file;
+  std::unique_ptr<FileEntry> file;
   std::string version;
   std::vector<std::string> languages;
   std::vector<std::string> oses;
   // True if size is specified in Metalink document.
   bool sizeKnown;
-  std::vector<std::shared_ptr<MetalinkResource> > resources;
-  std::vector<std::shared_ptr<MetalinkMetaurl> > metaurls;
+  std::vector<std::unique_ptr<MetalinkResource>> resources;
+  std::vector<std::unique_ptr<MetalinkMetaurl>> metaurls;
   int maxConnections; // Metalink3Spec
 #ifdef ENABLE_MESSAGE_DIGEST
-  std::shared_ptr<Checksum> checksum;
-  std::shared_ptr<ChunkChecksum> chunkChecksum;
+  std::unique_ptr<Checksum> checksum;
+  std::unique_ptr<ChunkChecksum> chunkChecksum;
 #endif // ENABLE_MESSAGE_DIGEST
 private:
-  std::shared_ptr<Signature> signature_;
+  std::unique_ptr<Signature> signature_;
 public:
   MetalinkEntry();
 
   ~MetalinkEntry();
 
-  MetalinkEntry& operator=(const MetalinkEntry& metalinkEntry);
-
   const std::string& getPath() const;
 
   int64_t getLength() const;
 
-  const std::shared_ptr<FileEntry>& getFile() const
+  const std::unique_ptr<FileEntry>& getFile() const
   {
     return file;
   }
 
+  std::unique_ptr<FileEntry> popFile();
+
   void dropUnsupportedResource();
 
   void reorderResourcesByPriority();
@@ -100,16 +100,17 @@ public:
 
   void setProtocolPriority(const std::string& protocol, int priorityToAdd);
 
-  static void toFileEntry
-  (std::vector<std::shared_ptr<FileEntry> >& fileEntries,
-   const std::vector<std::shared_ptr<MetalinkEntry> >& metalinkEntries);
+  static std::vector<std::unique_ptr<FileEntry>> toFileEntry
+  (std::vector<std::unique_ptr<MetalinkEntry>> metalinkEntries);
 
-  void setSignature(const std::shared_ptr<Signature>& signature);
+  void setSignature(std::unique_ptr<Signature> signature);
 
-  const std::shared_ptr<Signature>& getSignature() const
+  const std::unique_ptr<Signature>& getSignature() const
   {
     return signature_;
   }
+
+  std::unique_ptr<Signature> popSignature();
 };
 
 } // namespace aria2
diff --git a/src/MetalinkParserController.cc b/src/MetalinkParserController.cc
index 00ddbbb9..5ae75845 100644
--- a/src/MetalinkParserController.cc
+++ b/src/MetalinkParserController.cc
@@ -57,20 +57,25 @@
 
 namespace aria2 {
 
-MetalinkParserController::MetalinkParserController():
-  metalinker_(new Metalinker())
+MetalinkParserController::MetalinkParserController()
+  : metalinker_{make_unique<Metalinker>()}
 {}
 
 MetalinkParserController::~MetalinkParserController() {}
 
 void MetalinkParserController::reset()
 {
-  metalinker_.reset(new Metalinker());
+  metalinker_ = make_unique<Metalinker>();
+}
+
+std::unique_ptr<Metalinker> MetalinkParserController::getResult()
+{
+  return std::move(metalinker_);
 }
 
 void MetalinkParserController::newEntryTransaction()
 {
-  tEntry_.reset(new MetalinkEntry());
+  tEntry_ = make_unique<MetalinkEntry>();
   tResource_.reset();
   tMetaurl_.reset();
 #ifdef ENABLE_MESSAGE_DIGEST
@@ -86,7 +91,7 @@ void MetalinkParserController::setFileNameOfEntry(const std::string& filename)
     return;
   }
   if(!tEntry_->file) {
-    tEntry_->file.reset(new FileEntry(util::escapePath(filename), 0, 0));
+    tEntry_->file = make_unique<FileEntry>(util::escapePath(filename), 0, 0);
   } else {
     tEntry_->file->setPath(util::escapePath(filename));
   }
@@ -147,8 +152,7 @@ void MetalinkParserController::commitEntryTransaction()
   commitChunkChecksumTransactionV4();
   commitChunkChecksumTransaction();
   commitSignatureTransaction();
-  metalinker_->addEntry(tEntry_);
-  tEntry_.reset();
+  metalinker_->addEntry(std::move(tEntry_));
 }
 
 void MetalinkParserController::cancelEntryTransaction()
@@ -167,7 +171,7 @@ void MetalinkParserController::newResourceTransaction()
   if(!tEntry_) {
     return;
   }
-  tResource_.reset(new MetalinkResource());
+  tResource_ = make_unique<MetalinkResource>();
 }
 
 void MetalinkParserController::setURLOfResource(const std::string& url)
@@ -237,16 +241,16 @@ void MetalinkParserController::commitResourceTransaction()
   }
 #ifdef ENABLE_BITTORRENT
   if(tResource_->type == MetalinkResource::TYPE_BITTORRENT) {
-    std::shared_ptr<MetalinkMetaurl> metaurl(new MetalinkMetaurl());
-    metaurl->url = tResource_->url;
+    auto metaurl = make_unique<MetalinkMetaurl>();
+    metaurl->url = std::move(tResource_->url);
     metaurl->priority = tResource_->priority;
     metaurl->mediatype = MetalinkMetaurl::MEDIATYPE_TORRENT;
-    tEntry_->metaurls.push_back(metaurl);
+    tEntry_->metaurls.push_back(std::move(metaurl));
   } else {
-    tEntry_->resources.push_back(tResource_);
+    tEntry_->resources.push_back(std::move(tResource_));
   }
 #else // !ENABLE_BITTORRENT
-  tEntry_->resources.push_back(tResource_);
+  tEntry_->resources.push_back(std::move(tResource_));
 #endif // !ENABLE_BITTORRENT
   tResource_.reset();
 }
@@ -262,7 +266,7 @@ void MetalinkParserController::newChecksumTransaction()
   if(!tEntry_) {
     return;
   }
-  tChecksum_.reset(new Checksum());
+  tChecksum_ = make_unique<Checksum>();
 #endif // ENABLE_MESSAGE_DIGEST
 }
 
@@ -304,7 +308,7 @@ void MetalinkParserController::commitChecksumTransaction()
   if(!tEntry_->checksum ||
      MessageDigest::isStronger(tChecksum_->getHashType(),
                                tEntry_->checksum->getHashType())) {
-    tEntry_->checksum = tChecksum_;
+    tEntry_->checksum = std::move(tChecksum_);
   }
   tChecksum_.reset();
 #endif // ENABLE_MESSAGE_DIGEST
@@ -323,7 +327,7 @@ void MetalinkParserController::newChunkChecksumTransactionV4()
   if(!tEntry_) {
     return;
   }
-  tChunkChecksumV4_.reset(new ChunkChecksum());
+  tChunkChecksumV4_ = make_unique<ChunkChecksum>();
   tempChunkChecksumsV4_.clear();
 #endif // ENABLE_MESSAGE_DIGEST
 }
@@ -380,10 +384,8 @@ void MetalinkParserController::commitChunkChecksumTransactionV4()
   if(!tEntry_->chunkChecksum ||
      MessageDigest::isStronger(tChunkChecksumV4_->getHashType(),
                                tEntry_->chunkChecksum->getHashType())) {
-    std::vector<std::string> pieceHashes(tempChunkChecksumsV4_.begin(),
-                                         tempChunkChecksumsV4_.end());
-    tChunkChecksumV4_->setPieceHashes(pieceHashes);
-    tEntry_->chunkChecksum = tChunkChecksumV4_;
+    tChunkChecksumV4_->setPieceHashes(std::move(tempChunkChecksumsV4_));
+    tEntry_->chunkChecksum = std::move(tChunkChecksumV4_);
   }
   tChunkChecksumV4_.reset();
 #endif // ENABLE_MESSAGE_DIGEST
@@ -402,7 +404,7 @@ void MetalinkParserController::newChunkChecksumTransaction()
   if(!tEntry_) {
     return;
   }
-  tChunkChecksum_.reset(new ChunkChecksum());
+  tChunkChecksum_ = make_unique<ChunkChecksum>();
   tempChunkChecksums_.clear();
 #endif // ENABLE_MESSAGE_DIGEST
 }
@@ -493,14 +495,15 @@ void MetalinkParserController::commitChunkChecksumTransaction()
   if(!tEntry_->chunkChecksum ||
      MessageDigest::isStronger(tChunkChecksum_->getHashType(),
                                tEntry_->chunkChecksum->getHashType())) {
-    std::sort(tempChunkChecksums_.begin(), tempChunkChecksums_.end());
+    std::sort(std::begin(tempChunkChecksums_), std::end(tempChunkChecksums_));
     std::vector<std::string> pieceHashes;
-    std::transform(tempChunkChecksums_.begin(), tempChunkChecksums_.end(),
+    std::transform(std::begin(tempChunkChecksums_),
+                   std::end(tempChunkChecksums_),
                    std::back_inserter(pieceHashes),
                    [](const std::pair<size_t, std::string>& p)
                    { return p.second; });
-    tChunkChecksum_->setPieceHashes(pieceHashes);
-    tEntry_->chunkChecksum = tChunkChecksum_;
+    tChunkChecksum_->setPieceHashes(std::move(pieceHashes));
+    tEntry_->chunkChecksum = std::move(tChunkChecksum_);
   }
   tChunkChecksum_.reset();
 #endif // ENABLE_MESSAGE_DIGEST
@@ -518,7 +521,7 @@ void MetalinkParserController::newSignatureTransaction()
   if(!tEntry_) {
     return;
   }
-  tSignature_.reset(new Signature());
+  tSignature_ = make_unique<Signature>();
 }
 
 void MetalinkParserController::setTypeOfSignature(const std::string& type)
@@ -550,8 +553,7 @@ void MetalinkParserController::commitSignatureTransaction()
   if(!tSignature_) {
     return;
   }
-  tEntry_->setSignature(tSignature_);
-  tSignature_.reset();
+  tEntry_->setSignature(std::move(tSignature_));
 }
 
 void MetalinkParserController::cancelSignatureTransaction()
@@ -564,7 +566,7 @@ void MetalinkParserController::newMetaurlTransaction()
   if(!tEntry_) {
     return;
   }
-  tMetaurl_.reset(new MetalinkMetaurl());
+  tMetaurl_ = make_unique<MetalinkMetaurl>();
 }
 
 void MetalinkParserController::setURLOfMetaurl(const std::string& url)
@@ -619,7 +621,7 @@ void MetalinkParserController::commitMetaurlTransaction()
   }
 #ifdef ENABLE_BITTORRENT
   if(tMetaurl_->mediatype == MetalinkMetaurl::MEDIATYPE_TORRENT) {
-    tEntry_->metaurls.push_back(tMetaurl_);
+    tEntry_->metaurls.push_back(std::move(tMetaurl_));
   }
 #endif // ENABLE_BITTORRENT
   tMetaurl_.reset();
diff --git a/src/MetalinkParserController.h b/src/MetalinkParserController.h
index c3bd537a..12fd6f4f 100644
--- a/src/MetalinkParserController.h
+++ b/src/MetalinkParserController.h
@@ -57,21 +57,21 @@ class ChunkChecksum;
 
 class MetalinkParserController {
 private:
-  std::shared_ptr<Metalinker> metalinker_;
+  std::unique_ptr<Metalinker> metalinker_;
 
-  std::shared_ptr<MetalinkEntry> tEntry_;
+  std::unique_ptr<MetalinkEntry> tEntry_;
 
-  std::shared_ptr<MetalinkResource> tResource_;
+  std::unique_ptr<MetalinkResource> tResource_;
 
-  std::shared_ptr<MetalinkMetaurl> tMetaurl_;
+  std::unique_ptr<MetalinkMetaurl> tMetaurl_;
 #ifdef ENABLE_MESSAGE_DIGEST
-  std::shared_ptr<Checksum> tChecksum_;
+  std::unique_ptr<Checksum> tChecksum_;
 
-  std::shared_ptr<ChunkChecksum> tChunkChecksumV4_; // Metalink4Spec
+  std::unique_ptr<ChunkChecksum> tChunkChecksumV4_; // Metalink4Spec
 
   std::vector<std::string> tempChunkChecksumsV4_; // Metalink4Spec
 
-  std::shared_ptr<ChunkChecksum> tChunkChecksum_; // Metalink3Spec
+  std::unique_ptr<ChunkChecksum> tChunkChecksum_; // Metalink3Spec
 
   std::vector<std::pair<size_t, std::string> > tempChunkChecksums_;//Metalink3Spec
 
@@ -79,7 +79,7 @@ private:
 
 #endif // ENABLE_MESSAGE_DIGEST
 
-  std::shared_ptr<Signature> tSignature_;
+  std::unique_ptr<Signature> tSignature_;
   std::string baseUri_;
 public:
   MetalinkParserController();
@@ -88,10 +88,7 @@ public:
 
   void reset();
 
-  const std::shared_ptr<Metalinker>& getResult() const
-  {
-    return metalinker_;
-  }
+  std::unique_ptr<Metalinker> getResult();
 
   void newEntryTransaction();
 
diff --git a/src/MetalinkParserStateMachine.cc b/src/MetalinkParserStateMachine.cc
index bcca4410..2f4fd242 100644
--- a/src/MetalinkParserStateMachine.cc
+++ b/src/MetalinkParserStateMachine.cc
@@ -42,6 +42,7 @@
 #include "MetalinkParserStateV4Impl.h"
 #include "Metalinker.h"
 #include "MetalinkEntry.h"
+#include "a2functional.h"
 
 namespace aria2 {
 
@@ -104,8 +105,8 @@ MetalinkParserState* MetalinkParserStateMachine::urlStateV4_ =
 MetalinkParserState* MetalinkParserStateMachine::metaurlStateV4_ =
   new MetaurlMetalinkParserStateV4();
 
-MetalinkParserStateMachine::MetalinkParserStateMachine():
-  ctrl_(new MetalinkParserController())
+MetalinkParserStateMachine::MetalinkParserStateMachine()
+  : ctrl_{make_unique<MetalinkParserController>()}
 {
   stateStack_.push(initialState_);
 }
@@ -551,6 +552,11 @@ std::string MetalinkParserStateMachine::getErrorString() const
   return error.str();
 }
 
+std::unique_ptr<Metalinker> MetalinkParserStateMachine::getResult()
+{
+  return ctrl_->getResult();
+}
+
 void MetalinkParserStateMachine::setBaseUri(const std::string& uri)
 {
   ctrl_->setBaseUri(uri);
diff --git a/src/MetalinkParserStateMachine.h b/src/MetalinkParserStateMachine.h
index 13b6581c..ad7c1456 100644
--- a/src/MetalinkParserStateMachine.h
+++ b/src/MetalinkParserStateMachine.h
@@ -51,7 +51,7 @@ class Metalinker;
 
 class MetalinkParserStateMachine : public ParserStateMachine {
 private:
-  std::shared_ptr<MetalinkParserController> ctrl_;
+  std::unique_ptr<MetalinkParserController> ctrl_;
 
   std::stack<MetalinkParserState*> stateStack_;
 
@@ -265,10 +265,7 @@ public:
 
   std::string getErrorString() const;
 
-  const std::shared_ptr<Metalinker>& getResult() const
-  {
-    return ctrl_->getResult();
-  }
+  std::unique_ptr<Metalinker> getResult();
 
   void setBaseUri(const std::string& uri);
 };
diff --git a/src/MetalinkResource.h b/src/MetalinkResource.h
index d4d53944..725a5c16 100644
--- a/src/MetalinkResource.h
+++ b/src/MetalinkResource.h
@@ -63,8 +63,8 @@ public:
   ~MetalinkResource();
 
   // Don't allow copying
-  MetalinkResource(const MetalinkResource&);
-  MetalinkResource& operator=(const MetalinkResource&);
+  MetalinkResource(const MetalinkResource&) = delete;
+  MetalinkResource& operator=(const MetalinkResource&) = delete;
 
   static const std::string& getTypeString(TYPE type)
   {
diff --git a/src/Metalinker.cc b/src/Metalinker.cc
index 70e8fcfa..91bb145e 100644
--- a/src/Metalinker.cc
+++ b/src/Metalinker.cc
@@ -43,56 +43,32 @@ Metalinker::Metalinker() {}
 
 Metalinker::~Metalinker() {}
 
-namespace {
-class EntryQuery:
-    public std::unary_function<std::shared_ptr<MetalinkEntry>, bool> {
-private:
-  std::string version;
-  std::string language;
-  std::string os;
-public:
-  EntryQuery(const std::string& version,
-             const std::string& language,
-             const std::string& os):
-    version(version),
-    language(language),
-    os(os) {}
-
-  bool operator()(const std::shared_ptr<MetalinkEntry>& entry) const {
-    if(!version.empty()) {
-      if(version != entry->version) {
-        return false;
-      }
-    }
-    if(!language.empty()) {
-      if(!entry->containsLanguage(language)) {
-        return false;
-      }
-    }
-    if(!os.empty()) {
-      if(!entry->containsOS(os)) {
-        return false;
-      }
+std::vector<std::unique_ptr<MetalinkEntry>>
+Metalinker::queryEntry(const std::string& version,
+                       const std::string& language,
+                       const std::string& os)
+{
+  std::vector<std::unique_ptr<MetalinkEntry>> res;
+  for(auto& entry : entries_) {
+    if((!version.empty() && version != entry->version) ||
+       (!language.empty() && !entry->containsLanguage(language)) ||
+       (!os.empty() && !entry->containsOS(os))) {
+      continue;
     }
-    return true;
+    res.push_back(std::move(entry));
   }
-};
-} // namespace
-
-void Metalinker::queryEntry
-(std::vector<std::shared_ptr<MetalinkEntry> >& queryResult,
- const std::string& version,
- const std::string& language,
- const std::string& os) const
-{
-  std::remove_copy_if(entries_.begin(), entries_.end(),
-                      std::back_inserter(queryResult),
-                      std::not1(EntryQuery(version, language, os)));
+  entries_.erase(std::remove_if(std::begin(entries_), std::end(entries_),
+                                [](const std::unique_ptr<MetalinkEntry>& entry)
+                                {
+                                  return !entry.get();
+                                }),
+                 std::end(entries_));
+  return res;
 }
 
-void Metalinker::addEntry(const std::shared_ptr<MetalinkEntry>& entry)
+void Metalinker::addEntry(std::unique_ptr<MetalinkEntry> entry)
 {
-  entries_.push_back(entry);
+  entries_.push_back(std::move(entry));
 }
 
 } // namespace aria2
diff --git a/src/Metalinker.h b/src/Metalinker.h
index 6e2726d9..4fc61c33 100644
--- a/src/Metalinker.h
+++ b/src/Metalinker.h
@@ -47,27 +47,26 @@ class MetalinkEntry;
 
 class Metalinker {
 private:
-  std::vector<std::shared_ptr<MetalinkEntry> > entries_;
+  std::vector<std::unique_ptr<MetalinkEntry>> entries_;
 public:
   Metalinker();
   ~Metalinker();
 
   // Don't allow copying
-  Metalinker(const Metalinker&);
-  Metalinker& operator=(const Metalinker&);
+  Metalinker(const Metalinker&) = delete;
+  Metalinker& operator=(const Metalinker&) = delete;
 
-  void queryEntry
-  (std::vector<std::shared_ptr<MetalinkEntry> >& queryResult,
-   const std::string& version,
-   const std::string& language,
-   const std::string& os) const;
+  std::vector<std::unique_ptr<MetalinkEntry>>
+  queryEntry(const std::string& version,
+             const std::string& language,
+             const std::string& os);
 
-  const std::vector<std::shared_ptr<MetalinkEntry> >& getEntries() const
+  const std::vector<std::unique_ptr<MetalinkEntry>>& getEntries() const
   {
     return entries_;
   }
 
-  void addEntry(const std::shared_ptr<MetalinkEntry>& entry);
+  void addEntry(std::unique_ptr<MetalinkEntry> entry);
 };
 
 } // namespace aria2
diff --git a/src/RequestGroupMan.cc b/src/RequestGroupMan.cc
index 933f3807..6cae6b34 100644
--- a/src/RequestGroupMan.cc
+++ b/src/RequestGroupMan.cc
@@ -257,8 +257,7 @@ private:
 
   void saveSignature(const std::shared_ptr<RequestGroup>& group)
   {
-    std::shared_ptr<Signature> sig =
-      group->getDownloadContext()->getSignature();
+    auto& sig = group->getDownloadContext()->getSignature();
     if(sig && !sig->getBody().empty()) {
       // filename of signature file is the path to download file followed by
       // ".sig".
diff --git a/src/metalink_helper.cc b/src/metalink_helper.cc
index 3f70ae5f..bebbc0f7 100644
--- a/src/metalink_helper.cc
+++ b/src/metalink_helper.cc
@@ -49,77 +49,65 @@ namespace metalink {
 
 namespace {
 
-void query
-(std::vector<std::shared_ptr<MetalinkEntry> >& result,
- const std::shared_ptr<Metalinker>& metalinker,
- const Option* option)
+std::vector<std::unique_ptr<MetalinkEntry>>
+query(const std::shared_ptr<Metalinker>& metalinker,
+      const Option* option)
 {
-  metalinker->queryEntry(result,
-                         option->get(PREF_METALINK_VERSION),
-                         option->get(PREF_METALINK_LANGUAGE),
-                         option->get(PREF_METALINK_OS));
+  return metalinker->queryEntry(option->get(PREF_METALINK_VERSION),
+                                option->get(PREF_METALINK_LANGUAGE),
+                                option->get(PREF_METALINK_OS));
 }
 
 } // namespace
 
-void parseAndQuery
-(std::vector<std::shared_ptr<MetalinkEntry> >& result,
- const std::string& filename,
+std::vector<std::unique_ptr<MetalinkEntry>> parseAndQuery
+(const std::string& filename,
  const Option* option,
  const std::string& baseUri)
 {
-  std::shared_ptr<Metalinker> metalinker = parseFile(filename, baseUri);
-  query(result, metalinker, option);
+  return query(parseFile(filename, baseUri), option);
 }
 
-void parseAndQuery
-(std::vector<std::shared_ptr<MetalinkEntry> >& result,
- BinaryStream* bs,
+std::vector<std::unique_ptr<MetalinkEntry>> parseAndQuery
+(BinaryStream* bs,
  const Option* option,
  const std::string& baseUri)
 {
-  std::shared_ptr<Metalinker> metalinker = parseBinaryStream(bs, baseUri);
-  query(result, metalinker, option);
+  return query(parseBinaryStream(bs, baseUri), option);
 }
 
-void groupEntryByMetaurlName
-(std::vector<
-  std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > >& result,
- const std::vector<std::shared_ptr<MetalinkEntry> >& entries)
+std::vector<std::pair<std::string,
+                      std::vector<MetalinkEntry*>>> groupEntryByMetaurlName
+(const std::vector<std::unique_ptr<MetalinkEntry>>& entries)
 {
-  for(std::vector<std::shared_ptr<MetalinkEntry> >::const_iterator eiter =
-        entries.begin(), eoi = entries.end(); eiter != eoi; ++eiter) {
-    if((*eiter)->metaurls.empty()) {
-      std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > p;
-      p.second.push_back(*eiter);
-      result.push_back(p);
+  std::vector<std::pair<std::string,
+                        std::vector<MetalinkEntry*>>> result;
+  for(auto& entry : entries) {
+    if(entry->metaurls.empty()) {
+      // std::pair<std::string, std::vector<MetalinkEntry*>> p;
+      // p.second.push_back(entry.get());
+      result.push_back({"", {entry.get()}});
     } else {
-      std::vector<
-      std::pair<std::string,
-        std::vector<std::shared_ptr<MetalinkEntry> > > >::iterator i =
-        result.begin();
-      if((*eiter)->metaurls[0]->name.empty() ||
-         !(*eiter)->sizeKnown) {
-        i = result.end();
+      auto i = std::begin(result);
+      if(entry->metaurls[0]->name.empty() || !entry->sizeKnown) {
+        i = std::end(result);
       }
-      for(; i != result.end(); ++i) {
-        if((*i).first == (*eiter)->metaurls[0]->url &&
+      for(; i != std::end(result); ++i) {
+        if((*i).first == entry->metaurls[0]->url &&
            !(*i).second[0]->metaurls[0]->name.empty()) {
-          (*i).second.push_back(*eiter);
+          (*i).second.push_back(entry.get());
           break;
         }
       }
-      if(i == result.end()) {
-        std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > p;
-        p.first = (*eiter)->metaurls[0]->url;
-        p.second.push_back(*eiter);
-        result.push_back(p);
+      if(i == std::end(result)) {
+        result.push_back({entry->metaurls[0]->url, {entry.get()}});
       }
     }
   }
+  return result;
 }
 
-std::shared_ptr<Metalinker> parseFile
+std::unique_ptr<Metalinker> parseFile
 (const std::string& filename,
  const std::string& baseUri)
 {
@@ -136,7 +124,7 @@ std::shared_ptr<Metalinker> parseFile
   return psm.getResult();
 }
 
-std::shared_ptr<Metalinker> parseBinaryStream
+std::unique_ptr<Metalinker> parseBinaryStream
 (BinaryStream* bs,
  const std::string& baseUri)
 {
diff --git a/src/metalink_helper.h b/src/metalink_helper.h
index 875733be..495ac70e 100644
--- a/src/metalink_helper.h
+++ b/src/metalink_helper.h
@@ -52,28 +52,25 @@ class Metalinker;
 
 namespace metalink {
 
-void parseAndQuery
-(std::vector<std::shared_ptr<MetalinkEntry> >& result,
- const std::string& filename,
+std::vector<std::unique_ptr<MetalinkEntry>> parseAndQuery
+(const std::string& filename,
  const Option* option,
  const std::string& baseUri = A2STR::NIL);
 
-void parseAndQuery
-(std::vector<std::shared_ptr<MetalinkEntry> >& result,
- BinaryStream* bs,
+std::vector<std::unique_ptr<MetalinkEntry>> parseAndQuery
+(BinaryStream* bs,
  const Option* option,
  const std::string& baseUri = A2STR::NIL);
 
-void groupEntryByMetaurlName
-(std::vector<
-  std::pair<std::string, std::vector<std::shared_ptr<MetalinkEntry> > > >& result,
- const std::vector<std::shared_ptr<MetalinkEntry> >& entries);
+std::vector<std::pair<std::string,
+                      std::vector<MetalinkEntry*>>> groupEntryByMetaurlName
+(const std::vector<std::unique_ptr<MetalinkEntry>>& entries);
 
-std::shared_ptr<Metalinker> parseFile
+std::unique_ptr<Metalinker> parseFile
 (const std::string& filename,
  const std::string& baseUri = A2STR::NIL);
 
-std::shared_ptr<Metalinker> parseBinaryStream
+std::unique_ptr<Metalinker> parseBinaryStream
 (BinaryStream* bs,
  const std::string& baseUri = A2STR::NIL);