ServiceWorker: Implement navigator.serviceWorker.getRegistration [3/3]

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 "config.h"
 #include "modules/serviceworkers/ServiceWorkerContainer.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
@@ skipping 187 matching lines @@
         ServiceWorkerContainer* container = ServiceWorkerContainer::create(executionContext());
         ScriptState::Scope scriptScope(scriptState());
         Dictionary options = Dictionary::createEmpty(isolate());
         EXPECT_TRUE(options.set("scope", scope));
         ScriptPromise promise = container->unregisterServiceWorker(scriptState(), scope);
         expectRejected(scriptState(), promise, valueTest);
 
         container->willBeDetachedFromFrame();
     }
 
+    void testGetRegistrationRejected(const String& documentURL, const ScriptValueTest& valueTest)
+    {
+        provide(adoptPtr(new NotReachedWebServiceWorkerProvider()));
+
+        ServiceWorkerContainer* container = ServiceWorkerContainer::create(executionContext());
+        ScriptState::Scope scriptScope(scriptState());
+        ScriptPromise promise = container->getRegistration(scriptState(), documentURL);
+        expectRejected(scriptState(), promise, valueTest);
+
+        container->willBeDetachedFromFrame();
+    }
+
 private:
     OwnPtr<DummyPageHolder> m_page;
 };
 
 TEST_F(ServiceWorkerContainerTest, Register_NonSecureOriginIsRejected)
 {
     setPageURL("http://www.example.com/");
     testRegisterRejected(
         "http://www.example.com/worker.js",
         "http://www.example.com/",
@@ skipping 27 matching lines @@
 }
 
 TEST_F(ServiceWorkerContainerTest, Unregister_CrossOriginScopeIsRejected)
 {
     setPageURL("https://www.example.com");
     testUnregisterRejected(
         "https://example.com/", // Differs by host
         ExpectDOMException("SecurityError", "The scope must match the current origin."));
 }
 
+TEST_F(ServiceWorkerContainerTest, GetRegistration_NonSecureOriginIsRejected)
+{
+    setPageURL("http://www.example.com/");
+    testGetRegistrationRejected(
+        "http://www.example.com/",
+        ExpectDOMException("NotSupportedError", "Only secure origins are allowed. http://goo.gl/lq4gCo"));
+}
+
+TEST_F(ServiceWorkerContainerTest, GetRegistration_CrossOriginURLIsRejected)
+{
+    setPageURL("https://www.example.com/");
+    testGetRegistrationRejected(
+        "https://foo.example.com/", // Differs by host
+        ExpectDOMException("SecurityError", "The documentURL must match the current origin."));
+}
+
 class StubWebServiceWorkerProvider {
 public:
     StubWebServiceWorkerProvider()
         : m_registerCallCount(0)
         , m_unregisterCallCount(0)
+        , m_getRegistrationCallCount(0)
     {
     }
 
     // Creates a WebServiceWorkerProvider. This can outlive the
     // StubWebServiceWorkerProvider, but |registerServiceWorker| and
     // other methods must not be called after the
     // StubWebServiceWorkerProvider dies.
     PassOwnPtr<WebServiceWorkerProvider> provider()
     {
         return adoptPtr(new WebServiceWorkerProviderImpl(*this));
     }
 
     size_t registerCallCount() { return m_registerCallCount; }
     const WebURL& registerScope() { return m_registerScope; }
     const WebURL& registerScriptURL() { return m_registerScriptURL; }
     size_t unregisterCallCount() { return m_unregisterCallCount; }
     const WebURL& unregisterScope() { return m_unregisterScope; }
+    size_t getRegistrationCallCount() { return m_getRegistrationCallCount; }
+    const WebURL& getRegistrationURL() { return m_getRegistrationURL; }
 
 private:
     class WebServiceWorkerProviderImpl : public WebServiceWorkerProvider {
     public:
         WebServiceWorkerProviderImpl(StubWebServiceWorkerProvider& owner)
             : m_owner(owner)
         {
         }
 
         virtual ~WebServiceWorkerProviderImpl() OVERRIDE { }
 
         virtual void registerServiceWorker(const WebURL& pattern, const WebURL& scriptURL, WebServiceWorkerRegistrationCallbacks* callbacks) OVERRIDE
         {
             m_owner.m_registerCallCount++;
             m_owner.m_registerScope = pattern;
             m_owner.m_registerScriptURL = scriptURL;
             m_registrationCallbacksToDelete.append(adoptPtr(callbacks));
         }
 
         virtual void unregisterServiceWorker(const WebURL& pattern, WebServiceWorkerUnregistrationCallbacks* callbacks) OVERRIDE
         {
             m_owner.m_unregisterCallCount++;
             m_owner.m_unregisterScope = pattern;
             m_unregistrationCallbacksToDelete.append(adoptPtr(callbacks));
         }
 
+        virtual void getRegistration(const WebURL& documentURL, WebServiceWorkerGetRegistrationCallbacks* callbacks) OVERRIDE
+        {
+            m_owner.m_getRegistrationCallCount++;
+            m_owner.m_getRegistrationURL = documentURL;
+            m_getRegistrationCallbacksToDelete.append(adoptPtr(callbacks));
+        }
+
     private:
         StubWebServiceWorkerProvider& m_owner;
         Vector<OwnPtr<WebServiceWorkerRegistrationCallbacks> > m_registrationCallbacksToDelete;
         Vector<OwnPtr<WebServiceWorkerUnregistrationCallbacks> > m_unregistrationCallbacksToDelete;
+        Vector<OwnPtr<WebServiceWorkerGetRegistrationCallbacks> > m_getRegistrationCallbacksToDelete;
     };
 
 private:
     size_t m_registerCallCount;
     WebURL m_registerScope;
     WebURL m_registerScriptURL;
     size_t m_unregisterCallCount;
     WebURL m_unregisterScope;
+    size_t m_getRegistrationCallCount;
+    WebURL m_getRegistrationURL;
 };
 
 TEST_F(ServiceWorkerContainerTest, RegisterUnregister_NonHttpsSecureOriginDelegatesToProvider)
 {
     setPageURL("http://localhost/x/index.html");
 
     StubWebServiceWorkerProvider stubProvider;
     provide(stubProvider.provider());
 
     ServiceWorkerContainer* container = ServiceWorkerContainer::create(executionContext());
@@ skipping 15 matching lines @@
         ScriptState::Scope scriptScope(scriptState());
         container->unregisterServiceWorker(scriptState(), "y/");
 
         EXPECT_EQ(1ul, stubProvider.unregisterCallCount());
         EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/y/")), stubProvider.unregisterScope());
     }
 
     container->willBeDetachedFromFrame();
 }
 
+TEST_F(ServiceWorkerContainerTest, GetRegistration_OmittedDocumentURLDefaultsToPageURL)
+{
+    setPageURL("http://localhost/x/index.html");
+
+    StubWebServiceWorkerProvider stubProvider;
+    provide(stubProvider.provider());
+
+    ServiceWorkerContainer* container = ServiceWorkerContainer::create(executionContext());
+
+    {
+        ScriptState::Scope scriptScope(scriptState());
+        container->getRegistration(scriptState(), "");
+        EXPECT_EQ(1ul, stubProvider.getRegistrationCallCount());
+        EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/index.html")), stubProvider.getRegistrationURL());
+    }
+
+    container->willBeDetachedFromFrame();
+}
+
 } // namespace
 } // namespace blink