From 098f1571be6f9d30d394eb83d35cc67f8e9ebcb0 Mon Sep 17 00:00:00 2001 From: Tatsuhiro Tsujikawa Date: Sun, 30 Jun 2013 16:55:15 +0900 Subject: [PATCH] Wrap BtMessage objects by std::unique_ptr instead of std::shared_ptr --- src/BtAllowedFastMessage.cc | 2 +- src/BtAllowedFastMessage.h | 2 +- src/BtBitfieldMessage.cc | 4 +- src/BtBitfieldMessage.h | 2 +- src/BtCancelMessage.cc | 2 +- src/BtCancelMessage.h | 3 +- src/BtChokeMessage.cc | 4 +- src/BtChokeMessage.h | 3 +- src/BtExtendedMessage.cc | 5 +- src/BtExtendedMessage.h | 2 +- src/BtHandshakeMessage.cc | 4 +- src/BtHandshakeMessage.h | 2 +- src/BtHaveAllMessage.cc | 2 +- src/BtHaveAllMessage.h | 2 +- src/BtHaveMessage.cc | 2 +- src/BtHaveMessage.h | 3 +- src/BtHaveNoneMessage.cc | 2 +- src/BtHaveNoneMessage.h | 2 +- src/BtInterestedMessage.cc | 2 +- src/BtInterestedMessage.h | 2 +- src/BtMessageDispatcher.h | 5 +- src/BtMessageFactory.h | 61 ++-- src/BtNotInterestedMessage.cc | 2 +- src/BtNotInterestedMessage.h | 2 +- src/BtPieceMessage.cc | 25 +- src/BtPieceMessage.h | 3 +- src/BtPortMessage.cc | 5 +- src/BtPortMessage.h | 3 +- src/BtRejectMessage.cc | 2 +- src/BtRejectMessage.h | 3 +- src/BtRequestFactory.h | 24 +- src/BtRequestMessage.cc | 18 +- src/BtRequestMessage.h | 2 +- src/BtSuggestPieceMessage.cc | 6 +- src/BtSuggestPieceMessage.h | 4 +- src/BtUnchokeMessage.cc | 2 +- src/BtUnchokeMessage.h | 2 +- src/DefaultBtInteractive.cc | 63 ++-- src/DefaultBtMessageDispatcher.cc | 72 ++-- src/DefaultBtMessageDispatcher.h | 9 +- src/DefaultBtMessageFactory.cc | 325 +++++++++--------- src/DefaultBtMessageFactory.h | 44 +-- src/DefaultBtMessageReceiver.cc | 8 +- src/DefaultBtRequestFactory.cc | 62 ++-- src/DefaultBtRequestFactory.h | 12 +- src/ExtensionMessage.h | 2 +- src/HandshakeExtensionMessage.h | 2 +- src/IndexBtMessage.h | 7 +- src/RangeBtMessage.h | 11 +- src/UTMetadataExtensionMessage.h | 2 +- src/UTMetadataRequestExtensionMessage.cc | 9 +- src/UTMetadataRequestFactory.cc | 22 +- src/UTMetadataRequestFactory.h | 8 +- src/UTPexExtensionMessage.h | 2 +- src/ZeroBtMessage.cc | 4 + src/ZeroBtMessage.h | 9 +- test/BtCancelMessageTest.cc | 7 +- test/BtChokeMessageTest.cc | 26 +- test/BtPieceMessageTest.cc | 54 ++- test/BtRequestMessageTest.cc | 103 +++--- test/BtSuggestPieceMessageTest.cc | 5 +- test/DefaultBtMessageDispatcherTest.cc | 189 +++++----- test/DefaultBtMessageFactoryTest.cc | 27 +- test/DefaultBtRequestFactoryTest.cc | 166 ++++----- test/MockBtMessageDispatcher.h | 12 +- test/MockBtMessageFactory.h | 95 +++-- test/MockBtRequestFactory.h | 16 +- test/MockExtensionMessage.h | 25 +- test/UTMetadataRequestExtensionMessageTest.cc | 29 +- test/UTMetadataRequestFactoryTest.cc | 12 +- test/extension_message_test_helper.h | 8 +- 71 files changed, 816 insertions(+), 852 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::create (const unsigned char* data, size_t dataLength) { return IndexBtMessage::create(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 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::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(); 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 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::create (const unsigned char* data, size_t dataLength) { return RangeBtMessage::create(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 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::create (const unsigned char* data, size_t dataLength) { return ZeroBtMessage::create(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 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::create(const std::shared_ptr& factory, const std::shared_ptr& peer, const unsigned char* data, size_t dataLength) @@ -106,8 +106,7 @@ BtExtendedMessage::create(const std::shared_ptr& factor assert(factory); std::shared_ptr extmsg = factory->createMessage(data+1, dataLength-1); - BtExtendedMessage* message(new BtExtendedMessage(extmsg)); - return message; + return make_unique(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 create (const std::shared_ptr& factory, const std::shared_ptr& 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 +std::unique_ptr BtHandshakeMessage::create(const unsigned char* data, size_t dataLength) { - std::shared_ptr message(new BtHandshakeMessage()); + auto message = make_unique(); 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 + static std::unique_ptr 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::create (const unsigned char* data, size_t dataLength) { return ZeroBtMessage::create(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 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::create (const unsigned char* data, size_t dataLength) { return IndexBtMessage::create(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 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::create (const unsigned char* data, size_t dataLength) { return ZeroBtMessage::create(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 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::create (const unsigned char* data, size_t dataLength) { return ZeroBtMessage::create(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 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) = 0; - - virtual void - addMessageToQueue(const std::vector >& btMessages) =0; + virtual void addMessageToQueue(std::unique_ptr 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 + virtual std::unique_ptr createBtMessage(const unsigned char* msg, size_t msgLength) = 0; - virtual std::shared_ptr + virtual std::unique_ptr createHandshakeMessage(const unsigned char* msg, size_t msgLength) = 0; - virtual std::shared_ptr + virtual std::unique_ptr createHandshakeMessage(const unsigned char* infoHash, const unsigned char* peerId) = 0; - virtual std::shared_ptr - createRequestMessage(const std::shared_ptr& piece, size_t blockIndex) = 0; + virtual std::unique_ptr + createRequestMessage(const std::shared_ptr& piece, + size_t blockIndex) = 0; - virtual std::shared_ptr + virtual std::unique_ptr createCancelMessage(size_t index, int32_t begin, int32_t length) = 0; - virtual std::shared_ptr + virtual std::unique_ptr createPieceMessage(size_t index, int32_t begin, int32_t length) = 0; - virtual std::shared_ptr createHaveMessage(size_t index) = 0; + virtual std::unique_ptr createHaveMessage(size_t index) = 0; - virtual std::shared_ptr createChokeMessage() = 0; + virtual std::unique_ptr createChokeMessage() = 0; - virtual std::shared_ptr createUnchokeMessage() = 0; + virtual std::unique_ptr createUnchokeMessage() = 0; - virtual std::shared_ptr createInterestedMessage() = 0; + virtual std::unique_ptr createInterestedMessage() = 0; - virtual std::shared_ptr createNotInterestedMessage() = 0; + virtual std::unique_ptr + createNotInterestedMessage() = 0; - virtual std::shared_ptr createBitfieldMessage() = 0; + virtual std::unique_ptr createBitfieldMessage() = 0; - virtual std::shared_ptr createKeepAliveMessage() = 0; + virtual std::unique_ptr createKeepAliveMessage() = 0; - virtual std::shared_ptr createHaveAllMessage() = 0; + virtual std::unique_ptr createHaveAllMessage() = 0; - virtual std::shared_ptr createHaveNoneMessage() = 0; + virtual std::unique_ptr createHaveNoneMessage() = 0; - virtual std::shared_ptr + virtual std::unique_ptr createRejectMessage(size_t index, int32_t begin, int32_t length) = 0; - virtual std::shared_ptr createAllowedFastMessage(size_t index) = 0; + virtual std::unique_ptr + createAllowedFastMessage(size_t index) = 0; - virtual std::shared_ptr createPortMessage(uint16_t port) = 0; + virtual std::unique_ptr createPortMessage(uint16_t port) = 0; - virtual std::shared_ptr + virtual std::unique_ptr createBtExtendedMessage(const std::shared_ptr& 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::create (const unsigned char* data, size_t dataLength) { return ZeroBtMessage::create(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 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::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(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 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 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 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::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(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 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::create (const unsigned char* data, size_t dataLength) { return RangeBtMessage::create(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 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 >& requests, size_t max) = 0; + virtual std::vector> 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 >& requests, size_t max) = 0; - - /** - * Stores the list of index of pieces added using addTargetPiece() into - * indexes. - */ - virtual void getTargetPieceIndexes(std::vector& indexes) const = 0; + virtual std::vector 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::create (const unsigned char* data, size_t dataLength) { return RangeBtMessage::create(data, dataLength); @@ -63,16 +65,14 @@ void BtRequestMessage::doReceivedAction() (!getPeer()->amChoking() || (getPeer()->amChoking() && getPeer()->isInAmAllowedIndexSet(getIndex())))) { - std::shared_ptr msg = - getBtMessageFactory()->createPieceMessage - (getIndex(), getBegin(), getLength()); - getBtMessageDispatcher()->addMessageToQueue(msg); + getBtMessageDispatcher()->addMessageToQueue + (getBtMessageFactory()->createPieceMessage + (getIndex(), getBegin(), getLength())); } else { if(getPeer()->isFastExtensionEnabled()) { - std::shared_ptr 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 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::create (const unsigned char* data, size_t dataLength) { return IndexBtMessage::create(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 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::create (const unsigned char* data, size_t dataLength) { return ZeroBtMessage::create(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 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 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 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 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 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 > 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 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 > 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) +(std::unique_ptr btMessage) { btMessage->onQueued(); - messageQueue_.push_back(btMessage); -} - -void DefaultBtMessageDispatcher::addMessageToQueue -(const std::vector >& btMessages) -{ - for(std::vector >::const_iterator itr = - btMessages.begin(), eoi = btMessages.end(); itr != eoi; ++itr) { - addMessageToQueue(*itr); - } + messageQueue_.push_back(std::move(btMessage)); } void DefaultBtMessageDispatcher::sendMessagesInternal() { - std::vector > tempQueue; + auto tempQueue = std::vector>{}; while(!messageQueue_.empty()) { - std::shared_ptr 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 toRawPointers +(const std::deque>& v) +{ + auto x = std::vector{}; + 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 > 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 > 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 > 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 > messageQueue_; + std::deque > messageQueue_; std::deque> requestSlots_; DownloadContext* downloadContext_; PeerStorage* peerStorage_; @@ -72,10 +72,7 @@ public: virtual ~DefaultBtMessageDispatcher(); - virtual void addMessageToQueue(const std::shared_ptr& btMessage); - - virtual void addMessageToQueue - (const std::vector >& btMessages); + virtual void addMessageToQueue(std::unique_ptr btMessage); virtual void sendMessages(); @@ -117,7 +114,7 @@ public: virtual size_t countOutstandingUpload(); - const std::deque >& getMessageQueue() const + const std::deque>& 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 +std::unique_ptr DefaultBtMessageFactory::createBtMessage (const unsigned char* data, size_t dataLength) { - std::shared_ptr msg; + auto msg = std::unique_ptr{}; if(dataLength == 0) { // keep-alive - msg.reset(new BtKeepAliveMessage()); + msg = make_unique(); } 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 (static_cast(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 (static_cast(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 - (m, + (static_cast(m.get()), downloadContext_->getNumPieces(), pieceStorage_->getPieceLength(m->getIndex()))); } - msg.reset(m); - break; - } - case BtCancelMessage::ID: { - BtCancelMessage* m = BtCancelMessage::create(data, dataLength); - if(!metadataGetMode_) { - m->setBtMessageValidator - (make_unique - (m, - downloadContext_->getNumPieces(), - pieceStorage_->getPieceLength(m->getIndex()))); - } - msg.reset(m); + msg = std::move(m); break; } case BtPieceMessage::ID: { - BtPieceMessage* m = BtPieceMessage::create(data, dataLength); + auto m = BtPieceMessage::create(data, dataLength); if(!metadataGetMode_) { m->setBtMessageValidator (make_unique - (m, + (static_cast(m.get()), downloadContext_->getNumPieces(), pieceStorage_->getPieceLength(m->getIndex()))); } m->setDownloadContext(downloadContext_); m->setPeerStorage(peerStorage_); - msg.reset(m); + msg = std::move(m); break; } - case BtHaveAllMessage::ID: - msg.reset(BtHaveAllMessage::create(data, dataLength)); - break; - case BtHaveNoneMessage::ID: - msg.reset(BtHaveNoneMessage::create(data, dataLength)); - break; - case BtRejectMessage::ID: { - BtRejectMessage* m = BtRejectMessage::create(data, dataLength); + case BtCancelMessage::ID: { + auto m = BtCancelMessage::create(data, dataLength); if(!metadataGetMode_) { m->setBtMessageValidator (make_unique - (m, + (static_cast(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 - (m, downloadContext_->getNumPieces())); - } - msg.reset(m); - break; - } - case BtAllowedFastMessage::ID: { - BtAllowedFastMessage* m = BtAllowedFastMessage::create(data, dataLength); - if(!metadataGetMode_) { - std::shared_ptr validator - (new IndexBtMessageValidator(m, downloadContext_->getNumPieces())); - m->setBtMessageValidator(make_unique - (m, downloadContext_->getNumPieces())); - } - msg.reset(m); + msg = std::move(m); break; } case BtPortMessage::ID: { - BtPortMessage* m = BtPortMessage::create(data, dataLength); + auto m = BtPortMessage::create(data, dataLength); m->setLocalNode(localNode_); m->setRoutingTable(routingTable_); m->setTaskQueue(taskQueue_); m->setTaskFactory(taskFactory_); - msg.reset(m); + msg = std::move(m); + break; + } + case BtSuggestPieceMessage::ID: { + auto m = BtSuggestPieceMessage::create(data, dataLength); + if(!metadataGetMode_) { + m->setBtMessageValidator(make_unique + (static_cast(m.get()), + downloadContext_->getNumPieces())); + } + msg = std::move(m); + break; + } + case BtHaveAllMessage::ID: + msg = BtHaveAllMessage::create(data, dataLength); + break; + case BtHaveNoneMessage::ID: + msg = BtHaveNoneMessage::create(data, dataLength); + break; + case BtRejectMessage::ID: { + auto m = BtRejectMessage::create(data, dataLength); + if(!metadataGetMode_) { + m->setBtMessageValidator + (make_unique + (static_cast(m.get()), + downloadContext_->getNumPieces(), + pieceStorage_->getPieceLength(m->getIndex()))); + } + msg = std::move(m); + break; + } + case BtAllowedFastMessage::ID: { + auto m = BtAllowedFastMessage::create(data, dataLength); + if(!metadataGetMode_) { + m->setBtMessageValidator(make_unique + (static_cast(m.get()), + downloadContext_->getNumPieces())); + } + msg = std::move(m); break; } case BtExtendedMessage::ID: { if(peer_->isExtendedMessagingEnabled()) { - msg.reset(BtExtendedMessage::create(extensionMessageFactory_, - peer_, data, dataLength)); + msg = BtExtendedMessage::create(extensionMessageFactory_, + peer_, data, dataLength); } else { throw DL_ABORT_EX("Received extended message from peer during" " a session with extended messaging disabled."); @@ -237,7 +231,7 @@ DefaultBtMessageFactory::createBtMessage } } setCommonProperty(msg.get()); - return msg; + return std::move(msg); } void DefaultBtMessageFactory::setCommonProperty(AbstractBtMessage* msg) @@ -254,12 +248,11 @@ void DefaultBtMessageFactory::setCommonProperty(AbstractBtMessage* msg) } } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createHandshakeMessage (const unsigned char* data, size_t dataLength) { - std::shared_ptr msg = - BtHandshakeMessage::create(data, dataLength); + auto msg = BtHandshakeMessage::create(data, dataLength); msg->setBtMessageValidator(make_unique (msg.get(), bittorrent::getInfoHash(downloadContext_))); @@ -267,155 +260,153 @@ DefaultBtMessageFactory::createHandshakeMessage return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash, const unsigned char* peerId) { - std::shared_ptr msg - (new BtHandshakeMessage(infoHash, peerId)); + auto msg = make_unique(infoHash, peerId); msg->setDHTEnabled(dhtEnabled_); setCommonProperty(msg.get()); return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createRequestMessage (const std::shared_ptr& piece, size_t blockIndex) { - BtRequestMessage* msg - (new BtRequestMessage(piece->getIndex(), - blockIndex*piece->getBlockLength(), - piece->getBlockLength(blockIndex), - blockIndex)); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(piece->getIndex(), + blockIndex*piece->getBlockLength(), + piece->getBlockLength(blockIndex), + blockIndex); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createCancelMessage (size_t index, int32_t begin, int32_t length) { - BtCancelMessage* msg(new BtCancelMessage(index, begin, length)); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(index, begin, length); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createPieceMessage (size_t index, int32_t begin, int32_t length) { - BtPieceMessage* msg(new BtPieceMessage(index, begin, length)); + auto msg = make_unique(index, begin, length); msg->setDownloadContext(downloadContext_); - setCommonProperty(msg); - return std::shared_ptr(msg); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createHaveMessage(size_t index) { - BtHaveMessage* msg(new BtHaveMessage(index)); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(index); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createChokeMessage() { - BtChokeMessage* msg(new BtChokeMessage()); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createUnchokeMessage() { - BtUnchokeMessage* msg(new BtUnchokeMessage()); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createInterestedMessage() { - BtInterestedMessage* msg(new BtInterestedMessage()); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createNotInterestedMessage() { - BtNotInterestedMessage* msg(new BtNotInterestedMessage()); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createBitfieldMessage() { - BtBitfieldMessage* msg - (new BtBitfieldMessage(pieceStorage_->getBitfield(), - pieceStorage_->getBitfieldLength())); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique + (pieceStorage_->getBitfield(), + pieceStorage_->getBitfieldLength()); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createKeepAliveMessage() { - BtKeepAliveMessage* msg(new BtKeepAliveMessage()); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createHaveAllMessage() { - BtHaveAllMessage* msg(new BtHaveAllMessage()); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createHaveNoneMessage() { - BtHaveNoneMessage* msg(new BtHaveNoneMessage()); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createRejectMessage (size_t index, int32_t begin, int32_t length) { - BtRejectMessage* msg(new BtRejectMessage(index, begin, length)); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(index, begin, length); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createAllowedFastMessage(size_t index) { - BtAllowedFastMessage* msg(new BtAllowedFastMessage(index)); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(index); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createPortMessage(uint16_t port) { - BtPortMessage* msg(new BtPortMessage(port)); - setCommonProperty(msg); - return std::shared_ptr(msg); + auto msg = make_unique(port); + setCommonProperty(msg.get()); + return msg; } -std::shared_ptr +std::unique_ptr DefaultBtMessageFactory::createBtExtendedMessage -(const std::shared_ptr& msg) +(const std::shared_ptr& exmsg) { - BtExtendedMessage* m(new BtExtendedMessage(msg)); - setCommonProperty(m); - return std::shared_ptr(m); + auto msg = make_unique(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 + virtual std::unique_ptr createBtMessage(const unsigned char* msg, size_t msgLength); - virtual std::shared_ptr + virtual std::unique_ptr createHandshakeMessage(const unsigned char* msg, size_t msgLength); - virtual std::shared_ptr + virtual std::unique_ptr createHandshakeMessage(const unsigned char* infoHash, const unsigned char* peerId); - virtual std::shared_ptr - createRequestMessage(const std::shared_ptr& piece, size_t blockIndex); + virtual std::unique_ptr + createRequestMessage(const std::shared_ptr& piece, + size_t blockIndex); - virtual std::shared_ptr + virtual std::unique_ptr createCancelMessage(size_t index, int32_t begin, int32_t length); - virtual std::shared_ptr + virtual std::unique_ptr createPieceMessage(size_t index, int32_t begin, int32_t length); - virtual std::shared_ptr createHaveMessage(size_t index); + virtual std::unique_ptr createHaveMessage(size_t index); - virtual std::shared_ptr createChokeMessage(); + virtual std::unique_ptr createChokeMessage(); - virtual std::shared_ptr createUnchokeMessage(); + virtual std::unique_ptr createUnchokeMessage(); - virtual std::shared_ptr createInterestedMessage(); + virtual std::unique_ptr createInterestedMessage(); - virtual std::shared_ptr createNotInterestedMessage(); + virtual std::unique_ptr createNotInterestedMessage(); - virtual std::shared_ptr createBitfieldMessage(); + virtual std::unique_ptr createBitfieldMessage(); - virtual std::shared_ptr createKeepAliveMessage(); + virtual std::unique_ptr createKeepAliveMessage(); - virtual std::shared_ptr createHaveAllMessage(); + virtual std::unique_ptr createHaveAllMessage(); - virtual std::shared_ptr createHaveNoneMessage(); + virtual std::unique_ptr createHaveNoneMessage(); - virtual std::shared_ptr + virtual std::unique_ptr createRejectMessage(size_t index, int32_t begin, int32_t length); - virtual std::shared_ptr createAllowedFastMessage(size_t index); + virtual std::unique_ptr createAllowedFastMessage + (size_t index); - virtual std::shared_ptr createPortMessage(uint16_t port); + virtual std::unique_ptr createPortMessage(uint16_t port); - virtual std::shared_ptr + virtual std::unique_ptr createBtExtendedMessage(const std::shared_ptr& msg); void setPeer(const std::shared_ptr& 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 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 >& requests, size_t max) +std::vector> +DefaultBtRequestFactory::createRequestMessages(size_t max, bool endGame) { - if(requests.size() >= max) { - return; + if(endGame) { + return createRequestMessagesOnEndGame(max); } + auto requests = std::vector>{}; size_t getnum = max-requests.size(); - std::vector blockIndexes; + auto blockIndexes = std::vector{}; blockIndexes.reserve(getnum); - for(std::deque >::iterator itr = pieces_.begin(), - eoi = pieces_.end(); itr != eoi && getnum; ++itr) { - std::shared_ptr& 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::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(piece->getIndex()), static_cast((*i)*piece->getBlockLength()), static_cast(*i))); - requests.push_back - (messageFactory_->createRequestMessage(piece, *i)); + requests.push_back(messageFactory_->createRequestMessage(piece, *i)); } blockIndexes.clear(); } } + return requests; } -void DefaultBtRequestFactory::createRequestMessagesOnEndGame -(std::vector >& requests, size_t max) +std::vector> +DefaultBtRequestFactory::createRequestMessagesOnEndGame(size_t max) { - for(std::deque >::iterator itr = pieces_.begin(), - eoi = pieces_.end(); itr != eoi && requests.size() < max; ++itr) { - std::shared_ptr& piece = *itr; + auto requests = std::vector>{}; + 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 misbitfield(new unsigned char[mislen]); piece->getAllMissingBlockIndexes(misbitfield, mislen); - std::vector missingBlockIndexes; + auto missingBlockIndexes = std::vector{}; 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::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& indexes) const +std::vector +DefaultBtRequestFactory::getTargetPieceIndexes() const { - std::transform(pieces_.begin(), pieces_.end(), std::back_inserter(indexes), - std::mem_fn(&Piece::getIndex)); + auto res = std::vector{}; + 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> createRequestMessagesOnEndGame + (size_t max); + PieceStorage* pieceStorage_; std::shared_ptr peer_; BtMessageDispatcher* dispatcher_; @@ -78,13 +81,10 @@ public: virtual void doChokedAction(); - virtual void createRequestMessages - (std::vector >& requests, size_t max); + virtual std::vector> createRequestMessages + (size_t max, bool endGame); - virtual void createRequestMessagesOnEndGame - (std::vector >& requests, size_t max); - - virtual void getTargetPieceIndexes(std::vector& indexes) const; + virtual std::vector getTargetPieceIndexes() const; std::deque >& 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 - static T* create(const unsigned char* data, size_t dataLength) + static std::unique_ptr 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(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 - static T* create(const unsigned char* data, size_t dataLength) + static std::unique_ptr 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(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 m (new UTMetadataRejectExtensionMessage(id)); m->setIndex(getIndex()); - std::shared_ptr msg = messageFactory_->createBtExtendedMessage(m); - dispatcher_->addMessageToQueue(msg); + dispatcher_->addMessageToQueue + (messageFactory_->createBtExtendedMessage(m)); }else if(getIndex()*METADATA_PIECE_SIZE < attrs->metadataSize) { std::shared_ptr 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 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 >& msgs, size_t num, - const std::shared_ptr& pieceStorage) +std::vector> UTMetadataRequestFactory::create +(size_t num, const std::shared_ptr& pieceStorage) { + auto msgs = std::vector>{}; while(num) { - std::vector metadataRequests = tracker_->getAllTrackedIndex(); - std::shared_ptr 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 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 >& msgs, size_t num, - const std::shared_ptr& pieceStorage); + // Creates and returns at most num of ut_metadata request + // message. pieceStorage is used to identify missing piece. + std::vector> create + (size_t num, const std::shared_ptr& pieceStorage); void setDownloadContext(const std::shared_ptr& 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 - static T* create(const unsigned char* data, size_t dataLength) + static std::unique_ptr 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(); } 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 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 dispatcher - (new MockBtMessageDispatcher2()); + auto dispatcher = make_unique(); 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 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 dispatcher(new MockBtMessageDispatcher2()); + auto dispatcher = make_unique(); msg.setBtMessageDispatcher(dispatcher.get()); - std::shared_ptr requestFactory(new MockBtRequestFactory2()); + auto requestFactory = make_unique(); msg.setBtRequestFactory(requestFactory.get()); msg.doReceivedAction(); @@ -121,10 +127,10 @@ void BtChokeMessageTest::testOnSendComplete() { BtChokeMessage msg; msg.setPeer(peer); - std::shared_ptr dispatcher(new MockBtMessageDispatcher2()); + auto dispatcher = make_unique(); msg.setBtMessageDispatcher(dispatcher.get()); - std::shared_ptr pu(msg.getProgressUpdate()); + auto pu = std::unique_ptr{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 + virtual std::unique_ptr createRejectMessage(size_t index, int32_t begin, int32_t length) { - std::shared_ptr msg(new MockBtMessage2(index, begin, length)); - return msg; + return make_unique(index, begin, length); } }; - std::shared_ptr dctx_; - std::shared_ptr btMessageDispatcher; - std::shared_ptr btMessageFactory_; + std::unique_ptr dctx_; + std::unique_ptr btMessageDispatcher; + std::unique_ptr btMessageFactory_; std::shared_ptr peer; - std::shared_ptr msg; + std::unique_ptr msg; void setUp() { - dctx_.reset(new DownloadContext(16*1024, 256*1024, "/path/to/file")); + dctx_ = make_unique(16*1024, 256*1024, "/path/to/file"); - peer.reset(new Peer("host", 6969)); + peer = std::make_shared("host", 6969); peer->allocateSessionResource(dctx_->getPieceLength(), dctx_->getTotalLength()); - btMessageDispatcher.reset(new MockBtMessageDispatcher()); - btMessageFactory_.reset(new MockBtMessageFactory2()); + btMessageDispatcher = make_unique(); + btMessageFactory_ = make_unique(); - msg.reset(new BtPieceMessage()); + msg = make_unique(); 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 - (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 + (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 - (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 + (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 MockBtMessage2Handle; - class MockBtMessageFactory2 : public MockBtMessageFactory { public: - virtual std::shared_ptr - createPieceMessage(size_t index, int32_t begin, int32_t length) { - std::shared_ptr btMsg - (new MockBtMessage2("piece", index, begin, length)); - return btMsg; + virtual std::unique_ptr + createPieceMessage(size_t index, int32_t begin, int32_t length) override + { + return make_unique(index, begin, length); } - virtual std::shared_ptr - createRejectMessage(size_t index, int32_t begin, int32_t length) { - std::shared_ptr btMsg - (new MockBtMessage2("reject", index, begin, length)); - return btMsg; + virtual std::unique_ptr + createRejectMessage(size_t index, int32_t begin, int32_t length) override + { + return make_unique(index, begin, length); } }; - typedef std::shared_ptr MockBtMessageFactory2Handle; - - std::shared_ptr pieceStorage_; + std::unique_ptr pieceStorage_; std::shared_ptr peer_; - std::shared_ptr dispatcher_; - std::shared_ptr messageFactory_; - std::shared_ptr msg; + std::unique_ptr dispatcher_; + std::unique_ptr messageFactory_; + std::unique_ptr msg; void setUp() { - pieceStorage_.reset(new MockPieceStorage2()); + pieceStorage_ = make_unique(); - peer_.reset(new Peer("host", 6969)); + peer_ = std::make_shared("host", 6969); peer_->allocateSessionResource(16*1024, 256*1024); - dispatcher_.reset(new MockBtMessageDispatcher()); + dispatcher_ = make_unique(); - messageFactory_.reset(new MockBtMessageFactory2()); + messageFactory_ = make_unique(); - msg.reset(new BtRequestMessage()); + msg = make_unique(); 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 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 - (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 + (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 - (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 + (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 - (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 + (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(new Piece(1, 16*1024)); + auto piece = std::make_shared(1, 16*1024); CPPUNIT_ASSERT(!msg->isInvalidate()); msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece)); CPPUNIT_ASSERT(msg->isInvalidate()); } void BtRequestMessageTest::testHandleAbortRequestEvent_indexNoMatch() { - std::shared_ptr piece(new Piece(2, 16*1024)); + auto piece = std::make_shared(2, 16*1024); CPPUNIT_ASSERT(!msg->isInvalidate()); msg->onAbortOutstandingRequestEvent(BtAbortOutstandingRequestEvent(piece)); CPPUNIT_ASSERT(!msg->isInvalidate()); } void BtRequestMessageTest::testHandleAbortRequestEvent_alreadyInvalidated() { - std::shared_ptr piece(new Piece(1, 16*1024)); + auto piece = std::make_shared(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 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 dctx_; std::shared_ptr peer; - std::shared_ptr btMessageDispatcher; - std::shared_ptr peerStorage; - std::shared_ptr pieceStorage; - std::shared_ptr messageFactory_; - std::shared_ptr rgman_; + std::unique_ptr btMessageDispatcher; + std::unique_ptr peerStorage; + std::unique_ptr pieceStorage; + std::unique_ptr messageFactory_; + std::unique_ptr rgman_; std::shared_ptr