Implement updateViaCache flag and no-cache by default for main service worker scripts

content/browser/service_worker/service_worker_dispatcher_host_unittest.cc

 // Copyright 2013 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_dispatcher_host.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 151 matching lines @@
     helper_.reset(helper.release());
     // Replace the default dispatcher host.
     int process_id = helper_->mock_render_process_id();
     dispatcher_host_ = new TestingServiceWorkerDispatcherHost(
         process_id, &resource_context_, helper_.get());
     helper_->RegisterDispatcherHost(process_id, nullptr);
     dispatcher_host_->Init(context_wrapper());
   }
 
   void SetUpRegistration(const GURL& scope, const GURL& script_url) {
-    registration_ = new ServiceWorkerRegistration(
-        scope, 1L, helper_->context()->AsWeakPtr());
+    registration_ =
+        new ServiceWorkerRegistration(ServiceWorkerRegistrationOptions(scope),
+                                      1L, helper_->context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(registration_.get(), script_url, 1L,
                                         helper_->context()->AsWeakPtr());
     std::vector<ServiceWorkerDatabase::ResourceRecord> records;
     records.push_back(
         ServiceWorkerDatabase::ResourceRecord(10, version_->script_url(), 100));
     version_->script_cache_map()->SetResources(records);
     version_->SetMainScriptHttpResponseInfo(
         EmbeddedWorkerTestHelper::CreateHttpResponseInfo());
     version_->set_fetch_handler_existence(
         ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
@@ skipping 27 matching lines @@
     remote_endpoint_.BindWithProviderHostInfo(&info);
 
     dispatcher_host_->OnProviderCreated(std::move(info));
     helper_->SimulateAddProcessToPattern(pattern,
                                          helper_->mock_render_process_id());
     provider_host_ = context()->GetProviderHost(
         helper_->mock_render_process_id(), kProviderId);
   }
 
   void SendRegister(int64_t provider_id, GURL pattern, GURL worker_url) {
+    ServiceWorkerRegistrationOptions options(pattern);
     dispatcher_host_->OnMessageReceived(
-        ServiceWorkerHostMsg_RegisterServiceWorker(
-            -1, -1, provider_id, pattern, worker_url));
+        ServiceWorkerHostMsg_RegisterServiceWorker(-1, -1, provider_id,
+                                                   worker_url, options));
     base::RunLoop().RunUntilIdle();
   }
 
   void Register(int64_t provider_id,
                 GURL pattern,
                 GURL worker_url,
                 uint32_t expected_message) {
     SendRegister(provider_id, pattern, worker_url);
     EXPECT_TRUE(dispatcher_host_->ipc_sink()->GetUniqueMessageMatching(
         expected_message));
@@ skipping 105 matching lines @@
   GetRegistration(kProviderId,
                   GURL("https://www.example.com/"),
                   ServiceWorkerMsg_ServiceWorkerGetRegistrationError::ID);
   GetRegistrations(kProviderId,
                    ServiceWorkerMsg_ServiceWorkerGetRegistrationsError::ID);
 
   // Add a registration into a live registration map so that Unregister() can
   // find it.
   const int64_t kRegistrationId = 999;  // Dummy value
   scoped_refptr<ServiceWorkerRegistration> registration(
-      new ServiceWorkerRegistration(GURL("https://www.example.com/"),
-                                    kRegistrationId, context()->AsWeakPtr()));
+      new ServiceWorkerRegistration(
+          ServiceWorkerRegistrationOptions(GURL("https://www.example.com/")),
+          kRegistrationId, context()->AsWeakPtr()));
   Unregister(kProviderId, kRegistrationId,
              ServiceWorkerMsg_ServiceWorkerUnregistrationError::ID);
 
   SetBrowserClientForTesting(old_browser_client);
 }
 
 TEST_F(ServiceWorkerDispatcherHostTest, Register_HTTPS) {
   const int64_t kProviderId = 99;  // Dummy value
   std::unique_ptr<ServiceWorkerProviderHost> host(
       CreateServiceWorkerProviderHost(kProviderId));
@@ skipping 553 matching lines @@
   const int kFetchEventId = 91;  // Dummy value
   dispatcher_host_->OnMessageReceived(ServiceWorkerHostMsg_FetchEventResponse(
       version_->embedded_worker()->embedded_worker_id(), kFetchEventId,
       ServiceWorkerResponse(), base::Time::Now()));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, dispatcher_host_->bad_messages_received_count_);
 }
 
 }  // namespace content