Set response headers for data URL.

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.
 
 // An implementation of WebURLLoader in terms of ResourceLoaderBridge.
 
 #include "content/child/web_url_loader_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 48 matching lines @@
 using blink::WebURLResponse;
 using webkit_glue::MultipartResponseDelegate;
 using webkit_glue::ResourceDevToolsInfo;
 using webkit_glue::ResourceLoaderBridge;
 using webkit_glue::WebURLResponseExtraDataImpl;
 
 namespace content {
 
 // Utilities ------------------------------------------------------------------
 
+int GetInfoFromDataURL(const GURL& url,
+                       ResourceResponseInfo* info,
+                       std::string* data) {
+  std::string mime_type;
+  std::string charset;
+  if (!net::DataURL::Parse(url, &mime_type, &charset, data))

[darin (slow to review), 2014/06/02 16:49:25]

Keep in mind that for navigations to data: URL, we actually skip this code.
Instead, we use this code:
https://code.google.com/p/chromium/codesearch#chromium/src/net/url_request/ur...

I don't know if that matters. Maybe you want to do the same change there as well
just for future proof'ness?

[tyoshino (SeeGerritForStatus), 2014/06/03 13:04:38]

Thanks for the pointer, Darin.

Once IsToken check below is moved to DataURL::Parse, we have nothing to do on
URLRequestDataJob, I guess.

It seems the access control headers are not needed for the other use cases.
Updating URLRequestDataJob and URLRequestSimpleJob requires some more work. We
could do it in the future if needed.

+    return net::ERR_INVALID_URL;
+
+  DCHECK(!mime_type.empty());
+  DCHECK(!charset.empty());
+
+  // mime_type set by net::DataURL::Parse() is guaranteed to be in
+  //     token "/" token
+  // form. Now just ensure charset is token. The grammar for charset is not
+  // specially defined in RFC2045 and RFC2397. It just need to be token or
+  // quoted-string since it's an attribute value of media type. But charset in
+  // Content-Type header is specified explicitly to follow token ABNF in
+  // httpbis spec.
+  if (!net::HttpUtil::IsToken(charset))

[darin (slow to review), 2014/06/02 16:49:25]

perhaps this check should be performed by net::DataURL::Parse? there are other
callers of net::DataURL::Parse, and shouldn't they have the similar IsToken
check?

[tyoshino (SeeGerritForStatus), 2014/06/03 13:04:38]

It's worth doing for spec compliance. However, it widens impact of this change
(lots of DataURL::Parse users).

+    return net::ERR_INVALID_URL;
+
+  // Assure same time for all time fields of data: URLs.
+  Time now = Time::Now();
+  info->load_timing.request_start = TimeTicks::Now();
+  info->load_timing.request_start_time = now;
+  info->request_time = now;
+  info->response_time = now;
+
+  scoped_refptr<net::HttpResponseHeaders> headers(
+      new net::HttpResponseHeaders(std::string()));
+  headers->ReplaceStatusLine("HTTP/1.1 200 OK");
+  std::string content_type_header =
+      "Content-Type: " + mime_type + ";charset=" + charset;
+  headers->AddHeader(content_type_header);
+  headers->AddHeader("Access-Control-Allow-Origin: *");
+  info->headers = headers;
+
+  info->mime_type.swap(mime_type);
+  info->charset.swap(charset);
+  info->security_info.clear();
+  info->content_length = data->length();
+  info->encoded_data_length = 0;
+
+  return net::OK;
+}
+
 namespace {
 
 const char kThrottledErrorDescription[] =
     "Request throttled. Visit http://dev.chromium.org/throttling for more "
     "information.";
 
 class HeaderFlattener : public WebHTTPHeaderVisitor {
  public:
   explicit HeaderFlattener(int load_flags)
       : load_flags_(load_flags),
@@ skipping 39 matching lines @@
     }
     return buffer_;
   }
 
  private:
   int load_flags_;
   std::string buffer_;
   bool has_accept_header_;
 };
 
-// Extracts the information from a data: url.
-bool GetInfoFromDataURL(const GURL& url,
-                        ResourceResponseInfo* info,
-                        std::string* data,
-                        int* error_code) {
-  std::string mime_type;
-  std::string charset;
-  if (net::DataURL::Parse(url, &mime_type, &charset, data)) {
-    *error_code = net::OK;
-    // Assure same time for all time fields of data: URLs.
-    Time now = Time::Now();
-    info->load_timing.request_start = TimeTicks::Now();
-    info->load_timing.request_start_time = now;
-    info->request_time = now;
-    info->response_time = now;
-    info->headers = NULL;
-    info->mime_type.swap(mime_type);
-    info->charset.swap(charset);
-    info->security_info.clear();
-    info->content_length = data->length();
-    info->encoded_data_length = 0;
-
-    return true;
-  }
-
-  *error_code = net::ERR_INVALID_URL;
-  return false;
-}
-
 typedef ResourceDevToolsInfo::HeadersVector 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 148 matching lines @@
   DCHECK(!bridge_.get());
 
   request_ = request;  // Save the request.
 
   GURL url = request.url();
   if (url.SchemeIs("data") && CanHandleDataURL(url)) {
     if (sync_load_response) {
       // This is a sync load. Do the work now.
       sync_load_response->url = url;
       std::string data;
-      GetInfoFromDataURL(sync_load_response->url, sync_load_response,
-                         &sync_load_response->data,
-                         &sync_load_response->error_code);
+      sync_load_response->error_code =
+          GetInfoFromDataURL(sync_load_response->url, sync_load_response,
+                             &sync_load_response->data);
     } else {
       AddRef();  // Balanced in OnCompletedRequest
       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(&Context::HandleDataURL, this));
     }
     return;
   }
 
   GURL referrer_url(
       request.httpHeaderField(WebString::fromUTF8("Referer")).latin1());
@@ skipping 335 matching lines @@
   std::string mime_type, unused_charset;
   if (net::DataURL::Parse(url, &mime_type, &unused_charset, NULL) &&
       net::IsSupportedMimeType(mime_type))
     return true;
 
   return false;
 }
 
 void WebURLLoaderImpl::Context::HandleDataURL() {
   ResourceResponseInfo info;
-  int error_code;
   std::string data;
 
-  if (GetInfoFromDataURL(request_.url(), &info, &data, &error_code)) {
+  int error_code = GetInfoFromDataURL(request_.url(), &info, &data);
+  if (error_code == net::OK) {
     OnReceivedResponse(info);
     if (!data.empty())
       OnReceivedData(data.data(), data.size(), 0);
   }
 
   OnCompletedRequest(error_code, false, false, info.security_info,
                      base::TimeTicks::Now(), 0);
 }
 
 // WebURLLoaderImpl -----------------------------------------------------------
@@ skipping 175 matching lines @@
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 void WebURLLoaderImpl::didChangePriority(WebURLRequest::Priority new_priority,
                                          int intra_priority_value) {
   context_->DidChangePriority(new_priority, intra_priority_value);
 }
 
 }  // namespace content