Use std::unique_ptr for HttpRequest instead of std::shared_ptr

8 files changed, 50 insertions, 69 deletions

diff --git a/src/AbstractProxyRequestCommand.cc b/src/AbstractProxyRequestCommand.cc
index 4e8d83ac..f515bd68 100644
--- a/src/AbstractProxyRequestCommand.cc
+++ b/src/AbstractProxyRequestCommand.cc
@@ -74,12 +74,12 @@ AbstractProxyRequestCommand::~AbstractProxyRequestCommand() {}
 bool AbstractProxyRequestCommand::executeInternal() {
   //socket->setBlockingMode();
   if(httpConnection_->sendBufferIsEmpty()) {
-    std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+    auto httpRequest = make_unique<HttpRequest>();
     httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT));
     httpRequest->setRequest(getRequest());
     httpRequest->setProxyRequest(proxyRequest_);
 
-    httpConnection_->sendProxyRequest(httpRequest);
+    httpConnection_->sendProxyRequest(std::move(httpRequest));
   } else {
     httpConnection_->sendPendingData();
   }
diff --git a/src/FtpNegotiationCommand.cc b/src/FtpNegotiationCommand.cc
index af0f80e1..ef943859 100644
--- a/src/FtpNegotiationCommand.cc
+++ b/src/FtpNegotiationCommand.cc
@@ -734,7 +734,7 @@ bool FtpNegotiationCommand::sendTunnelRequest()
         }
       }
     }
-    std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+    auto httpRequest = make_unique<HttpRequest>();
     httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT));
     std::shared_ptr<Request> req(new Request());
     // Construct fake URI in order to use HttpRequest
@@ -749,7 +749,7 @@ bool FtpNegotiationCommand::sendTunnelRequest()
     }
     httpRequest->setRequest(req);
     httpRequest->setProxyRequest(createProxyRequest());
-    http_->sendProxyRequest(httpRequest);
+    http_->sendProxyRequest(std::move(httpRequest));
   } else {
     http_->sendPendingData();
   }
diff --git a/src/HttpConnection.cc b/src/HttpConnection.cc
index f3925295..42ca5d7f 100644
--- a/src/HttpConnection.cc
+++ b/src/HttpConnection.cc
@@ -62,12 +62,15 @@
 namespace aria2 {
 
 HttpRequestEntry::HttpRequestEntry
-(const std::shared_ptr<HttpRequest>& httpRequest)
-  : httpRequest_{httpRequest},
+(std::unique_ptr<HttpRequest> httpRequest)
+  : httpRequest_{std::move(httpRequest)},
     proc_{make_unique<HttpHeaderProcessor>(HttpHeaderProcessor::CLIENT_PARSER)}
 {}
 
-HttpRequestEntry::~HttpRequestEntry() {}
+std::unique_ptr<HttpRequest> HttpRequestEntry::popHttpRequest()
+{
+  return std::move(httpRequest_);
+}
 
 const std::unique_ptr<HttpHeaderProcessor>&
 HttpRequestEntry::getHttpHeaderProcessor() const
@@ -106,7 +109,7 @@ std::string HttpConnection::eraseConfidentialInfo(const std::string& request)
 }
 
 void HttpConnection::sendRequest
-(const std::shared_ptr<HttpRequest>& httpRequest, std::string request)
+(std::unique_ptr<HttpRequest> httpRequest, std::string request)
 {
   A2_LOG_INFO(fmt(MSG_SENDING_REQUEST,
                   cuid_,
@@ -114,19 +117,19 @@ void HttpConnection::sendRequest
   socketBuffer_.pushStr(std::move(request));
   socketBuffer_.send();
   outstandingHttpRequests_.push_back(make_unique<HttpRequestEntry>
-                                     (httpRequest));
+                                     (std::move(httpRequest)));
 }
 
 void HttpConnection::sendRequest
-(const std::shared_ptr<HttpRequest>& httpRequest)
+(std::unique_ptr<HttpRequest> httpRequest)
 {
-  sendRequest(httpRequest, httpRequest->createRequest());
+  sendRequest(std::move(httpRequest), httpRequest->createRequest());
 }
 
 void HttpConnection::sendProxyRequest
-(const std::shared_ptr<HttpRequest>& httpRequest)
+(std::unique_ptr<HttpRequest> httpRequest)
 {
-  sendRequest(httpRequest, httpRequest->createProxyRequest());
+  sendRequest(std::move(httpRequest), httpRequest->createProxyRequest());
 }
 
 std::unique_ptr<HttpResponse> HttpConnection::receiveResponse()
@@ -150,7 +153,7 @@ std::unique_ptr<HttpResponse> HttpConnection::receiveResponse()
     httpResponse->setCuid(cuid_);
     httpResponse->setHttpHeader(proc->getResult());
     httpResponse->setHttpRequest(outstandingHttpRequests_.front()->
-                                 getHttpRequest());
+                                 popHttpRequest());
     socketRecvBuffer_->shiftBuffer(proc->getLastBytesProcessed());
     outstandingHttpRequests_.pop_front();
     return httpResponse;
@@ -170,15 +173,6 @@ bool HttpConnection::isIssued(const std::shared_ptr<Segment>& segment) const
   return false;
 }
 
-std::shared_ptr<HttpRequest> HttpConnection::getFirstHttpRequest() const
-{
-  if(outstandingHttpRequests_.empty()) {
-    return std::shared_ptr<HttpRequest>();
-  } else {
-    return outstandingHttpRequests_.front()->getHttpRequest();
-  }
-}
-
 bool HttpConnection::sendBufferIsEmpty() const
 {
   return socketBuffer_.sendBufferIsEmpty();
diff --git a/src/HttpConnection.h b/src/HttpConnection.h
index 70c133f8..1a8cef5d 100644
--- a/src/HttpConnection.h
+++ b/src/HttpConnection.h
@@ -56,18 +56,18 @@ class SocketRecvBuffer;
 
 class HttpRequestEntry {
 private:
-  std::shared_ptr<HttpRequest> httpRequest_;
+  std::unique_ptr<HttpRequest> httpRequest_;
   std::unique_ptr<HttpHeaderProcessor> proc_;
 public:
-  HttpRequestEntry(const std::shared_ptr<HttpRequest>& httpRequest);
+  HttpRequestEntry(std::unique_ptr<HttpRequest> httpRequest);
 
-  ~HttpRequestEntry();
-
-  const std::shared_ptr<HttpRequest>& getHttpRequest() const
+  const std::unique_ptr<HttpRequest>& getHttpRequest() const
   {
     return httpRequest_;
   }
 
+  std::unique_ptr<HttpRequest> popHttpRequest();
+
   const std::unique_ptr<HttpHeaderProcessor>& getHttpHeaderProcessor() const;
 };
 
@@ -84,7 +84,7 @@ private:
 
   std::string eraseConfidentialInfo(const std::string& request);
   void sendRequest
-  (const std::shared_ptr<HttpRequest>& httpRequest, std::string request);
+  (std::unique_ptr<HttpRequest> httpRequest, std::string request);
 public:
   HttpConnection
   (cuid_t cuid,
@@ -99,12 +99,12 @@ public:
    * HTTP proxy(GET method).
    * @param segment indicates starting postion of the file for downloading
    */
-  void sendRequest(const std::shared_ptr<HttpRequest>& httpRequest);
+  void sendRequest(std::unique_ptr<HttpRequest> httpRequest);
 
   /**
    * Sends Http proxy request using CONNECT method.
    */
-  void sendProxyRequest(const std::shared_ptr<HttpRequest>& httpRequest);
+  void sendProxyRequest(std::unique_ptr<HttpRequest> httpRequest);
 
   /**
    * Receives HTTP response from the server and returns HttpResponseHandle
@@ -119,8 +119,6 @@ public:
    */
   std::unique_ptr<HttpResponse> receiveResponse();
 
-  std::shared_ptr<HttpRequest> getFirstHttpRequest() const;
-
   bool isIssued(const std::shared_ptr<Segment>& segment) const;
 
   bool sendBufferIsEmpty() const;
diff --git a/src/HttpRequestCommand.cc b/src/HttpRequestCommand.cc
index 34b708a1..c92d2a4f 100644
--- a/src/HttpRequestCommand.cc
+++ b/src/HttpRequestCommand.cc
@@ -82,7 +82,7 @@ HttpRequestCommand::HttpRequestCommand
 HttpRequestCommand::~HttpRequestCommand() {}
 
 namespace {
-std::shared_ptr<HttpRequest>
+std::unique_ptr<HttpRequest>
 createHttpRequest(const std::shared_ptr<Request>& req,
                   const std::shared_ptr<FileEntry>& fileEntry,
                   const std::shared_ptr<Segment>& segment,
@@ -92,7 +92,7 @@ createHttpRequest(const std::shared_ptr<Request>& req,
                   const std::shared_ptr<Request>& proxyRequest,
                   int64_t endOffset = 0)
 {
-  std::shared_ptr<HttpRequest> httpRequest(new HttpRequest());
+  auto httpRequest = make_unique<HttpRequest>();
   httpRequest->setUserAgent(option->get(PREF_USER_AGENT));
   httpRequest->setRequest(req);
   httpRequest->setFileEntry(fileEntry);
@@ -135,14 +135,13 @@ bool HttpRequestCommand::executeInternal() {
     }
 #endif // ENABLE_SSL
     if(getSegments().empty()) {
-      std::shared_ptr<HttpRequest> httpRequest
-        (createHttpRequest(getRequest(),
-                           getFileEntry(),
-                           std::shared_ptr<Segment>(),
-                           getOption(),
-                           getRequestGroup(),
-                           getDownloadEngine(),
-                           proxyRequest_));
+      auto httpRequest = createHttpRequest(getRequest(),
+                                           getFileEntry(),
+                                           std::shared_ptr<Segment>(),
+                                           getOption(),
+                                           getRequestGroup(),
+                                           getDownloadEngine(),
+                                           proxyRequest_);
       if(getOption()->getAsBool(PREF_CONDITIONAL_GET) &&
          (getRequest()->getProtocol() == "http" ||
           getRequest()->getProtocol() == "https")) {
@@ -167,12 +166,9 @@ bool HttpRequestCommand::executeInternal() {
           }
         }
       }
-      httpConnection_->sendRequest(httpRequest);
+      httpConnection_->sendRequest(std::move(httpRequest));
     } else {
-      for(std::vector<std::shared_ptr<Segment> >::const_iterator itr =
-            getSegments().begin(), eoi = getSegments().end();
-          itr != eoi; ++itr) {
-        const std::shared_ptr<Segment>& segment = *itr;
+      for(auto& segment : getSegments()) {
         if(!httpConnection_->isIssued(segment)) {
           int64_t endOffset = 0;
           // FTP via HTTP proxy does not support end byte marker
@@ -185,16 +181,14 @@ bool HttpRequestCommand::executeInternal() {
                getFileEntry()->gtoloff
                (static_cast<int64_t>(segment->getSegmentLength())*nextIndex));
           }
-          std::shared_ptr<HttpRequest> httpRequest
-            (createHttpRequest(getRequest(),
-                               getFileEntry(),
-                               segment,
-                               getOption(),
-                               getRequestGroup(),
-                               getDownloadEngine(),
-                               proxyRequest_,
-                               endOffset));
-          httpConnection_->sendRequest(httpRequest);
+          httpConnection_->sendRequest(createHttpRequest(getRequest(),
+                                                         getFileEntry(),
+                                                         segment,
+                                                         getOption(),
+                                                         getRequestGroup(),
+                                                         getDownloadEngine(),
+                                                         proxyRequest_,
+                                                         endOffset));
         }
       }
     }
diff --git a/src/HttpResponse.cc b/src/HttpResponse.cc
index 33341f0c..4741c5ce 100644
--- a/src/HttpResponse.cc
+++ b/src/HttpResponse.cc
@@ -68,11 +68,9 @@
 namespace aria2 {
 
 HttpResponse::HttpResponse()
-  : cuid_(0)
+  : cuid_{0}
 {}
 
-HttpResponse::~HttpResponse() {}
-
 void HttpResponse::validateResponse() const
 {
   int statusCode = getStatusCode();
@@ -266,9 +264,9 @@ const std::unique_ptr<HttpHeader>& HttpResponse::getHttpHeader() const
   return httpHeader_;
 }
 
-void HttpResponse::setHttpRequest(const std::shared_ptr<HttpRequest>& httpRequest)
+void HttpResponse::setHttpRequest(std::unique_ptr<HttpRequest> httpRequest)
 {
-  httpRequest_ = httpRequest;
+  httpRequest_ = std::move(httpRequest);
 }
 
 int HttpResponse::getStatusCode() const
diff --git a/src/HttpResponse.h b/src/HttpResponse.h
index eb4bad18..e2c29a62 100644
--- a/src/HttpResponse.h
+++ b/src/HttpResponse.h
@@ -56,13 +56,11 @@ class Checksum;
 class HttpResponse {
 private:
   cuid_t cuid_;
-  std::shared_ptr<HttpRequest> httpRequest_;
+  std::unique_ptr<HttpRequest> httpRequest_;
   std::unique_ptr<HttpHeader> httpHeader_;
 public:
   HttpResponse();
 
-  ~HttpResponse();
-
   void validateResponse() const;
 
   /**
@@ -109,9 +107,9 @@ public:
 
   int getStatusCode() const;
 
-  void setHttpRequest(const std::shared_ptr<HttpRequest>& httpRequest);
+  void setHttpRequest(std::unique_ptr<HttpRequest> httpRequest);
 
-  const std::shared_ptr<HttpRequest>& getHttpRequest() const
+  const std::unique_ptr<HttpRequest>& getHttpRequest() const
   {
     return httpRequest_;
   }
diff --git a/src/HttpResponseCommand.cc b/src/HttpResponseCommand.cc
index fc4b9021..04824a8f 100644
--- a/src/HttpResponseCommand.cc
+++ b/src/HttpResponseCommand.cc
@@ -151,7 +151,6 @@ HttpResponseCommand::~HttpResponseCommand() {}
 
 bool HttpResponseCommand::executeInternal()
 {
-  std::shared_ptr<HttpRequest> httpRequest =httpConnection_->getFirstHttpRequest();
   auto httpResponse = httpConnection_->receiveResponse();
   if(!httpResponse) {
     // The server has not responded to our request yet.