Move multipart resource handling to core/fetch (1/2)

content/child/web_url_loader_impl.cc

 // Copyright 2014 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 "content/child/web_url_loader_impl.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 65 matching lines @@
 using blink::WebURLLoaderClient;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 
 namespace content {
 
 // Utilities ------------------------------------------------------------------
 
 namespace {
 
+// The list of response headers that we do not copy from the original
+// response when generating a WebURLResponse for a MIME payload.
+const char* kReplaceHeaders[] = {
+  "content-type",
+  "content-length",
+  "content-disposition",
+  "content-range",
+  "range",
+  "set-cookie"
+};
+
 using HeadersVector = ResourceDevToolsInfo::HeadersVector;
 
 // Converts timing data from |load_timing| to the format used by WebKit.
 void PopulateURLLoadTiming(const net::LoadTimingInfo& load_timing,
                            WebURLLoadTiming* url_timing) {
   DCHECK(!load_timing.request_start.is_null());
 
   const TimeTicks kNullTicks;
   url_timing->initialize();
   url_timing->setRequestTime(
@@ skipping 1057 matching lines @@
   return context_->AttachThreadedDataReceiver(threaded_data_receiver);
 }
 
 void WebURLLoaderImpl::setLoadingTaskRunner(
     blink::WebTaskRunner* loading_task_runner) {
   // There's no guarantee on the lifetime of |loading_task_runner| so we take a
   // copy.
   context_->SetWebTaskRunner(make_scoped_ptr(loading_task_runner->clone()));
 }
 
+bool WebURLLoaderImpl::ParseAdditionalHeaders(

[hiroshige, 2016/02/25 18:10:24]

What is the reason to place ParseAdditionalHeaders() here under content//, while
moving the other parts to Blink?

[yhirano, 2016/02/25 18:35:13]

Because I want to use net:: functions.

[hiroshige, 2016/02/25 21:46:31]

Hmm.
The code around this has some issues: |kReplaceHeaders| is duplicated in
content// and Blink, ResourceResponse is converted into WebURLResponse and then
back to ResourceResponse.

But currently I haven't come up with better implementation, and I don't want to
this issue to block this CL (having MultipartImageResourceParser in Blink will
result in greater benefits than issues here).
How about leaving TODO comments that mentions why
MultipartImageResourceParser::parseHeaders()
WebURLLoaderImpl::ParseAdditionalHeaders() are separated and that they should be
clean up?

+    const char* bytes,
+    size_t size,
+    blink::WebURLResponse* response,
+    size_t* end) {
+  int headers_end_pos =
+      net::HttpUtil::LocateEndOfAdditionalHeaders(bytes, size, 0);
+
+  if (headers_end_pos < 0)
+    return false;
+
+  *end = headers_end_pos;
+  // Eat headers and prepend a status line as is required by
+  // HttpResponseHeaders.
+  std::string headers("HTTP/1.1 200 OK\r\n");
+  headers.append(bytes, headers_end_pos);
+
+  scoped_refptr<net::HttpResponseHeaders> response_headers =
+      new net::HttpResponseHeaders(
+          net::HttpUtil::AssembleRawHeaders(headers.c_str(), headers.size()));
+
+  std::string mime_type;
+  response_headers->GetMimeType(&mime_type);
+  response->setMIMEType(WebString::fromUTF8(mime_type));
+
+  std::string charset;
+  response_headers->GetCharset(&charset);
+  response->setTextEncodingName(WebString::fromUTF8(charset));
+
+  // Copy headers listed in kReplaceHeaders to the response.
+  for (size_t i = 0; i < arraysize(kReplaceHeaders); ++i) {
+    std::string name(kReplaceHeaders[i]);
+    std::string value;
+    size_t iterator = 0;
+    while (response_headers->EnumerateHeader(&iterator, name, &value)) {
+      response->addHTTPHeaderField(WebString::fromLatin1(name),
+                                   WebString::fromLatin1(value));
+    }
+  }
+  return true;
+}
+
 }  // namespace content