remove buffer copy

chenzhaoyu · chenzhaoyu · commit 4fc7dda5f121 · 2016-12-01T17:14:28.000+09:00
diff --git a/boost/network/protocol/http/client/connection/async_normal.hpp b/boost/network/protocol/http/client/connection/async_normal.hpp
@@ -367,21 +367,14 @@ struct http_async_connection
                 this->part_begin;
             typename protocol_base::buffer_type::const_iterator end = begin;
             std::advance(end, remainder);
-            string_type body_string(begin, end);
-            if (check_parse_body_complete(body_string)) {
-              this->append_body(remainder);
-              handle_received_data(body, get_body, callback,
-                                   boost::asio::error::eof, bytes_transferred);
-            } else {
-              this->parse_body(
-                delegate_,
-                request_strand_.wrap([=] (boost::system::error_code const &ec,
-                                          std::size_t bytes_transferred) {
-                                       self->handle_received_data(body, get_body, callback,
-                                                                  ec, bytes_transferred);
-                                     }),
-                remainder);
-            }
+            this->parse_body(
+              delegate_,
+              request_strand_.wrap([=] (boost::system::error_code const &ec,
+                                        std::size_t bytes_transferred) {
+                                     self->handle_received_data(body, get_body, callback,
+                                                                ec, bytes_transferred);
+                                   }),
+              remainder);
           }
           return;
         case body:
@@ -439,25 +432,17 @@ struct http_async_connection
                                                                     ec, bytes_transferred);
                                        }));
             } else {
-              string_type body_string(this->partial_parsed);
-              body_string.append(this->part.begin(), bytes_transferred);
-              if (check_parse_body_complete (body_string)) {
-                this->append_body(bytes_transferred);
-                handle_received_data(body, get_body, callback,
-                                     boost::asio::error::eof, bytes_transferred);
-              } else {
-                // Here we don't have a body callback. Let's make sure that we
-                // deal with the remainder from the headers part in case we do
-                // have data that's still in the buffer.
-                this->parse_body(
-                  delegate_,
-                  request_strand_.wrap([=] (boost::system::error_code const &ec,
-                                            std::size_t bytes_transferred) {
-                                         self->handle_received_data(body, get_body, callback,
-                                                                    ec, bytes_transferred);
-                                       }),
-                  bytes_transferred);
-              }
+              // Here we don't have a body callback. Let's make sure that we
+              // deal with the remainder from the headers part in case we do
+              // have data that's still in the buffer.
+              this->parse_body(
+                delegate_,
+                request_strand_.wrap([=] (boost::system::error_code const &ec,
+                                          std::size_t bytes_transferred) {
+                                       self->handle_received_data(body, get_body, callback,
+                                                                  ec, bytes_transferred);
+                                     }),
+                bytes_transferred);
             }
           }
           return;
@@ -495,50 +480,6 @@ struct http_async_connection
     }
   }
 
-  inline bool check_parse_body_complete(string_type& body_string)
-  {
-    if (this->is_chunk_encoding) {
-      return parse_chunk_encoding_complete(body_string);
-    }
-    if (this->is_content_length && this->content_length >= 0) {
-      return parse_content_length_complete(body_string, this->content_length);
-    }
-    return false;
-  }
-
-  inline bool parse_content_length_complete(string_type& body_string, size_t content_length){
-    return body_string.length() >= content_length;
-  }
-
-  bool parse_chunk_encoding_complete(string_type& body_string) {
-    string_type body;
-    string_type crlf = "\r\n";
-
-    typename string_type::iterator begin = body_string.begin();
-    for (typename string_type::iterator iter =
-             std::search(begin, body_string.end(), crlf.begin(), crlf.end());
-         iter != body_string.end();
-         iter =
-             std::search(begin, body_string.end(), crlf.begin(), crlf.end())) {
-      string_type line(begin, iter);
-      if (line.empty()) {
-          std::advance(iter, 2);
-          begin = iter;
-          continue;
-      }
-      std::stringstream stream(line);
-      int len;
-      stream >> std::hex >> len;
-      std::advance(iter, 2);
-      if (!len) return true;
-      if (len <= body_string.end() - iter) {
-        std::advance(iter, len + 2);
-      }
-      begin = iter;
-    }
-    return false;
-  }
-
   string_type parse_chunk_encoding(string_type& body_string) {
     string_type body;
     string_type crlf = "\r\n";
diff --git a/boost/network/protocol/http/client/connection/async_protocol_handler.hpp b/boost/network/protocol/http/client/connection/async_protocol_handler.hpp
@@ -333,9 +333,47 @@ struct http_async_protocol_handler {
         parsed_ok, std::distance(std::end(result_range), part_end));
   }
 
-  void append_body(size_t bytes) {
-    partial_parsed.append(part_begin, part_begin + bytes);
-    part_begin = part.begin();
+  inline bool check_parse_body_complete() const {
+    if (this->is_chunk_encoding) {
+      return parse_chunk_encoding_complete();
+    }
+    if (this->is_content_length && this->content_length >= 0) {
+      return parse_content_length_complete();
+    }
+    return false;
+  }
+  
+  inline bool parse_content_length_complete() const {
+    return this->partial_parsed.length() >= this-> content_length;
+  }
+
+  bool parse_chunk_encoding_complete() const {
+    string_type body;
+    string_type crlf = "\r\n";
+
+    typename string_type::const_iterator begin = partial_parsed.begin();
+    for (typename string_type::const_iterator iter =
+             std::search(begin, partial_parsed.end(), crlf.begin(), crlf.end());
+         iter != partial_parsed.end();
+         iter =
+             std::search(begin, partial_parsed.end(), crlf.begin(), crlf.end())) {
+      string_type line(begin, iter);
+      if (line.empty()) {
+          std::advance(iter, 2);
+          begin = iter;
+          continue;
+      }
+      std::stringstream stream(line);
+      int len;
+      stream >> std::hex >> len;
+      std::advance(iter, 2);
+      if (!len) return true;
+      if (len <= partial_parsed.end() - iter) {
+        std::advance(iter, len + 2);
+      }
+      begin = iter;
+    }
+    return false;
   }
 
   template <class Delegate, class Callback>
@@ -344,8 +382,12 @@ struct http_async_protocol_handler {
     // buffer.
     partial_parsed.append(part_begin, part_begin + bytes);
     part_begin = part.begin();
-    delegate_->read_some(
-        boost::asio::mutable_buffers_1(part.data(), part.size()), callback);
+    if (check_parse_body_complete()) {
+      callback(boost::asio::error::eof, bytes);
+    } else {
+      delegate_->read_some(
+          boost::asio::mutable_buffers_1(part.data(), part.size()), callback);
+    }
   }
 
   typedef response_parser<Tag> response_parser_type;
