Wrap BtMessage objects by std::unique_ptr instead of std::shared_ptr

56 files changed, 449 insertions, 431 deletions

diff --git a/src/BtAllowedFastMessage.cc b/src/BtAllowedFastMessage.cc
index 9400f5b5..9821d378 100644
--- a/src/BtAllowedFastMessage.cc
+++ b/src/BtAllowedFastMessage.cc
@@ -45,7 +45,7 @@ const char BtAllowedFastMessage::NAME[] = "allowed fast";
 BtAllowedFastMessage::BtAllowedFastMessage(size_t index):
   IndexBtMessage(ID, NAME, index) {}
 
-BtAllowedFastMessage* BtAllowedFastMessage::create
+std::unique_ptr<BtAllowedFastMessage> BtAllowedFastMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return IndexBtMessage::create<BtAllowedFastMessage>(data, dataLength);
diff --git a/src/BtAllowedFastMessage.h b/src/BtAllowedFastMessage.h
index 079ca84e..134084a5 100644
--- a/src/BtAllowedFastMessage.h
+++ b/src/BtAllowedFastMessage.h
@@ -47,7 +47,7 @@ public:
 
   static const char NAME[];
 
-  static BtAllowedFastMessage* create
+  static std::unique_ptr<BtAllowedFastMessage> create
   (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
diff --git a/src/BtBitfieldMessage.cc b/src/BtBitfieldMessage.cc
index 1da36dad..dca8959f 100644
--- a/src/BtBitfieldMessage.cc
+++ b/src/BtBitfieldMessage.cc
@@ -78,12 +78,12 @@ void BtBitfieldMessage::setBitfield
   memcpy(bitfield_, bitfield, bitfieldLength_);
 }
 
-BtBitfieldMessage*
+std::unique_ptr<BtBitfieldMessage>
 BtBitfieldMessage::create(const unsigned char* data, size_t dataLength)
 {
   bittorrent::assertPayloadLengthGreater(1,dataLength, NAME);
   bittorrent::assertID(ID, data, NAME);
-  BtBitfieldMessage* message(new BtBitfieldMessage());
+  auto message = make_unique<BtBitfieldMessage>();
   message->setBitfield(data+1, dataLength-1);
   return message;
 }
diff --git a/src/BtBitfieldMessage.h b/src/BtBitfieldMessage.h
index e14009e6..e88be944 100644
--- a/src/BtBitfieldMessage.h
+++ b/src/BtBitfieldMessage.h
@@ -60,7 +60,7 @@ public:
 
   size_t getBitfieldLength() const { return bitfieldLength_; }
 
-  static BtBitfieldMessage* create
+  static std::unique_ptr<BtBitfieldMessage> create
   (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
diff --git a/src/BtCancelMessage.cc b/src/BtCancelMessage.cc
index d2575c56..ecfff4f0 100644
--- a/src/BtCancelMessage.cc
+++ b/src/BtCancelMessage.cc
@@ -43,7 +43,7 @@ BtCancelMessage::BtCancelMessage
 (size_t index, int32_t begin, int32_t length)
   :RangeBtMessage(ID, NAME, index, begin, length) {}
 
-BtCancelMessage* BtCancelMessage::create
+std::unique_ptr<BtCancelMessage> BtCancelMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return RangeBtMessage::create<BtCancelMessage>(data, dataLength);
diff --git a/src/BtCancelMessage.h b/src/BtCancelMessage.h
index a0ec9e3e..42ca7d9c 100644
--- a/src/BtCancelMessage.h
+++ b/src/BtCancelMessage.h
@@ -47,7 +47,8 @@ public:
 
   static const char NAME[];
 
-  static BtCancelMessage* create(const unsigned char* data, size_t dataLength);
+  static std::unique_ptr<BtCancelMessage> create
+  (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
 };
diff --git a/src/BtChokeMessage.cc b/src/BtChokeMessage.cc
index e8ac9bdf..441f3cf1 100644
--- a/src/BtChokeMessage.cc
+++ b/src/BtChokeMessage.cc
@@ -42,9 +42,9 @@ namespace aria2 {
 
 const char BtChokeMessage::NAME[] = "choke";
 
-BtChokeMessage::BtChokeMessage():ZeroBtMessage(ID, NAME) {}
+BtChokeMessage::BtChokeMessage():ZeroBtMessage{ID, NAME} {}
 
-BtChokeMessage* BtChokeMessage::create
+std::unique_ptr<BtChokeMessage> BtChokeMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtChokeMessage>(data, dataLength);
diff --git a/src/BtChokeMessage.h b/src/BtChokeMessage.h
index ee02e415..878b4e9d 100644
--- a/src/BtChokeMessage.h
+++ b/src/BtChokeMessage.h
@@ -49,7 +49,8 @@ public:
 
   virtual void doReceivedAction();
 
-  static BtChokeMessage* create(const unsigned char* data, size_t dataLength);
+  static std::unique_ptr<BtChokeMessage> create
+  (const unsigned char* data, size_t dataLength);
 
   virtual bool sendPredicate() const;
 
diff --git a/src/BtExtendedMessage.cc b/src/BtExtendedMessage.cc
index faa1934b..901d72f3 100644
--- a/src/BtExtendedMessage.cc
+++ b/src/BtExtendedMessage.cc
@@ -96,7 +96,7 @@ std::string BtExtendedMessage::toString() const {
   return s;
 }
 
-BtExtendedMessage*
+std::unique_ptr<BtExtendedMessage>
 BtExtendedMessage::create(const std::shared_ptr<ExtensionMessageFactory>& factory,
                           const std::shared_ptr<Peer>& peer,
                           const unsigned char* data, size_t dataLength)
@@ -106,8 +106,7 @@ BtExtendedMessage::create(const std::shared_ptr<ExtensionMessageFactory>& factor
   assert(factory);
   std::shared_ptr<ExtensionMessage> extmsg = factory->createMessage(data+1,
                                                                  dataLength-1);
-  BtExtendedMessage* message(new BtExtendedMessage(extmsg));
-  return message;
+  return make_unique<BtExtendedMessage>(extmsg);
 }
 
 void BtExtendedMessage::doReceivedAction()
diff --git a/src/BtExtendedMessage.h b/src/BtExtendedMessage.h
index 092b9df5..584287e9 100644
--- a/src/BtExtendedMessage.h
+++ b/src/BtExtendedMessage.h
@@ -56,7 +56,7 @@ public:
 
   static const char NAME[];
 
-  static BtExtendedMessage* create
+  static std::unique_ptr<BtExtendedMessage> create
   (const std::shared_ptr<ExtensionMessageFactory>& factory,
    const std::shared_ptr<Peer>& peer,
    const unsigned char* data,
diff --git a/src/BtHandshakeMessage.cc b/src/BtHandshakeMessage.cc
index bdc084ce..cbec38ff 100644
--- a/src/BtHandshakeMessage.cc
+++ b/src/BtHandshakeMessage.cc
@@ -75,10 +75,10 @@ void BtHandshakeMessage::init() {
   reserved_[5] |= 0x10u;
 }
 
-std::shared_ptr<BtHandshakeMessage>
+std::unique_ptr<BtHandshakeMessage>
 BtHandshakeMessage::create(const unsigned char* data, size_t dataLength)
 {
-  std::shared_ptr<BtHandshakeMessage> message(new BtHandshakeMessage());
+  auto message = make_unique<BtHandshakeMessage>();
   message->pstrlen_ = data[0];
   memcpy(message->pstr_, &data[1], PSTR_LENGTH);
   memcpy(message->reserved_, &data[20], RESERVED_LENGTH);
diff --git a/src/BtHandshakeMessage.h b/src/BtHandshakeMessage.h
index 14d967c4..1d9dc78e 100644
--- a/src/BtHandshakeMessage.h
+++ b/src/BtHandshakeMessage.h
@@ -60,7 +60,7 @@ public:
    */
   BtHandshakeMessage(const unsigned char* infoHash, const unsigned char* peerId);
 
-  static std::shared_ptr<BtHandshakeMessage>
+  static std::unique_ptr<BtHandshakeMessage>
   create(const unsigned char* data, size_t dataLength);
 
   virtual ~BtHandshakeMessage() {
diff --git a/src/BtHaveAllMessage.cc b/src/BtHaveAllMessage.cc
index 81f74203..9bf23472 100644
--- a/src/BtHaveAllMessage.cc
+++ b/src/BtHaveAllMessage.cc
@@ -45,7 +45,7 @@ const char BtHaveAllMessage::NAME[] = "have all";
 
 BtHaveAllMessage::BtHaveAllMessage():ZeroBtMessage(ID, NAME) {}
 
-BtHaveAllMessage* BtHaveAllMessage::create
+std::unique_ptr<BtHaveAllMessage> BtHaveAllMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtHaveAllMessage>(data, dataLength);
diff --git a/src/BtHaveAllMessage.h b/src/BtHaveAllMessage.h
index c19ca004..04d8e553 100644
--- a/src/BtHaveAllMessage.h
+++ b/src/BtHaveAllMessage.h
@@ -47,7 +47,7 @@ public:
 
   static const char NAME[];
 
-  static BtHaveAllMessage* create
+  static std::unique_ptr<BtHaveAllMessage> create
   (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
diff --git a/src/BtHaveMessage.cc b/src/BtHaveMessage.cc
index 92ae8f8c..22b3c27a 100644
--- a/src/BtHaveMessage.cc
+++ b/src/BtHaveMessage.cc
@@ -44,7 +44,7 @@ const char BtHaveMessage::NAME[] = "have";
 
 BtHaveMessage::BtHaveMessage(size_t index):IndexBtMessage(ID, NAME, index) {}
 
-BtHaveMessage* BtHaveMessage::create
+std::unique_ptr<BtHaveMessage> BtHaveMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return IndexBtMessage::create<BtHaveMessage>(data, dataLength);
diff --git a/src/BtHaveMessage.h b/src/BtHaveMessage.h
index 03c3f565..3285774e 100644
--- a/src/BtHaveMessage.h
+++ b/src/BtHaveMessage.h
@@ -47,7 +47,8 @@ public:
 
   static const char NAME[];
 
-  static BtHaveMessage* create(const unsigned char* data, size_t dataLength);
+  static std::unique_ptr<BtHaveMessage> create
+  (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
 };
diff --git a/src/BtHaveNoneMessage.cc b/src/BtHaveNoneMessage.cc
index 1257b7e5..6f1e5460 100644
--- a/src/BtHaveNoneMessage.cc
+++ b/src/BtHaveNoneMessage.cc
@@ -43,7 +43,7 @@ const char BtHaveNoneMessage::NAME[] = "have none";
 
 BtHaveNoneMessage::BtHaveNoneMessage():ZeroBtMessage(ID, NAME) {}
 
-BtHaveNoneMessage* BtHaveNoneMessage::create
+std::unique_ptr<BtHaveNoneMessage> BtHaveNoneMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtHaveNoneMessage>(data, dataLength);
diff --git a/src/BtHaveNoneMessage.h b/src/BtHaveNoneMessage.h
index fcc3f4a2..84ad4f64 100644
--- a/src/BtHaveNoneMessage.h
+++ b/src/BtHaveNoneMessage.h
@@ -47,7 +47,7 @@ public:
 
   static const char NAME[];
 
-  static BtHaveNoneMessage* create
+  static std::unique_ptr<BtHaveNoneMessage> create
   (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
diff --git a/src/BtInterestedMessage.cc b/src/BtInterestedMessage.cc
index e4e92e63..0ba100f3 100644
--- a/src/BtInterestedMessage.cc
+++ b/src/BtInterestedMessage.cc
@@ -48,7 +48,7 @@ BtInterestedMessage::BtInterestedMessage()
 
 BtInterestedMessage::~BtInterestedMessage() {}
 
-BtInterestedMessage* BtInterestedMessage::create
+std::unique_ptr<BtInterestedMessage> BtInterestedMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtInterestedMessage>(data, dataLength);
diff --git a/src/BtInterestedMessage.h b/src/BtInterestedMessage.h
index 0f794126..d6232f02 100644
--- a/src/BtInterestedMessage.h
+++ b/src/BtInterestedMessage.h
@@ -53,7 +53,7 @@ public:
 
   static const char NAME[];
 
-  static BtInterestedMessage* create
+  static std::unique_ptr<BtInterestedMessage> create
   (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
diff --git a/src/BtMessageDispatcher.h b/src/BtMessageDispatcher.h
index e5543a86..6f587630 100644
--- a/src/BtMessageDispatcher.h
+++ b/src/BtMessageDispatcher.h
@@ -51,10 +51,7 @@ class BtMessageDispatcher {
 public:
   virtual ~BtMessageDispatcher() {}
 
-  virtual void addMessageToQueue(const std::shared_ptr<BtMessage>& btMessage) = 0;
-
-  virtual void
-  addMessageToQueue(const std::vector<std::shared_ptr<BtMessage> >& btMessages) =0;
+  virtual void addMessageToQueue(std::unique_ptr<BtMessage> btMessage) = 0;
 
   virtual void sendMessages() = 0;
 
diff --git a/src/BtMessageFactory.h b/src/BtMessageFactory.h
index cb244d9b..a664828a 100644
--- a/src/BtMessageFactory.h
+++ b/src/BtMessageFactory.h
@@ -43,58 +43,77 @@ namespace aria2 {
 
 class BtMessage;
 class BtHandshakeMessage;
-class Piece;
+class BtAllowedFastMessage;
+class BtBitfieldMessage;
+class BtCancelMessage;
+class BtChokeMessage;
+class BtHaveAllMessage;
+class BtHaveMessage;
+class BtHaveNoneMessage;
+class BtInterestedMessage;
+class BtKeepAliveMessage;
+class BtNotInterestedMessage;
+class BtPieceMessage;
+class BtPortMessage;
+class BtRejectMessage;
+class BtRequestMessage;
+class BtUnchokeMessage;
+class BtExtendedMessage;
 class ExtensionMessage;
+class Piece;
 
 class BtMessageFactory {
 public:
   virtual ~BtMessageFactory() {}
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtMessage>
   createBtMessage(const unsigned char* msg, size_t msgLength) = 0;
 
-  virtual std::shared_ptr<BtHandshakeMessage>
+  virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* msg, size_t msgLength) = 0;
 
-  virtual std::shared_ptr<BtHandshakeMessage>
+  virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* infoHash,
                          const unsigned char* peerId) = 0;
 
-  virtual std::shared_ptr<BtMessage>
-  createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex) = 0;
+  virtual std::unique_ptr<BtRequestMessage>
+  createRequestMessage(const std::shared_ptr<Piece>& piece,
+                       size_t blockIndex) = 0;
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtCancelMessage>
   createCancelMessage(size_t index, int32_t begin, int32_t length) = 0;
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtPieceMessage>
   createPieceMessage(size_t index, int32_t begin, int32_t length) = 0;
 
-  virtual std::shared_ptr<BtMessage> createHaveMessage(size_t index) = 0;
+  virtual std::unique_ptr<BtHaveMessage> createHaveMessage(size_t index) = 0;
 
-  virtual std::shared_ptr<BtMessage> createChokeMessage() = 0;
+  virtual std::unique_ptr<BtChokeMessage> createChokeMessage() = 0;
 
-  virtual std::shared_ptr<BtMessage> createUnchokeMessage() = 0;
+  virtual std::unique_ptr<BtUnchokeMessage> createUnchokeMessage() = 0;
 
-  virtual std::shared_ptr<BtMessage> createInterestedMessage() = 0;
+  virtual std::unique_ptr<BtInterestedMessage> createInterestedMessage() = 0;
 
-  virtual std::shared_ptr<BtMessage> createNotInterestedMessage() = 0;
+  virtual std::unique_ptr<BtNotInterestedMessage>
+  createNotInterestedMessage() = 0;
 
-  virtual std::shared_ptr<BtMessage> createBitfieldMessage() = 0;
+  virtual std::unique_ptr<BtBitfieldMessage> createBitfieldMessage() = 0;
 
-  virtual std::shared_ptr<BtMessage> createKeepAliveMessage() = 0;
+  virtual std::unique_ptr<BtKeepAliveMessage> createKeepAliveMessage() = 0;
 
-  virtual std::shared_ptr<BtMessage> createHaveAllMessage() = 0;
+  virtual std::unique_ptr<BtHaveAllMessage> createHaveAllMessage() = 0;
 
-  virtual std::shared_ptr<BtMessage> createHaveNoneMessage() = 0;
+  virtual std::unique_ptr<BtHaveNoneMessage> createHaveNoneMessage() = 0;
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtRejectMessage>
   createRejectMessage(size_t index, int32_t begin, int32_t length) = 0;
 
-  virtual std::shared_ptr<BtMessage> createAllowedFastMessage(size_t index) = 0;
+  virtual std::unique_ptr<BtAllowedFastMessage>
+  createAllowedFastMessage(size_t index) = 0;
 
-  virtual std::shared_ptr<BtMessage> createPortMessage(uint16_t port) = 0;
+  virtual std::unique_ptr<BtPortMessage> createPortMessage(uint16_t port) = 0;
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtExtendedMessage>
   createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& msg) = 0;
 };
 
diff --git a/src/BtNotInterestedMessage.cc b/src/BtNotInterestedMessage.cc
index dcd9b810..911faac4 100644
--- a/src/BtNotInterestedMessage.cc
+++ b/src/BtNotInterestedMessage.cc
@@ -48,7 +48,7 @@ BtNotInterestedMessage::BtNotInterestedMessage()
 
 BtNotInterestedMessage::~BtNotInterestedMessage() {}
 
-BtNotInterestedMessage* BtNotInterestedMessage::create
+std::unique_ptr<BtNotInterestedMessage> BtNotInterestedMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtNotInterestedMessage>(data, dataLength);
diff --git a/src/BtNotInterestedMessage.h b/src/BtNotInterestedMessage.h
index d356a802..8bb4b9b2 100644
--- a/src/BtNotInterestedMessage.h
+++ b/src/BtNotInterestedMessage.h
@@ -53,7 +53,7 @@ public:
 
   static const char NAME[];
 
-  static BtNotInterestedMessage* create
+  static std::unique_ptr<BtNotInterestedMessage> create
   (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
diff --git a/src/BtPieceMessage.cc b/src/BtPieceMessage.cc
index d26c6268..8ab0cf89 100644
--- a/src/BtPieceMessage.cc
+++ b/src/BtPieceMessage.cc
@@ -60,6 +60,7 @@
 #include "WrDiskCache.h"
 #include "WrDiskCacheEntry.h"
 #include "DownloadFailureException.h"
+#include "BtRejectMessage.h"
 
 namespace aria2 {
 
@@ -86,16 +87,14 @@ void BtPieceMessage::setMsgPayload(const unsigned char* data)
   data_ = data;
 }
 
-BtPieceMessage* BtPieceMessage::create
+std::unique_ptr<BtPieceMessage> BtPieceMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   bittorrent::assertPayloadLengthGreater(9, dataLength, NAME);
   bittorrent::assertID(ID, data, NAME);
-  BtPieceMessage* message(new BtPieceMessage());
-  message->setIndex(bittorrent::getIntParam(data, 1));
-  message->setBegin(bittorrent::getIntParam(data, 5));
-  message->setBlockLength(dataLength-9);
-  return message;
+  return make_unique<BtPieceMessage>(bittorrent::getIntParam(data, 1),
+                                     bittorrent::getIntParam(data, 5),
+                                     dataLength-9);
 }
 
 void BtPieceMessage::doReceivedAction()
@@ -305,10 +304,9 @@ void BtPieceMessage::onChokingEvent(const BtChokingEvent& event)
                      begin_,
                      blockLength_));
     if(getPeer()->isFastExtensionEnabled()) {
-      std::shared_ptr<BtMessage> rej =
-        getBtMessageFactory()->createRejectMessage
-        (index_, begin_, blockLength_);
-      getBtMessageDispatcher()->addMessageToQueue(rej);
+      getBtMessageDispatcher()->addMessageToQueue
+        (getBtMessageFactory()->createRejectMessage
+         (index_, begin_, blockLength_));
     }
     setInvalidate(true);
   }
@@ -327,10 +325,9 @@ void BtPieceMessage::onCancelSendingPieceEvent
                      begin_,
                      blockLength_));
     if(getPeer()->isFastExtensionEnabled()) {
-      std::shared_ptr<BtMessage> rej =
-        getBtMessageFactory()->createRejectMessage
-        (index_, begin_, blockLength_);
-      getBtMessageDispatcher()->addMessageToQueue(rej);
+      getBtMessageDispatcher()->addMessageToQueue
+        (getBtMessageFactory()->createRejectMessage
+         (index_, begin_, blockLength_));
     }
     setInvalidate(true);
   }
diff --git a/src/BtPieceMessage.h b/src/BtPieceMessage.h
index 41dcfb46..f802d919 100644
--- a/src/BtPieceMessage.h
+++ b/src/BtPieceMessage.h
@@ -92,7 +92,8 @@ public:
 
   void setPeerStorage(PeerStorage* peerStorage);
 
-  static BtPieceMessage* create(const unsigned char* data, size_t dataLength);
+  static std::unique_ptr<BtPieceMessage> create
+  (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
 
diff --git a/src/BtPortMessage.cc b/src/BtPortMessage.cc
index 95e6e0bd..37abc352 100644
--- a/src/BtPortMessage.cc
+++ b/src/BtPortMessage.cc
@@ -61,14 +61,13 @@ BtPortMessage::BtPortMessage(uint16_t port)
     taskFactory_(0)
 {}
 
-BtPortMessage* BtPortMessage::create
+std::unique_ptr<BtPortMessage> BtPortMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   bittorrent::assertPayloadLengthEqual(3, dataLength, NAME);
   bittorrent::assertID(ID, data, NAME);
   uint16_t port = bittorrent::getShortIntParam(data, 1);
-  BtPortMessage* message(new BtPortMessage(port));
-  return message;
+  return make_unique<BtPortMessage>(port);
 }
 
 void BtPortMessage::doReceivedAction()
diff --git a/src/BtPortMessage.h b/src/BtPortMessage.h
index 75d459fd..c903bc84 100644
--- a/src/BtPortMessage.h
+++ b/src/BtPortMessage.h
@@ -65,7 +65,8 @@ public:
 
   uint16_t getPort() const { return port_; }
 
-  static BtPortMessage* create(const unsigned char* data, size_t dataLength);
+  static std::unique_ptr<BtPortMessage> create
+  (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
 
diff --git a/src/BtRejectMessage.cc b/src/BtRejectMessage.cc
index 0b08b00e..d26440ea 100644
--- a/src/BtRejectMessage.cc
+++ b/src/BtRejectMessage.cc
@@ -47,7 +47,7 @@ BtRejectMessage::BtRejectMessage
 (size_t index, int32_t begin, int32_t length):
   RangeBtMessage(ID, NAME, index, begin, length) {}
 
-BtRejectMessage* BtRejectMessage::create
+std::unique_ptr<BtRejectMessage> BtRejectMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return RangeBtMessage::create<BtRejectMessage>(data, dataLength);
diff --git a/src/BtRejectMessage.h b/src/BtRejectMessage.h
index 644a022a..34722586 100644
--- a/src/BtRejectMessage.h
+++ b/src/BtRejectMessage.h
@@ -47,7 +47,8 @@ public:
 
   static const char NAME[];
 
-  static BtRejectMessage* create(const unsigned char* data, size_t dataLength);
+  static std::unique_ptr<BtRejectMessage> create
+  (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
 };
diff --git a/src/BtRequestFactory.h b/src/BtRequestFactory.h
index 1e77f34d..6f2da075 100644
--- a/src/BtRequestFactory.h
+++ b/src/BtRequestFactory.h
@@ -43,7 +43,7 @@
 namespace aria2 {
 
 class Piece;
-class BtMessage;
+class BtRequestMessage;
 
 class BtRequestFactory {
 public:
@@ -65,24 +65,18 @@ public:
 
   /**
    * Creates RequestMessage objects associated to the pieces added by
-   * addTargetPiece() and returns them.
-   * The number of objects returned is capped by max.
+   * addTargetPiece() and returns them.  The number of objects
+   * returned is capped by max.  If |endGame| is true, returns
+   * requests in end game mode.
    */
-  virtual void createRequestMessages
-  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) = 0;
+  virtual std::vector<std::unique_ptr<BtRequestMessage>> createRequestMessages
+  (size_t max, bool endGame) = 0;
 
   /**
-   * Use this method in end game mode.
-   *
+   * Returns the list of index of pieces added using addTargetPiece()
+   * into indexes.
    */
-  virtual void createRequestMessagesOnEndGame
-  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) = 0;
-
-  /**
-   * Stores the list of index of pieces added using addTargetPiece() into
-   * indexes.
-   */
-  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const = 0;
+  virtual std::vector<size_t> getTargetPieceIndexes() const = 0;
 
 };
 
diff --git a/src/BtRequestMessage.cc b/src/BtRequestMessage.cc
index 31ddc8a9..19ed7743 100644
--- a/src/BtRequestMessage.cc
+++ b/src/BtRequestMessage.cc
@@ -38,6 +38,8 @@
 #include "PieceStorage.h"
 #include "BtMessageDispatcher.h"
 #include "BtMessageFactory.h"
+#include "BtPieceMessage.h"
+#include "BtRejectMessage.h"
 
 namespace aria2 {
 
@@ -48,7 +50,7 @@ BtRequestMessage::BtRequestMessage
   RangeBtMessage(ID, NAME, index, begin, length),
   blockIndex_(blockIndex) {}
 
-BtRequestMessage* BtRequestMessage::create
+std::unique_ptr<BtRequestMessage> BtRequestMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return RangeBtMessage::create<BtRequestMessage>(data, dataLength);
@@ -63,16 +65,14 @@ void BtRequestMessage::doReceivedAction()
      (!getPeer()->amChoking() ||
       (getPeer()->amChoking() &&
        getPeer()->isInAmAllowedIndexSet(getIndex())))) {
-    std::shared_ptr<BtMessage> msg =
-      getBtMessageFactory()->createPieceMessage
-      (getIndex(), getBegin(), getLength());
-    getBtMessageDispatcher()->addMessageToQueue(msg);
+    getBtMessageDispatcher()->addMessageToQueue
+      (getBtMessageFactory()->createPieceMessage
+       (getIndex(), getBegin(), getLength()));
   } else {
     if(getPeer()->isFastExtensionEnabled()) {
-      std::shared_ptr<BtMessage> msg =
-        getBtMessageFactory()->createRejectMessage
-        (getIndex(), getBegin(), getLength());
-      getBtMessageDispatcher()->addMessageToQueue(msg);
+      getBtMessageDispatcher()->addMessageToQueue
+        (getBtMessageFactory()->createRejectMessage
+         (getIndex(), getBegin(), getLength()));
     }
   }
 }
diff --git a/src/BtRequestMessage.h b/src/BtRequestMessage.h
index ce10b6b6..15ad37a6 100644
--- a/src/BtRequestMessage.h
+++ b/src/BtRequestMessage.h
@@ -55,7 +55,7 @@ public:
   size_t getBlockIndex() const { return blockIndex_; }
   void setBlockIndex(size_t blockIndex) { blockIndex_ = blockIndex; }
 
-  static BtRequestMessage* create
+  static std::unique_ptr<BtRequestMessage> create
   (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
diff --git a/src/BtSuggestPieceMessage.cc b/src/BtSuggestPieceMessage.cc
index 79739f1f..a12b7be7 100644
--- a/src/BtSuggestPieceMessage.cc
+++ b/src/BtSuggestPieceMessage.cc
@@ -36,9 +36,13 @@
 
 namespace aria2 {
 
+BtSuggestPieceMessage::BtSuggestPieceMessage(size_t index)
+  : IndexBtMessage{ID, NAME, index}
+{}
+
 const char BtSuggestPieceMessage::NAME[] = "suggest piece";
 
-BtSuggestPieceMessage* BtSuggestPieceMessage::create
+std::unique_ptr<BtSuggestPieceMessage> BtSuggestPieceMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return IndexBtMessage::create<BtSuggestPieceMessage>(data, dataLength);
diff --git a/src/BtSuggestPieceMessage.h b/src/BtSuggestPieceMessage.h
index 05c9c1f2..dac39ba4 100644
--- a/src/BtSuggestPieceMessage.h
+++ b/src/BtSuggestPieceMessage.h
@@ -41,13 +41,13 @@ namespace aria2 {
 
 class BtSuggestPieceMessage : public IndexBtMessage {
 public:
-  BtSuggestPieceMessage():IndexBtMessage(ID, NAME, 0) {}
+  BtSuggestPieceMessage(size_t index = 0);
 
   static const uint8_t ID = 13;
 
   static const char NAME[];
 
-  static BtSuggestPieceMessage* create
+  static std::unique_ptr<BtSuggestPieceMessage> create
   (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction() {
diff --git a/src/BtUnchokeMessage.cc b/src/BtUnchokeMessage.cc
index 36bda089..35d4ac08 100644
--- a/src/BtUnchokeMessage.cc
+++ b/src/BtUnchokeMessage.cc
@@ -42,7 +42,7 @@ const char BtUnchokeMessage::NAME[] = "unchoke";
 
 BtUnchokeMessage::BtUnchokeMessage():ZeroBtMessage(ID, NAME) {}
 
-BtUnchokeMessage* BtUnchokeMessage::create
+std::unique_ptr<BtUnchokeMessage> BtUnchokeMessage::create
 (const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtUnchokeMessage>(data, dataLength);
diff --git a/src/BtUnchokeMessage.h b/src/BtUnchokeMessage.h
index 710e0a23..d40eaf44 100644
--- a/src/BtUnchokeMessage.h
+++ b/src/BtUnchokeMessage.h
@@ -49,7 +49,7 @@ public:
 
   static const char NAME[];
 
-  static BtUnchokeMessage* create
+  static std::unique_ptr<BtUnchokeMessage> create
   (const unsigned char* data, size_t dataLength);
 
   virtual void doReceivedAction();
diff --git a/src/DefaultBtInteractive.cc b/src/DefaultBtInteractive.cc
index c6c088e9..16c9149e 100644
--- a/src/DefaultBtInteractive.cc
+++ b/src/DefaultBtInteractive.cc
@@ -46,6 +46,14 @@
 #include "BtUnchokeMessage.h"
 #include "BtRequestMessage.h"
 #include "BtPieceMessage.h"
+#include "BtPortMessage.h"
+#include "BtInterestedMessage.h"
+#include "BtNotInterestedMessage.h"
+#include "BtHaveMessage.h"
+#include "BtHaveAllMessage.h"
+#include "BtBitfieldMessage.h"
+#include "BtHaveNoneMessage.h"
+#include "BtAllowedFastMessage.h"
 #include "DlAbortEx.h"
 #include "BtExtendedMessage.h"
 #include "HandshakeExtensionMessage.h"
@@ -104,10 +112,10 @@ DefaultBtInteractive::DefaultBtInteractive
 DefaultBtInteractive::~DefaultBtInteractive() {}
 
 void DefaultBtInteractive::initiateHandshake() {
-  std::shared_ptr<BtMessage> message =
-    messageFactory_->createHandshakeMessage
-    (bittorrent::getInfoHash(downloadContext_), bittorrent::getStaticPeerId());
-  dispatcher_->addMessageToQueue(message);
+  dispatcher_->addMessageToQueue
+    (messageFactory_->createHandshakeMessage
+     (bittorrent::getInfoHash(downloadContext_),
+      bittorrent::getStaticPeerId()));
   dispatcher_->sendMessages();
 }
 
@@ -199,8 +207,7 @@ void DefaultBtInteractive::addHandshakeExtendedMessageToQueue()
   if(!attrs->metadata.empty()) {
     m->setMetadataSize(attrs->metadataSize);
   }
-  std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
-  dispatcher_->addMessageToQueue(msg);
+  dispatcher_->addMessageToQueue(messageFactory_->createBtExtendedMessage(m));
 }
 
 void DefaultBtInteractive::addBitfieldMessageToQueue() {
@@ -301,9 +308,6 @@ size_t DefaultBtInteractive::receiveMessages() {
     message->doReceivedAction();
 
     switch(message->getId()) {
-    case BtKeepAliveMessage::ID:
-      floodingStat_.incKeepAliveCount();
-      break;
     case BtChokeMessage::ID:
       if(!peer_->peerChoking()) {
         floodingStat_.incChokeUnchokeCount();
@@ -314,10 +318,13 @@ size_t DefaultBtInteractive::receiveMessages() {
         floodingStat_.incChokeUnchokeCount();
       }
       break;
-    case BtPieceMessage::ID:
     case BtRequestMessage::ID:
+    case BtPieceMessage::ID:
       inactiveTimer_ = global::wallclock();
       break;
+    case BtKeepAliveMessage::ID:
+      floodingStat_.incKeepAliveCount();
+      break;
     }
   }
 
@@ -359,11 +366,9 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
     if(peer_->peerChoking()) {
       if(peer_->isFastExtensionEnabled()) {
         if(pieceStorage_->isEndGame()) {
-          std::vector<size_t> excludedIndexes;
-          excludedIndexes.reserve(btRequestFactory_->countTargetPiece());
-          btRequestFactory_->getTargetPieceIndexes(excludedIndexes);
           pieceStorage_->getMissingFastPiece
-            (pieces, diffMissingBlock, peer_, excludedIndexes, cuid_);
+            (pieces, diffMissingBlock, peer_,
+             btRequestFactory_->getTargetPieceIndexes(), cuid_);
         } else {
           pieces.reserve(diffMissingBlock);
           pieceStorage_->getMissingFastPiece
@@ -372,11 +377,9 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
       }
     } else {
       if(pieceStorage_->isEndGame()) {
-        std::vector<size_t> excludedIndexes;
-        excludedIndexes.reserve(btRequestFactory_->countTargetPiece());
-        btRequestFactory_->getTargetPieceIndexes(excludedIndexes);
         pieceStorage_->getMissingPiece
-          (pieces, diffMissingBlock, peer_, excludedIndexes, cuid_);
+          (pieces, diffMissingBlock, peer_,
+           btRequestFactory_->getTargetPieceIndexes(), cuid_);
       } else {
         pieces.reserve(diffMissingBlock);
         pieceStorage_->getMissingPiece(pieces, diffMissingBlock, peer_, cuid_);
@@ -399,14 +402,12 @@ void DefaultBtInteractive::addRequests() {
     0 : maxOutstandingRequest_-dispatcher_->countOutstandingRequest();
 
   if(reqNumToCreate > 0) {
-    std::vector<std::shared_ptr<BtMessage> > requests;
-    requests.reserve(reqNumToCreate);
-    if(pieceStorage_->isEndGame()) {
-      btRequestFactory_->createRequestMessagesOnEndGame(requests,reqNumToCreate);
-    } else {
-      btRequestFactory_->createRequestMessages(requests, reqNumToCreate);
+    auto requests =
+      btRequestFactory_->createRequestMessages(reqNumToCreate,
+                                               pieceStorage_->isEndGame());
+    for(auto& i : requests) {
+      dispatcher_->addMessageToQueue(std::move(i));
     }
-    dispatcher_->addMessageToQueue(requests);
   }
 }
 
@@ -502,8 +503,8 @@ void DefaultBtInteractive::addPeerExchangeMessage()
       }
     }
 
-    std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
-    dispatcher_->addMessageToQueue(msg);
+    dispatcher_->addMessageToQueue
+      (messageFactory_->createBtExtendedMessage(m));
     pexTimer_ = global::wallclock();
   }
 }
@@ -520,9 +521,11 @@ void DefaultBtInteractive::doInteractionProcessing() {
        downloadContext_->getTotalLength() > 0) {
       size_t num = utMetadataRequestTracker_->avail();
       if(num > 0) {
-        std::vector<std::shared_ptr<BtMessage> > requests;
-        utMetadataRequestFactory_->create(requests, num, pieceStorage_);
-        dispatcher_->addMessageToQueue(requests);
+        auto requests =
+          utMetadataRequestFactory_->create(num, pieceStorage_);
+        for(auto& i : requests) {
+          dispatcher_->addMessageToQueue(std::move(i));
+        }
       }
       if(perSecTimer_.difference(global::wallclock()) >= 1) {
         perSecTimer_ = global::wallclock();
diff --git a/src/DefaultBtMessageDispatcher.cc b/src/DefaultBtMessageDispatcher.cc
index 447cc9f9..a0749470 100644
--- a/src/DefaultBtMessageDispatcher.cc
+++ b/src/DefaultBtMessageDispatcher.cc
@@ -57,18 +57,19 @@
 #include "util.h"
 #include "fmt.h"
 #include "PeerConnection.h"
+#include "BtCancelMessage.h"
 
 namespace aria2 {
 
 DefaultBtMessageDispatcher::DefaultBtMessageDispatcher()
-  : cuid_(0),
-    downloadContext_{0},
-    peerStorage_{0},
-    pieceStorage_{0},
-    peerConnection_{0},
-    messageFactory_(0),
-    requestGroupMan_(0),
-    requestTimeout_(0)
+  : cuid_{0},
+    downloadContext_{nullptr},
+    peerStorage_{nullptr},
+    pieceStorage_{nullptr},
+    peerConnection_{nullptr},
+    messageFactory_{nullptr},
+    requestGroupMan_{nullptr},
+    requestTimeout_{0}
 {}
 
 DefaultBtMessageDispatcher::~DefaultBtMessageDispatcher()
@@ -77,39 +78,31 @@ DefaultBtMessageDispatcher::~DefaultBtMessageDispatcher()
 }
 
 void DefaultBtMessageDispatcher::addMessageToQueue
-(const std::shared_ptr<BtMessage>& btMessage)
+(std::unique_ptr<BtMessage> btMessage)
 {
   btMessage->onQueued();
-  messageQueue_.push_back(btMessage);
-}
-
-void DefaultBtMessageDispatcher::addMessageToQueue
-(const std::vector<std::shared_ptr<BtMessage> >& btMessages)
-{
-  for(std::vector<std::shared_ptr<BtMessage> >::const_iterator itr =
-        btMessages.begin(), eoi = btMessages.end(); itr != eoi; ++itr) {
-    addMessageToQueue(*itr);
-  }
+  messageQueue_.push_back(std::move(btMessage));
 }
 
 void DefaultBtMessageDispatcher::sendMessagesInternal()
 {
-  std::vector<std::shared_ptr<BtMessage> > tempQueue;
+  auto tempQueue = std::vector<std::unique_ptr<BtMessage>>{};
   while(!messageQueue_.empty()) {
-    std::shared_ptr<BtMessage> msg = messageQueue_.front();
+    auto msg = std::move(messageQueue_.front());
     messageQueue_.pop_front();
     if(msg->isUploading()) {
       if(requestGroupMan_->doesOverallUploadSpeedExceed() ||
          downloadContext_->getOwnerRequestGroup()->doesUploadSpeedExceed()) {
-        tempQueue.push_back(msg);
+        tempQueue.push_back(std::move(msg));
         continue;
       }
     }
     msg->send();
   }
   if(!tempQueue.empty()) {
-      messageQueue_.insert(messageQueue_.begin(),
-                           tempQueue.begin(), tempQueue.end());
+    messageQueue_.insert(std::begin(messageQueue_),
+                         std::make_move_iterator(std::begin(tempQueue)),
+                         std::make_move_iterator(std::end(tempQueue)));
   }
 }
 
@@ -121,15 +114,26 @@ void DefaultBtMessageDispatcher::sendMessages()
   peerConnection_->sendPendingData();
 }
 
+namespace {
+std::vector<BtMessage*> toRawPointers
+(const std::deque<std::unique_ptr<BtMessage>>& v)
+{
+  auto x = std::vector<BtMessage*>{};
+  x.reserve(v.size());
+  for(auto& i : v) {
+    x.push_back(i.get());
+  }
+  return x;
+}
+} // namespace
+
 // Cancel sending piece message to peer.
 void DefaultBtMessageDispatcher::doCancelSendingPieceAction
 (size_t index, int32_t begin, int32_t length)
 {
   BtCancelSendingPieceEvent event(index, begin, length);
-
-  std::vector<std::shared_ptr<BtMessage> > tempQueue
-    (messageQueue_.begin(), messageQueue_.end());
-  for(const auto& i : tempQueue) {
+  auto q = toRawPointers(messageQueue_);
+  for(auto i : q) {
     i->onCancelSendingPieceEvent(event);
   }
 }
@@ -173,9 +177,8 @@ void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction
 
   BtAbortOutstandingRequestEvent event(piece);
 
-  std::vector<std::shared_ptr<BtMessage> > tempQueue
-    (messageQueue_.begin(), messageQueue_.end());
-  for(const auto& i : tempQueue) {
+  auto tempQueue = toRawPointers(messageQueue_);
+  for(auto i : tempQueue) {
     i->onAbortOutstandingRequestEvent(event);
   }
 }
@@ -207,9 +210,8 @@ void DefaultBtMessageDispatcher::doChokingAction()
 {
   BtChokingEvent event;
 
-  std::vector<std::shared_ptr<BtMessage> > tempQueue
-    (messageQueue_.begin(), messageQueue_.end());
-  for(const auto& i : tempQueue) {
+  auto tempQueue = toRawPointers(messageQueue_);
+  for(auto i : tempQueue) {
     i->onChokingEvent(event);
   }
 }
@@ -298,7 +300,7 @@ void DefaultBtMessageDispatcher::addOutstandingRequest
 
 size_t DefaultBtMessageDispatcher::countOutstandingUpload()
 {
-  return std::count_if(messageQueue_.begin(), messageQueue_.end(),
+  return std::count_if(std::begin(messageQueue_), std::end(messageQueue_),
                        std::mem_fn(&BtMessage::isUploading));
 }
 
diff --git a/src/DefaultBtMessageDispatcher.h b/src/DefaultBtMessageDispatcher.h
index 46cddb89..27192f6d 100644
--- a/src/DefaultBtMessageDispatcher.h
+++ b/src/DefaultBtMessageDispatcher.h
@@ -57,7 +57,7 @@ class PeerConnection;
 class DefaultBtMessageDispatcher : public BtMessageDispatcher {
 private:
   cuid_t cuid_;
-  std::deque<std::shared_ptr<BtMessage> > messageQueue_;
+  std::deque<std::unique_ptr<BtMessage> > messageQueue_;
   std::deque<std::unique_ptr<RequestSlot>> requestSlots_;
   DownloadContext* downloadContext_;
   PeerStorage* peerStorage_;
@@ -72,10 +72,7 @@ public:
 
   virtual ~DefaultBtMessageDispatcher();
 
-  virtual void addMessageToQueue(const std::shared_ptr<BtMessage>& btMessage);
-
-  virtual void addMessageToQueue
-  (const std::vector<std::shared_ptr<BtMessage> >& btMessages);
+  virtual void addMessageToQueue(std::unique_ptr<BtMessage> btMessage);
 
   virtual void sendMessages();
 
@@ -117,7 +114,7 @@ public:
 
   virtual size_t countOutstandingUpload();
 
-  const std::deque<std::shared_ptr<BtMessage> >& getMessageQueue() const
+  const std::deque<std::unique_ptr<BtMessage>>& getMessageQueue() const
   {
     return messageQueue_;
   }
diff --git a/src/DefaultBtMessageFactory.cc b/src/DefaultBtMessageFactory.cc
index 1f519fdb..978b5c8d 100644
--- a/src/DefaultBtMessageFactory.cc
+++ b/src/DefaultBtMessageFactory.cc
@@ -70,58 +70,53 @@
 
 namespace aria2 {
 
-DefaultBtMessageFactory::DefaultBtMessageFactory():
-  cuid_(0),
-  downloadContext_(0),
-  pieceStorage_(0),
-  peerStorage_(0),
-  dhtEnabled_(false),
-  dispatcher_(0),
-  requestFactory_(0),
-  peerConnection_(0),
-  localNode_(0),
-  routingTable_(0),
-  taskQueue_(0),
-  taskFactory_(0),
-  metadataGetMode_(false)
+DefaultBtMessageFactory::DefaultBtMessageFactory()
+  : cuid_{0},
+    downloadContext_{nullptr},
+    pieceStorage_{nullptr},
+    peerStorage_{nullptr},
+    dhtEnabled_(false),
+    dispatcher_{nullptr},
+    requestFactory_{nullptr},
+    peerConnection_{nullptr},
+    localNode_{nullptr},
+    routingTable_{nullptr},
+    taskQueue_{nullptr},
+    taskFactory_{nullptr},
+    metadataGetMode_(false)
 {}
 
-DefaultBtMessageFactory::~DefaultBtMessageFactory() {}
-
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtMessage>
 DefaultBtMessageFactory::createBtMessage
 (const unsigned char* data, size_t dataLength)
 {
-  std::shared_ptr<AbstractBtMessage> msg;
+  auto msg = std::unique_ptr<AbstractBtMessage>{};
   if(dataLength == 0) {
     // keep-alive
-    msg.reset(new BtKeepAliveMessage());
+    msg = make_unique<BtKeepAliveMessage>();
   } else {
     uint8_t id = bittorrent::getId(data);
     switch(id) {
     case BtChokeMessage::ID:
-      msg.reset(BtChokeMessage::create(data, dataLength));
+      msg = BtChokeMessage::create(data, dataLength);
       break;
     case BtUnchokeMessage::ID:
-      msg.reset(BtUnchokeMessage::create(data, dataLength));
+      msg = BtUnchokeMessage::create(data, dataLength);
       break;
-    case BtInterestedMessage::ID:
-      {
-        BtInterestedMessage* m = BtInterestedMessage::create(data, dataLength);
-        m->setPeerStorage(peerStorage_);
-        msg.reset(m);
-      }
+    case BtInterestedMessage::ID: {
+      auto m = BtInterestedMessage::create(data, dataLength);
+      m->setPeerStorage(peerStorage_);
+      msg = std::move(m);
       break;
-    case BtNotInterestedMessage::ID:
-      {
-        BtNotInterestedMessage* m =
-          BtNotInterestedMessage::create(data, dataLength);
-        m->setPeerStorage(peerStorage_);
-        msg.reset(m);
-      }
+    }
+    case BtNotInterestedMessage::ID: {
+      auto m = BtNotInterestedMessage::create(data, dataLength);
+      m->setPeerStorage(peerStorage_);
+      msg = std::move(m);
       break;
+    }
     case BtHaveMessage::ID:
-      msg.reset(BtHaveMessage::create(data, dataLength));
+      msg = BtHaveMessage::create(data, dataLength);
       if(!metadataGetMode_) {
         msg->setBtMessageValidator(make_unique<IndexBtMessageValidator>
                                    (static_cast<BtHaveMessage*>(msg.get()),
@@ -129,7 +124,7 @@ DefaultBtMessageFactory::createBtMessage
       }
       break;
     case BtBitfieldMessage::ID:
-      msg.reset(BtBitfieldMessage::create(data, dataLength));
+      msg = BtBitfieldMessage::create(data, dataLength);
       if(!metadataGetMode_) {
         msg->setBtMessageValidator(make_unique<BtBitfieldMessageValidator>
                                    (static_cast<BtBitfieldMessage*>(msg.get()),
@@ -137,95 +132,94 @@ DefaultBtMessageFactory::createBtMessage
       }
       break;
     case BtRequestMessage::ID: {
-      BtRequestMessage* m = BtRequestMessage::create(data, dataLength);
+      auto m = BtRequestMessage::create(data, dataLength);
       if(!metadataGetMode_) {
         m->setBtMessageValidator
           (make_unique<RangeBtMessageValidator>
-           (m,
+           (static_cast<BtRequestMessage*>(m.get()),
             downloadContext_->getNumPieces(),
             pieceStorage_->getPieceLength(m->getIndex())));
       }
-      msg.reset(m);
+      msg = std::move(m);
       break;
     }
-    case BtCancelMessage::ID: {
-      BtCancelMessage* m = BtCancelMessage::create(data, dataLength);
+    case BtPieceMessage::ID: {
+      auto m = BtPieceMessage::create(data, dataLength);
       if(!metadataGetMode_) {
         m->setBtMessageValidator
-          (make_unique<RangeBtMessageValidator>
-           (m,
+          (make_unique<BtPieceMessageValidator>
+           (static_cast<BtPieceMessage*>(m.get()),
             downloadContext_->getNumPieces(),
             pieceStorage_->getPieceLength(m->getIndex())));
       }
-      msg.reset(m);
+      m->setDownloadContext(downloadContext_);
+      m->setPeerStorage(peerStorage_);
+      msg = std::move(m);
       break;
     }
-    case BtPieceMessage::ID: {
-      BtPieceMessage* m = BtPieceMessage::create(data, dataLength);
+    case BtCancelMessage::ID: {
+      auto m = BtCancelMessage::create(data, dataLength);
       if(!metadataGetMode_) {
         m->setBtMessageValidator
-          (make_unique<BtPieceMessageValidator>
-           (m,
+          (make_unique<RangeBtMessageValidator>
+           (static_cast<BtCancelMessage*>(m.get()),
             downloadContext_->getNumPieces(),
             pieceStorage_->getPieceLength(m->getIndex())));
       }
-      m->setDownloadContext(downloadContext_);
-      m->setPeerStorage(peerStorage_);
-      msg.reset(m);
+      msg = std::move(m);
+      break;
+    }
+    case BtPortMessage::ID: {
+      auto m = BtPortMessage::create(data, dataLength);
+      m->setLocalNode(localNode_);
+      m->setRoutingTable(routingTable_);
+      m->setTaskQueue(taskQueue_);
+      m->setTaskFactory(taskFactory_);
+      msg = std::move(m);
+      break;
+    }
+    case BtSuggestPieceMessage::ID: {
+      auto m = BtSuggestPieceMessage::create(data, dataLength);
+      if(!metadataGetMode_) {
+        m->setBtMessageValidator(make_unique<IndexBtMessageValidator>
+                                 (static_cast<BtSuggestPieceMessage*>(m.get()),
+                                  downloadContext_->getNumPieces()));
+      }
+      msg = std::move(m);
       break;
     }
     case BtHaveAllMessage::ID:
-      msg.reset(BtHaveAllMessage::create(data, dataLength));
+      msg = BtHaveAllMessage::create(data, dataLength);
       break;
     case BtHaveNoneMessage::ID:
-      msg.reset(BtHaveNoneMessage::create(data, dataLength));
+      msg = BtHaveNoneMessage::create(data, dataLength);
       break;
     case BtRejectMessage::ID: {
-      BtRejectMessage* m = BtRejectMessage::create(data, dataLength);
+      auto m = BtRejectMessage::create(data, dataLength);
       if(!metadataGetMode_) {
         m->setBtMessageValidator
           (make_unique<RangeBtMessageValidator>
-           (m,
+           (static_cast<BtRejectMessage*>(m.get()),
             downloadContext_->getNumPieces(),
             pieceStorage_->getPieceLength(m->getIndex())));
       }
-      msg.reset(m);
-      break;
-    }
-    case BtSuggestPieceMessage::ID: {
-      BtSuggestPieceMessage* m =
-        BtSuggestPieceMessage::create(data, dataLength);
-      if(!metadataGetMode_) {
-        m->setBtMessageValidator(make_unique<IndexBtMessageValidator>
-                                 (m, downloadContext_->getNumPieces()));
-      }
-      msg.reset(m);
+      msg = std::move(m);
       break;
     }
     case BtAllowedFastMessage::ID: {
-      BtAllowedFastMessage* m = BtAllowedFastMessage::create(data, dataLength);
+      auto m = BtAllowedFastMessage::create(data, dataLength);
       if(!metadataGetMode_) {
-        std::shared_ptr<BtMessageValidator> validator
-          (new IndexBtMessageValidator(m, downloadContext_->getNumPieces()));
         m->setBtMessageValidator(make_unique<IndexBtMessageValidator>
-                                 (m, downloadContext_->getNumPieces()));
+                                 (static_cast<BtAllowedFastMessage*>(m.get()),
+                                  downloadContext_->getNumPieces()));
       }
-      msg.reset(m);
-      break;
-    }
-    case BtPortMessage::ID: {
-      BtPortMessage* m = BtPortMessage::create(data, dataLength);
-      m->setLocalNode(localNode_);
-      m->setRoutingTable(routingTable_);
-      m->setTaskQueue(taskQueue_);
-      m->setTaskFactory(taskFactory_);
-      msg.reset(m);
+      msg = std::move(m);
       break;
     }
     case BtExtendedMessage::ID: {
       if(peer_->isExtendedMessagingEnabled()) {
-        msg.reset(BtExtendedMessage::create(extensionMessageFactory_,
-                                            peer_, data, dataLength));
+        msg = BtExtendedMessage::create(extensionMessageFactory_,
+                                        peer_, data, dataLength);
       } else {
         throw DL_ABORT_EX("Received extended message from peer during"
                           " a session with extended messaging disabled.");
@@ -237,7 +231,7 @@ DefaultBtMessageFactory::createBtMessage
     }
   }
   setCommonProperty(msg.get());
-  return msg;
+  return std::move(msg);
 }
 
 void DefaultBtMessageFactory::setCommonProperty(AbstractBtMessage* msg)
@@ -254,12 +248,11 @@ void DefaultBtMessageFactory::setCommonProperty(AbstractBtMessage* msg)
   }
 }
 
-std::shared_ptr<BtHandshakeMessage>
+std::unique_ptr<BtHandshakeMessage>
 DefaultBtMessageFactory::createHandshakeMessage
 (const unsigned char* data, size_t dataLength)
 {
-  std::shared_ptr<BtHandshakeMessage> msg =
-    BtHandshakeMessage::create(data, dataLength);
+  auto msg = BtHandshakeMessage::create(data, dataLength);
   msg->setBtMessageValidator(make_unique<BtHandshakeMessageValidator>
                              (msg.get(),
                               bittorrent::getInfoHash(downloadContext_)));
@@ -267,155 +260,153 @@ DefaultBtMessageFactory::createHandshakeMessage
   return msg;
 }
 
-std::shared_ptr<BtHandshakeMessage>
+std::unique_ptr<BtHandshakeMessage>
 DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash,
                                                 const unsigned char* peerId)
 {
-  std::shared_ptr<BtHandshakeMessage> msg
-    (new BtHandshakeMessage(infoHash, peerId));
+  auto msg = make_unique<BtHandshakeMessage>(infoHash, peerId);
   msg->setDHTEnabled(dhtEnabled_);
   setCommonProperty(msg.get());
   return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtRequestMessage>
 DefaultBtMessageFactory::createRequestMessage
 (const std::shared_ptr<Piece>& piece, size_t blockIndex)
 {
-  BtRequestMessage* msg
-    (new BtRequestMessage(piece->getIndex(),
-                          blockIndex*piece->getBlockLength(),
-                          piece->getBlockLength(blockIndex),
-                          blockIndex));
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtRequestMessage>(piece->getIndex(),
+                                           blockIndex*piece->getBlockLength(),
+                                           piece->getBlockLength(blockIndex),
+                                           blockIndex);
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtCancelMessage>
 DefaultBtMessageFactory::createCancelMessage
 (size_t index, int32_t begin, int32_t length)
 {
-  BtCancelMessage* msg(new BtCancelMessage(index, begin, length));
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtCancelMessage>(index, begin, length);
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtPieceMessage>
 DefaultBtMessageFactory::createPieceMessage
 (size_t index, int32_t begin, int32_t length)
 {
-  BtPieceMessage* msg(new BtPieceMessage(index, begin, length));
+  auto msg = make_unique<BtPieceMessage>(index, begin, length);
   msg->setDownloadContext(downloadContext_);
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtHaveMessage>
 DefaultBtMessageFactory::createHaveMessage(size_t index)
 {
-  BtHaveMessage* msg(new BtHaveMessage(index));
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtHaveMessage>(index);
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtChokeMessage>
 DefaultBtMessageFactory::createChokeMessage()
 {
-  BtChokeMessage* msg(new BtChokeMessage());
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtChokeMessage>();
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtUnchokeMessage>
 DefaultBtMessageFactory::createUnchokeMessage()
 {
-  BtUnchokeMessage* msg(new BtUnchokeMessage());
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtUnchokeMessage>();
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtInterestedMessage>
 DefaultBtMessageFactory::createInterestedMessage()
 {
-  BtInterestedMessage* msg(new BtInterestedMessage());
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtInterestedMessage>();
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtNotInterestedMessage>
 DefaultBtMessageFactory::createNotInterestedMessage()
 {
-  BtNotInterestedMessage* msg(new BtNotInterestedMessage());
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtNotInterestedMessage>();
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtBitfieldMessage>
 DefaultBtMessageFactory::createBitfieldMessage()
 {
-  BtBitfieldMessage* msg
-    (new BtBitfieldMessage(pieceStorage_->getBitfield(),
-                           pieceStorage_->getBitfieldLength()));
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtBitfieldMessage>
+    (pieceStorage_->getBitfield(),
+     pieceStorage_->getBitfieldLength());
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtKeepAliveMessage>
 DefaultBtMessageFactory::createKeepAliveMessage()
 {
-  BtKeepAliveMessage* msg(new BtKeepAliveMessage());
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtKeepAliveMessage>();
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtHaveAllMessage>
 DefaultBtMessageFactory::createHaveAllMessage()
 {
-  BtHaveAllMessage* msg(new BtHaveAllMessage());
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtHaveAllMessage>();
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtHaveNoneMessage>
 DefaultBtMessageFactory::createHaveNoneMessage()
 {
-  BtHaveNoneMessage* msg(new BtHaveNoneMessage());
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtHaveNoneMessage>();
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtRejectMessage>
 DefaultBtMessageFactory::createRejectMessage
 (size_t index, int32_t begin, int32_t length)
 {
-  BtRejectMessage* msg(new BtRejectMessage(index, begin, length));
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtRejectMessage>(index, begin, length);
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtAllowedFastMessage>
 DefaultBtMessageFactory::createAllowedFastMessage(size_t index)
 {
-  BtAllowedFastMessage* msg(new BtAllowedFastMessage(index));
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtAllowedFastMessage>(index);
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtPortMessage>
 DefaultBtMessageFactory::createPortMessage(uint16_t port)
 {
-  BtPortMessage* msg(new BtPortMessage(port));
-  setCommonProperty(msg);
-  return std::shared_ptr<BtMessage>(msg);
+  auto msg = make_unique<BtPortMessage>(port);
+  setCommonProperty(msg.get());
+  return msg;
 }
 
-std::shared_ptr<BtMessage>
+std::unique_ptr<BtExtendedMessage>
 DefaultBtMessageFactory::createBtExtendedMessage
-(const std::shared_ptr<ExtensionMessage>& msg)
+(const std::shared_ptr<ExtensionMessage>& exmsg)
 {
-  BtExtendedMessage* m(new BtExtendedMessage(msg));
-  setCommonProperty(m);
-  return std::shared_ptr<BtMessage>(m);
+  auto msg = make_unique<BtExtendedMessage>(exmsg);
+  setCommonProperty(msg.get());
+  return msg;
 }
 
 void DefaultBtMessageFactory::setTaskQueue(DHTTaskQueue* taskQueue)
diff --git a/src/DefaultBtMessageFactory.h b/src/DefaultBtMessageFactory.h
index cad09116..28299efb 100644
--- a/src/DefaultBtMessageFactory.h
+++ b/src/DefaultBtMessageFactory.h
@@ -86,53 +86,53 @@ private:
 public:
   DefaultBtMessageFactory();
 
-  virtual ~DefaultBtMessageFactory();
-
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtMessage>
   createBtMessage(const unsigned char* msg, size_t msgLength);
 
-  virtual std::shared_ptr<BtHandshakeMessage>
+  virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* msg, size_t msgLength);
 
-  virtual std::shared_ptr<BtHandshakeMessage>
+  virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* infoHash,
                          const unsigned char* peerId);
 
-  virtual std::shared_ptr<BtMessage>
-  createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex);
+  virtual std::unique_ptr<BtRequestMessage>
+  createRequestMessage(const std::shared_ptr<Piece>& piece,
+                       size_t blockIndex);
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtCancelMessage>
   createCancelMessage(size_t index, int32_t begin, int32_t length);
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtPieceMessage>
   createPieceMessage(size_t index, int32_t begin, int32_t length);
 
-  virtual std::shared_ptr<BtMessage> createHaveMessage(size_t index);
+  virtual std::unique_ptr<BtHaveMessage> createHaveMessage(size_t index);
 
-  virtual std::shared_ptr<BtMessage> createChokeMessage();
+  virtual std::unique_ptr<BtChokeMessage> createChokeMessage();
 
-  virtual std::shared_ptr<BtMessage> createUnchokeMessage();
+  virtual std::unique_ptr<BtUnchokeMessage> createUnchokeMessage();
 
-  virtual std::shared_ptr<BtMessage> createInterestedMessage();
+  virtual std::unique_ptr<BtInterestedMessage> createInterestedMessage();
 
-  virtual std::shared_ptr<BtMessage> createNotInterestedMessage();
+  virtual std::unique_ptr<BtNotInterestedMessage> createNotInterestedMessage();
 
-  virtual std::shared_ptr<BtMessage> createBitfieldMessage();
+  virtual std::unique_ptr<BtBitfieldMessage> createBitfieldMessage();
 
-  virtual std::shared_ptr<BtMessage> createKeepAliveMessage();
+  virtual std::unique_ptr<BtKeepAliveMessage> createKeepAliveMessage();
 
-  virtual std::shared_ptr<BtMessage> createHaveAllMessage();
+  virtual std::unique_ptr<BtHaveAllMessage> createHaveAllMessage();
 
-  virtual std::shared_ptr<BtMessage> createHaveNoneMessage();
+  virtual std::unique_ptr<BtHaveNoneMessage> createHaveNoneMessage();
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtRejectMessage>
   createRejectMessage(size_t index, int32_t begin, int32_t length);
 
-  virtual std::shared_ptr<BtMessage> createAllowedFastMessage(size_t index);
+  virtual std::unique_ptr<BtAllowedFastMessage> createAllowedFastMessage
+  (size_t index);
 
-  virtual std::shared_ptr<BtMessage> createPortMessage(uint16_t port);
+  virtual std::unique_ptr<BtPortMessage> createPortMessage(uint16_t port);
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtExtendedMessage>
   createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& msg);
 
   void setPeer(const std::shared_ptr<Peer>& peer);
diff --git a/src/DefaultBtMessageReceiver.cc b/src/DefaultBtMessageReceiver.cc
index 60433f03..152d2f15 100644
--- a/src/DefaultBtMessageReceiver.cc
+++ b/src/DefaultBtMessageReceiver.cc
@@ -108,10 +108,10 @@ DefaultBtMessageReceiver::receiveAndSendHandshake()
 }
 
 void DefaultBtMessageReceiver::sendHandshake() {
-  std::shared_ptr<BtMessage> msg =
-    messageFactory_->createHandshakeMessage
-    (bittorrent::getInfoHash(downloadContext_), bittorrent::getStaticPeerId());
-  dispatcher_->addMessageToQueue(msg);
+  dispatcher_->addMessageToQueue
+    (messageFactory_->createHandshakeMessage
+     (bittorrent::getInfoHash(downloadContext_),
+      bittorrent::getStaticPeerId()));
   dispatcher_->sendMessages();
 }
 
diff --git a/src/DefaultBtRequestFactory.cc b/src/DefaultBtRequestFactory.cc
index 121f0f32..277f28b7 100644
--- a/src/DefaultBtRequestFactory.cc
+++ b/src/DefaultBtRequestFactory.cc
@@ -48,6 +48,7 @@
 #include "SimpleRandomizer.h"
 #include "array_fun.h"
 #include "fmt.h"
+#include "BtRequestMessage.h"
 
 namespace aria2 {
 
@@ -88,7 +89,7 @@ void DefaultBtRequestFactory::removeCompletedPiece() {
                 AbortCompletedPieceRequest(dispatcher_));
   pieces_.erase(std::remove_if(pieces_.begin(), pieces_.end(),
                                std::mem_fn(&Piece::pieceComplete)),
-               pieces_.end());
+                pieces_.end());
 }
 
 void DefaultBtRequestFactory::removeTargetPiece
@@ -157,48 +158,50 @@ void DefaultBtRequestFactory::removeAllTargetPiece() {
   pieces_.clear();
 }
 
-void DefaultBtRequestFactory::createRequestMessages
-(std::vector<std::shared_ptr<BtMessage> >& requests, size_t max)
+std::vector<std::unique_ptr<BtRequestMessage>>
+DefaultBtRequestFactory::createRequestMessages(size_t max, bool endGame)
 {
-  if(requests.size() >= max) {
-    return;
+  if(endGame) {
+    return createRequestMessagesOnEndGame(max);
   }
+  auto requests = std::vector<std::unique_ptr<BtRequestMessage>>{};
   size_t getnum = max-requests.size();
-  std::vector<size_t> blockIndexes;
+  auto blockIndexes = std::vector<size_t>{};
   blockIndexes.reserve(getnum);
-  for(std::deque<std::shared_ptr<Piece> >::iterator itr = pieces_.begin(),
-        eoi = pieces_.end(); itr != eoi && getnum; ++itr) {
-    std::shared_ptr<Piece>& piece = *itr;
+  for(auto itr = std::begin(pieces_), eoi = std::end(pieces_);
+      itr != eoi && getnum; ++itr) {
+    auto& piece = *itr;
     if(piece->getMissingUnusedBlockIndex(blockIndexes, getnum)) {
       getnum -= blockIndexes.size();
-      for(std::vector<size_t>::const_iterator i = blockIndexes.begin(),
-            eoi2 = blockIndexes.end(); i != eoi2; ++i) {
+      for(auto i = std::begin(blockIndexes), eoi2 = std::end(blockIndexes);
+          i != eoi2; ++i) {
         A2_LOG_DEBUG
           (fmt("Creating RequestMessage index=%lu, begin=%u,"
                " blockIndex=%lu",
                static_cast<unsigned long>(piece->getIndex()),
                static_cast<unsigned int>((*i)*piece->getBlockLength()),
                static_cast<unsigned long>(*i)));
-        requests.push_back
-          (messageFactory_->createRequestMessage(piece, *i));
+        requests.push_back(messageFactory_->createRequestMessage(piece, *i));
       }
       blockIndexes.clear();
     }
   }
+  return requests;
 }
 
-void DefaultBtRequestFactory::createRequestMessagesOnEndGame
-(std::vector<std::shared_ptr<BtMessage> >& requests, size_t max)
+std::vector<std::unique_ptr<BtRequestMessage>>
+DefaultBtRequestFactory::createRequestMessagesOnEndGame(size_t max)
 {
-  for(std::deque<std::shared_ptr<Piece> >::iterator itr = pieces_.begin(),
-        eoi = pieces_.end(); itr != eoi && requests.size() < max; ++itr) {
-    std::shared_ptr<Piece>& piece = *itr;
+  auto requests = std::vector<std::unique_ptr<BtRequestMessage>>{};
+  for(auto itr = std::begin(pieces_), eoi = std::end(pieces_);
+      itr != eoi && requests.size() < max; ++itr) {
+    auto& piece = *itr;
     const size_t mislen = piece->getBitfieldLength();
     array_ptr<unsigned char> misbitfield(new unsigned char[mislen]);
 
     piece->getAllMissingBlockIndexes(misbitfield, mislen);
 
-    std::vector<size_t> missingBlockIndexes;
+    auto missingBlockIndexes = std::vector<size_t>{};
     size_t blockIndex = 0;
     for(size_t i = 0; i < mislen; ++i) {
       unsigned char bits = misbitfield[i];
@@ -209,12 +212,13 @@ void DefaultBtRequestFactory::createRequestMessagesOnEndGame
         }
       }
     }
-    std::random_shuffle(missingBlockIndexes.begin(), missingBlockIndexes.end(),
+    std::random_shuffle(std::begin(missingBlockIndexes),
+                        std::end(missingBlockIndexes),
                         *SimpleRandomizer::getInstance());
-    for(std::vector<size_t>::const_iterator bitr = missingBlockIndexes.begin(),
-          eoi2 = missingBlockIndexes.end();
+    for(auto bitr = std::begin(missingBlockIndexes),
+          eoi2 = std::end(missingBlockIndexes);
         bitr != eoi2 && requests.size() < max; ++bitr) {
-      const size_t& blockIndex = *bitr;
+      size_t blockIndex = *bitr;
       if(!dispatcher_->isOutstandingRequest(piece->getIndex(),
                                            blockIndex)) {
         A2_LOG_DEBUG
@@ -228,6 +232,7 @@ void DefaultBtRequestFactory::createRequestMessagesOnEndGame
       }
     }
   }
+  return requests;
 }
 
 namespace {
@@ -256,11 +261,14 @@ size_t DefaultBtRequestFactory::countMissingBlock()
                        CountMissingBlock()).getNumMissingBlock();
 }
 
-void DefaultBtRequestFactory::getTargetPieceIndexes
-(std::vector<size_t>& indexes) const
+std::vector<size_t>
+DefaultBtRequestFactory::getTargetPieceIndexes() const
 {
-  std::transform(pieces_.begin(), pieces_.end(), std::back_inserter(indexes),
-                 std::mem_fn(&Piece::getIndex));
+  auto res = std::vector<size_t>{};
+  res.reserve(pieces_.size());
+  std::transform(std::begin(pieces_), std::end(pieces_),
+                 std::back_inserter(res), std::mem_fn(&Piece::getIndex));
+  return res;
 }
 
 void DefaultBtRequestFactory::setPieceStorage(PieceStorage* pieceStorage)
diff --git a/src/DefaultBtRequestFactory.h b/src/DefaultBtRequestFactory.h
index 0ae52e3a..a6f03a3e 100644
--- a/src/DefaultBtRequestFactory.h
+++ b/src/DefaultBtRequestFactory.h
@@ -51,6 +51,9 @@ class Piece;
 
 class DefaultBtRequestFactory : public BtRequestFactory {
 private:
+  std::vector<std::unique_ptr<BtRequestMessage>> createRequestMessagesOnEndGame
+  (size_t max);
+
   PieceStorage* pieceStorage_;
   std::shared_ptr<Peer> peer_;
   BtMessageDispatcher* dispatcher_;
@@ -78,13 +81,10 @@ public:
 
   virtual void doChokedAction();
 
-  virtual void createRequestMessages
-  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max);
-
-  virtual void createRequestMessagesOnEndGame
-  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max);
+  virtual std::vector<std::unique_ptr<BtRequestMessage>> createRequestMessages
+  (size_t max, bool endGame);
 
-  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const;
+  virtual std::vector<size_t> getTargetPieceIndexes() const;
 
   std::deque<std::shared_ptr<Piece> >& getTargetPieces()
   {
diff --git a/src/ExtensionMessage.h b/src/ExtensionMessage.h
index 86418d66..67d8256d 100644
--- a/src/ExtensionMessage.h
+++ b/src/ExtensionMessage.h
@@ -46,7 +46,7 @@ public:
 
   virtual std::string getPayload() = 0;
 
-  virtual uint8_t getExtensionMessageID() = 0;
+  virtual uint8_t getExtensionMessageID() const = 0;
 
   virtual const char* getExtensionName() const = 0;
 
diff --git a/src/HandshakeExtensionMessage.h b/src/HandshakeExtensionMessage.h
index 520b8a9c..7690a485 100644
--- a/src/HandshakeExtensionMessage.h
+++ b/src/HandshakeExtensionMessage.h
@@ -67,7 +67,7 @@ public:
 
   virtual std::string getPayload();
 
-  virtual uint8_t getExtensionMessageID()
+  virtual uint8_t getExtensionMessageID() const
   {
     return 0;
   }
diff --git a/src/IndexBtMessage.h b/src/IndexBtMessage.h
index 6ee16758..61bc6da1 100644
--- a/src/IndexBtMessage.h
+++ b/src/IndexBtMessage.h
@@ -47,13 +47,12 @@ private:
   static const size_t MESSAGE_LENGTH = 9;
 protected:
   template<typename T>
-  static T* create(const unsigned char* data, size_t dataLength)
+  static std::unique_ptr<T> create(const unsigned char* data,
+                                   size_t dataLength)
   {
     bittorrent::assertPayloadLengthEqual(5, dataLength, T::NAME);
     bittorrent::assertID(T::ID, data, T::NAME);
-    T* message(new T());
-    message->setIndex(bittorrent::getIntParam(data, 1));
-    return message;
+    return make_unique<T>(bittorrent::getIntParam(data, 1));
   }
 public:
   IndexBtMessage(uint8_t id, const char* name, size_t index)
diff --git a/src/RangeBtMessage.h b/src/RangeBtMessage.h
index 3ba2179f..a9c590e3 100644
--- a/src/RangeBtMessage.h
+++ b/src/RangeBtMessage.h
@@ -49,15 +49,14 @@ private:
   static const size_t MESSAGE_LENGTH = 17;
 protected:
   template<typename T>
-  static T* create(const unsigned char* data, size_t dataLength)
+  static std::unique_ptr<T> create(const unsigned char* data,
+                                   size_t dataLength)
   {
     bittorrent::assertPayloadLengthEqual(13, dataLength, T::NAME);
     bittorrent::assertID(T::ID, data, T::NAME);
-    T* message(new T());
-    message->setIndex(bittorrent::getIntParam(data, 1));
-    message->setBegin(bittorrent::getIntParam(data, 5));
-    message->setLength(bittorrent::getIntParam(data, 9));
-    return message;
+    return make_unique<T>(bittorrent::getIntParam(data, 1),
+                          bittorrent::getIntParam(data, 5),
+                          bittorrent::getIntParam(data, 9));
   }
 public:
   RangeBtMessage(uint8_t id, const char* name,
diff --git a/src/UTMetadataExtensionMessage.h b/src/UTMetadataExtensionMessage.h
index 221702e3..70e27b15 100644
--- a/src/UTMetadataExtensionMessage.h
+++ b/src/UTMetadataExtensionMessage.h
@@ -47,7 +47,7 @@ private:
 public:
   UTMetadataExtensionMessage(uint8_t extensionMessageID);
 
-  virtual uint8_t getExtensionMessageID()
+  virtual uint8_t getExtensionMessageID() const
   {
     return extensionMessageID_;
   }
diff --git a/src/UTMetadataRequestExtensionMessage.cc b/src/UTMetadataRequestExtensionMessage.cc
index 695be23e..21795929 100644
--- a/src/UTMetadataRequestExtensionMessage.cc
+++ b/src/UTMetadataRequestExtensionMessage.cc
@@ -49,6 +49,7 @@
 #include "BtMessage.h"
 #include "PieceStorage.h"
 #include "ExtensionMessageRegistry.h"
+#include "BtExtendedMessage.h"
 
 namespace aria2 {
 
@@ -83,8 +84,8 @@ void UTMetadataRequestExtensionMessage::doReceivedAction()
     std::shared_ptr<UTMetadataRejectExtensionMessage> m
       (new UTMetadataRejectExtensionMessage(id));
     m->setIndex(getIndex());
-    std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
-    dispatcher_->addMessageToQueue(msg);
+    dispatcher_->addMessageToQueue
+      (messageFactory_->createBtExtendedMessage(m));
   }else if(getIndex()*METADATA_PIECE_SIZE < attrs->metadataSize) {
     std::shared_ptr<UTMetadataDataExtensionMessage> m
       (new UTMetadataDataExtensionMessage(id));
@@ -97,8 +98,8 @@ void UTMetadataRequestExtensionMessage::doReceivedAction()
       attrs->metadata.begin()+(getIndex()+1)*METADATA_PIECE_SIZE:
       attrs->metadata.end();
     m->setData(begin, end);
-    std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
-    dispatcher_->addMessageToQueue(msg);
+    dispatcher_->addMessageToQueue
+      (messageFactory_->createBtExtendedMessage(m));
   } else {
     throw DL_ABORT_EX
       (fmt("Metadata piece index is too big. piece=%lu",
diff --git a/src/UTMetadataRequestFactory.cc b/src/UTMetadataRequestFactory.cc
index 06e13dad..fe895bfe 100644
--- a/src/UTMetadataRequestFactory.cc
+++ b/src/UTMetadataRequestFactory.cc
@@ -45,24 +45,24 @@
 #include "LogFactory.h"
 #include "fmt.h"
 #include "ExtensionMessageRegistry.h"
+#include "BtExtendedMessage.h"
 
 namespace aria2 {
 
 UTMetadataRequestFactory::UTMetadataRequestFactory()
-  : dispatcher_(0),
-    messageFactory_(0),
-    tracker_(0),
+  : dispatcher_{nullptr},
+    messageFactory_{nullptr},
+    tracker_{nullptr},
     cuid_(0)
 {}
 
-void UTMetadataRequestFactory::create
-(std::vector<std::shared_ptr<BtMessage> >& msgs, size_t num,
- const std::shared_ptr<PieceStorage>& pieceStorage)
+std::vector<std::unique_ptr<BtMessage>> UTMetadataRequestFactory::create
+(size_t num, const std::shared_ptr<PieceStorage>& pieceStorage)
 {
+  auto msgs = std::vector<std::unique_ptr<BtMessage>>{};
   while(num) {
-    std::vector<size_t> metadataRequests = tracker_->getAllTrackedIndex();
-    std::shared_ptr<Piece> p =
-      pieceStorage->getMissingPiece(peer_, metadataRequests, cuid_);
+    auto metadataRequests = tracker_->getAllTrackedIndex();
+    auto p = pieceStorage->getMissingPiece(peer_, metadataRequests, cuid_);
     if(!p) {
       A2_LOG_DEBUG("No ut_metadata piece is available to download.");
       break;
@@ -79,10 +79,10 @@ void UTMetadataRequestFactory::create
     m->setBtMessageFactory(messageFactory_);
     m->setPeer(peer_);
 
-    std::shared_ptr<BtMessage> msg = messageFactory_->createBtExtendedMessage(m);
-    msgs.push_back(msg);
+    msgs.push_back(messageFactory_->createBtExtendedMessage(m));
     tracker_->add(p->getIndex());
   }
+  return msgs;
 }
 
 } // namespace aria2
diff --git a/src/UTMetadataRequestFactory.h b/src/UTMetadataRequestFactory.h
index 8839cfe4..e8de1e67 100644
--- a/src/UTMetadataRequestFactory.h
+++ b/src/UTMetadataRequestFactory.h
@@ -67,10 +67,10 @@ private:
 public:
   UTMetadataRequestFactory();
 
-  // Creates at most num of ut_metadata request message and appends
-  // them to msgs. pieceStorage is used to identify missing piece.
-  void create(std::vector<std::shared_ptr<BtMessage> >& msgs, size_t num,
-              const std::shared_ptr<PieceStorage>& pieceStorage);
+  // Creates and returns at most num of ut_metadata request
+  // message. pieceStorage is used to identify missing piece.
+  std::vector<std::unique_ptr<BtMessage>> create
+  (size_t num, const std::shared_ptr<PieceStorage>& pieceStorage);
 
   void setDownloadContext(const std::shared_ptr<DownloadContext>& dctx)
   {
diff --git a/src/UTPexExtensionMessage.h b/src/UTPexExtensionMessage.h
index 8ae7bee2..6bbcd302 100644
--- a/src/UTPexExtensionMessage.h
+++ b/src/UTPexExtensionMessage.h
@@ -75,7 +75,7 @@ public:
 
   virtual std::string getPayload();
 
-  virtual uint8_t getExtensionMessageID()
+  virtual uint8_t getExtensionMessageID() const
   {
     return extensionMessageID_;
   }
diff --git a/src/ZeroBtMessage.cc b/src/ZeroBtMessage.cc
index 1717453c..582b657c 100644
--- a/src/ZeroBtMessage.cc
+++ b/src/ZeroBtMessage.cc
@@ -37,6 +37,10 @@
 
 namespace aria2 {
 
+ZeroBtMessage::ZeroBtMessage(uint8_t id, const char* name)
+  : SimpleBtMessage{id, name}
+{}
+
 unsigned char* ZeroBtMessage::createMessage()
 {
   /**
diff --git a/src/ZeroBtMessage.h b/src/ZeroBtMessage.h
index f387cc70..223d3d68 100644
--- a/src/ZeroBtMessage.h
+++ b/src/ZeroBtMessage.h
@@ -45,17 +45,16 @@ private:
   static const size_t MESSAGE_LENGTH = 5;
 protected:
   template<typename T>
-  static T* create(const unsigned char* data, size_t dataLength)
+  static std::unique_ptr<T> create(const unsigned char* data,
+                                   size_t dataLength)
   {
     bittorrent::assertPayloadLengthEqual(1, dataLength, T::NAME);
     bittorrent::assertID(T::ID, data, T::NAME);
-    T* message(new T());
-    return message;
+    return make_unique<T>();
   }
 
 public:
-  ZeroBtMessage(uint8_t id, const char* name):
-    SimpleBtMessage(id, name) {}
+  ZeroBtMessage(uint8_t id, const char* name);
 
   virtual unsigned char* createMessage();