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