Index: content/browser/service_worker/service_worker_url_job_wrapper.cc |
diff --git a/content/browser/service_worker/service_worker_url_job_wrapper.cc b/content/browser/service_worker/service_worker_url_job_wrapper.cc |
index 41dbc205fec6c1ccdef88da63eac7de9b9a4ba08..d1195599ce524c2ca44e74f845e58e5d59bc481d 100644 |
--- a/content/browser/service_worker/service_worker_url_job_wrapper.cc |
+++ b/content/browser/service_worker/service_worker_url_job_wrapper.cc |
@@ -6,12 +6,142 @@ |
#include "base/command_line.h" |
#include "content/browser/service_worker/service_worker_response_type.h" |
+#include "content/browser/service_worker/service_worker_version.h" |
+#include "content/common/service_worker/service_worker_utils.h" |
+#include "content/public/browser/browser_thread.h" |
#include "content/public/browser/resource_request_info.h" |
#include "content/public/common/browser_side_navigation_policy.h" |
#include "content/public/common/content_switches.h" |
+#include "net/base/io_buffer.h" |
+#include "storage/browser/blob/blob_storage_context.h" |
namespace content { |
+namespace { |
+ |
+class URLLoaderImpl : public mojom::URLLoader { |
+ public: |
+ URLLoaderImpl(const ServiceWorkerResponse& response, |
+ blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream, |
+ base::WeakPtr<storage::BlobStorageContext> blob_storage_context, |
+ mojom::URLLoaderAssociatedRequest url_loader_request, |
+ mojom::URLLoaderClientPtr url_loader_client) |
+ : blob_storage_context_(blob_storage_context), |
+ binding_(this, std::move(url_loader_request)), |
+ url_loader_client_(std::move(url_loader_client)), |
+ weak_factory_(this) { |
+ ResourceResponseHead head; |
+ // TODO(scottmg): More fields in |head| required? |
+ head.headers = new net::HttpResponseHeaders(""); |
+ for (const auto& kv : response.headers) |
+ head.headers->AddHeader(kv.first + ": " + kv.second); |
+ head.url_list_via_service_worker = response.url_list; |
+ head.mime_type = "text/html"; // TODO(scottmg): No idea where to get this. |
+ head.was_fetched_via_service_worker = true; |
+ head.cors_exposed_header_names = response.cors_exposed_header_names; |
+ url_loader_client_->OnReceiveResponse( |
+ head, base::nullopt /* TODO(scottmg): ssl info */, |
+ mojom::DownloadedTempFilePtr()); |
+ |
+ // Ideally, we would always get a data pipe fom SWFetchDispatcher and use |
+ // this case. See: |
+ // https://docs.google.com/a/google.com/document/d/1_ROmusFvd8ATwIZa29-P6Ls5yyLjfld0KvKchVfA84Y/edit?usp=drive_web |
+ if (!body_as_stream.is_null() && body_as_stream->stream.is_valid()) { |
+ url_loader_client_->OnStartLoadingResponseBody( |
+ std::move(body_as_stream->stream)); |
+ } else { |
+ // TODO(scottmg): This is temporary way to load the blob right here and |
+ // turn it into a data pipe to respond with, until we are always able to |
+ // take the above path. |
+ if (!response.blob_uuid.empty() && blob_storage_context_) { |
+ std::unique_ptr<storage::BlobDataHandle> blob_data_handle = |
+ blob_storage_context_->GetBlobDataFromUUID(response.blob_uuid); |
+ blob_reader_ = blob_data_handle->CreateReader( |
+ nullptr /* file system context */, |
+ BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get()); |
+ CHECK(storage::BlobReader::Status::DONE == |
+ blob_reader_->CalculateSize(net::CompletionCallback())); |
+ blob_reader_->SetReadRange(0, blob_reader_->total_size()); |
+ scoped_refptr<net::IOBuffer> buffer( |
+ new net::IOBuffer(static_cast<size_t>(blob_reader_->total_size()))); |
+ |
+ int bytes_read; |
+ blob_reader_->Read(buffer.get(), blob_reader_->total_size(), |
+ &bytes_read, |
+ base::Bind(&URLLoaderImpl::AfterRead, |
+ weak_factory_.GetWeakPtr(), buffer)); |
+ } |
+ } |
+ } |
+ |
+ // mojom::URLLoader: |
+ void FollowRedirect() override { NOTIMPLEMENTED(); } |
+ |
+ void SetPriority(net::RequestPriority priority, |
+ int32_t intra_priority_value) override { |
+ NOTIMPLEMENTED(); |
+ } |
+ |
+ private: |
+ void AfterRead(scoped_refptr<net::IOBuffer> buffer, int bytes) { |
+ uint32_t bytes_written = static_cast<uint32_t>(bytes); |
+ mojo::WriteDataRaw(data_pipe_.producer_handle.get(), buffer->data(), |
+ &bytes_written, MOJO_WRITE_DATA_FLAG_NONE); |
+ url_loader_client_->OnStartLoadingResponseBody( |
+ std::move(data_pipe_.consumer_handle)); |
+ } |
+ |
+ base::WeakPtr<storage::BlobStorageContext> blob_storage_context_; |
+ mojo::AssociatedBinding<mojom::URLLoader> binding_; |
+ mojom::URLLoaderClientPtr url_loader_client_; |
+ std::unique_ptr<storage::BlobReader> blob_reader_; |
+ mojo::DataPipe data_pipe_; |
+ |
+ base::WeakPtrFactory<URLLoaderImpl> weak_factory_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(URLLoaderImpl); |
+}; |
+ |
+} // namespace |
+ |
+class ServiceWorkerURLJobWrapper::Factory : public mojom::URLLoaderFactory { |
+ public: |
+ Factory(const ServiceWorkerResponse& response, |
+ blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream, |
+ base::WeakPtr<storage::BlobStorageContext> blob_storage_context) |
+ : response_(response), |
+ body_as_stream_(std::move(body_as_stream)), |
+ blob_storage_context_(blob_storage_context) {} |
+ |
+ void CreateLoaderAndStart(mojom::URLLoaderAssociatedRequest request, |
+ int32_t routing_id, |
+ int32_t request_id, |
+ uint32_t options, |
+ const ResourceRequest& url_request, |
+ mojom::URLLoaderClientPtr client) override { |
+ // Note that url_request is ignored here, as we've already processed the |
+ // fetch before even creating the factory. |
+ // TODO(scottmg): Use options. |
+ new URLLoaderImpl(response_, std::move(body_as_stream_), |
shimazu
2017/06/06 01:33:30
If the lifecycle of URLLoaderImpl is the same with
scottmg
2017/06/06 16:50:09
Done.
|
+ blob_storage_context_, std::move(request), |
+ std::move(client)); |
+ } |
+ |
+ void SyncLoad(int32_t routing_id, |
+ int32_t request_id, |
+ const ResourceRequest& url_request, |
+ SyncLoadCallback callback) override { |
+ NOTREACHED(); |
+ } |
+ |
+ private: |
+ ServiceWorkerResponse response_; |
+ blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream_; |
+ base::WeakPtr<storage::BlobStorageContext> blob_storage_context_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(Factory); |
+}; |
+ |
ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper( |
base::WeakPtr<ServiceWorkerURLRequestJob> url_request_job) |
: job_type_(JobType::kURLRequest), |
@@ -19,9 +149,15 @@ ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper( |
weak_factory_(this) {} |
ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper( |
- LoaderFactoryCallback callback) |
+ LoaderFactoryCallback callback, |
+ Delegate* delegate, |
+ const ResourceRequest& resource_request, |
+ base::WeakPtr<storage::BlobStorageContext> blob_storage_context) |
: job_type_(JobType::kURLLoader), |
loader_factory_callback_(std::move(callback)), |
+ delegate_(delegate), |
+ resource_request_(resource_request), |
+ blob_storage_context_(blob_storage_context), |
weak_factory_(this) { |
DCHECK(IsBrowserSideNavigationEnabled() && |
base::CommandLine::ForCurrentProcess()->HasSwitch( |
@@ -112,11 +248,74 @@ bool ServiceWorkerURLJobWrapper::WasCanceled() const { |
void ServiceWorkerURLJobWrapper::StartRequest() { |
DCHECK_EQ(FORWARD_TO_SERVICE_WORKER, response_type_); |
- // TODO(kinuko): Implement. For now we just exercise async fall back path |
- // to the network. |
- base::ThreadTaskRunnerHandle::Get()->PostTask( |
- FROM_HERE, base::Bind(&ServiceWorkerURLJobWrapper::FallbackToNetwork, |
- weak_factory_.GetWeakPtr())); |
+ |
+ ServiceWorkerMetrics::URLRequestJobResult result = |
+ ServiceWorkerMetrics::REQUEST_JOB_ERROR_BAD_DELEGATE; |
+ ServiceWorkerVersion* active_worker = |
+ delegate_->GetServiceWorkerVersion(&result); |
+ |
+ // TODO(scottmg): Get this from somewhere, and maybe it should probably be set |
+ // elsewhere too. |
+ net::HttpResponseInfo http_info; |
+ http_info.was_cached = true; |
+ active_worker->SetMainScriptHttpResponseInfo(http_info); |
kinuko
2017/06/06 12:52:37
Do we need this? (Esp. with the change in Service
falken
2017/06/06 13:20:22
Good point. I think quite a few things might break
scottmg
2017/06/06 16:50:09
OK, removed for now.
|
+ |
+ fetch_dispatcher_.reset(new ServiceWorkerFetchDispatcher( |
+ CreateFetchRequest(resource_request_), active_worker, |
+ resource_request_.resource_type, base::nullopt, |
+ net::NetLogWithSource() /* TODO(scottmg): net log? */, |
+ base::Bind(&ServiceWorkerURLJobWrapper::DidPrepareFetchEvent, |
+ weak_factory_.GetWeakPtr(), active_worker), |
+ base::Bind(&ServiceWorkerURLJobWrapper::DidDispatchFetchEvent, |
+ weak_factory_.GetWeakPtr()))); |
+ fetch_dispatcher_->Run(); |
+} |
+ |
+std::unique_ptr<ServiceWorkerFetchRequest> |
+ServiceWorkerURLJobWrapper::CreateFetchRequest(const ResourceRequest& request) { |
+ std::string blob_uuid; |
+ uint64_t blob_size = 0; |
+ // TODO(scottmg): Implement passing body as blob to handler. |
+ DCHECK(!request.request_body); |
+ std::unique_ptr<ServiceWorkerFetchRequest> new_request( |
+ new ServiceWorkerFetchRequest()); |
+ new_request->mode = request.fetch_request_mode; |
+ new_request->is_main_resource_load = |
+ ServiceWorkerUtils::IsMainResourceType(request.resource_type); |
+ new_request->request_context_type = request.fetch_request_context_type; |
+ new_request->frame_type = request.fetch_frame_type; |
+ new_request->url = request.url; |
+ new_request->method = request.method; |
+ new_request->blob_uuid = blob_uuid; |
+ new_request->blob_size = blob_size; |
+ new_request->credentials_mode = request.fetch_credentials_mode; |
+ new_request->redirect_mode = request.fetch_redirect_mode; |
+ CHECK(request.referrer_policy == |
+ blink::kWebReferrerPolicyNoReferrerWhenDowngrade); |
+ new_request->referrer = |
+ Referrer(GURL(request.referrer), blink::kWebReferrerPolicyDefault); |
falken
2017/06/06 13:20:22
Why is line 293 a CHECK instead of DCHECK and line
scottmg
2017/06/06 16:50:09
Oops, yeah. I copied the fallback case from Servic
|
+ new_request->fetch_type = ServiceWorkerFetchType::FETCH; |
+ return new_request; |
+} |
+ |
+void ServiceWorkerURLJobWrapper::DidPrepareFetchEvent( |
+ scoped_refptr<ServiceWorkerVersion> version) {} |
+ |
+void ServiceWorkerURLJobWrapper::DidDispatchFetchEvent( |
+ ServiceWorkerStatusCode status, |
+ ServiceWorkerFetchEventResult fetch_result, |
+ const ServiceWorkerResponse& response, |
+ blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream, |
+ const scoped_refptr<ServiceWorkerVersion>& version) { |
+ if (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK) { |
+ std::move(loader_factory_callback_).Run(nullptr); |
+ return; |
+ } |
+ DCHECK_EQ(fetch_result, SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE); |
+ |
+ factory_ = base::MakeUnique<Factory>(response, std::move(body_as_stream), |
+ blob_storage_context_); |
+ std::move(loader_factory_callback_).Run(factory_.get()); |
} |
} // namespace content |