Update from https://crrev.com/316786

net/test/embedded_test_server/http_request.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/test/embedded_test_server/http_request.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "net/http/http_chunked_decoder.h"
 
 namespace net {
 namespace test_server {
 
 namespace {
 
 size_t kRequestSizeLimit = 64 * 1024 * 1024;  // 64 mb.
 
 // Helper function used to trim tokens in http request headers.
 std::string Trim(const std::string& value) {
@@ skipping 110 matching lines @@
   }
 
   // Headers done. Is any content data attached to the request?
   declared_content_length_ = 0;
   if (http_request_->headers.count("Content-Length") > 0) {
     http_request_->has_content = true;
     const bool success = base::StringToSizeT(
         http_request_->headers["Content-Length"],
         &declared_content_length_);
     DCHECK(success) << "Malformed Content-Length header's value.";
+  } else if (http_request_->headers.count("Transfer-Encoding") > 0) {
+    if (http_request_->headers["Transfer-Encoding"] == "chunked") {
+      http_request_->has_content = true;
+      chunked_decoder_.reset(new HttpChunkedDecoder());
+      state_ = STATE_CONTENT;
+      return WAITING;
+    }
   }
   if (declared_content_length_ == 0) {
     // No content data, so parsing is finished.
     state_ = STATE_ACCEPTED;
     return ACCEPTED;
   }
 
   // The request has not yet been parsed yet, content data is still to be
   // processed.
   state_ = STATE_CONTENT;
   return WAITING;
 }
 
 HttpRequestParser::ParseResult HttpRequestParser::ParseContent() {
   const size_t available_bytes = buffer_.size() - buffer_position_;
+  if (chunked_decoder_.get()) {
+    int bytes_written = chunked_decoder_->FilterBuf(
+        const_cast<char*>(buffer_.data()) + buffer_position_, available_bytes);
+    http_request_->content.append(buffer_.data() + buffer_position_,
+                                  bytes_written);
+
+    if (chunked_decoder_->reached_eof()) {
+      buffer_ =
+          buffer_.substr(buffer_.size() - chunked_decoder_->bytes_after_eof());
+      buffer_position_ = 0;
+      state_ = STATE_ACCEPTED;
+      return ACCEPTED;
+    }
+    buffer_ = "";
+    buffer_position_ = 0;
+    state_ = STATE_CONTENT;
+    return WAITING;
+  }
+
   const size_t fetch_bytes = std::min(
       available_bytes,
       declared_content_length_ - http_request_->content.size());
   http_request_->content.append(buffer_.data() + buffer_position_,
                                 fetch_bytes);
   buffer_position_ += fetch_bytes;
 
   if (declared_content_length_ == http_request_->content.size()) {
     state_ = STATE_ACCEPTED;
     return ACCEPTED;
@@ skipping 30 matching lines @@
     return METHOD_DELETE;
   } else if (token == "patch") {
     return METHOD_PATCH;
   }
   NOTREACHED() << "Method not implemented: " << token;
   return METHOD_UNKNOWN;
 }
 
 }  // namespace test_server
 }  // namespace net