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

content/browser/service_worker/service_worker_provider_host_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_provider_host.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 39 matching lines @@
 
   void SetUp() override {
     old_content_browser_client_ =
         SetBrowserClientForTesting(&test_content_browser_client_);
     ResetSchemesAndOriginsWhitelist();
 
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
     context_ = helper_->context();
     script_url_ = GURL("https://www.example.com/service_worker.js");
     registration1_ = new ServiceWorkerRegistration(
-        GURL("https://www.example.com/"), 1L, context_->AsWeakPtr());
+        ServiceWorkerRegistrationOptions(GURL("https://www.example.com/")), 1L,
+        context_->AsWeakPtr());
     registration2_ = new ServiceWorkerRegistration(
-        GURL("https://www.example.com/example"), 2L, context_->AsWeakPtr());
+        ServiceWorkerRegistrationOptions(
+            GURL("https://www.example.com/example")),
+        2L, context_->AsWeakPtr());
     registration3_ = new ServiceWorkerRegistration(
-        GURL("https://other.example.com/"), 3L, context_->AsWeakPtr());
+        ServiceWorkerRegistrationOptions(GURL("https://other.example.com/")),
+        3L, context_->AsWeakPtr());
   }
 
   void TearDown() override {
     registration1_ = 0;
     registration2_ = 0;
     helper_.reset();
     SetBrowserClientForTesting(old_content_browser_client_);
     // Reset cached security schemes so we don't affect other tests.
     ResetSchemesAndOriginsWhitelist();
   }
@@ skipping 166 matching lines @@
   EXPECT_TRUE(provider_host_secure_parent->IsContextSecureForServiceWorker());
 
   // Exceptional service worker scheme with insecure parent frame.
   provider_host_insecure_parent->SetDocumentUrl(url);
   EXPECT_FALSE(
       provider_host_insecure_parent->IsContextSecureForServiceWorker());
 }
 
 class MockServiceWorkerRegistration : public ServiceWorkerRegistration {
  public:
-  MockServiceWorkerRegistration(const GURL& pattern,
+  MockServiceWorkerRegistration(const ServiceWorkerRegistrationOptions& options,
                                 int64_t registration_id,
                                 base::WeakPtr<ServiceWorkerContextCore> context)
-      : ServiceWorkerRegistration(pattern, registration_id, context) {}
+      : ServiceWorkerRegistration(options, registration_id, context) {}
 
   void AddListener(ServiceWorkerRegistration::Listener* listener) override {
     listeners_.insert(listener);
   }
 
   void RemoveListener(ServiceWorkerRegistration::Listener* listener) override {
     listeners_.erase(listener);
   }
 
   const std::set<ServiceWorkerRegistration::Listener*>& listeners() {
     return listeners_;
   }
 
  protected:
   ~MockServiceWorkerRegistration() override{};
 
  private:
   std::set<ServiceWorkerRegistration::Listener*> listeners_;
 };
 
 TEST_F(ServiceWorkerProviderHostTest, CrossSiteTransfer) {
   if (IsBrowserSideNavigationEnabled())
     return;
 
   // Create a mock registration before creating the provider host which is in
   // the scope.
+  ServiceWorkerRegistrationOptions options(GURL("https://cross.example.com/"));
   scoped_refptr<MockServiceWorkerRegistration> registration =
-      new MockServiceWorkerRegistration(GURL("https://cross.example.com/"), 4L,
+      new MockServiceWorkerRegistration(options, 4L,
                                         helper_->context()->AsWeakPtr());
 
   ServiceWorkerProviderHost* provider_host =
       CreateProviderHost(GURL("https://cross.example.com/example.html"));
   const int process_id = provider_host->process_id();
   const int provider_id = provider_host->provider_id();
   const int frame_id = provider_host->frame_id();
   const ServiceWorkerProviderType type = provider_host->provider_type();
   const bool is_parent_frame_secure = provider_host->is_parent_frame_secure();
   const ServiceWorkerDispatcherHost* dispatcher_host =
@@ skipping 47 matching lines @@
   EXPECT_TRUE(context_->GetProviderHost(process_id, provider_id));
 
   // Disconnect the mojo pipe from the renderer side.
   ASSERT_TRUE(remote_endpoints_.back().host_ptr()->is_bound());
   remote_endpoints_.back().host_ptr()->reset();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(context_->GetProviderHost(process_id, provider_id));
 }
 
 }  // namespace content