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 111 matching lines @@
 
 // Service Worker-specific tests.
 
 class NotReachedWebServiceWorkerProvider : public WebServiceWorkerProvider {
  public:
   ~NotReachedWebServiceWorkerProvider() override {}
 
   void registerServiceWorker(
       const WebURL& pattern,
       const WebURL& scriptURL,
+      bool useCache,
       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& scriptURL,
                                  WebString* errorMessage) {
     return true;
@@ skipping 130 matching lines @@
   // StubWebServiceWorkerProvider dies.
   std::unique_ptr<WebServiceWorkerProvider> provider() {
     return WTF::wrapUnique(new WebServiceWorkerProviderImpl(*this));
   }
 
   size_t registerCallCount() { return m_registerCallCount; }
   const WebURL& registerScope() { return m_registerScope; }
   const WebURL& registerScriptURL() { return m_registerScriptURL; }
   size_t getRegistrationCallCount() { return m_getRegistrationCallCount; }
   const WebURL& getRegistrationURL() { return m_getRegistrationURL; }
+  bool useCache() const { return m_useCache; }
 
  private:
   class WebServiceWorkerProviderImpl : public WebServiceWorkerProvider {
    public:
     WebServiceWorkerProviderImpl(StubWebServiceWorkerProvider& owner)
         : m_owner(owner) {}
 
     ~WebServiceWorkerProviderImpl() override {}
 
     void registerServiceWorker(
         const WebURL& pattern,
         const WebURL& scriptURL,
+        bool useCache,
         std::unique_ptr<WebServiceWorkerRegistrationCallbacks> callbacks)
         override {
       m_owner.m_registerCallCount++;
       m_owner.m_registerScope = pattern;
       m_owner.m_registerScriptURL = scriptURL;
+      m_owner.m_useCache = useCache;
       m_registrationCallbacksToDelete.push_back(std::move(callbacks));
     }
 
     void getRegistration(
         const WebURL& documentURL,
         std::unique_ptr<WebServiceWorkerGetRegistrationCallbacks> callbacks)
         override {
       m_owner.m_getRegistrationCallCount++;
       m_owner.m_getRegistrationURL = documentURL;
       m_getRegistrationCallbacksToDelete.push_back(std::move(callbacks));
@@ skipping 12 matching lines @@
     Vector<std::unique_ptr<WebServiceWorkerGetRegistrationCallbacks>>
         m_getRegistrationCallbacksToDelete;
   };
 
  private:
   size_t m_registerCallCount;
   WebURL m_registerScope;
   WebURL m_registerScriptURL;
   size_t m_getRegistrationCallCount;
   WebURL m_getRegistrationURL;
+  bool m_useCache;
 };
 
 TEST_F(ServiceWorkerContainerTest,
        RegisterUnregister_NonHttpsSecureOriginDelegatesToProvider) {
   setPageURL("http://localhost/x/index.html");
 
   StubWebServiceWorkerProvider stubProvider;
   provide(stubProvider.provider());
 
   ServiceWorkerContainer* container = ServiceWorkerContainer::create(
       getExecutionContext(), getNavigatorServiceWorker());
 
   // register
   {
     ScriptState::Scope scriptScope(getScriptState());
     RegistrationOptions options;
     options.setScope("y/");
     container->registerServiceWorker(getScriptState(), "/x/y/worker.js",
                                      options);
 
     EXPECT_EQ(1ul, stubProvider.registerCallCount());
     EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/y/")),
               stubProvider.registerScope());
     EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/y/worker.js")),
               stubProvider.registerScriptURL());
+    EXPECT_EQ(false, stubProvider.useCache());
   }
 }
 
 TEST_F(ServiceWorkerContainerTest,
        GetRegistration_OmittedDocumentURLDefaultsToPageURL) {
   setPageURL("http://localhost/x/index.html");
 
   StubWebServiceWorkerProvider stubProvider;
   provide(stubProvider.provider());
 
   ServiceWorkerContainer* container = ServiceWorkerContainer::create(
       getExecutionContext(), getNavigatorServiceWorker());
 
   {
     ScriptState::Scope scriptScope(getScriptState());
     container->getRegistration(getScriptState(), "");
     EXPECT_EQ(1ul, stubProvider.getRegistrationCallCount());
     EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/index.html")),
               stubProvider.getRegistrationURL());
   }
 }
 
+TEST_F(ServiceWorkerContainerTest,
+       RegisterUnregister_UseCacheOptionDelegatesToProvider) {
+  setPageURL("http://localhost/x/index.html");
+
+  StubWebServiceWorkerProvider stubProvider;
+  provide(stubProvider.provider());
+
+  ServiceWorkerContainer* container = ServiceWorkerContainer::create(
+      getExecutionContext(), getNavigatorServiceWorker());
+
+  // register
+  {
+    ScriptState::Scope scriptScope(getScriptState());
+    RegistrationOptions options;
+    options.setUseCache(true);
+    container->registerServiceWorker(getScriptState(), "/x/y/worker.js",
+                                     options);
+
+    EXPECT_EQ(1ul, stubProvider.registerCallCount());
+    EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/y/")),
+              stubProvider.registerScope());
+    EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/y/worker.js")),
+              stubProvider.registerScriptURL());
+    EXPECT_EQ(true, stubProvider.useCache());
+  }
+}
+
 }  // namespace
 }  // namespace blink