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

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

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();

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

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();

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

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

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

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;
 

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()

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,

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

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() {

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

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();

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

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

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

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();

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

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();

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;
 

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

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

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();

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

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();
 

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()

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();
 

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

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

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

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

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();

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

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() {

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

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();

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();

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

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

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);
-      break;
-    }
-    case BtCancelMessage::ID: {
-      BtCancelMessage* m = BtCancelMessage::create(data, dataLength);
-      if(!metadataGetMode_) {
-        m->setBtMessageValidator
-          (make_unique<RangeBtMessageValidator>
-           (m,
-            downloadContext_->getNumPieces(),
-            pieceStorage_->getPieceLength(m->getIndex())));
-      }
-      msg.reset(m);
+      msg = std::move(m);
       break;
     }
     case BtPieceMessage::ID: {
-      BtPieceMessage* m = BtPieceMessage::create(data, dataLength);
+      auto m = BtPieceMessage::create(data, dataLength);
       if(!metadataGetMode_) {
         m->setBtMessageValidator
           (make_unique<BtPieceMessageValidator>
-           (m,
+           (static_cast<BtPieceMessage*>(m.get()),
             downloadContext_->getNumPieces(),
             pieceStorage_->getPieceLength(m->getIndex())));
       }
       m->setDownloadContext(downloadContext_);
       m->setPeerStorage(peerStorage_);
-      msg.reset(m);
+      msg = std::move(m);
       break;
     }
-    case BtHaveAllMessage::ID:
-      msg.reset(BtHaveAllMessage::create(data, dataLength));
-      break;
-    case BtHaveNoneMessage::ID:
-      msg.reset(BtHaveNoneMessage::create(data, dataLength));
-      break;
-    case BtRejectMessage::ID: {
-      BtRejectMessage* m = BtRejectMessage::create(data, dataLength);
+    case BtCancelMessage::ID: {
+      auto m = BtCancelMessage::create(data, dataLength);
       if(!metadataGetMode_) {
         m->setBtMessageValidator
           (make_unique<RangeBtMessageValidator>
-           (m,
+           (static_cast<BtCancelMessage*>(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);
-      break;
-    }
-    case BtAllowedFastMessage::ID: {
-      BtAllowedFastMessage* 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()));
-      }
-      msg.reset(m);
+      msg = std::move(m);
       break;
     }
     case BtPortMessage::ID: {
-      BtPortMessage* m = BtPortMessage::create(data, dataLength);
+      auto 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 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 = BtHaveAllMessage::create(data, dataLength);
+      break;
+    case BtHaveNoneMessage::ID:
+      msg = BtHaveNoneMessage::create(data, dataLength);
+      break;
+    case BtRejectMessage::ID: {
+      auto m = BtRejectMessage::create(data, dataLength);
+      if(!metadataGetMode_) {
+        m->setBtMessageValidator
+          (make_unique<RangeBtMessageValidator>
+           (static_cast<BtRejectMessage*>(m.get()),
+            downloadContext_->getNumPieces(),
+            pieceStorage_->getPieceLength(m->getIndex())));
+      }
+      msg = std::move(m);
+      break;
+    }
+    case BtAllowedFastMessage::ID: {
+      auto m = BtAllowedFastMessage::create(data, dataLength);
+      if(!metadataGetMode_) {
+        m->setBtMessageValidator(make_unique<IndexBtMessageValidator>
+                                 (static_cast<BtAllowedFastMessage*>(m.get()),
+                                  downloadContext_->getNumPieces()));
+      }
+      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)

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

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

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)

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 std::vector<std::unique_ptr<BtRequestMessage>> createRequestMessages
+  (size_t max, bool endGame);
 
-  virtual void createRequestMessagesOnEndGame
-  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max);
-
-  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const;
+  virtual std::vector<size_t> getTargetPieceIndexes() const;
 
   std::deque<std::shared_ptr<Piece> >& getTargetPieces()
   {

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;
 

src/HandshakeExtensionMessage.h

@@ -67,7 +67,7 @@ public:
 
   virtual std::string getPayload();
 
-  virtual uint8_t getExtensionMessageID()
+  virtual uint8_t getExtensionMessageID() const
   {
     return 0;
   }

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)

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,

src/UTMetadataExtensionMessage.h

@@ -47,7 +47,7 @@ private:
 public:
   UTMetadataExtensionMessage(uint8_t extensionMessageID);
 
-  virtual uint8_t getExtensionMessageID()
+  virtual uint8_t getExtensionMessageID() const
   {
     return extensionMessageID_;
   }

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",

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

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)
   {

src/UTPexExtensionMessage.h

@@ -75,7 +75,7 @@ public:
 
   virtual std::string getPayload();
 
-  virtual uint8_t getExtensionMessageID()
+  virtual uint8_t getExtensionMessageID() const
   {
     return extensionMessageID_;
   }

src/ZeroBtMessage.cc

@@ -37,6 +37,10 @@
 
 namespace aria2 {
 
+ZeroBtMessage::ZeroBtMessage(uint8_t id, const char* name)
+  : SimpleBtMessage{id, name}
+{}
+
 unsigned char* ZeroBtMessage::createMessage()
 {
   /**

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();
 

test/BtCancelMessageTest.cc

@@ -41,7 +41,7 @@ public:
                                length(0) {}
 
     virtual void doCancelSendingPieceAction
-    (size_t index, int32_t begin, int32_t length) {
+    (size_t index, int32_t begin, int32_t length) override {
       this->index = index;
       this->begin = begin;
       this->length = length;
@@ -58,7 +58,7 @@ void BtCancelMessageTest::testCreate() {
   bittorrent::setIntParam(&msg[5], 12345);
   bittorrent::setIntParam(&msg[9], 256);
   bittorrent::setIntParam(&msg[13], 1024);
-  std::shared_ptr<BtCancelMessage> pm(BtCancelMessage::create(&msg[4], 13));
+  auto pm = BtCancelMessage::create(&msg[4], 13);
   CPPUNIT_ASSERT_EQUAL((uint8_t)8, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL(256, pm->getBegin());
@@ -103,8 +103,7 @@ void BtCancelMessageTest::testDoReceivedAction() {
   msg.setBegin(2*16*1024);
   msg.setLength(16*1024);
   msg.setPeer(peer);
-  std::shared_ptr<MockBtMessageDispatcher2> dispatcher
-    (new MockBtMessageDispatcher2());
+  auto dispatcher = make_unique<MockBtMessageDispatcher2>();
   msg.setBtMessageDispatcher(dispatcher.get());
 
   msg.doReceivedAction();

test/BtChokeMessageTest.cc

@@ -43,13 +43,18 @@ public:
     bool doChokedActionCalled;
     bool doChokingActionCalled;
   public:
-    MockBtMessageDispatcher2():doChokedActionCalled(false), doChokingActionCalled(false) {}
+    MockBtMessageDispatcher2()
+      : doChokedActionCalled{false},
+        doChokingActionCalled{false}
+    {}
 
-    virtual void doChokedAction() {
+    virtual void doChokedAction() override
+    {
       doChokedActionCalled = true;
     }
 
-    virtual void doChokingAction() {
+    virtual void doChokingAction() override
+    {
       doChokingActionCalled = true;
     }
   };
@@ -58,9 +63,10 @@ public:
   public:
     bool doChokedActionCalled;
   public:
-    MockBtRequestFactory2():doChokedActionCalled(false) {}
+    MockBtRequestFactory2():doChokedActionCalled{false} {}
 
-    virtual void doChokedAction() {
+    virtual void doChokedAction() override
+    {
       doChokedActionCalled = true;
     }
   };
@@ -72,7 +78,7 @@ CPPUNIT_TEST_SUITE_REGISTRATION(BtChokeMessageTest);
 void BtChokeMessageTest::testCreate() {
   unsigned char msg[5];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 1, 0);
-  std::shared_ptr<BtChokeMessage> pm(BtChokeMessage::create(&msg[4], 1));
+  auto pm = BtChokeMessage::create(&msg[4], 1);
   CPPUNIT_ASSERT_EQUAL((uint8_t)0, pm->getId());
 
   // case: payload size is wrong
@@ -106,9 +112,9 @@ void BtChokeMessageTest::testDoReceivedAction() {
   BtChokeMessage msg;
   msg.setPeer(peer);
 
-  std::shared_ptr<MockBtMessageDispatcher2> dispatcher(new MockBtMessageDispatcher2());
+  auto dispatcher = make_unique<MockBtMessageDispatcher2>();
   msg.setBtMessageDispatcher(dispatcher.get());
-  std::shared_ptr<MockBtRequestFactory2> requestFactory(new MockBtRequestFactory2());
+  auto requestFactory = make_unique<MockBtRequestFactory2>();
   msg.setBtRequestFactory(requestFactory.get());
 
   msg.doReceivedAction();
@@ -121,10 +127,10 @@ void BtChokeMessageTest::testOnSendComplete() {
   BtChokeMessage msg;
   msg.setPeer(peer);
 
-  std::shared_ptr<MockBtMessageDispatcher2> dispatcher(new MockBtMessageDispatcher2());
+  auto dispatcher = make_unique<MockBtMessageDispatcher2>();
   msg.setBtMessageDispatcher(dispatcher.get());
 
-  std::shared_ptr<ProgressUpdate> pu(msg.getProgressUpdate());
+  auto pu = std::unique_ptr<ProgressUpdate>{msg.getProgressUpdate()};
   pu->update(0, true);
 
   CPPUNIT_ASSERT(dispatcher->doChokingActionCalled);

test/BtPieceMessageTest.cc

@@ -15,6 +15,7 @@
 #include "Piece.h"
 #include "BtHandshakeMessage.h"
 #include "DownloadContext.h"
+#include "BtRejectMessage.h"
 
 namespace aria2 {
 
@@ -47,44 +48,33 @@ public:
   void testCancelSendingPieceEvent_invalidate();
   void testToString();
 
-  class MockBtMessage2 : public MockBtMessage {
-  public:
-    size_t index;
-    uint32_t begin;
-    size_t length;
-  public:
-    MockBtMessage2(size_t index, uint32_t begin, size_t length):index(index), begin(begin), length(length) {}
-
-  };
-
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual std::shared_ptr<BtMessage>
+    virtual std::unique_ptr<BtRejectMessage>
     createRejectMessage(size_t index,
                         int32_t begin,
                         int32_t length) {
-      std::shared_ptr<MockBtMessage2> msg(new MockBtMessage2(index, begin, length));
-      return msg;
+      return make_unique<BtRejectMessage>(index, begin, length);
     }
   };
 
-  std::shared_ptr<DownloadContext> dctx_;
-  std::shared_ptr<MockBtMessageDispatcher> btMessageDispatcher;
-  std::shared_ptr<MockBtMessageFactory> btMessageFactory_;
+  std::unique_ptr<DownloadContext> dctx_;
+  std::unique_ptr<MockBtMessageDispatcher> btMessageDispatcher;
+  std::unique_ptr<MockBtMessageFactory> btMessageFactory_;
   std::shared_ptr<Peer> peer;
-  std::shared_ptr<BtPieceMessage> msg;
+  std::unique_ptr<BtPieceMessage> msg;
 
   void setUp() {
-    dctx_.reset(new DownloadContext(16*1024, 256*1024, "/path/to/file"));
+    dctx_ = make_unique<DownloadContext>(16*1024, 256*1024, "/path/to/file");
 
-    peer.reset(new Peer("host", 6969));
+    peer = std::make_shared<Peer>("host", 6969);
     peer->allocateSessionResource(dctx_->getPieceLength(),
                                   dctx_->getTotalLength());
 
-    btMessageDispatcher.reset(new MockBtMessageDispatcher());
-    btMessageFactory_.reset(new MockBtMessageFactory2());
+    btMessageDispatcher = make_unique<MockBtMessageDispatcher>();
+    btMessageFactory_ = make_unique<MockBtMessageFactory2>();
 
-    msg.reset(new BtPieceMessage());
+    msg = make_unique<BtPieceMessage>();
     msg->setIndex(1);
     msg->setBegin(1024);
     msg->setBlockLength(16*1024);
@@ -166,11 +156,11 @@ void BtPieceMessageTest::testChokingEvent_allowedFastEnabled() {
 
   CPPUNIT_ASSERT(msg->isInvalidate());
   CPPUNIT_ASSERT_EQUAL((size_t)1, btMessageDispatcher->messageQueue.size());
-  auto rej = std::dynamic_pointer_cast<MockBtMessage2>
-    (btMessageDispatcher->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, rej->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, rej->length);
+  auto rej = static_cast<const BtRejectMessage*>
+    (btMessageDispatcher->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)1024, rej->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, rej->getLength());
 }
 
 void BtPieceMessageTest::testChokingEvent_inAmAllowedIndexSet() {
@@ -234,11 +224,11 @@ void BtPieceMessageTest::testCancelSendingPieceEvent_allowedFastEnabled() {
 
   CPPUNIT_ASSERT(msg->isInvalidate());
   CPPUNIT_ASSERT_EQUAL((size_t)1, btMessageDispatcher->messageQueue.size());
-  auto rej = std::dynamic_pointer_cast<MockBtMessage2>
-    (btMessageDispatcher->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)1024, rej->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)16*1024, rej->length);
+  auto rej = static_cast<const BtRejectMessage*>
+    (btMessageDispatcher->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, rej->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)1024, rej->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16*1024, rej->getLength());
 }
 
 void BtPieceMessageTest::testCancelSendingPieceEvent_invalidate() {

test/BtRequestMessageTest.cc

@@ -54,62 +54,44 @@ public:
 
   class MockPieceStorage2 : public MockPieceStorage {
   public:
-    virtual bool hasPiece(size_t index) {
+    virtual bool hasPiece(size_t index) override
+    {
       return index == 1;
     }
   };
 
-  class MockBtMessage2 : public MockBtMessage {
-  public:
-    std::string type;
-    size_t index;
-    uint32_t begin;
-    size_t length;
-  public:
-    MockBtMessage2(std::string type, size_t index, uint32_t begin,
-                   size_t length)
-      :
-      type(type), index(index), begin(begin), length(length) {}
-  };
-
-  typedef std::shared_ptr<MockBtMessage2> MockBtMessage2Handle;
-
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual std::shared_ptr<BtMessage>
-    createPieceMessage(size_t index, int32_t begin, int32_t length) {
-      std::shared_ptr<MockBtMessage2> btMsg
-        (new MockBtMessage2("piece", index, begin, length));
-      return btMsg;
+    virtual std::unique_ptr<BtPieceMessage>
+    createPieceMessage(size_t index, int32_t begin, int32_t length) override
+    {
+      return make_unique<BtPieceMessage>(index, begin, length);
     }
 
-    virtual std::shared_ptr<BtMessage>
-    createRejectMessage(size_t index, int32_t begin, int32_t length) {
-      std::shared_ptr<MockBtMessage2> btMsg
-        (new MockBtMessage2("reject", index, begin, length));
-      return btMsg;
+    virtual std::unique_ptr<BtRejectMessage>
+    createRejectMessage(size_t index, int32_t begin, int32_t length) override
+    {
+      return make_unique<BtRejectMessage>(index, begin, length);
     }
   };
 
-  typedef std::shared_ptr<MockBtMessageFactory2> MockBtMessageFactory2Handle;
-
-  std::shared_ptr<MockPieceStorage> pieceStorage_;
+  std::unique_ptr<MockPieceStorage> pieceStorage_;
   std::shared_ptr<Peer> peer_;
-  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
-  std::shared_ptr<MockBtMessageFactory> messageFactory_;
-  std::shared_ptr<BtRequestMessage> msg;
+  std::unique_ptr<MockBtMessageDispatcher> dispatcher_;
+  std::unique_ptr<MockBtMessageFactory> messageFactory_;
+  std::unique_ptr<BtRequestMessage> msg;
 
   void setUp() {
-    pieceStorage_.reset(new MockPieceStorage2());
+    pieceStorage_ = make_unique<MockPieceStorage2>();
 
-    peer_.reset(new Peer("host", 6969));
+    peer_ = std::make_shared<Peer>("host", 6969);
     peer_->allocateSessionResource(16*1024, 256*1024);
 
-    dispatcher_.reset(new MockBtMessageDispatcher());
+    dispatcher_ = make_unique<MockBtMessageDispatcher>();
 
-    messageFactory_.reset(new MockBtMessageFactory2());
+    messageFactory_ = make_unique<MockBtMessageFactory2>();
 
-    msg.reset(new BtRequestMessage());
+    msg = make_unique<BtRequestMessage>();
     msg->setPeer(peer_);
     msg->setIndex(1);
     msg->setBegin(16);
@@ -130,7 +112,7 @@ void BtRequestMessageTest::testCreate() {
   bittorrent::setIntParam(&msg[5], 12345);
   bittorrent::setIntParam(&msg[9], 256);
   bittorrent::setIntParam(&msg[13], 1024);
-  std::shared_ptr<BtRequestMessage> pm(BtRequestMessage::create(&msg[4], 13));
+  auto pm = BtRequestMessage::create(&msg[4], 13);
   CPPUNIT_ASSERT_EQUAL((uint8_t)6, pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
   CPPUNIT_ASSERT_EQUAL(256, pm->getBegin());
@@ -174,12 +156,13 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmNotChoking() {
   msg->doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size());
-  auto pieceMsg = std::dynamic_pointer_cast<MockBtMessage2>
-    (dispatcher_->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL(std::string("piece"), pieceMsg->type);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)32, pieceMsg->length);
+  CPPUNIT_ASSERT(BtPieceMessage::ID ==
+                 dispatcher_->messageQueue.front()->getId());
+  auto pieceMsg = static_cast<const BtPieceMessage*>
+    (dispatcher_->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16, pieceMsg->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)32, pieceMsg->getBlockLength());
 }
 
 void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExtensionEnabled() {
@@ -188,12 +171,13 @@ void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExten
   msg->doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size());
-  auto pieceMsg = std::dynamic_pointer_cast<MockBtMessage2>
-    (dispatcher_->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, pieceMsg->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)32, pieceMsg->length);
+  CPPUNIT_ASSERT(BtRejectMessage::ID ==
+                 dispatcher_->messageQueue.front()->getId());
+  auto rejectMsg = static_cast<const BtRejectMessage*>
+    (dispatcher_->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, rejectMsg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16, rejectMsg->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)32, rejectMsg->getLength());
 }
 
 void BtRequestMessageTest::testDoReceivedAction_hasPieceAndAmChokingAndFastExtensionDisabled() {
@@ -210,12 +194,13 @@ void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionE
   msg->doReceivedAction();
 
   CPPUNIT_ASSERT_EQUAL((size_t)1, dispatcher_->messageQueue.size());
-  auto pieceMsg = std::dynamic_pointer_cast<MockBtMessage2>
-    (dispatcher_->messageQueue.front());
-  CPPUNIT_ASSERT_EQUAL(std::string("reject"), pieceMsg->type);
-  CPPUNIT_ASSERT_EQUAL((size_t)2, pieceMsg->index);
-  CPPUNIT_ASSERT_EQUAL((uint32_t)16, pieceMsg->begin);
-  CPPUNIT_ASSERT_EQUAL((size_t)32, pieceMsg->length);
+  CPPUNIT_ASSERT(BtRejectMessage::ID ==
+                 dispatcher_->messageQueue.front()->getId());
+  auto rejectMsg = static_cast<const BtRejectMessage*>
+    (dispatcher_->messageQueue.front().get());
+  CPPUNIT_ASSERT_EQUAL((size_t)2, rejectMsg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((int32_t)16, rejectMsg->getBegin());
+  CPPUNIT_ASSERT_EQUAL((int32_t)32, rejectMsg->getLength());
 }
 
 void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionDisabled() {
@@ -227,21 +212,21 @@ void BtRequestMessageTest::testDoReceivedAction_doesntHavePieceAndFastExtensionD
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent() {
-  std::shared_ptr<Piece> piece(new Piece(1, 16*1024));
+  auto piece = std::make_shared<Piece>(1, 16*1024);
   CPPUNIT_ASSERT(!msg->isInvalidate());
   msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece));
   CPPUNIT_ASSERT(msg->isInvalidate());
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent_indexNoMatch() {
-  std::shared_ptr<Piece> piece(new Piece(2, 16*1024));
+  auto piece = std::make_shared<Piece>(2, 16*1024);
   CPPUNIT_ASSERT(!msg->isInvalidate());
   msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece));
   CPPUNIT_ASSERT(!msg->isInvalidate());
 }
 
 void BtRequestMessageTest::testHandleAbortRequestEvent_alreadyInvalidated() {
-  std::shared_ptr<Piece> piece(new Piece(1, 16*1024));
+  auto piece = std::make_shared<Piece>(1, 16*1024);
   msg->setInvalidate(true);
   CPPUNIT_ASSERT(msg->isInvalidate());
   msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece));

test/BtSuggestPieceMessageTest.cc

@@ -32,9 +32,8 @@ void BtSuggestPieceMessageTest::testCreate() {
   unsigned char msg[9];
   bittorrent::createPeerMessageString(msg, sizeof(msg), 5, 13);
   bittorrent::setIntParam(&msg[5], 12345);
-  std::shared_ptr<BtSuggestPieceMessage> pm
-    (BtSuggestPieceMessage::create(&msg[4], 5));
-  CPPUNIT_ASSERT_EQUAL((uint8_t)13, pm->getId());
+  auto pm = BtSuggestPieceMessage::create(&msg[4], 5);
+  CPPUNIT_ASSERT(BtSuggestPieceMessage::ID == pm->getId());
   CPPUNIT_ASSERT_EQUAL((size_t)12345, pm->getIndex());
 
   // case: payload size is wrong

test/DefaultBtMessageDispatcherTest.cc

@@ -43,13 +43,13 @@ class DefaultBtMessageDispatcherTest:public CppUnit::TestFixture {
 private:
   std::shared_ptr<DownloadContext> dctx_;
   std::shared_ptr<Peer> peer;
-  std::shared_ptr<DefaultBtMessageDispatcher> btMessageDispatcher;
-  std::shared_ptr<MockPeerStorage> peerStorage;
-  std::shared_ptr<MockPieceStorage> pieceStorage;
-  std::shared_ptr<MockBtMessageFactory> messageFactory_;
-  std::shared_ptr<RequestGroupMan> rgman_;
+  std::unique_ptr<DefaultBtMessageDispatcher> btMessageDispatcher;
+  std::unique_ptr<MockPeerStorage> peerStorage;
+  std::unique_ptr<MockPieceStorage> pieceStorage;
+  std::unique_ptr<MockBtMessageFactory> messageFactory_;
+  std::unique_ptr<RequestGroupMan> rgman_;
   std::shared_ptr<Option> option_;
-  std::shared_ptr<RequestGroup> rg_;
+  std::unique_ptr<RequestGroup> rg_;
 public:
   void tearDown() {}
 
@@ -66,45 +66,43 @@ public:
   void testGetOutstandingRequest();
   void testRemoveOutstandingRequest();
 
-  class MockBtMessage2 : public MockBtMessage {
-  private:
+  struct EventCheck {
+    EventCheck() : onQueuedCalled{false}, sendCalled{false},
+      doCancelActionCalled{false}
+    {}
     bool onQueuedCalled;
     bool sendCalled;
     bool doCancelActionCalled;
+  };
+
+  class MockBtMessage2 : public MockBtMessage {
   public:
+    EventCheck* evcheck;
     std::string type;
-  public:
-    MockBtMessage2():onQueuedCalled(false),
-                     sendCalled(false),
-                     doCancelActionCalled(false)
+    MockBtMessage2(EventCheck* evcheck = nullptr)
+      : evcheck{evcheck}
     {}
 
-    virtual ~MockBtMessage2() {}
-
-    virtual void onQueued() {
-      onQueuedCalled = true;
+    virtual void onQueued() override
+    {
+      if(evcheck){
+        evcheck->onQueuedCalled = true;
+      }
     }
 
-    bool isOnQueuedCalled() const {
-      return onQueuedCalled;
-    }
-
-    virtual void send() {
-      sendCalled = true;
-    }
-
-    bool isSendCalled() const {
-      return sendCalled;
+    virtual void send() override
+    {
+      if(evcheck) {
+        evcheck->sendCalled = true;
+      }
     }
 
     virtual void onCancelSendingPieceEvent
-    (const BtCancelSendingPieceEvent& event)
+    (const BtCancelSendingPieceEvent& event) override
     {
-      doCancelActionCalled = true;
-    }
-
-    bool isDoCancelActionCalled() const {
-      return doCancelActionCalled;
+      if(evcheck) {
+        evcheck->doCancelActionCalled = true;
+      }
     }
   };
 
@@ -112,48 +110,50 @@ public:
   private:
     std::shared_ptr<Piece> piece;
   public:
-    virtual std::shared_ptr<Piece> getPiece(size_t index) {
+    virtual std::shared_ptr<Piece> getPiece(size_t index) override
+    {
       return piece;
     }
 
-    void setPiece(const std::shared_ptr<Piece>& piece) {
+    void setPiece(const std::shared_ptr<Piece>& piece)
+    {
       this->piece = piece;
     }
   };
 
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual std::shared_ptr<BtMessage>
-    createCancelMessage(size_t index, int32_t begin, int32_t length) {
-      std::shared_ptr<MockBtMessage2> btMsg(new MockBtMessage2());
-      btMsg->type = "cancel";
-      return btMsg;
+    virtual std::unique_ptr<BtCancelMessage>
+    createCancelMessage(size_t index, int32_t begin, int32_t length) override
+    {
+      return make_unique<BtCancelMessage>(index, begin, length);
     }
   };
 
-  void setUp() {
-    option_.reset(new Option());
+  void setUp()
+  {
+    option_ = std::make_shared<Option>();
     option_->put(PREF_DIR, ".");
 
-    rg_.reset(new RequestGroup(GroupId::create(), option_));
+    rg_ = make_unique<RequestGroup>(GroupId::create(), option_);
 
-    dctx_.reset(new DownloadContext());
+    dctx_ = std::make_shared<DownloadContext>();
     bittorrent::load(A2_TEST_DIR"/test.torrent", dctx_, option_);
 
     rg_->setDownloadContext(dctx_);
 
-    peer.reset(new Peer("192.168.0.1", 6969));
+    peer = std::make_shared<Peer>("192.168.0.1", 6969);
     peer->allocateSessionResource
       (dctx_->getPieceLength(), dctx_->getTotalLength());
-    peerStorage.reset(new MockPeerStorage());
-    pieceStorage.reset(new MockPieceStorage());
+    peerStorage = make_unique<MockPeerStorage>();
+    pieceStorage = make_unique<MockPieceStorage>();
 
-    messageFactory_.reset(new MockBtMessageFactory2());
+    messageFactory_ = make_unique<MockBtMessageFactory2>();
 
-    rgman_.reset(new RequestGroupMan(std::vector<std::shared_ptr<RequestGroup> >(),
-                                     0, option_.get()));
+    rgman_ = make_unique<RequestGroupMan>
+      (std::vector<std::shared_ptr<RequestGroup>>{}, 0, option_.get());
 
-    btMessageDispatcher.reset(new DefaultBtMessageDispatcher());
+    btMessageDispatcher = make_unique<DefaultBtMessageDispatcher>();
     btMessageDispatcher->setPeer(peer);
     btMessageDispatcher->setDownloadContext(dctx_.get());
     btMessageDispatcher->setPieceStorage(pieceStorage.get());
@@ -167,87 +167,66 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtMessageDispatcherTest);
 
-void DefaultBtMessageDispatcherTest::testAddMessage() {
-  std::shared_ptr<MockBtMessage2> msg(new MockBtMessage2());
-  CPPUNIT_ASSERT_EQUAL(false, msg->isOnQueuedCalled());
-  btMessageDispatcher->addMessageToQueue(msg);
-  CPPUNIT_ASSERT_EQUAL(true, msg->isOnQueuedCalled());
+void DefaultBtMessageDispatcherTest::testAddMessage()
+  {
+  auto evcheck = EventCheck{};
+  auto msg = make_unique<MockBtMessage2>(&evcheck);
+  btMessageDispatcher->addMessageToQueue(std::move(msg));
+  CPPUNIT_ASSERT_EQUAL(true, evcheck.onQueuedCalled);
   CPPUNIT_ASSERT_EQUAL((size_t)1,
                        btMessageDispatcher->getMessageQueue().size());
 }
 
 void DefaultBtMessageDispatcherTest::testSendMessages() {
-  std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
+  auto evcheck1 = EventCheck{};
+  auto msg1 = make_unique<MockBtMessage2>(&evcheck1);
   msg1->setUploading(false);
-  std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
+  auto evcheck2 = EventCheck{};
+  auto msg2 = make_unique<MockBtMessage2>(&evcheck2);
   msg2->setUploading(false);
-  btMessageDispatcher->addMessageToQueue(msg1);
-  btMessageDispatcher->addMessageToQueue(msg2);
+  btMessageDispatcher->addMessageToQueue(std::move(msg1));
+  btMessageDispatcher->addMessageToQueue(std::move(msg2));
   btMessageDispatcher->sendMessagesInternal();
 
-  CPPUNIT_ASSERT(msg1->isSendCalled());
-  CPPUNIT_ASSERT(msg2->isSendCalled());
+  CPPUNIT_ASSERT(evcheck1.sendCalled);
+  CPPUNIT_ASSERT(evcheck2.sendCalled);
 }
 
 void DefaultBtMessageDispatcherTest::testSendMessages_underUploadLimit() {
-  std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
+  auto evcheck1 = EventCheck{};
+  auto msg1 = make_unique<MockBtMessage2>(&evcheck1);
   msg1->setUploading(true);
-  std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
+  auto evcheck2 = EventCheck{};
+  auto msg2 = make_unique<MockBtMessage2>(&evcheck2);
   msg2->setUploading(true);
-  btMessageDispatcher->addMessageToQueue(msg1);
-  btMessageDispatcher->addMessageToQueue(msg2);
+  btMessageDispatcher->addMessageToQueue(std::move(msg1));
+  btMessageDispatcher->addMessageToQueue(std::move(msg2));
   btMessageDispatcher->sendMessagesInternal();
 
-  CPPUNIT_ASSERT(msg1->isSendCalled());
-  CPPUNIT_ASSERT(msg2->isSendCalled());
+  CPPUNIT_ASSERT(evcheck1.sendCalled);
+  CPPUNIT_ASSERT(evcheck2.sendCalled);
 }
 
-// TODO Because we no longer directly use PeerStorage::calculateStat()
-// and Neither RequestGroup nor RequestGroupMan can be stubbed, this
-// test is commented out for now.
-//
-// void DefaultBtMessageDispatcherTest::testSendMessages_overUploadLimit() {
-//   btMessageDispatcher->setMaxUploadSpeedLimit(100);
-//   TransferStat stat;
-//   stat.setUploadSpeed(150);
-//   peerStorage->setStat(stat);
+void DefaultBtMessageDispatcherTest::testDoCancelSendingPieceAction()
+{
+  auto evcheck1 = EventCheck{};
+  auto msg1 = make_unique<MockBtMessage2>(&evcheck1);
+  auto evcheck2 = EventCheck{};
+  auto msg2 = make_unique<MockBtMessage2>(&evcheck2);
 
-//   std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
-//   msg1->setUploading(true);
-//   std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
-//   msg2->setUploading(true);
-//   std::shared_ptr<MockBtMessage2> msg3(new MockBtMessage2());
-//   msg3->setUploading(false);
-
-//   btMessageDispatcher->addMessageToQueue(msg1);
-//   btMessageDispatcher->addMessageToQueue(msg2);
-//   btMessageDispatcher->addMessageToQueue(msg3);
-//   btMessageDispatcher->sendMessagesInternal();
-
-//   CPPUNIT_ASSERT(!msg1->isSendCalled());
-//   CPPUNIT_ASSERT(!msg2->isSendCalled());
-//   CPPUNIT_ASSERT(msg3->isSendCalled());
-
-//   CPPUNIT_ASSERT_EQUAL((size_t)2,
-//                     btMessageDispatcher->getMessageQueue().size());
-// }
-
-void DefaultBtMessageDispatcherTest::testDoCancelSendingPieceAction() {
-  std::shared_ptr<MockBtMessage2> msg1(new MockBtMessage2());
-  std::shared_ptr<MockBtMessage2> msg2(new MockBtMessage2());
-
-  btMessageDispatcher->addMessageToQueue(msg1);
-  btMessageDispatcher->addMessageToQueue(msg2);
+  btMessageDispatcher->addMessageToQueue(std::move(msg1));
+  btMessageDispatcher->addMessageToQueue(std::move(msg2));
 
   btMessageDispatcher->doCancelSendingPieceAction(0, 0, 0);
 
-  CPPUNIT_ASSERT_EQUAL(true, msg1->isDoCancelActionCalled());
-  CPPUNIT_ASSERT_EQUAL(true, msg2->isDoCancelActionCalled());
+  CPPUNIT_ASSERT(evcheck1.doCancelActionCalled);
+  CPPUNIT_ASSERT(evcheck2.doCancelActionCalled);
 }
 
 int MY_PIECE_LENGTH = 16*1024;
 
-void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing() {
+void DefaultBtMessageDispatcherTest::testCheckRequestSlotAndDoNecessaryThing()
+{
   auto piece = std::make_shared<Piece>(0, MY_PIECE_LENGTH);
   size_t index;
   CPPUNIT_ASSERT(piece->getMissingUnusedBlockIndex(index));

test/DefaultBtMessageFactoryTest.cc

@@ -24,22 +24,22 @@ class DefaultBtMessageFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST(testCreatePortMessage);
   CPPUNIT_TEST_SUITE_END();
 private:
-  std::shared_ptr<DownloadContext> dctx_;
+  std::unique_ptr<DownloadContext> dctx_;
   std::shared_ptr<Peer> peer_;
   std::shared_ptr<MockExtensionMessageFactory> exmsgFactory_;
-  std::shared_ptr<DefaultBtMessageFactory> factory_;
+  std::unique_ptr<DefaultBtMessageFactory> factory_;
 public:
   void setUp()
   {
-    dctx_.reset(new DownloadContext());
+    dctx_ = make_unique<DownloadContext>();
 
-    peer_.reset(new Peer("192.168.0.1", 6969));
+    peer_ = std::make_shared<Peer>("192.168.0.1", 6969);
     peer_->allocateSessionResource(1024, 1024*1024);
     peer_->setExtendedMessagingEnabled(true);
 
-    exmsgFactory_.reset(new MockExtensionMessageFactory());
+    exmsgFactory_ = std::make_shared<MockExtensionMessageFactory>();
 
-    factory_.reset(new DefaultBtMessageFactory());
+    factory_ = make_unique<DefaultBtMessageFactory>();
     factory_->setDownloadContext(dctx_.get());
     factory_->setPeer(peer_);
     factory_->setExtensionMessageFactory(exmsgFactory_);
@@ -62,9 +62,9 @@ void DefaultBtMessageFactoryTest::testCreateBtMessage_BtExtendedMessage()
   msg[5] = 1; // Set dummy extended message ID 1
   memcpy(msg+6, payload.c_str(), payload.size());
 
-  auto m = std::dynamic_pointer_cast<BtExtendedMessage>
-    (factory_->createBtMessage((const unsigned char*)msg+4, sizeof(msg)));
-
+  auto m =
+    factory_->createBtMessage((const unsigned char*)msg+4, sizeof(msg));
+  CPPUNIT_ASSERT(BtExtendedMessage::ID == m->getId());
   try {
     // disable extended messaging
     peer_->setExtendedMessagingEnabled(false);
@@ -82,17 +82,16 @@ void DefaultBtMessageFactoryTest::testCreatePortMessage()
     bittorrent::createPeerMessageString(data, sizeof(data), 3, 9);
     bittorrent::setShortIntParam(&data[5], 6881);
     try {
-      auto m = std::dynamic_pointer_cast<BtPortMessage>
-        (factory_->createBtMessage(&data[4], sizeof(data)-4));
-      CPPUNIT_ASSERT(m);
+      auto r = factory_->createBtMessage(&data[4], sizeof(data)-4);
+      CPPUNIT_ASSERT(BtPortMessage::ID == r->getId());
+      auto m = static_cast<const BtPortMessage*>(r.get());
       CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort());
     } catch(Exception& e) {
       CPPUNIT_FAIL(e.stackTrace());
     }
   }
   {
-    auto m = std::dynamic_pointer_cast<BtPortMessage>
-      (factory_->createPortMessage(6881));
+    auto m = factory_->createPortMessage(6881);
     CPPUNIT_ASSERT_EQUAL((uint16_t)6881, m->getPort());
   }
 }

test/DefaultBtRequestFactoryTest.cc

@@ -28,11 +28,10 @@ class DefaultBtRequestFactoryTest:public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE_END();
 private:
   std::shared_ptr<Peer> peer_;
-  std::shared_ptr<DefaultBtRequestFactory> requestFactory_;
-  std::shared_ptr<DownloadContext> dctx_;
-  std::shared_ptr<MockPieceStorage> pieceStorage_;
-  std::shared_ptr<MockBtMessageFactory> messageFactory_;
-  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
+  std::unique_ptr<DefaultBtRequestFactory> requestFactory_;
+  std::unique_ptr<MockPieceStorage> pieceStorage_;
+  std::unique_ptr<MockBtMessageFactory> messageFactory_;
+  std::unique_ptr<MockBtMessageDispatcher> dispatcher_;
 public:
   void testAddTargetPiece();
   void testRemoveCompletedPiece();
@@ -50,53 +49,43 @@ public:
       index(index), blockIndex(blockIndex) {}
   };
 
-  typedef std::shared_ptr<MockBtRequestMessage> MockBtRequestMessageHandle;
-
   class MockBtMessageFactory2 : public MockBtMessageFactory {
   public:
-    virtual std::shared_ptr<BtMessage>
-    createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex) {
-      return std::shared_ptr<BtMessage>
-        (new MockBtRequestMessage(piece->getIndex(), blockIndex));
+    virtual std::unique_ptr<BtRequestMessage>
+    createRequestMessage(const std::shared_ptr<Piece>& piece,
+                         size_t blockIndex) override
+    {
+      return make_unique<BtRequestMessage>(piece->getIndex(), 0, 0,
+                                           blockIndex);
     }
   };
 
   class MockBtMessageDispatcher2 : public MockBtMessageDispatcher {
   public:
-    virtual bool isOutstandingRequest(size_t index, size_t blockIndex) {
+    virtual bool isOutstandingRequest(size_t index, size_t blockIndex) override
+    {
       return index == 0 && blockIndex == 0;
     }
   };
 
-  class SortMockBtRequestMessage {
+  class BtRequestMessageSorter {
   public:
-    bool operator()(const std::shared_ptr<MockBtRequestMessage>& a,
-                    const std::shared_ptr<MockBtRequestMessage>& b) {
-      if(a->index < b->index) {
-        return true;
-      } else if(b->index < a->index) {
-        return false;
-      } else if(a->blockIndex < b->blockIndex) {
-        return true;
-      } else if(b->blockIndex < a->blockIndex) {
-        return false;
-      } else {
-        return true;
-      }
+    bool operator()(const std::unique_ptr<BtRequestMessage>& a,
+                    const std::unique_ptr<BtRequestMessage>& b)
+    {
+      return a->getIndex() < b->getIndex() ||
+        (a->getIndex() == b->getIndex() &&
+         a->getBlockIndex() < b->getBlockIndex());
     }
   };
 
   void setUp()
   {
-    pieceStorage_.reset(new MockPieceStorage());
-
-    peer_.reset(new Peer("host", 6969));
-
-    messageFactory_.reset(new MockBtMessageFactory2());
-
-    dispatcher_.reset(new MockBtMessageDispatcher());
-
-    requestFactory_.reset(new DefaultBtRequestFactory());
+    pieceStorage_ = make_unique<MockPieceStorage>();
+    peer_ = std::make_shared<Peer>("host", 6969);
+    messageFactory_ = make_unique<MockBtMessageFactory2>();
+    dispatcher_ = make_unique<MockBtMessageDispatcher>();
+    requestFactory_ = make_unique<DefaultBtRequestFactory>();
     requestFactory_->setPieceStorage(pieceStorage_.get());
     requestFactory_->setPeer(peer_);
     requestFactory_->setBtMessageDispatcher(dispatcher_.get());
@@ -107,14 +96,15 @@ public:
 
 CPPUNIT_TEST_SUITE_REGISTRATION(DefaultBtRequestFactoryTest);
 
-void DefaultBtRequestFactoryTest::testAddTargetPiece() {
+void DefaultBtRequestFactoryTest::testAddTargetPiece()
+{
   {
-    std::shared_ptr<Piece> piece(new Piece(0, 16*1024*10));
+    auto piece = std::make_shared<Piece>(0, 16*1024*10);
     requestFactory_->addTargetPiece(piece);
     CPPUNIT_ASSERT_EQUAL((size_t)1, requestFactory_->countTargetPiece());
   }
   {
-    std::shared_ptr<Piece> piece(new Piece(1, 16*1024*9));
+    auto piece = std::make_shared<Piece>(1, 16*1024*9);
     piece->completeBlock(0);
     requestFactory_->addTargetPiece(piece);
     CPPUNIT_ASSERT_EQUAL((size_t)2, requestFactory_->countTargetPiece());
@@ -122,9 +112,10 @@ void DefaultBtRequestFactoryTest::testAddTargetPiece() {
   CPPUNIT_ASSERT_EQUAL((size_t)18, requestFactory_->countMissingBlock());
 }
 
-void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
-  std::shared_ptr<Piece> piece1(new Piece(0, 16*1024));
-  std::shared_ptr<Piece> piece2(new Piece(1, 16*1024));
+void DefaultBtRequestFactoryTest::testRemoveCompletedPiece()
+{
+  auto piece1 = std::make_shared<Piece>(0, 16*1024);
+  auto piece2 = std::make_shared<Piece>(1, 16*1024);
   piece2->setAllBlock();
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece2);
@@ -135,77 +126,63 @@ void DefaultBtRequestFactoryTest::testRemoveCompletedPiece() {
                        requestFactory_->getTargetPieces().front()->getIndex());
 }
 
-void DefaultBtRequestFactoryTest::testCreateRequestMessages() {
+void DefaultBtRequestFactoryTest::testCreateRequestMessages()
+{
   int PIECE_LENGTH = 16*1024*2;
-  std::shared_ptr<Piece> piece1(new Piece(0, PIECE_LENGTH));
-  std::shared_ptr<Piece> piece2(new Piece(1, PIECE_LENGTH));
+  auto piece1 = std::make_shared<Piece>(0, PIECE_LENGTH);
+  auto piece2 = std::make_shared<Piece>(1, PIECE_LENGTH);
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece2);
 
-  std::vector<std::shared_ptr<BtMessage> > msgs;
-  requestFactory_->createRequestMessages(msgs, 3);
+  auto msgs = requestFactory_->createRequestMessages(3, false);
 
   CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
-  std::vector<std::shared_ptr<BtMessage> >::iterator itr = msgs.begin();
-  auto msg = std::dynamic_pointer_cast<MockBtRequestMessage>(*itr);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
-  ++itr;
-  msg = std::dynamic_pointer_cast<MockBtRequestMessage>(*itr);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
-  ++itr;
-  msg = std::dynamic_pointer_cast<MockBtRequestMessage>(*itr);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
+  auto msg = msgs[0].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getBlockIndex());
+  msg = msgs[1].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getBlockIndex());
+  msg = msgs[2].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getBlockIndex());
 
   {
-    std::vector<std::shared_ptr<BtMessage> > msgs;
-    requestFactory_->createRequestMessages(msgs, 3);
+    auto msgs = requestFactory_->createRequestMessages(3, false);
     CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
   }
 }
 
-void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame() {
-  std::shared_ptr<MockBtMessageDispatcher2> dispatcher
-    (new MockBtMessageDispatcher2());
+void DefaultBtRequestFactoryTest::testCreateRequestMessages_onEndGame()
+{
+  auto dispatcher = make_unique<MockBtMessageDispatcher2>();
 
   requestFactory_->setBtMessageDispatcher(dispatcher.get());
 
   int PIECE_LENGTH = 16*1024*2;
-  std::shared_ptr<Piece> piece1(new Piece(0, PIECE_LENGTH));
-  std::shared_ptr<Piece> piece2(new Piece(1, PIECE_LENGTH));
+  auto piece1 = std::make_shared<Piece>(0, PIECE_LENGTH);
+  auto piece2 = std::make_shared<Piece>(1, PIECE_LENGTH);
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece2);
 
-  std::vector<std::shared_ptr<BtMessage> > msgs;
-  requestFactory_->createRequestMessagesOnEndGame(msgs, 3);
+  auto msgs = requestFactory_->createRequestMessages(3, true);
+  std::sort(std::begin(msgs), std::end(msgs), BtRequestMessageSorter());
 
-  std::vector<std::shared_ptr<MockBtRequestMessage> > mmsgs;
-  for(std::vector<std::shared_ptr<BtMessage> >::iterator i = msgs.begin();
-      i != msgs.end(); ++i) {
-    mmsgs.push_back(std::dynamic_pointer_cast<MockBtRequestMessage>(*i));
-  }
-
-  std::sort(mmsgs.begin(), mmsgs.end(), SortMockBtRequestMessage());
-
-  CPPUNIT_ASSERT_EQUAL((size_t)3, mmsgs.size());
-  std::vector<std::shared_ptr<MockBtRequestMessage> >::iterator itr =mmsgs.begin();
-  MockBtRequestMessage* msg = (*itr).get();
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
-  ++itr;
-  msg = (*itr).get();
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->blockIndex);
-  ++itr;
-  msg = (*itr).get();
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->index);
-  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->blockIndex);
+  CPPUNIT_ASSERT_EQUAL((size_t)3, msgs.size());
+  auto msg = msgs[0].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getBlockIndex());
+  msg = msgs[1].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msg->getBlockIndex());
+  msg = msgs[2].get();
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getIndex());
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msg->getBlockIndex());
 }
 
-void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {
-  std::shared_ptr<Piece> piece1(new Piece(0, 16*1024));
+void DefaultBtRequestFactoryTest::testRemoveTargetPiece()
+{
+  auto piece1 = std::make_shared<Piece>(0, 16*1024);
 
   requestFactory_->addTargetPiece(piece1);
 
@@ -224,16 +201,15 @@ void DefaultBtRequestFactoryTest::testRemoveTargetPiece() {
 
 void DefaultBtRequestFactoryTest::testGetTargetPieceIndexes()
 {
-  std::shared_ptr<Piece> piece1(new Piece(1, 16*1024));
-  std::shared_ptr<Piece> piece3(new Piece(3, 16*1024));
-  std::shared_ptr<Piece> piece5(new Piece(5, 16*1024));
+  auto piece1 = std::make_shared<Piece>(1, 16*1024);
+  auto piece3 = std::make_shared<Piece>(3, 16*1024);
+  auto piece5 = std::make_shared<Piece>(5, 16*1024);
 
   requestFactory_->addTargetPiece(piece3);
   requestFactory_->addTargetPiece(piece1);
   requestFactory_->addTargetPiece(piece5);
 
-  std::vector<size_t> indexes;
-  requestFactory_->getTargetPieceIndexes(indexes);
+  auto indexes = requestFactory_->getTargetPieceIndexes();
   CPPUNIT_ASSERT_EQUAL((size_t)3, indexes.size());
   CPPUNIT_ASSERT_EQUAL((size_t)3, indexes[0]);
   CPPUNIT_ASSERT_EQUAL((size_t)1, indexes[1]);

test/MockBtMessageDispatcher.h

@@ -12,18 +12,12 @@ namespace aria2 {
 
 class MockBtMessageDispatcher : public BtMessageDispatcher {
 public:
-  std::deque<std::shared_ptr<BtMessage> > messageQueue;
+  std::deque<std::unique_ptr<BtMessage>> messageQueue;
 
   virtual ~MockBtMessageDispatcher() {}
 
-  virtual void addMessageToQueue(const std::shared_ptr<BtMessage>& btMessage) {
-    messageQueue.push_back(btMessage);
-  }
-
-  virtual void addMessageToQueue
-  (const std::vector<std::shared_ptr<BtMessage> >& btMessages)
-  {
-    std::copy(btMessages.begin(), btMessages.end(), back_inserter(messageQueue));
+  virtual void addMessageToQueue(std::unique_ptr<BtMessage> btMessage) {
+    messageQueue.push_back(std::move(btMessage));
   }
 
   virtual void sendMessages() {}

test/MockBtMessageFactory.h

@@ -3,6 +3,24 @@
 
 #include "BtMessageFactory.h"
 
+#include "BtHandshakeMessage.h"
+#include "BtRequestMessage.h"
+#include "BtCancelMessage.h"
+#include "BtPieceMessage.h"
+#include "BtHaveMessage.h"
+#include "BtChokeMessage.h"
+#include "BtUnchokeMessage.h"
+#include "BtInterestedMessage.h"
+#include "BtNotInterestedMessage.h"
+#include "BtBitfieldMessage.h"
+#include "BtKeepAliveMessage.h"
+#include "BtHaveAllMessage.h"
+#include "BtHaveNoneMessage.h"
+#include "BtRejectMessage.h"
+#include "BtAllowedFastMessage.h"
+#include "BtPortMessage.h"
+#include "BtExtendedMessage.h"
+
 namespace aria2 {
 
 class ExtensionMessage;
@@ -13,91 +31,92 @@ public:
 
   virtual ~MockBtMessageFactory() {}
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtMessage>
   createBtMessage(const unsigned char* msg, size_t msgLength) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtMessage>{};
   };
 
-  virtual std::shared_ptr<BtHandshakeMessage>
+  virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* msg, size_t msgLength) {
-    return std::shared_ptr<BtHandshakeMessage>();
+    return std::unique_ptr<BtHandshakeMessage>{};
   }
 
-  virtual std::shared_ptr<BtHandshakeMessage>
+  virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* infoHash,
                          const unsigned char* peerId) {
-    return std::shared_ptr<BtHandshakeMessage>();
+    return std::unique_ptr<BtHandshakeMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtRequestMessage>
   createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtRequestMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtCancelMessage>
   createCancelMessage(size_t index, int32_t begin, int32_t length) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtCancelMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtPieceMessage>
   createPieceMessage(size_t index, int32_t begin, int32_t length) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtPieceMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createHaveMessage(size_t index) {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtHaveMessage> createHaveMessage(size_t index) {
+    return std::unique_ptr<BtHaveMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createChokeMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtChokeMessage> createChokeMessage() {
+    return std::unique_ptr<BtChokeMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createUnchokeMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtUnchokeMessage> createUnchokeMessage() {
+    return std::unique_ptr<BtUnchokeMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createInterestedMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtInterestedMessage> createInterestedMessage() {
+    return std::unique_ptr<BtInterestedMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createNotInterestedMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtNotInterestedMessage> createNotInterestedMessage() {
+    return std::unique_ptr<BtNotInterestedMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createBitfieldMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtBitfieldMessage> createBitfieldMessage() {
+    return std::unique_ptr<BtBitfieldMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createKeepAliveMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtKeepAliveMessage> createKeepAliveMessage() {
+    return std::unique_ptr<BtKeepAliveMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createHaveAllMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtHaveAllMessage> createHaveAllMessage() {
+    return std::unique_ptr<BtHaveAllMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createHaveNoneMessage() {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtHaveNoneMessage> createHaveNoneMessage() {
+    return std::unique_ptr<BtHaveNoneMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtRejectMessage>
   createRejectMessage(size_t index, int32_t begin, int32_t length) {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtRejectMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createAllowedFastMessage(size_t index) {
-    return std::shared_ptr<BtMessage>();
+  virtual std::unique_ptr<BtAllowedFastMessage> createAllowedFastMessage
+  (size_t index) {
+    return std::unique_ptr<BtAllowedFastMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage> createPortMessage(uint16_t port)
+  virtual std::unique_ptr<BtPortMessage> createPortMessage(uint16_t port)
   {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtPortMessage>{};
   }
 
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtExtendedMessage>
   createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& extmsg)
   {
-    return std::shared_ptr<BtMessage>();
+    return std::unique_ptr<BtExtendedMessage>{};
   }
 };
 

test/MockBtRequestFactory.h

@@ -2,6 +2,7 @@
 #define D_MOCK_BT_REQUEST_FACTORY_H
 
 #include "BtRequestFactory.h"
+#include "BtRequestMessage.h"
 
 namespace aria2 {
 
@@ -23,13 +24,16 @@ public:
 
   virtual void doChokedAction() {}
 
-  virtual void createRequestMessages
-  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) {}
+  virtual std::vector<std::unique_ptr<BtRequestMessage>> createRequestMessages
+  (size_t max, bool endGame)
+  {
+    return std::vector<std::unique_ptr<BtRequestMessage>>{};
+  }
 
-  virtual void createRequestMessagesOnEndGame
-  (std::vector<std::shared_ptr<BtMessage> >& requests, size_t max) {}
-
-  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const {}
+  virtual std::vector<size_t> getTargetPieceIndexes() const
+  {
+    return std::vector<size_t>{};
+  }
 };
 
 } // namespace aria2

test/MockExtensionMessage.h

@@ -15,27 +15,28 @@ public:
   MockExtensionMessage(const std::string& extensionName,
                        uint8_t extensionMessageID,
                        const unsigned char* data,
-                       size_t length):extensionName_(extensionName),
-                                      extensionMessageID_(extensionMessageID),
-                                      data_(&data[0], &data[length]),
-                                      doReceivedActionCalled_(false) {}
+                       size_t length)
+    : extensionName_{extensionName},
+      extensionMessageID_{extensionMessageID},
+      data_{&data[0], &data[length]},
+      doReceivedActionCalled_{false}
+  {}
 
   MockExtensionMessage(const std::string& extensionName,
                        uint8_t extensionMessageID,
-                       const std::string& data):
-    extensionName_(extensionName),
-    extensionMessageID_(extensionMessageID),
-    data_(data),
-    doReceivedActionCalled_(false) {}
-
-  virtual ~MockExtensionMessage() {}
+                       const std::string& data)
+    : extensionName_{extensionName},
+      extensionMessageID_{extensionMessageID},
+      data_{data},
+      doReceivedActionCalled_{false}
+  {}
 
   virtual std::string getPayload()
   {
     return data_;
   }
 
-  virtual uint8_t getExtensionMessageID()
+  virtual uint8_t getExtensionMessageID() const
   {
     return extensionMessageID_;
   }

test/UTMetadataRequestExtensionMessageTest.cc

@@ -32,28 +32,29 @@ class UTMetadataRequestExtensionMessageTest:public CppUnit::TestFixture {
   CPPUNIT_TEST_SUITE_END();
 public:
   std::shared_ptr<DownloadContext> dctx_;
-  std::shared_ptr<WrapExtBtMessageFactory> messageFactory_;
-  std::shared_ptr<MockBtMessageDispatcher> dispatcher_;
+  std::unique_ptr<WrapExtBtMessageFactory> messageFactory_;
+  std::unique_ptr<MockBtMessageDispatcher> dispatcher_;
   std::shared_ptr<Peer> peer_;
 
   void setUp()
   {
-    messageFactory_.reset(new WrapExtBtMessageFactory());
-    dispatcher_.reset(new MockBtMessageDispatcher());
-    dctx_.reset(new DownloadContext());
+    messageFactory_ = make_unique<WrapExtBtMessageFactory>();
+    dispatcher_ = make_unique<MockBtMessageDispatcher>();
+    dctx_ = std::make_shared<DownloadContext>();
     dctx_->setAttribute(CTX_ATTR_BT, make_unique<TorrentAttribute>());
-    peer_.reset(new Peer("host", 6880));
+    peer_ = std::make_shared<Peer>("host", 6880);
     peer_->allocateSessionResource(0, 0);
     peer_->setExtension(ExtensionMessageRegistry::UT_METADATA, 1);
   }
 
   template<typename T>
-  std::shared_ptr<T> getFirstDispatchedMessage()
+  const T* getFirstDispatchedMessage()
   {
-    auto wrapmsg = std::dynamic_pointer_cast<WrapExtBtMessage>
-      (dispatcher_->messageQueue.front());
-
-    return std::dynamic_pointer_cast<T>(wrapmsg->m_);
+    CPPUNIT_ASSERT(BtExtendedMessage::ID ==
+                   dispatcher_->messageQueue.front()->getId());
+    auto msg = static_cast<const BtExtendedMessage*>
+      (dispatcher_->messageQueue.front().get());
+    return dynamic_cast<const T*>(msg->getExtensionMessage().get());
   }
 
   void testGetExtensionMessageID();
@@ -106,8 +107,7 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_reject()
   msg.setBtMessageDispatcher(dispatcher_.get());
   msg.doReceivedAction();
 
-  std::shared_ptr<UTMetadataRejectExtensionMessage> m =
-    getFirstDispatchedMessage<UTMetadataRejectExtensionMessage>();
+  auto m = getFirstDispatchedMessage<UTMetadataRejectExtensionMessage>();
 
   CPPUNIT_ASSERT(m);
   CPPUNIT_ASSERT_EQUAL((size_t)10, m->getIndex());
@@ -132,8 +132,7 @@ void UTMetadataRequestExtensionMessageTest::testDoReceivedAction_data()
 
   msg.doReceivedAction();
 
-  std::shared_ptr<UTMetadataDataExtensionMessage> m =
-    getFirstDispatchedMessage<UTMetadataDataExtensionMessage>();
+  auto m = getFirstDispatchedMessage<UTMetadataDataExtensionMessage>();
 
   CPPUNIT_ASSERT(m);
   CPPUNIT_ASSERT_EQUAL((size_t)1, m->getIndex());

test/UTMetadataRequestFactoryTest.cc

@@ -66,16 +66,14 @@ void UTMetadataRequestFactoryTest::testCreate()
     (new UTMetadataRequestTracker());
   factory.setUTMetadataRequestTracker(tracker.get());
 
-  std::vector<std::shared_ptr<BtMessage> > msgs;
-
-  factory.create(msgs, 1, ps);
+  auto msgs = factory.create(1, ps);
   CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
 
-  factory.create(msgs, 1, ps);
-  CPPUNIT_ASSERT_EQUAL((size_t)2, msgs.size());
+  msgs = factory.create(1, ps);
+  CPPUNIT_ASSERT_EQUAL((size_t)1, msgs.size());
 
-  factory.create(msgs, 1, ps);
-  CPPUNIT_ASSERT_EQUAL((size_t)2, msgs.size());
+  msgs = factory.create(1, ps);
+  CPPUNIT_ASSERT_EQUAL((size_t)0, msgs.size());
 }
 
 } // namespace aria2

test/extension_message_test_helper.h

@@ -1,19 +1,17 @@
 #ifndef D_EXTENSION_MESSAGE_TEST_HELPER_H
 #define D_EXTENSION_MESSAGE_TEST_HELPER_H
 
-#include "MockBtMessage.h"
 #include "MockBtMessageFactory.h"
 
 namespace aria2 {
 
-typedef WrapBtMessage<ExtensionMessage> WrapExtBtMessage;
-
 class WrapExtBtMessageFactory:public MockBtMessageFactory {
 public:
-  virtual std::shared_ptr<BtMessage>
+  virtual std::unique_ptr<BtExtendedMessage>
   createBtExtendedMessage(const std::shared_ptr<ExtensionMessage>& extmsg)
+    override
   {
-    return std::shared_ptr<BtMessage>(new WrapExtBtMessage(extmsg));
+    return make_unique<BtExtendedMessage>(extmsg);
   }
 };