Return nullptr directly where std::unique_ptr is expected

The constructor of std::unique_ptr which takes nullptr is not explicit
so we can return nullptr directly.

src/AuthConfig.cc

@@ -61,7 +61,7 @@ std::unique_ptr<AuthConfig> AuthConfig::create
 (std::string user, std::string password)
 {
   if(user.empty()) {
-    return std::unique_ptr<AuthConfig>();
+    return nullptr;
   } else {
     return make_unique<AuthConfig>(std::move(user), std::move(password));
   }

src/AuthConfigFactory.cc

@@ -74,7 +74,7 @@ AuthConfigFactory::createAuthConfig
       auto i = findBasicCred(request->getHost(), request->getPort(),
                              request->getDir());
       if(i == std::end(basicCreds_)) {
-        return std::unique_ptr<AuthConfig>();
+        return nullptr;
       } else {
         return AuthConfig::create((*i)->user_, (*i)->password_);
       }
@@ -114,7 +114,7 @@ AuthConfigFactory::createAuthConfig
         createFtpAuthResolver(op)->resolveAuthConfig(request->getHost());
     }
   } else {
-    return std::unique_ptr<AuthConfig>();
+    return nullptr;
   }
 }
 

src/HttpConnection.cc

@@ -159,7 +159,7 @@ std::unique_ptr<HttpResponse> HttpConnection::receiveResponse()
     return httpResponse;
   } else {
     socketRecvBuffer_->shiftBuffer(proc->getLastBytesProcessed());
-    return std::unique_ptr<HttpResponse>{};
+    return nullptr;
   }
 }
 

src/HttpResponse.cc

@@ -199,7 +199,7 @@ HttpResponse::getTransferEncodingStreamFilter() const
       return make_unique<ChunkedDecodingStreamFilter>();
     }
   }
-  return std::unique_ptr<StreamFilter>{};
+  return nullptr;
 }
 
 bool HttpResponse::isContentEncodingSpecified() const
@@ -221,7 +221,7 @@ HttpResponse::getContentEncodingStreamFilter() const
     return make_unique<GZipDecodingStreamFilter>();
   }
 #endif // HAVE_ZLIB
-  return std::unique_ptr<StreamFilter>{};
+  return nullptr;
 }
 
 int64_t HttpResponse::getContentLength() const

src/LpdMessageReceiver.cc

@@ -86,11 +86,11 @@ std::unique_ptr<LpdMessage> LpdMessageReceiver::receiveMessage()
     try {
       length = socket_->readDataFrom(buf, sizeof(buf), peerAddr);
       if(length == 0) {
-        return std::unique_ptr<LpdMessage>{};
+        return nullptr;
       }
     } catch(RecoverableException& e) {
       A2_LOG_INFO_EX("Failed to receive LPD message.", e);
-      return std::unique_ptr<LpdMessage>{};
+      return nullptr;
     }
     HttpHeaderProcessor proc(HttpHeaderProcessor::SERVER_PARSER);
     try {

src/NsCookieParser.cc

@@ -61,17 +61,17 @@ std::unique_ptr<Cookie> parseNsCookie
   util::splitIter(cookieStr.begin(), cookieStr.end(), std::back_inserter(vs),
                   '\t', true);
   if(vs.size() < 6) {
-    return std::unique_ptr<Cookie>{};
+    return nullptr;
   }
   vs[0].first = util::lstripIter(vs[0].first, vs[0].second, '.');
   if(vs[5].first == vs[5].second || vs[0].first == vs[0].second ||
      !cookie::goodPath(vs[2].first, vs[2].second)) {
-    return std::unique_ptr<Cookie>{};
+    return nullptr;
   }
   int64_t expiryTime;
   if(!util::parseLLIntNoThrow(expiryTime,
                               std::string(vs[4].first, vs[4].second))) {
-    return std::unique_ptr<Cookie>{};
+    return nullptr;
   }
   if(std::numeric_limits<time_t>::max() < expiryTime) {
     expiryTime = std::numeric_limits<time_t>::max();

src/SimpleBtMessage.cc

@@ -65,7 +65,7 @@ void SimpleBtMessage::send() {
 
 std::unique_ptr<ProgressUpdate> SimpleBtMessage::getProgressUpdate()
 {
-  return std::unique_ptr<ProgressUpdate>{};
+  return nullptr;
 }
 
 } // namespace aria2

src/cookie_helper.cc

@@ -230,13 +230,13 @@ std::unique_ptr<Cookie> parse
   std::string::const_iterator eq = cookieStr.begin();
   for(; eq != nvEnd && *eq != '='; ++eq);
   if(eq == nvEnd) {
-    return std::unique_ptr<Cookie>{};
+    return nullptr;
   }
   std::pair<std::string::const_iterator,
             std::string::const_iterator> p =
     util::stripIter(cookieStr.begin(), eq);
   if(p.first == p.second) {
-    return std::unique_ptr<Cookie>{};
+    return nullptr;
   }
   Scip cookieName(p.first, p.second);
   p = util::stripIter(eq+1, nvEnd);
@@ -275,18 +275,18 @@ std::unique_ptr<Cookie> parse
       if(parseDate(expiryTime, attrp.first, attrp.second)) {
         foundExpires = true;
       } else {
-        return std::unique_ptr<Cookie>{};
+        return nullptr;
       }
     } else if(util::strieq(p.first, p.second, "max-age")) {
       if(attrp.first == attrp.second ||
          (!in(static_cast<unsigned char>(*attrp.first), 0x30u, 0x39u) &&
           *attrp.first != '-')) {
-        return std::unique_ptr<Cookie>{};
+        return nullptr;
       }
       for(std::string::const_iterator s = attrp.first+1,
             eos = attrp.second; s != eos; ++s) {
         if(!in(static_cast<unsigned char>(*s), 0x30u, 0x39u)) {
-          return std::unique_ptr<Cookie>{};
+          return nullptr;
         }
       }
       int64_t delta;
@@ -305,17 +305,17 @@ std::unique_ptr<Cookie> parse
           }
         }
       } else {
-        return std::unique_ptr<Cookie>{};
+        return nullptr;
       }
     } else if(util::strieq(p.first, p.second, "domain")) {
       if(attrp.first == attrp.second) {
-        return std::unique_ptr<Cookie>{};
+        return nullptr;
       }
       std::string::const_iterator noDot = attrp.first;
       std::string::const_iterator end = attrp.second;
       for(; noDot != end && *noDot == '.'; ++noDot);
       if(noDot == end) {
-        return std::unique_ptr<Cookie>{};
+        return nullptr;
       }
       cookieDomain.assign(noDot, end);
     } else if(util::strieq(p.first, p.second, "path")) {
@@ -348,7 +348,7 @@ std::unique_ptr<Cookie> parse
   } else if(domainMatch(canonicalizedHost, cookieDomain)) {
     hostOnly = util::isNumericHost(canonicalizedHost);
   } else {
-    return std::unique_ptr<Cookie>{};
+    return nullptr;
   }
 
   if(cookiePath.empty()) {

test/MockBtMessageFactory.h

@@ -34,90 +34,90 @@ public:
 
   virtual std::unique_ptr<BtMessage>
   createBtMessage(const unsigned char* msg, size_t msgLength) {
-    return std::unique_ptr<BtMessage>{};
+    return nullptr;
   };
 
   virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* msg, size_t msgLength) {
-    return std::unique_ptr<BtHandshakeMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* infoHash,
                          const unsigned char* peerId) {
-    return std::unique_ptr<BtHandshakeMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtRequestMessage>
   createRequestMessage(const std::shared_ptr<Piece>& piece, size_t blockIndex) {
-    return std::unique_ptr<BtRequestMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtCancelMessage>
   createCancelMessage(size_t index, int32_t begin, int32_t length) {
-    return std::unique_ptr<BtCancelMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtPieceMessage>
   createPieceMessage(size_t index, int32_t begin, int32_t length) {
-    return std::unique_ptr<BtPieceMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtHaveMessage> createHaveMessage(size_t index) {
-    return std::unique_ptr<BtHaveMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtChokeMessage> createChokeMessage() {
-    return std::unique_ptr<BtChokeMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtUnchokeMessage> createUnchokeMessage() {
-    return std::unique_ptr<BtUnchokeMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtInterestedMessage> createInterestedMessage() {
-    return std::unique_ptr<BtInterestedMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtNotInterestedMessage> createNotInterestedMessage() {
-    return std::unique_ptr<BtNotInterestedMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtBitfieldMessage> createBitfieldMessage() {
-    return std::unique_ptr<BtBitfieldMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtKeepAliveMessage> createKeepAliveMessage() {
-    return std::unique_ptr<BtKeepAliveMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtHaveAllMessage> createHaveAllMessage() {
-    return std::unique_ptr<BtHaveAllMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtHaveNoneMessage> createHaveNoneMessage() {
-    return std::unique_ptr<BtHaveNoneMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtRejectMessage>
   createRejectMessage(size_t index, int32_t begin, int32_t length) {
-    return std::unique_ptr<BtRejectMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtAllowedFastMessage> createAllowedFastMessage
   (size_t index) {
-    return std::unique_ptr<BtAllowedFastMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtPortMessage> createPortMessage(uint16_t port)
   {
-    return std::unique_ptr<BtPortMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<BtExtendedMessage>
   createBtExtendedMessage(std::unique_ptr<ExtensionMessage> extmsg)
   {
-    return std::unique_ptr<BtExtendedMessage>{};
+    return nullptr;
   }
 };
 

test/MockDHTMessageFactory.h

@@ -26,7 +26,7 @@ public:
   createQueryMessage(const Dict* dict,
                      const std::string& ipaddr, uint16_t port)
   {
-    return std::unique_ptr<DHTQueryMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<DHTResponseMessage>
@@ -46,7 +46,7 @@ public:
   createPingMessage(const std::shared_ptr<DHTNode>& remoteNode,
                     const std::string& transactionID = "")
   {
-    return std::unique_ptr<DHTPingMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<DHTPingReplyMessage>
@@ -54,7 +54,7 @@ public:
                          const unsigned char* remoteNodeID,
                          const std::string& transactionID)
   {
-    return std::unique_ptr<DHTPingReplyMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<DHTFindNodeMessage>
@@ -62,7 +62,7 @@ public:
                         const unsigned char* targetNodeID,
                         const std::string& transactionID = "")
   {
-    return std::unique_ptr<DHTFindNodeMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<DHTFindNodeReplyMessage>
@@ -71,7 +71,7 @@ public:
    std::vector<std::shared_ptr<DHTNode>> closestKNodes,
    const std::string& transactionID)
   {
-    return std::unique_ptr<DHTFindNodeReplyMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<DHTGetPeersMessage>
@@ -79,7 +79,7 @@ public:
                         const unsigned char* infoHash,
                         const std::string& transactionID)
   {
-    return std::unique_ptr<DHTGetPeersMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<DHTGetPeersReplyMessage>
@@ -90,7 +90,7 @@ public:
    const std::string& token,
    const std::string& transactionID)
   {
-    return std::unique_ptr<DHTGetPeersReplyMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<DHTAnnouncePeerMessage>
@@ -100,21 +100,21 @@ public:
                             const std::string& token,
                             const std::string& transactionID = "")
   {
-    return std::unique_ptr<DHTAnnouncePeerMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<DHTAnnouncePeerReplyMessage>
   createAnnouncePeerReplyMessage(const std::shared_ptr<DHTNode>& remoteNode,
                                  const std::string& transactionID)
   {
-    return std::unique_ptr<DHTAnnouncePeerReplyMessage>{};
+    return nullptr;
   }
 
   virtual std::unique_ptr<DHTUnknownMessage>
   createUnknownMessage(const unsigned char* data, size_t length,
                        const std::string& ipaddr, uint16_t port)
   {
-    return std::unique_ptr<DHTUnknownMessage>{};
+    return nullptr;
   }
 
   void setLocalNode(const std::shared_ptr<DHTNode>& node)