Set service worker response info data for foreign fetch intercepted fetches.

content/browser/service_worker/service_worker_controllee_request_handler.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_controllee_request_handler.h"
 
 #include <memory>
 #include <string>
 
 #include "base/trace_event/trace_event.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_registration.h"
+#include "content/browser/service_worker/service_worker_response_info.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/common/resource_request_body.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/resource_response_info.h"
 #include "net/base/load_flags.h"
 #include "net/base/url_util.h"
 #include "net/url_request/url_request.h"
@@ skipping 18 matching lines @@
       is_main_resource_load_(
           ServiceWorkerUtils::IsMainResourceType(resource_type)),
       request_mode_(request_mode),
       credentials_mode_(credentials_mode),
       redirect_mode_(redirect_mode),
       request_context_type_(request_context_type),
       frame_type_(frame_type),
       body_(body),
       force_update_started_(false),
       use_network_(false),
-      was_fetched_via_service_worker_(false),
-      was_fallback_required_(false),
-      response_type_via_service_worker_(
-          blink::WebServiceWorkerResponseTypeDefault),
       weak_factory_(this) {}
 
 ServiceWorkerControlleeRequestHandler::
     ~ServiceWorkerControlleeRequestHandler() {
   // Navigation triggers an update to occur shortly after the page and
   // its initial subresources load.
   if (provider_host_ && provider_host_->active_version()) {
     if (is_main_resource_load_ && !force_update_started_)
       provider_host_->active_version()->ScheduleUpdate();
     else
       provider_host_->active_version()->DeferScheduledUpdate();
   }
 
   if (is_main_resource_load_ && provider_host_)
     provider_host_->SetAllowAssociation(true);
 }
 
 net::URLRequestJob* ServiceWorkerControlleeRequestHandler::MaybeCreateJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     ResourceContext* resource_context) {
   ClearJob();
+  ServiceWorkerResponseInfo::ResetDataForRequest(request);
 
   if (!context_ || !provider_host_) {
     // We can't do anything other than to fall back to network.
     return NULL;
   }
 
   // This may get called multiple times for original and redirect requests:
   // A. original request case: use_network_ is false, no previous location info.
   // B. redirect or restarted request case:
   //  a) use_network_ is false if the previous location was forwarded to SW.
@@ skipping 37 matching lines @@
     if (!is_main_resource_load_)
       use_network_ = true;
 
     job.reset();
     ClearJob();
   }
 
   return job.release();
 }
 
-void ServiceWorkerControlleeRequestHandler::GetExtraResponseInfo(
-    ResourceResponseInfo* response_info) const {
-  response_info->was_fetched_via_service_worker =
-      was_fetched_via_service_worker_;
-  response_info->was_fallback_required_by_service_worker =
-      was_fallback_required_;
-  response_info->original_url_via_service_worker =
-      original_url_via_service_worker_;
-  response_info->response_type_via_service_worker =
-      response_type_via_service_worker_;
-  response_info->service_worker_start_time = service_worker_start_time_;
-  response_info->service_worker_ready_time = service_worker_ready_time_;
-  response_info->is_in_cache_storage = response_is_in_cache_storage_;
-  response_info->cache_storage_cache_name = response_cache_storage_cache_name_;
-}
-
 void ServiceWorkerControlleeRequestHandler::PrepareForMainResource(
     const net::URLRequest* request) {
   DCHECK(job_.get());
   DCHECK(context_);
   DCHECK(provider_host_);
   TRACE_EVENT_ASYNC_BEGIN1(
       "ServiceWorker",
       "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
       job_.get(),
       "URL", request->url().spec());
@@ skipping 204 matching lines @@
                  weak_factory_.GetWeakPtr(), registration, version));
 }
 
 void ServiceWorkerControlleeRequestHandler::PrepareForSubResource() {
   DCHECK(job_.get());
   DCHECK(context_);
   DCHECK(provider_host_->active_version());
   job_->ForwardToServiceWorker();
 }
 
-void ServiceWorkerControlleeRequestHandler::OnPrepareToRestart(
-    base::TimeTicks service_worker_start_time,
-    base::TimeTicks service_worker_ready_time) {
+void ServiceWorkerControlleeRequestHandler::OnPrepareToRestart() {
   use_network_ = true;
   ClearJob();
-  // Update times, if not already set by a previous Job.
-  if (service_worker_start_time_.is_null()) {
-    service_worker_start_time_ = service_worker_start_time;
-    service_worker_ready_time_ = service_worker_ready_time;
-  }
-}
-
-void ServiceWorkerControlleeRequestHandler::OnStartCompleted(
-    bool was_fetched_via_service_worker,
-    bool was_fallback_required,
-    const GURL& original_url_via_service_worker,
-    blink::WebServiceWorkerResponseType response_type_via_service_worker,
-    base::TimeTicks service_worker_start_time,
-    base::TimeTicks service_worker_ready_time,
-    bool response_is_in_cache_storage,
-    const std::string& response_cache_storage_cache_name) {
-  was_fetched_via_service_worker_ = was_fetched_via_service_worker;
-  was_fallback_required_ = was_fallback_required;
-  original_url_via_service_worker_ = original_url_via_service_worker;
-  response_type_via_service_worker_ = response_type_via_service_worker;
-  response_is_in_cache_storage_ = response_is_in_cache_storage;
-  response_cache_storage_cache_name_ = response_cache_storage_cache_name;
-
-  // Update times, if not already set by a previous Job.
-  if (service_worker_start_time_.is_null()) {
-    service_worker_start_time_ = service_worker_start_time;
-    service_worker_ready_time_ = service_worker_ready_time;
-  }
 }
 
 ServiceWorkerVersion*
 ServiceWorkerControlleeRequestHandler::GetServiceWorkerVersion(
     ServiceWorkerMetrics::URLRequestJobResult* result) {
   if (!provider_host_) {
     *result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_NO_PROVIDER_HOST;
     return nullptr;
   }
   if (!provider_host_->active_version()) {
@@ skipping 15 matching lines @@
 }
 
 void ServiceWorkerControlleeRequestHandler::MainResourceLoadFailed() {
   DCHECK(provider_host_);
   // Detach the controller so subresource requests also skip the worker.
   provider_host_->NotifyControllerLost();
 }
 
 void ServiceWorkerControlleeRequestHandler::ClearJob() {
   job_.reset();
-  was_fetched_via_service_worker_ = false;
-  was_fallback_required_ = false;
-  original_url_via_service_worker_ = GURL();
-  response_type_via_service_worker_ =
-      blink::WebServiceWorkerResponseTypeDefault;
-  response_is_in_cache_storage_ = false;
-  response_cache_storage_cache_name_ = std::string();
 }
 
 }  // namespace content