Introduce url_list to the Response scheme of CacheStorage.

content/browser/service_worker/service_worker_url_request_job_unittest.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 <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 337 matching lines @@
 TEST_P(ServiceWorkerURLRequestJobTestP, Simple) {
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   TestRequest(200, "OK", std::string(), true /* expect_valid_ssl */);
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
   EXPECT_FALSE(info->response_is_in_cache_storage());
   EXPECT_EQ(std::string(), info->response_cache_storage_cache_name());
 }
 
 TEST_P(ServiceWorkerURLRequestJobTestP, CustomTimeout) {
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
@@ skipping 17 matching lines @@
   void OnFetchEvent(int embedded_worker_id,
                     int fetch_event_id,
                     const ServiceWorkerFetchRequest& request,
                     mojom::FetchEventPreloadHandlePtr preload_handle,
                     const FetchCallback& callback) override {
     context()->RemoveProviderHost(mock_render_process_id(), kProviderID);
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, fetch_event_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
-            GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
-            ServiceWorkerHeaderMap(), std::string(), 0, GURL(),
-            blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+            base::MakeUnique<std::vector<GURL>>(), 200, "OK",
+            blink::WebServiceWorkerResponseTypeDefault,
+            base::MakeUnique<ServiceWorkerHeaderMap>(), std::string(), 0,
+            GURL(), blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+            base::MakeUnique<
+                ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
         base::Time::Now()));
     callback.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProviderDeleteHelper);
 };
 
 TEST_P(ServiceWorkerURLRequestJobTestP, DeletedProviderHostOnFetchEvent) {
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   // Shouldn't crash if the ProviderHost is deleted prior to completion of
   // the fetch event.
   SetUpWithHelper(new ProviderDeleteHelper);
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   TestRequest(500, "Service Worker Response Error", std::string(),
               false /* expect_valid_ssl */);
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
 TEST_P(ServiceWorkerURLRequestJobTestP, DeletedProviderHostBeforeFetchEvent) {
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
       GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
 
   request_->set_method("GET");
   request_->Start();
   helper_->context()->RemoveProviderHost(helper_->mock_render_process_id(),
                                          kProviderID);
   base::RunLoop().RunUntilIdle();
   TestRequestResult(500, "Service Worker Response Error", std::string(),
                     false /* expect_valid_ssl */);
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_TRUE(info->service_worker_start_time().is_null());
   EXPECT_TRUE(info->service_worker_ready_time().is_null());
 }
 
 // Responds to fetch events with a blob.
 class BlobResponder : public EmbeddedWorkerTestHelper {
  public:
   BlobResponder(const std::string& blob_uuid, uint64_t blob_size)
       : EmbeddedWorkerTestHelper(base::FilePath()),
         blob_uuid_(blob_uuid),
         blob_size_(blob_size) {}
   ~BlobResponder() override {}
 
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int fetch_event_id,
                     const ServiceWorkerFetchRequest& request,
                     mojom::FetchEventPreloadHandlePtr preload_handle,
                     const FetchCallback& callback) override {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, fetch_event_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
-            GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
-            ServiceWorkerHeaderMap(), blob_uuid_, blob_size_, GURL(),
-            blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+            base::MakeUnique<std::vector<GURL>>(), 200, "OK",
+            blink::WebServiceWorkerResponseTypeDefault,
+            base::MakeUnique<ServiceWorkerHeaderMap>(), blob_uuid_, blob_size_,
+            GURL(), blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+            base::MakeUnique<
+                ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
         base::Time::Now()));
     callback.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
   std::string blob_uuid_;
   uint64_t blob_size_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BlobResponder);
 };
@@ skipping 14 matching lines @@
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   TestRequest(200, "OK", expected_response, true /* expect_valid_ssl */);
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
 TEST_P(ServiceWorkerURLRequestJobTestP, NonExistentBlobUUIDResponse) {
   SetUpWithHelper(new BlobResponder("blob-id:nothing-is-here", 0));
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   TestRequest(500, "Service Worker Response Error", std::string(),
               true /* expect_valid_ssl */);
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
 // Responds to fetch events with a stream.
 class StreamResponder : public EmbeddedWorkerTestHelper {
  public:
   explicit StreamResponder(const GURL& stream_url)
       : EmbeddedWorkerTestHelper(base::FilePath()), stream_url_(stream_url) {}
   ~StreamResponder() override {}
 
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int fetch_event_id,
                     const ServiceWorkerFetchRequest& request,
                     mojom::FetchEventPreloadHandlePtr preload_handle,
                     const FetchCallback& callback) override {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, fetch_event_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
-            GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
-            ServiceWorkerHeaderMap(), "", 0, stream_url_,
+            base::MakeUnique<std::vector<GURL>>(), 200, "OK",
+            blink::WebServiceWorkerResponseTypeDefault,
+            base::MakeUnique<ServiceWorkerHeaderMap>(), "", 0, stream_url_,
             blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+            base::MakeUnique<
+                ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
         base::Time::Now()));
     callback.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
   const GURL stream_url_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StreamResponder);
 };
 
@@ skipping 29 matching lines @@
   EXPECT_EQ("OK",
             request_->response_headers()->GetStatusText());
   EXPECT_EQ(expected_response, url_request_delegate_.response_data());
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 
   request_.reset();
   EXPECT_FALSE(HasWork());
 }
 
 TEST_P(ServiceWorkerURLRequestJobTestP, StreamResponse_DelayedRegistration) {
@@ skipping 29 matching lines @@
   EXPECT_EQ("OK",
             request_->response_headers()->GetStatusText());
   EXPECT_EQ(expected_response, url_request_delegate_.response_data());
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 
   request_.reset();
   EXPECT_FALSE(HasWork());
 }
 
 TEST_P(ServiceWorkerURLRequestJobTestP, StreamResponse_QuickFinalize) {
@@ skipping 27 matching lines @@
   EXPECT_EQ("OK",
             request_->response_headers()->GetStatusText());
   EXPECT_EQ(expected_response, url_request_delegate_.response_data());
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 
   request_.reset();
   EXPECT_FALSE(HasWork());
 }
 
 TEST_P(ServiceWorkerURLRequestJobTestP, StreamResponse_Flush) {
@@ skipping 28 matching lines @@
   EXPECT_EQ("OK",
             request_->response_headers()->GetStatusText());
   EXPECT_EQ(expected_response, url_request_delegate_.response_data());
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
 TEST_P(ServiceWorkerURLRequestJobTestP, StreamResponseAndCancel) {
   const GURL stream_url("blob://stream");
   StreamContext* stream_context =
       GetStreamContextForResourceContext(
@@ skipping 32 matching lines @@
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(request_->status().is_success());
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
 TEST_P(ServiceWorkerURLRequestJobTestP,
        StreamResponse_DelayedRegistrationAndCancel) {
   const GURL stream_url("blob://stream");
   StreamContext* stream_context =
@@ skipping 91 matching lines @@
   EXPECT_TRUE(request_->status().is_success());
   EXPECT_EQ(200, request_->GetResponseCode());
   EXPECT_EQ("", url_request_delegate_.response_data());
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
 TEST_P(ServiceWorkerURLRequestJobTestP, FailToActivate_MainResource) {
   RunFailToActivateTest(RESOURCE_TYPE_MAIN_FRAME);
 
   // The load should fail and we should have fallen back to network because
@@ skipping 39 matching lines @@
   void OnFetchEvent(int embedded_worker_id,
                     int fetch_event_id,
                     const ServiceWorkerFetchRequest& request,
                     mojom::FetchEventPreloadHandlePtr preload_handle,
                     const FetchCallback& callback) override {
     callback_ = callback;
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id, fetch_event_id,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
-            GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
-            ServiceWorkerHeaderMap(), std::string(), 0, GURL(),
-            blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+            base::MakeUnique<std::vector<GURL>>(), 200, "OK",
+            blink::WebServiceWorkerResponseTypeDefault,
+            base::MakeUnique<ServiceWorkerHeaderMap>(), std::string(), 0,
+            GURL(), blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+            base::MakeUnique<
+                ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
         base::Time::Now()));
   }
 
  private:
   FetchCallback callback_;
   DISALLOW_COPY_AND_ASSIGN(EarlyResponseHelper);
 };
 
 // This simulates the case when a response is returned and the fetch event is
 // still in flight.
 TEST_P(ServiceWorkerURLRequestJobTestP, EarlyResponse) {
   EarlyResponseHelper* helper = new EarlyResponseHelper;
   SetUpWithHelper(helper);
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   TestRequest(200, "OK", std::string(), true /* expect_valid_ssl */);
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
   ServiceWorkerResponseInfo* info =
       ServiceWorkerResponseInfo::ForRequest(request_.get());
   ASSERT_TRUE(info);
   EXPECT_TRUE(info->was_fetched_via_service_worker());
   EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(GURL(), info->original_url_via_service_worker());
+  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
   EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
             info->response_type_via_service_worker());
   EXPECT_FALSE(info->service_worker_start_time().is_null());
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
   EXPECT_FALSE(info->response_is_in_cache_storage());
   EXPECT_EQ(std::string(), info->response_cache_storage_cache_name());
 
   EXPECT_TRUE(version_->HasWork());
   helper->FinishWaitUntil();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(version_->HasWork());
 }
 
 // Helper for controlling when to respond to a fetch event.
 class DelayedResponseHelper : public EmbeddedWorkerTestHelper {
  public:
   DelayedResponseHelper() : EmbeddedWorkerTestHelper(base::FilePath()) {}
   ~DelayedResponseHelper() override {}
 
   void Respond() {
     SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
         embedded_worker_id_, fetch_event_id_,
         SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
         ServiceWorkerResponse(
-            GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
-            ServiceWorkerHeaderMap(), std::string(), 0, GURL(),
-            blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+            base::MakeUnique<std::vector<GURL>>(), 200, "OK",
+            blink::WebServiceWorkerResponseTypeDefault,
+            base::MakeUnique<ServiceWorkerHeaderMap>(), std::string(), 0,
+            GURL(), blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
-            ServiceWorkerHeaderList() /* cors_exposed_header_names */),
+            base::MakeUnique<
+                ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
         base::Time::Now()));
     callback_.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
  protected:
   void OnFetchEvent(int embedded_worker_id,
                     int fetch_event_id,
                     const ServiceWorkerFetchRequest& request,
                     mojom::FetchEventPreloadHandlePtr preload_handle,
                     const FetchCallback& callback) override {
@@ skipping 38 matching lines @@
 }
 
 // TODO(kinuko): Add more tests with different response data and also for
 // FallbackToNetwork case.
 
 INSTANTIATE_TEST_CASE_P(ServiceWorkerURLRequestJobTest,
                         ServiceWorkerURLRequestJobTestP,
                         testing::Bool());
 
 }  // namespace content