Refactor PeerInterationCommand ctor

src/DefaultBtInteractive.cc

@@ -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

src/DefaultBtInteractive.h

@@ -110,17 +110,15 @@ private:
 
   std::shared_ptr<Peer> peer_;
 
-  std::shared_ptr<BtMessageReceiver> btMessageReceiver_;
+  std::unique_ptr<BtMessageReceiver> btMessageReceiver_;
-  std::shared_ptr<BtMessageDispatcher> dispatcher_;
+  std::unique_ptr<BtMessageDispatcher> dispatcher_;
-  std::shared_ptr<BtRequestFactory> btRequestFactory_;
+  std::unique_ptr<BtRequestFactory> btRequestFactory_;
-  // Although peerStorage_ is not used in this class, this object
+  std::unique_ptr<PeerConnection> peerConnection_;
-  // holds the reference so that peerConnection_ is not deleted.
+  std::unique_ptr<BtMessageFactory> messageFactory_;
-  std::shared_ptr<PeerConnection> peerConnection_;
-  std::shared_ptr<BtMessageFactory> messageFactory_;
   std::unique_ptr<ExtensionMessageFactory> extensionMessageFactory_;
-  std::shared_ptr<ExtensionMessageRegistry> extensionMessageRegistry_;
+  std::unique_ptr<ExtensionMessageRegistry> extensionMessageRegistry_;
-  std::shared_ptr<UTMetadataRequestFactory> utMetadataRequestFactory_;
+  std::unique_ptr<UTMetadataRequestFactory> utMetadataRequestFactory_;
-  std::shared_ptr<UTMetadataRequestTracker> utMetadataRequestTracker_;
+  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)
+  (std::unique_ptr<ExtensionMessageRegistry> registry);
-  {
-    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)
+  (std::unique_ptr<UTMetadataRequestTracker> tracker);
-  {
-    utMetadataRequestTracker_ = tracker;
-  }
 
   void setUTMetadataRequestFactory
-  (const std::shared_ptr<UTMetadataRequestFactory>& factory)
+  (std::unique_ptr<UTMetadataRequestFactory> factory);
-  {
-    utMetadataRequestFactory_ = factory;
-  }
 
   void enableMetadataGetMode()
   {

src/InitiatorMSEHandshakeCommand.cc

@@ -149,8 +149,8 @@ bool InitiatorMSEHandshakeCommand::executeInternal() {
     }
     case INITIATOR_RECEIVE_PAD_D: {
       if(mseHandshake_->receivePad()) {
-        std::shared_ptr<PeerConnection> peerConnection
+        auto peerConnection = make_unique<PeerConnection>
-          (new PeerConnection(getCuid(), getPeer(), getSocket()));
+          (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;

src/PeerInteractionCommand.cc

@@ -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)
+ std::unique_ptr<PeerConnection> peerConnection)
-  :PeerAbstractCommand(cuid, p, e, s),
+  : PeerAbstractCommand{cuid, p, e, s},
-   requestGroup_(requestGroup),
+    requestGroup_{requestGroup},
-   btRuntime_(btRuntime),
+    btRuntime_{btRuntime},
-   pieceStorage_(pieceStorage),
+    pieceStorage_{pieceStorage},
-   peerStorage_(peerStorage),
+    peerStorage_{peerStorage},
-   sequence_(sequence)
+    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
+  auto exMsgRegistry = make_unique<ExtensionMessageRegistry>();
-    (new 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());
+  auto factory = make_unique<DefaultBtMessageFactory>();
-  factoryPtr->setCuid(cuid);
+  auto factoryPtr = factory.get();
-  factoryPtr->setDownloadContext(requestGroup_->getDownloadContext().get());
+  factory->setCuid(cuid);
-  factoryPtr->setPieceStorage(pieceStorage.get());
+  factory->setDownloadContext(requestGroup_->getDownloadContext().get());
-  factoryPtr->setPeerStorage(peerStorage.get());
+  factory->setPieceStorage(pieceStorage.get());
-  factoryPtr->setExtensionMessageFactory(extensionMessageFactory.get());
+  factory->setPeerStorage(peerStorage.get());
-  factoryPtr->setPeer(getPeer());
+  factory->setExtensionMessageFactory(extensionMessageFactory.get());
+  factory->setPeer(getPeer());
   if(family == AF_INET) {
-    factoryPtr->setLocalNode(DHTRegistry::getData().localNode.get());
+    factory->setLocalNode(DHTRegistry::getData().localNode.get());
-    factoryPtr->setRoutingTable(DHTRegistry::getData().routingTable.get());
+    factory->setRoutingTable(DHTRegistry::getData().routingTable.get());
-    factoryPtr->setTaskQueue(DHTRegistry::getData().taskQueue.get());
+    factory->setTaskQueue(DHTRegistry::getData().taskQueue.get());
-    factoryPtr->setTaskFactory(DHTRegistry::getData().taskFactory.get());
+    factory->setTaskFactory(DHTRegistry::getData().taskFactory.get());
   } else {
-    factoryPtr->setLocalNode(DHTRegistry::getData6().localNode.get());
+    factory->setLocalNode(DHTRegistry::getData6().localNode.get());
-    factoryPtr->setRoutingTable(DHTRegistry::getData6().routingTable.get());
+    factory->setRoutingTable(DHTRegistry::getData6().routingTable.get());
-    factoryPtr->setTaskQueue(DHTRegistry::getData6().taskQueue.get());
+    factory->setTaskQueue(DHTRegistry::getData6().taskQueue.get());
-    factoryPtr->setTaskFactory(DHTRegistry::getData6().taskFactory.get());
+    factory->setTaskFactory(DHTRegistry::getData6().taskFactory.get());
   }
   if(metadataGetMode) {
-    factoryPtr->enableMetadataGetMode();
+    factory->enableMetadataGetMode();
   }
-  std::shared_ptr<BtMessageFactory> factory(factoryPtr);
 
-
+  if(!peerConnection) {
-  std::shared_ptr<PeerConnection> peerConnection;
+    peerConnection = make_unique<PeerConnection>(cuid, getPeer(), getSocket());
-  if(!passedPeerConnection) {
-    peerConnection.reset(new 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());
+  auto dispatcher = make_unique<DefaultBtMessageDispatcher>();
-  dispatcherPtr->setCuid(cuid);
+  auto dispatcherPtr = dispatcher.get();
-  dispatcherPtr->setPeer(getPeer());
+  dispatcher->setCuid(cuid);
-  dispatcherPtr->setDownloadContext(requestGroup_->getDownloadContext().get());
+  dispatcher->setPeer(getPeer());
-  dispatcherPtr->setPieceStorage(pieceStorage.get());
+  dispatcher->setDownloadContext(requestGroup_->getDownloadContext().get());
-  dispatcherPtr->setPeerStorage(peerStorage.get());
+  dispatcher->setPieceStorage(pieceStorage.get());
-  dispatcherPtr->setRequestTimeout(getOption()->
+  dispatcher->setPeerStorage(peerStorage.get());
+  dispatcher->setRequestTimeout(getOption()->
                                    getAsInt(PREF_BT_REQUEST_TIMEOUT));
-  dispatcherPtr->setBtMessageFactory(factoryPtr);
+  dispatcher->setBtMessageFactory(factory.get());
-  dispatcherPtr->setRequestGroupMan
+  dispatcher->setRequestGroupMan
     (getDownloadEngine()->getRequestGroupMan().get());
-  dispatcherPtr->setPeerConnection(peerConnection.get());
+  dispatcher->setPeerConnection(peerConnection.get());
-  std::shared_ptr<BtMessageDispatcher> dispatcher(dispatcherPtr);
 
-  DefaultBtMessageReceiver* receiverPtr(new DefaultBtMessageReceiver());
+  auto receiver = make_unique<DefaultBtMessageReceiver>();
-  std::shared_ptr<BtMessageReceiver> receiver(receiverPtr);
+  receiver->setDownloadContext(requestGroup_->getDownloadContext().get());
-  receiverPtr->setDownloadContext(requestGroup_->getDownloadContext().get());
+  receiver->setPeerConnection(peerConnection.get());
-  receiverPtr->setPeerConnection(peerConnection.get());
+  receiver->setDispatcher(dispatcher.get());
-  receiverPtr->setDispatcher(dispatcherPtr);
+  receiver->setBtMessageFactory(factory.get());
-  receiverPtr->setBtMessageFactory(factoryPtr);
 
-  DefaultBtRequestFactory* reqFactoryPtr(new DefaultBtRequestFactory());
+  auto reqFactory = make_unique<DefaultBtRequestFactory>();
-  reqFactoryPtr->setPeer(getPeer());
+  reqFactory->setPeer(getPeer());
-  reqFactoryPtr->setPieceStorage(pieceStorage.get());
+  reqFactory->setPieceStorage(pieceStorage.get());
-  reqFactoryPtr->setBtMessageDispatcher(dispatcherPtr);
+  reqFactory->setBtMessageDispatcher(dispatcher.get());
-  reqFactoryPtr->setBtMessageFactory(factoryPtr);
+  reqFactory->setBtMessageFactory(factory.get());
-  reqFactoryPtr->setCuid(cuid);
+  reqFactory->setCuid(cuid);
-  std::shared_ptr<BtRequestFactory> reqFactory(reqFactoryPtr);
 
   // reverse depends
-  factoryPtr->setBtMessageDispatcher(dispatcherPtr);
+  factory->setBtMessageDispatcher(dispatcher.get());
-  factoryPtr->setBtRequestFactory(reqFactoryPtr);
+  factory->setBtRequestFactory(reqFactory.get());
-  factoryPtr->setPeerConnection(peerConnection.get());
+  factory->setPeerConnection(peerConnection.get());
 
-  extensionMessageFactory->setBtMessageDispatcher(dispatcherPtr);
+  extensionMessageFactory->setBtMessageDispatcher(dispatcher.get());
-  extensionMessageFactory->setBtMessageFactory(factoryPtr);
+  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
+  btInteractive->setTcpPort(e->getBtRegistry()->getTcpPort());
-    (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());
   if(metadataGetMode) {
-    btInteractivePtr->enableMetadataGetMode();
+    btInteractive->enableMetadataGetMode();
   }
-  std::shared_ptr<BtInteractive> btInteractive(btInteractivePtr);
+  btInteractive_ = std::move(btInteractive);
-
-  btInteractive_ = btInteractive;
-
 
   btRuntime_->increaseConnections();
   requestGroup_->increaseNumCommand();

src/PeerInteractionCommand.h

@@ -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::unique_ptr<PeerConnection> peerConnection =
-                         std::shared_ptr<PeerConnection>());
+                         nullptr);
 
   virtual ~PeerInteractionCommand();
 };

src/PeerReceiveHandshakeCommand.cc

@@ -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)
+ std::unique_ptr<PeerConnection> peerConnection)
-  : PeerAbstractCommand(cuid, peer, e, s),
+  : PeerAbstractCommand{cuid, peer, e, s},
-    peerConnection_(peerConnection)
+    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()));

src/PeerReceiveHandshakeCommand.h

@@ -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::unique_ptr<PeerConnection> peerConnection = nullptr);
-   std::shared_ptr<PeerConnection>());
 
   virtual ~PeerReceiveHandshakeCommand();
 };

src/ReceiverMSEHandshakeCommand.cc

@@ -103,16 +103,17 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
             ("The legacy BitTorrent handshake is not acceptable by the"
              " preference.");
         }
-        std::shared_ptr<PeerConnection> peerConnection
+        auto peerConnection = make_unique<PeerConnection>
-          (new PeerConnection(getCuid(), getPeer(), getSocket()));
+          (getCuid(), getPeer(), getSocket());
         peerConnection->presetBuffer(mseHandshake_->getBuffer(),
                                      mseHandshake_->getBufferLength());
         getDownloadEngine()->addCommand
-          (make_unique<PeerReceiveHandshakeCommand>(getCuid(),
+          (make_unique<PeerReceiveHandshakeCommand>
+           (getCuid(),
             getPeer(),
             getDownloadEngine(),
             getSocket(),
-                                                    peerConnection));
+            std::move(peerConnection)));
         return true;
       }
       default:
@@ -206,8 +207,8 @@ bool ReceiverMSEHandshakeCommand::executeInternal()
 
 void ReceiverMSEHandshakeCommand::createCommand()
 {
-  std::shared_ptr<PeerConnection> peerConnection
+  auto peerConnection = make_unique<PeerConnection>
-    (new PeerConnection(getCuid(), getPeer(), getSocket()));
+    (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