github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

Refactor PeerInterationCommand ctor

pull/106/head
Tatsuhiro Tsujikawa 2013-07-06 21:12:55 +09:00
parent 3c66c18489
commit 3f5f1e26d9
8 changed files with 181 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/DefaultBtInteractive.cc
View File

@ -614,27 +614,27 @@ void DefaultBtInteractive::setPeer(const std::shared_ptr<Peer>& peer)
}
void DefaultBtInteractive::setBtMessageReceiver
(const std::shared_ptr<BtMessageReceiver>& receiver)
(std::unique_ptr<BtMessageReceiver> receiver)
{
btMessageReceiver_ = receiver;
btMessageReceiver_ = std::move(receiver);
}
void DefaultBtInteractive::setDispatcher
(const std::shared_ptr<BtMessageDispatcher>& dispatcher)
(std::unique_ptr<BtMessageDispatcher> dispatcher)
{
dispatcher_ = dispatcher;
dispatcher_ = std::move(dispatcher);
}
void DefaultBtInteractive::setBtRequestFactory
(const std::shared_ptr<BtRequestFactory>& factory)
(std::unique_ptr<BtRequestFactory> factory)
{
btRequestFactory_ = factory;
btRequestFactory_ = std::move(factory);
}
void DefaultBtInteractive::setPeerConnection
(const std::shared_ptr<PeerConnection>& peerConnection)
(std::unique_ptr<PeerConnection> peerConnection)
{
peerConnection_ = peerConnection;
peerConnection_ = std::move(peerConnection);
}
void DefaultBtInteractive::setExtensionMessageFactory
@ -644,9 +644,9 @@ void DefaultBtInteractive::setExtensionMessageFactory
}
void DefaultBtInteractive::setBtMessageFactory
(const std::shared_ptr<BtMessageFactory>& factory)
(std::unique_ptr<BtMessageFactory> factory)
{
messageFactory_ = factory;
messageFactory_ = std::move(factory);
}
void DefaultBtInteractive::setRequestGroupMan(RequestGroupMan* rgman)
@ -654,4 +654,22 @@ void DefaultBtInteractive::setRequestGroupMan(RequestGroupMan* rgman)
requestGroupMan_ = rgman;
}
void DefaultBtInteractive::setExtensionMessageRegistry
(std::unique_ptr<ExtensionMessageRegistry> registry)
{
extensionMessageRegistry_ = std::move(registry);
}
void DefaultBtInteractive::setUTMetadataRequestTracker
(std::unique_ptr<UTMetadataRequestTracker> tracker)
{
utMetadataRequestTracker_ = std::move(tracker);
}
void DefaultBtInteractive::setUTMetadataRequestFactory
(std::unique_ptr<UTMetadataRequestFactory> factory)
{
utMetadataRequestFactory_ = std::move(factory);
}
} // namespace aria2

43
src/DefaultBtInteractive.h
View File

@ -110,17 +110,15 @@ private:
std::shared_ptr<Peer> peer_;
std::shared_ptr<BtMessageReceiver> btMessageReceiver_;
std::shared_ptr<BtMessageDispatcher> dispatcher_;
std::shared_ptr<BtRequestFactory> btRequestFactory_;
// Although peerStorage_ is not used in this class, this object
// holds the reference so that peerConnection_ is not deleted.
std::shared_ptr<PeerConnection> peerConnection_;
std::shared_ptr<BtMessageFactory> messageFactory_;
std::unique_ptr<BtMessageReceiver> btMessageReceiver_;
std::unique_ptr<BtMessageDispatcher> dispatcher_;
std::unique_ptr<BtRequestFactory> btRequestFactory_;
std::unique_ptr<PeerConnection> peerConnection_;
std::unique_ptr<BtMessageFactory> messageFactory_;
std::unique_ptr<ExtensionMessageFactory> extensionMessageFactory_;
std::shared_ptr<ExtensionMessageRegistry> extensionMessageRegistry_;
std::shared_ptr<UTMetadataRequestFactory> utMetadataRequestFactory_;
std::shared_ptr<UTMetadataRequestTracker> utMetadataRequestTracker_;
std::unique_ptr<ExtensionMessageRegistry> extensionMessageRegistry_;
std::unique_ptr<UTMetadataRequestFactory> utMetadataRequestFactory_;
std::unique_ptr<UTMetadataRequestTracker> utMetadataRequestTracker_;
bool metadataGetMode_;
@ -210,24 +208,21 @@ public:
void setPeer(const std::shared_ptr<Peer>& peer);
void setBtMessageReceiver(const std::shared_ptr<BtMessageReceiver>& receiver);
void setBtMessageReceiver(std::unique_ptr<BtMessageReceiver> receiver);
void setDispatcher(const std::shared_ptr<BtMessageDispatcher>& dispatcher);
void setDispatcher(std::unique_ptr<BtMessageDispatcher> dispatcher);
void setBtRequestFactory(const std::shared_ptr<BtRequestFactory>& factory);
void setBtRequestFactory(std::unique_ptr<BtRequestFactory> factory);
void setPeerConnection(const std::shared_ptr<PeerConnection>& peerConnection);
void setPeerConnection(std::unique_ptr<PeerConnection> peerConnection);
void setBtMessageFactory(const std::shared_ptr<BtMessageFactory>& factory);
void setBtMessageFactory(std::unique_ptr<BtMessageFactory> factory);
void setExtensionMessageFactory
(std::unique_ptr<ExtensionMessageFactory> factory);
void setExtensionMessageRegistry
(const std::shared_ptr<ExtensionMessageRegistry>& registry)
{
extensionMessageRegistry_ = registry;
}
(std::unique_ptr<ExtensionMessageRegistry> registry);
void setKeepAliveInterval(time_t keepAliveInterval) {
keepAliveInterval_ = keepAliveInterval;
@ -248,16 +243,10 @@ public:
void setRequestGroupMan(RequestGroupMan* rgman);
void setUTMetadataRequestTracker
(const std::shared_ptr<UTMetadataRequestTracker>& tracker)
{
utMetadataRequestTracker_ = tracker;
}
(std::unique_ptr<UTMetadataRequestTracker> tracker);
void setUTMetadataRequestFactory
(const std::shared_ptr<UTMetadataRequestFactory>& factory)
{
utMetadataRequestFactory_ = factory;
}
(std::unique_ptr<UTMetadataRequestFactory> factory);
void enableMetadataGetMode()
{

6
src/InitiatorMSEHandshakeCommand.cc
View File

@ -149,8 +149,8 @@ bool InitiatorMSEHandshakeCommand::executeInternal() {
}
case INITIATOR_RECEIVE_PAD_D: {
if(mseHandshake_->receivePad()) {
std::shared_ptr<PeerConnection> peerConnection
(new PeerConnection(getCuid(), getPeer(), getSocket()));
auto peerConnection = make_unique<PeerConnection>
(getCuid(), getPeer(), getSocket());
if(mseHandshake_->getNegotiatedCryptoType() ==
MSEHandshake::CRYPTO_ARC4){
size_t buflen = mseHandshake_->getBufferLength();
@ -172,7 +172,7 @@ bool InitiatorMSEHandshakeCommand::executeInternal() {
peerStorage_,
getSocket(),
PeerInteractionCommand::INITIATOR_SEND_HANDSHAKE,
peerConnection));
std::move(peerConnection)));
return true;
} else {
done = true;

231
src/PeerInteractionCommand.cc
View File

@ -90,13 +90,13 @@ PeerInteractionCommand::PeerInteractionCommand
const std::shared_ptr<PeerStorage>& peerStorage,
const std::shared_ptr<SocketCore>& s,
Seq sequence,
const std::shared_ptr<PeerConnection>& passedPeerConnection)
:PeerAbstractCommand(cuid, p, e, s),
requestGroup_(requestGroup),
btRuntime_(btRuntime),
pieceStorage_(pieceStorage),
peerStorage_(peerStorage),
sequence_(sequence)
std::unique_ptr<PeerConnection> peerConnection)
: PeerAbstractCommand{cuid, p, e, s},
requestGroup_{requestGroup},
btRuntime_{btRuntime},
pieceStorage_{pieceStorage},
peerStorage_{peerStorage},
sequence_{sequence}
{
// TODO move following bunch of processing to separate method, like init()
if(sequence_ == INITIATOR_SEND_HANDSHAKE) {
@ -119,59 +119,47 @@ PeerInteractionCommand::PeerInteractionCommand
bittorrent::getTorrentAttrs(requestGroup_->getDownloadContext());
bool metadataGetMode = torrentAttrs->metadata.empty();
std::shared_ptr<ExtensionMessageRegistry> exMsgRegistry
(new ExtensionMessageRegistry());
auto exMsgRegistry = make_unique<ExtensionMessageRegistry>();
exMsgRegistry->setExtensionMessageID(ExtensionMessageRegistry::UT_PEX, 8);
// http://www.bittorrent.org/beps/bep_0009.html
exMsgRegistry->setExtensionMessageID(ExtensionMessageRegistry::UT_METADATA,
9);
std::shared_ptr<UTMetadataRequestFactory> utMetadataRequestFactory;
std::shared_ptr<UTMetadataRequestTracker> utMetadataRequestTracker;
if(metadataGetMode) {
utMetadataRequestFactory.reset(new UTMetadataRequestFactory());
utMetadataRequestTracker.reset(new UTMetadataRequestTracker());
}
auto extensionMessageFactory =
make_unique<DefaultExtensionMessageFactory>(getPeer(),
exMsgRegistry.get());
auto extensionMessageFactoryPtr = extensionMessageFactory.get();
extensionMessageFactory->setPeerStorage(peerStorage.get());
extensionMessageFactory->setDownloadContext
(requestGroup_->getDownloadContext().get());
extensionMessageFactory->setUTMetadataRequestTracker
(utMetadataRequestTracker.get());
// PieceStorage will be set later.
DefaultBtMessageFactory* factoryPtr(new DefaultBtMessageFactory());
factoryPtr->setCuid(cuid);
factoryPtr->setDownloadContext(requestGroup_->getDownloadContext().get());
factoryPtr->setPieceStorage(pieceStorage.get());
factoryPtr->setPeerStorage(peerStorage.get());
factoryPtr->setExtensionMessageFactory(extensionMessageFactory.get());
factoryPtr->setPeer(getPeer());
auto factory = make_unique<DefaultBtMessageFactory>();
auto factoryPtr = factory.get();
factory->setCuid(cuid);
factory->setDownloadContext(requestGroup_->getDownloadContext().get());
factory->setPieceStorage(pieceStorage.get());
factory->setPeerStorage(peerStorage.get());
factory->setExtensionMessageFactory(extensionMessageFactory.get());
factory->setPeer(getPeer());
if(family == AF_INET) {
factoryPtr->setLocalNode(DHTRegistry::getData().localNode.get());
factoryPtr->setRoutingTable(DHTRegistry::getData().routingTable.get());
factoryPtr->setTaskQueue(DHTRegistry::getData().taskQueue.get());
factoryPtr->setTaskFactory(DHTRegistry::getData().taskFactory.get());
factory->setLocalNode(DHTRegistry::getData().localNode.get());
factory->setRoutingTable(DHTRegistry::getData().routingTable.get());
factory->setTaskQueue(DHTRegistry::getData().taskQueue.get());
factory->setTaskFactory(DHTRegistry::getData().taskFactory.get());
} else {
factoryPtr->setLocalNode(DHTRegistry::getData6().localNode.get());
factoryPtr->setRoutingTable(DHTRegistry::getData6().routingTable.get());
factoryPtr->setTaskQueue(DHTRegistry::getData6().taskQueue.get());
factoryPtr->setTaskFactory(DHTRegistry::getData6().taskFactory.get());
factory->setLocalNode(DHTRegistry::getData6().localNode.get());
factory->setRoutingTable(DHTRegistry::getData6().routingTable.get());
factory->setTaskQueue(DHTRegistry::getData6().taskQueue.get());
factory->setTaskFactory(DHTRegistry::getData6().taskFactory.get());
}
if(metadataGetMode) {
factoryPtr->enableMetadataGetMode();
factory->enableMetadataGetMode();
}
std::shared_ptr<BtMessageFactory> factory(factoryPtr);
std::shared_ptr<PeerConnection> peerConnection;
if(!passedPeerConnection) {
peerConnection.reset(new PeerConnection(cuid, getPeer(), getSocket()));
if(!peerConnection) {
peerConnection = make_unique<PeerConnection>(cuid, getPeer(), getSocket());
} else {
peerConnection = passedPeerConnection;
if(sequence_ == RECEIVER_WAIT_HANDSHAKE &&
peerConnection->getBufferLength() > 0) {
setStatus(Command::STATUS_ONESHOT_REALTIME);
@ -187,44 +175,88 @@ PeerInteractionCommand::PeerInteractionCommand
1+(requestGroup_->getDownloadContext()->getNumPieces()+7)/8;
peerConnection->reserveBuffer(bitfieldPayloadSize);
DefaultBtMessageDispatcher* dispatcherPtr(new DefaultBtMessageDispatcher());
dispatcherPtr->setCuid(cuid);
dispatcherPtr->setPeer(getPeer());
dispatcherPtr->setDownloadContext(requestGroup_->getDownloadContext().get());
dispatcherPtr->setPieceStorage(pieceStorage.get());
dispatcherPtr->setPeerStorage(peerStorage.get());
dispatcherPtr->setRequestTimeout(getOption()->
auto dispatcher = make_unique<DefaultBtMessageDispatcher>();
auto dispatcherPtr = dispatcher.get();
dispatcher->setCuid(cuid);
dispatcher->setPeer(getPeer());
dispatcher->setDownloadContext(requestGroup_->getDownloadContext().get());
dispatcher->setPieceStorage(pieceStorage.get());
dispatcher->setPeerStorage(peerStorage.get());
dispatcher->setRequestTimeout(getOption()->
getAsInt(PREF_BT_REQUEST_TIMEOUT));
dispatcherPtr->setBtMessageFactory(factoryPtr);
dispatcherPtr->setRequestGroupMan
dispatcher->setBtMessageFactory(factory.get());
dispatcher->setRequestGroupMan
(getDownloadEngine()->getRequestGroupMan().get());
dispatcherPtr->setPeerConnection(peerConnection.get());
std::shared_ptr<BtMessageDispatcher> dispatcher(dispatcherPtr);
dispatcher->setPeerConnection(peerConnection.get());
DefaultBtMessageReceiver* receiverPtr(new DefaultBtMessageReceiver());
std::shared_ptr<BtMessageReceiver> receiver(receiverPtr);
receiverPtr->setDownloadContext(requestGroup_->getDownloadContext().get());
receiverPtr->setPeerConnection(peerConnection.get());
receiverPtr->setDispatcher(dispatcherPtr);
receiverPtr->setBtMessageFactory(factoryPtr);
auto receiver = make_unique<DefaultBtMessageReceiver>();
receiver->setDownloadContext(requestGroup_->getDownloadContext().get());
receiver->setPeerConnection(peerConnection.get());
receiver->setDispatcher(dispatcher.get());
receiver->setBtMessageFactory(factory.get());
DefaultBtRequestFactory* reqFactoryPtr(new DefaultBtRequestFactory());
reqFactoryPtr->setPeer(getPeer());
reqFactoryPtr->setPieceStorage(pieceStorage.get());
reqFactoryPtr->setBtMessageDispatcher(dispatcherPtr);
reqFactoryPtr->setBtMessageFactory(factoryPtr);
reqFactoryPtr->setCuid(cuid);
std::shared_ptr<BtRequestFactory> reqFactory(reqFactoryPtr);
auto reqFactory = make_unique<DefaultBtRequestFactory>();
reqFactory->setPeer(getPeer());
reqFactory->setPieceStorage(pieceStorage.get());
reqFactory->setBtMessageDispatcher(dispatcher.get());
reqFactory->setBtMessageFactory(factory.get());
reqFactory->setCuid(cuid);
// reverse depends
factoryPtr->setBtMessageDispatcher(dispatcherPtr);
factoryPtr->setBtRequestFactory(reqFactoryPtr);
factoryPtr->setPeerConnection(peerConnection.get());
factory->setBtMessageDispatcher(dispatcher.get());
factory->setBtRequestFactory(reqFactory.get());
factory->setPeerConnection(peerConnection.get());
extensionMessageFactory->setBtMessageDispatcher(dispatcherPtr);
extensionMessageFactory->setBtMessageFactory(factoryPtr);
extensionMessageFactory->setBtMessageDispatcher(dispatcher.get());
extensionMessageFactory->setBtMessageFactory(factory.get());
getPeer()->allocateSessionResource
(requestGroup_->getDownloadContext()->getPieceLength(),
requestGroup_->getDownloadContext()->getTotalLength());
getPeer()->setBtMessageDispatcher(dispatcher.get());
auto btInteractive = make_unique<DefaultBtInteractive>
(requestGroup_->getDownloadContext(), getPeer());
btInteractive->setBtRuntime(btRuntime_);
btInteractive->setPieceStorage(pieceStorage_);
btInteractive->setPeerStorage(peerStorage); // Note: Not a member variable.
btInteractive->setCuid(cuid);
btInteractive->setBtMessageReceiver(std::move(receiver));
btInteractive->setDispatcher(std::move(dispatcher));
btInteractive->setBtRequestFactory(std::move(reqFactory));
btInteractive->setPeerConnection(std::move(peerConnection));
btInteractive->setExtensionMessageFactory
(std::move(extensionMessageFactory));
btInteractive->setExtensionMessageRegistry(std::move(exMsgRegistry));
btInteractive->setKeepAliveInterval
(getOption()->getAsInt(PREF_BT_KEEP_ALIVE_INTERVAL));
btInteractive->setRequestGroupMan
(getDownloadEngine()->getRequestGroupMan().get());
btInteractive->setBtMessageFactory(std::move(factory));
if((metadataGetMode || !torrentAttrs->privateTorrent) &&
!getPeer()->isLocalPeer()) {
if(getOption()->getAsBool(PREF_ENABLE_PEER_EXCHANGE)) {
btInteractive->setUTPexEnabled(true);
}
if(family == AF_INET) {
if(DHTRegistry::isInitialized()) {
btInteractive->setDHTEnabled(true);
factoryPtr->setDHTEnabled(true);
btInteractive->setLocalNode(DHTRegistry::getData().localNode.get());
}
} else {
if(DHTRegistry::isInitialized6()) {
btInteractive->setDHTEnabled(true);
factoryPtr->setDHTEnabled(true);
btInteractive->setLocalNode(DHTRegistry::getData6().localNode.get());
}
}
}
if(metadataGetMode) {
auto utMetadataRequestFactory = make_unique<UTMetadataRequestFactory>();
auto utMetadataRequestTracker = make_unique<UTMetadataRequestTracker>();
utMetadataRequestFactory->setCuid(cuid);
utMetadataRequestFactory->setDownloadContext
(requestGroup_->getDownloadContext().get());
@ -233,60 +265,21 @@ PeerInteractionCommand::PeerInteractionCommand
utMetadataRequestFactory->setPeer(getPeer());
utMetadataRequestFactory->setUTMetadataRequestTracker
(utMetadataRequestTracker.get());
extensionMessageFactoryPtr->setUTMetadataRequestTracker
(utMetadataRequestTracker.get());
btInteractive->setUTMetadataRequestFactory
(std::move(utMetadataRequestFactory));
btInteractive->setUTMetadataRequestTracker
(std::move(utMetadataRequestTracker));
}
getPeer()->allocateSessionResource
(requestGroup_->getDownloadContext()->getPieceLength(),
requestGroup_->getDownloadContext()->getTotalLength());
getPeer()->setBtMessageDispatcher(dispatcherPtr);
DefaultBtInteractive* btInteractivePtr
(new DefaultBtInteractive(requestGroup_->getDownloadContext(), getPeer()));
btInteractivePtr->setBtRuntime(btRuntime_);
btInteractivePtr->setPieceStorage(pieceStorage_);
btInteractivePtr->setPeerStorage(peerStorage); // Note: Not a member variable.
btInteractivePtr->setCuid(cuid);
btInteractivePtr->setBtMessageReceiver(receiver);
btInteractivePtr->setDispatcher(dispatcher);
btInteractivePtr->setBtRequestFactory(reqFactory);
btInteractivePtr->setPeerConnection(peerConnection);
btInteractivePtr->setExtensionMessageFactory
(std::move(extensionMessageFactory));
btInteractivePtr->setExtensionMessageRegistry(exMsgRegistry);
btInteractivePtr->setKeepAliveInterval
(getOption()->getAsInt(PREF_BT_KEEP_ALIVE_INTERVAL));
btInteractivePtr->setRequestGroupMan
(getDownloadEngine()->getRequestGroupMan().get());
btInteractivePtr->setBtMessageFactory(factory);
if((metadataGetMode || !torrentAttrs->privateTorrent) &&
!getPeer()->isLocalPeer()) {
if(getOption()->getAsBool(PREF_ENABLE_PEER_EXCHANGE)) {
btInteractivePtr->setUTPexEnabled(true);
}
if(family == AF_INET) {
if(DHTRegistry::isInitialized()) {
btInteractivePtr->setDHTEnabled(true);
factoryPtr->setDHTEnabled(true);
btInteractivePtr->setLocalNode(DHTRegistry::getData().localNode.get());
}
} else {
if(DHTRegistry::isInitialized6()) {
btInteractivePtr->setDHTEnabled(true);
factoryPtr->setDHTEnabled(true);
btInteractivePtr->setLocalNode(DHTRegistry::getData6().localNode.get());
}
}
}
btInteractivePtr->setUTMetadataRequestFactory(utMetadataRequestFactory);
btInteractivePtr->setUTMetadataRequestTracker(utMetadataRequestTracker);
btInteractivePtr->setTcpPort(e->getBtRegistry()->getTcpPort());
btInteractive->setTcpPort(e->getBtRegistry()->getTcpPort());
if(metadataGetMode) {
btInteractivePtr->enableMetadataGetMode();
btInteractive->enableMetadataGetMode();
}
std::shared_ptr<BtInteractive> btInteractive(btInteractivePtr);
btInteractive_ = btInteractive;
btInteractive_ = std::move(btInteractive);
btRuntime_->increaseConnections();
requestGroup_->increaseNumCommand();

6
src/PeerInteractionCommand.h
View File

@ -64,7 +64,7 @@ private:
std::shared_ptr<PeerStorage> peerStorage_;
Seq sequence_;
std::shared_ptr<BtInteractive> btInteractive_;
std::unique_ptr<BtInteractive> btInteractive_;
const std::shared_ptr<Option>& getOption() const;
protected:
@ -83,8 +83,8 @@ public:
const std::shared_ptr<PeerStorage>& peerStorage,
const std::shared_ptr<SocketCore>& s,
Seq sequence,
const std::shared_ptr<PeerConnection>& peerConnection =
std::shared_ptr<PeerConnection>());
std::unique_ptr<PeerConnection> peerConnection =
nullptr);
virtual ~PeerInteractionCommand();
};

11
src/PeerReceiveHandshakeCommand.cc
View File

@ -66,9 +66,9 @@ PeerReceiveHandshakeCommand::PeerReceiveHandshakeCommand
const std::shared_ptr<Peer>& peer,
DownloadEngine* e,
const std::shared_ptr<SocketCore>& s,
const std::shared_ptr<PeerConnection>& peerConnection)
: PeerAbstractCommand(cuid, peer, e, s),
peerConnection_(peerConnection)
std::unique_ptr<PeerConnection> peerConnection)
: PeerAbstractCommand{cuid, peer, e, s},
peerConnection_{std::move(peerConnection)}
{
if(peerConnection_) {
if(peerConnection_->getBufferLength() > 0) {
@ -76,7 +76,8 @@ PeerReceiveHandshakeCommand::PeerReceiveHandshakeCommand
getDownloadEngine()->setNoWait(true);
}
} else {
peerConnection_.reset(new PeerConnection(cuid, getPeer(), getSocket()));
peerConnection_ = make_unique<PeerConnection>
(cuid, getPeer(), getSocket());
}
}
@ -151,7 +152,7 @@ bool PeerReceiveHandshakeCommand::executeInternal()
peerStorage,
getSocket(),
PeerInteractionCommand::RECEIVER_WAIT_HANDSHAKE,
peerConnection_));
std::move(peerConnection_)));
A2_LOG_DEBUG(fmt(MSG_INCOMING_PEER_CONNECTION,
getCuid(),
getPeer()->usedBy()));

5
src/PeerReceiveHandshakeCommand.h
View File

@ -46,7 +46,7 @@ class Peer;
class PeerReceiveHandshakeCommand:public PeerAbstractCommand
{
private:
std::shared_ptr<PeerConnection> peerConnection_;
std::unique_ptr<PeerConnection> peerConnection_;
protected:
virtual bool executeInternal() CXX11_OVERRIDE;
virtual bool exitBeforeExecute() CXX11_OVERRIDE;
@ -56,8 +56,7 @@ public:
const std::shared_ptr<Peer>& peer,
DownloadEngine* e,
const std::shared_ptr<SocketCore>& s,
const std::shared_ptr<PeerConnection>& peerConnection =
std::shared_ptr<PeerConnection>());
std::unique_ptr<PeerConnection> peerConnection = nullptr);
virtual ~PeerReceiveHandshakeCommand();
};

21
src/ReceiverMSEHandshakeCommand.cc
View File

@ -103,16 +103,17 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
("The legacy BitTorrent handshake is not acceptable by the"
" preference.");
}
std::shared_ptr<PeerConnection> peerConnection
(new PeerConnection(getCuid(), getPeer(), getSocket()));
auto peerConnection = make_unique<PeerConnection>
(getCuid(), getPeer(), getSocket());
peerConnection->presetBuffer(mseHandshake_->getBuffer(),
mseHandshake_->getBufferLength());
getDownloadEngine()->addCommand
(make_unique<PeerReceiveHandshakeCommand>(getCuid(),
getPeer(),
getDownloadEngine(),
getSocket(),
peerConnection));
(make_unique<PeerReceiveHandshakeCommand>
(getCuid(),
getPeer(),
getDownloadEngine(),
getSocket(),
std::move(peerConnection)));
return true;
}
default:
@ -206,8 +207,8 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
void ReceiverMSEHandshakeCommand::createCommand()
{
std::shared_ptr<PeerConnection> peerConnection
(new PeerConnection(getCuid(), getPeer(), getSocket()));
auto peerConnection = make_unique<PeerConnection>
(getCuid(), getPeer(), getSocket());
if(mseHandshake_->getNegotiatedCryptoType() == MSEHandshake::CRYPTO_ARC4) {
peerConnection->enableEncryption(mseHandshake_->popEncryptor(),
mseHandshake_->popDecryptor());
@ -221,7 +222,7 @@ void ReceiverMSEHandshakeCommand::createCommand()
// match, then drop connection.
getDownloadEngine()->addCommand(make_unique<PeerReceiveHandshakeCommand>
(getCuid(), getPeer(), getDownloadEngine(),
getSocket(), peerConnection));
getSocket(), std::move(peerConnection)));
}
} // namespace aria2