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

third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerContainerTest.cpp

 
 // 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 "modules/serviceworkers/ServiceWorkerContainer.h"
 
 #include <memory>
 #include <utility>
 
@@ skipping 114 matching lines @@
 
 // Service Worker-specific tests.
 
 class NotReachedWebServiceWorkerProvider : public WebServiceWorkerProvider {
  public:
   ~NotReachedWebServiceWorkerProvider() override {}
 
   void RegisterServiceWorker(
       const WebURL& pattern,
       const WebURL& script_url,
+      WebServiceWorkerUpdateViaCache update_via_cache,
       std::unique_ptr<WebServiceWorkerRegistrationCallbacks> callbacks)
       override {
     ADD_FAILURE()
         << "the provider should not be called to register a Service Worker";
   }
 
   bool ValidateScopeAndScriptURL(const WebURL& scope,
                                  const WebURL& script_url,
                                  WebString* error_message) {
     return true;
@@ skipping 131 matching lines @@
   // StubWebServiceWorkerProvider dies.
   std::unique_ptr<WebServiceWorkerProvider> Provider() {
     return WTF::WrapUnique(new WebServiceWorkerProviderImpl(*this));
   }
 
   size_t RegisterCallCount() { return register_call_count_; }
   const WebURL& RegisterScope() { return register_scope_; }
   const WebURL& RegisterScriptURL() { return register_script_url_; }
   size_t GetRegistrationCallCount() { return get_registration_call_count_; }
   const WebURL& GetRegistrationURL() { return get_registration_url_; }
+  WebServiceWorkerUpdateViaCache UpdateViaCache() const {
+    return update_via_cache_;
+  }
 
  private:
   class WebServiceWorkerProviderImpl : public WebServiceWorkerProvider {
    public:
     WebServiceWorkerProviderImpl(StubWebServiceWorkerProvider& owner)
         : owner_(owner) {}
 
     ~WebServiceWorkerProviderImpl() override {}
 
     void RegisterServiceWorker(
         const WebURL& pattern,
         const WebURL& script_url,
+        WebServiceWorkerUpdateViaCache update_via_cache,
         std::unique_ptr<WebServiceWorkerRegistrationCallbacks> callbacks)
         override {
       owner_.register_call_count_++;
       owner_.register_scope_ = pattern;
       owner_.register_script_url_ = script_url;
+      owner_.update_via_cache_ = update_via_cache;
       registration_callbacks_to_delete_.push_back(std::move(callbacks));
     }
 
     void GetRegistration(
         const WebURL& document_url,
         std::unique_ptr<WebServiceWorkerGetRegistrationCallbacks> callbacks)
         override {
       owner_.get_registration_call_count_++;
       owner_.get_registration_url_ = document_url;
       get_registration_callbacks_to_delete_.push_back(std::move(callbacks));
@@ skipping 12 matching lines @@
     Vector<std::unique_ptr<WebServiceWorkerGetRegistrationCallbacks>>
         get_registration_callbacks_to_delete_;
   };
 
  private:
   size_t register_call_count_;
   WebURL register_scope_;
   WebURL register_script_url_;
   size_t get_registration_call_count_;
   WebURL get_registration_url_;
+  WebServiceWorkerUpdateViaCache update_via_cache_;
 };
 
 TEST_F(ServiceWorkerContainerTest,
        RegisterUnregister_NonHttpsSecureOriginDelegatesToProvider) {
   SetPageURL("http://localhost/x/index.html");
 
   StubWebServiceWorkerProvider stub_provider;
   Provide(stub_provider.Provider());
 
   ServiceWorkerContainer* container = ServiceWorkerContainer::Create(
       GetExecutionContext(), GetNavigatorServiceWorker());
 
   // register
   {
     ScriptState::Scope script_scope(GetScriptState());
     RegistrationOptions options;
     options.setScope("y/");
     container->registerServiceWorker(GetScriptState(), "/x/y/worker.js",
                                      options);
 
     EXPECT_EQ(1ul, stub_provider.RegisterCallCount());
     EXPECT_EQ(WebURL(KURL(NullURL(), "http://localhost/x/y/")),
               stub_provider.RegisterScope());
     EXPECT_EQ(WebURL(KURL(NullURL(), "http://localhost/x/y/worker.js")),
               stub_provider.RegisterScriptURL());
+    EXPECT_EQ(WebServiceWorkerUpdateViaCache::kImports,
+              stub_provider.UpdateViaCache());
   }
 }
 
 TEST_F(ServiceWorkerContainerTest,
        GetRegistration_OmittedDocumentURLDefaultsToPageURL) {
   SetPageURL("http://localhost/x/index.html");
 
   StubWebServiceWorkerProvider stub_provider;
   Provide(stub_provider.Provider());
 
   ServiceWorkerContainer* container = ServiceWorkerContainer::Create(
       GetExecutionContext(), GetNavigatorServiceWorker());
 
   {
     ScriptState::Scope script_scope(GetScriptState());
     container->getRegistration(GetScriptState(), "");
     EXPECT_EQ(1ul, stub_provider.GetRegistrationCallCount());
     EXPECT_EQ(WebURL(KURL(NullURL(), "http://localhost/x/index.html")),
               stub_provider.GetRegistrationURL());
+    EXPECT_EQ(WebServiceWorkerUpdateViaCache::kImports,
+              stub_provider.UpdateViaCache());
   }
 }
 
+TEST_F(ServiceWorkerContainerTest,
+       RegisterUnregister_UpdateViaCacheOptionDelegatesToProvider) {
+  SetPageURL("http://localhost/x/index.html");
+
+  StubWebServiceWorkerProvider stub_provider;
+  Provide(stub_provider.Provider());
+
+  ServiceWorkerContainer* container = ServiceWorkerContainer::Create(
+      GetExecutionContext(), GetNavigatorServiceWorker());
+
+  // register
+  {
+    ScriptState::Scope script_scope(GetScriptState());
+    RegistrationOptions options;
+    options.setUpdateViaCache("none");
+    container->registerServiceWorker(GetScriptState(), "/x/y/worker.js",
+                                     options);
+
+    EXPECT_EQ(1ul, stub_provider.RegisterCallCount());
+    EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/y/")),
+              stub_provider.RegisterScope());
+    EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/y/worker.js")),
+              stub_provider.RegisterScriptURL());
+    EXPECT_EQ(WebServiceWorkerUpdateViaCache::kNone,
+              stub_provider.UpdateViaCache());
+  }
+}
+
 }  // namespace
 }  // namespace blink