[ServiceWorker] Propagates ServiceWorker fetched response's URL and wasFetchedViaServiceWorker flag.

net/http/http_response_info.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/http/http_response_info.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/time/time.h"
 #include "net/base/auth.h"
@@ skipping 73 matching lines @@
 
   // This bit is set if the response info has connection info.
   RESPONSE_INFO_HAS_CONNECTION_INFO = 1 << 18,
 
   // This bit is set if the request has http authentication.
   RESPONSE_INFO_USE_HTTP_AUTHENTICATION = 1 << 19,
 
   // This bit is set if ssl_info has SCTs.
   RESPONSE_INFO_HAS_SIGNED_CERTIFICATE_TIMESTAMPS = 1 << 20,
 
+  // This bit is set if the response was received via a ServiceWorker .
+  RESPONSE_INFO_WAS_SERVICE_WORKER = 1 << 21,
+
   // TODO(darin): Add other bits to indicate alternate request methods.
   // For now, we don't support storing those.
 };
 
 HttpResponseInfo::HttpResponseInfo()
     : was_cached(false),
       server_data_unavailable(false),
       network_accessed(false),
       was_fetched_via_spdy(false),
       was_npn_negotiated(false),
       was_fetched_via_proxy(false),
       did_use_http_auth(false),
+      was_fetched_via_service_worker(false),
       connection_info(CONNECTION_INFO_UNKNOWN) {
 }
 
 HttpResponseInfo::HttpResponseInfo(const HttpResponseInfo& rhs)
     : was_cached(rhs.was_cached),
       server_data_unavailable(rhs.server_data_unavailable),
       network_accessed(rhs.network_accessed),
       was_fetched_via_spdy(rhs.was_fetched_via_spdy),
       was_npn_negotiated(rhs.was_npn_negotiated),
       was_fetched_via_proxy(rhs.was_fetched_via_proxy),
       proxy_server(rhs.proxy_server),
       did_use_http_auth(rhs.did_use_http_auth),
+      was_fetched_via_service_worker(rhs.was_fetched_via_service_worker),
+      original_url_via_service_worker(rhs.original_url_via_service_worker),
       socket_address(rhs.socket_address),
       npn_negotiated_protocol(rhs.npn_negotiated_protocol),
       connection_info(rhs.connection_info),
       request_time(rhs.request_time),
       response_time(rhs.response_time),
       auth_challenge(rhs.auth_challenge),
       cert_request_info(rhs.cert_request_info),
       ssl_info(rhs.ssl_info),
       headers(rhs.headers),
       vary_data(rhs.vary_data),
       metadata(rhs.metadata) {
 }
 
 HttpResponseInfo::~HttpResponseInfo() {
 }
 
 HttpResponseInfo& HttpResponseInfo::operator=(const HttpResponseInfo& rhs) {
   was_cached = rhs.was_cached;
   server_data_unavailable = rhs.server_data_unavailable;
   network_accessed = rhs.network_accessed;
   was_fetched_via_spdy = rhs.was_fetched_via_spdy;
   proxy_server = rhs.proxy_server;
   was_npn_negotiated = rhs.was_npn_negotiated;
   was_fetched_via_proxy = rhs.was_fetched_via_proxy;
   did_use_http_auth = rhs.did_use_http_auth;
+  was_fetched_via_service_worker = rhs.was_fetched_via_service_worker;
+  original_url_via_service_worker = rhs.original_url_via_service_worker;
   socket_address = rhs.socket_address;
   npn_negotiated_protocol = rhs.npn_negotiated_protocol;
   connection_info = rhs.connection_info;
   request_time = rhs.request_time;
   response_time = rhs.response_time;
   auth_challenge = rhs.auth_challenge;
   cert_request_info = rhs.cert_request_info;
   ssl_info = rhs.ssl_info;
   headers = rhs.headers;
   vary_data = rhs.vary_data;
@@ skipping 107 matching lines @@
     int value;
     if (!pickle.ReadInt(&iter, &value))
       return false;
 
     if (value > static_cast<int>(CONNECTION_INFO_UNKNOWN) &&
         value < static_cast<int>(NUM_OF_CONNECTION_INFOS)) {
       connection_info = static_cast<ConnectionInfo>(value);
     }
   }
 
+  // Read ServiceWorker info.
+  if (flags & RESPONSE_INFO_WAS_SERVICE_WORKER) {
+    std::string original_url;
+    if (!pickle.ReadString(&iter, &original_url))
+      return false;
+    original_url_via_service_worker = GURL(original_url);
+  }
+
   was_fetched_via_spdy = (flags & RESPONSE_INFO_WAS_SPDY) != 0;
 
   was_npn_negotiated = (flags & RESPONSE_INFO_WAS_NPN) != 0;
 
   was_fetched_via_proxy = (flags & RESPONSE_INFO_WAS_PROXY) != 0;
 
   *response_truncated = (flags & RESPONSE_INFO_TRUNCATED) != 0;
 
   did_use_http_auth = (flags & RESPONSE_INFO_USE_HTTP_AUTHENTICATION) != 0;
 
+  was_fetched_via_service_worker =
+      (flags & RESPONSE_INFO_WAS_SERVICE_WORKER) != 0;
+
   return true;
 }
 
 void HttpResponseInfo::Persist(Pickle* pickle,
                                bool skip_transient_headers,
                                bool response_truncated) const {
   int flags = RESPONSE_INFO_VERSION;
   if (ssl_info.is_valid()) {
     flags |= RESPONSE_INFO_HAS_CERT;
     flags |= RESPONSE_INFO_HAS_CERT_STATUS;
@@ skipping 13 matching lines @@
     flags |= RESPONSE_INFO_HAS_NPN_NEGOTIATED_PROTOCOL;
   }
   if (was_fetched_via_proxy)
     flags |= RESPONSE_INFO_WAS_PROXY;
   if (connection_info != CONNECTION_INFO_UNKNOWN)
     flags |= RESPONSE_INFO_HAS_CONNECTION_INFO;
   if (did_use_http_auth)
     flags |= RESPONSE_INFO_USE_HTTP_AUTHENTICATION;
   if (!ssl_info.signed_certificate_timestamps.empty())
     flags |= RESPONSE_INFO_HAS_SIGNED_CERTIFICATE_TIMESTAMPS;
+  if (was_fetched_via_service_worker)
+    flags |= RESPONSE_INFO_WAS_SERVICE_WORKER;
 
   pickle->WriteInt(flags);
   pickle->WriteInt64(request_time.ToInternalValue());
   pickle->WriteInt64(response_time.ToInternalValue());
 
   net::HttpResponseHeaders::PersistOptions persist_options =
       net::HttpResponseHeaders::PERSIST_RAW;
 
   if (skip_transient_headers) {
     persist_options =
@@ skipping 29 matching lines @@
     vary_data.Persist(pickle);
 
   pickle->WriteString(socket_address.host());
   pickle->WriteUInt16(socket_address.port());
 
   if (was_npn_negotiated)
     pickle->WriteString(npn_negotiated_protocol);
 
   if (connection_info != CONNECTION_INFO_UNKNOWN)
     pickle->WriteInt(static_cast<int>(connection_info));
+
+  if (was_fetched_via_service_worker)
+    pickle->WriteString(original_url_via_service_worker.spec());
 }
 
 HttpResponseInfo::ConnectionInfo HttpResponseInfo::ConnectionInfoFromNextProto(
     NextProto next_proto) {
   switch (next_proto) {
     case kProtoDeprecatedSPDY2:
       return CONNECTION_INFO_DEPRECATED_SPDY2;
     case kProtoSPDY3:
     case kProtoSPDY31:
       return CONNECTION_INFO_SPDY3;
@@ skipping 30 matching lines @@
     case CONNECTION_INFO_QUIC1_SPDY3:
       return "quic/1+spdy/3";
     case NUM_OF_CONNECTION_INFOS:
       break;
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace net