Refactoring: service worker: Factor out some duplicated code.

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 <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <map>
-#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 728 matching lines @@
     // written correctly, it may be null.
     // TODO(horo): Change this line to DCHECK when crbug.com/485900 is fixed.
     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());
     SetResponseBodyType(STREAM);
+    SetResponse(response);
     streaming_version_ = version;
     streaming_version_->AddStreamingURLRequestJob(this);
-    response_url_ = response.url;
-    service_worker_response_type_ = response.response_type;
-    cors_exposed_header_names_ = response.cors_exposed_header_names;
-    response_time_ = response.response_time;
-    CreateResponseHeader(
-        response.status_code, response.status_text, response.headers);
-    load_timing_info_.receive_headers_end = base::TimeTicks::Now();
     StreamContext* stream_context =
         GetStreamContextForResourceContext(resource_context_);
     stream_ =
         stream_context->registry()->GetStream(response.stream_url);
     if (!stream_.get()) {
       waiting_stream_url_ = response.stream_url;
       // Wait for StreamHostMsg_StartBuilding message from the ServiceWorker.
       stream_context->registry()->SetRegisterObserver(waiting_stream_url_,
                                                       this);
       return;
@@ skipping 12 matching lines @@
       // The renderer gave us a bad blob UUID.
       RecordResult(ServiceWorkerMetrics::REQUEST_JOB_ERROR_BAD_BLOB);
       DeliverErrorResponse();
       return;
     }
     blob_request_ = storage::BlobProtocolHandler::CreateBlobRequest(
         std::move(blob_data_handle), request()->context(), this);
     blob_request_->Start();
   }
 
-  response_url_ = response.url;
-  service_worker_response_type_ = response.response_type;
-  response_time_ = response.response_time;
-  response_is_in_cache_storage_ = response.is_in_cache_storage;
-  response_cache_storage_cache_name_ = response.cache_storage_cache_name;
-  cors_exposed_header_names_ = response.cors_exposed_header_names;
-  CreateResponseHeader(
-      response.status_code, response.status_text, response.headers);
-  load_timing_info_.receive_headers_end = base::TimeTicks::Now();
+  SetResponse(response);
+
   if (!blob_request_) {
     RecordResult(ServiceWorkerMetrics::REQUEST_JOB_HEADERS_ONLY_RESPONSE);
     CommitResponseHeader();
   }
 }
 
+void ServiceWorkerURLRequestJob::SetResponse(
+    const ServiceWorkerResponse& response) {
+  response_url_ = response.url;
+  service_worker_response_type_ = response.response_type;
+  cors_exposed_header_names_ = response.cors_exposed_header_names;
+  response_time_ = response.response_time;
+  CreateResponseHeader(response.status_code, response.status_text,
+                       response.headers);
+  load_timing_info_.receive_headers_end = base::TimeTicks::Now();
+
+  response_is_in_cache_storage_ = response.is_in_cache_storage;
+  response_cache_storage_cache_name_ = response.cache_storage_cache_name;

[falken, 2016/08/30 07:06:17]

Previously these cache_storage members were only set in the non-stream case. I
assume for streams the response fields are as expected (false and empty string),
so there is no need to special case.

+}
+
 void ServiceWorkerURLRequestJob::CreateResponseHeader(
     int status_code,
     const std::string& status_text,
     const ServiceWorkerHeaderMap& headers) {
   // TODO(kinuko): If the response has an identifier to on-disk cache entry,
   // pull response header from the disk.
   std::string status_line(
       base::StringPrintf("HTTP/1.1 %d %s", status_code, status_text.c_str()));
   status_line.push_back('\0');
   http_response_headers_ = new net::HttpResponseHeaders(status_line);
@@ skipping 212 matching lines @@
       CreateFetchRequest(), active_worker, resource_type_, request()->net_log(),
       base::Bind(&ServiceWorkerURLRequestJob::DidPrepareFetchEvent,
                  weak_factory_.GetWeakPtr(), active_worker),
       base::Bind(&ServiceWorkerURLRequestJob::DidDispatchFetchEvent,
                  weak_factory_.GetWeakPtr())));
   worker_start_time_ = base::TimeTicks::Now();
   fetch_dispatcher_->Run();
 }
 
 }  // namespace content