[ServiceWorker] Fills SSLInfo of the response from a SW with the SSLInfo of the SW script.

content/browser/service_worker/service_worker_url_request_job.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/browser/service_worker/service_worker_url_request_job.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 520 matching lines @@
   // Treat a response whose status is 0 as a Network Error.
   if (response.status_code == 0) {
     NotifyDone(
         net::URLRequestStatus(net::URLRequestStatus::FAILED, net::ERR_FAILED));
     return;
   }
 
   fetch_end_time_ = base::TimeTicks::Now();
   load_timing_info_.send_end = fetch_end_time_;
 
+  // Creates a new HttpResponseInfo using the the ServiceWorker script's
+  // HttpResponseInfo to show HTTPS padlock.
+  // TODO(horo): When we support mixed-content (HTTP) no-cors requests from a
+  // ServiceWorker, we have to check the security level of the responses.
+  DCHECK(!http_response_info_);
+  const net::HttpResponseInfo* main_script_http_info =
+      provider_host_->active_version()->GetMainScriptHttpResponseInfo();
+  DCHECK(main_script_http_info);
+  http_response_info_.reset(new net::HttpResponseInfo(*main_script_http_info));
+
   // Set up a request for reading the stream.
   if (response.stream_url.is_valid()) {
     DCHECK(response.blob_uuid.empty());
     DCHECK(provider_host_->active_version());
     streaming_version_ = provider_host_->active_version();
     streaming_version_->AddStreamingURLRequestJob(this);
     response_url_ = response.url;
     service_worker_response_type_ = response.response_type;
     CreateResponseHeader(
         response.status_code, response.status_text, response.headers);
@@ skipping 52 matching lines @@
     std::string header;
     header.reserve(it->first.size() + 2 + it->second.size());
     header.append(it->first);
     header.append(": ");
     header.append(it->second);
     http_response_headers_->AddHeader(header);
   }
 }
 
 void ServiceWorkerURLRequestJob::CommitResponseHeader() {
-  http_response_info_.reset(new net::HttpResponseInfo());
+  if (!http_response_info_)
+    http_response_info_.reset(new net::HttpResponseInfo());
   http_response_info_->headers.swap(http_response_headers_);
+  http_response_info_->vary_data = net::HttpVaryData();
+  http_response_info_->metadata = nullptr;
   NotifyHeadersComplete();

[Ryan Sleevi, 2015/01/30 23:20:43]

My understanding is that |request_time| and |response_time| are (eventually)
serviced up via Public API (Navigation Timing, I believe).

Should this information be made consistent with SW to reflect SW execution time?
(NB: I'm fine pushing that aspect to a separate detail, but I do want to make
sure it's considered)

[horo, 2015/01/31 08:34:07]

Ah, in current implementation, info->request_time is set in URLRequest::Start()
but is overwritten to 0 in ServiceWorkerURLRequestJob::GetResponseInfo().
This is bug.
I changed GetResponseInfo() not to overwrite request_time.

info->response_time is correctly set to response_time_ in GetResponseInfo().

 }
 
 void ServiceWorkerURLRequestJob::DeliverErrorResponse() {
   // TODO(falken): Print an error to the console of the ServiceWorker and of
   // the requesting page.
   CreateResponseHeader(
       500, "Service Worker Response Error", ServiceWorkerHeaderMap());
   CommitResponseHeader();
 }
 
 void ServiceWorkerURLRequestJob::ClearStream() {
   if (streaming_version_) {
     streaming_version_->RemoveStreamingURLRequestJob(this);
     streaming_version_ = nullptr;
   }
   if (stream_) {
     stream_->RemoveReadObserver(this);
     stream_->Abort();
     stream_ = nullptr;
   }
   if (!waiting_stream_url_.is_empty()) {
     StreamRegistry* stream_registry =
         GetStreamContextForResourceContext(resource_context_)->registry();
     stream_registry->RemoveRegisterObserver(waiting_stream_url_);
     stream_registry->AbortPendingStream(waiting_stream_url_);
   }
 }
 
 }  // namespace content