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

Source/modules/serviceworkers/ServiceWorkerContainer.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 36 matching lines @@
 #include "modules/serviceworkers/ServiceWorkerRegistration.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "public/platform/WebServiceWorker.h"
 #include "public/platform/WebServiceWorkerProvider.h"
 #include "public/platform/WebServiceWorkerRegistration.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 
 namespace blink {
 
+// This wraps CallbackPromiseAdapter and resolves the promise with undefined
+// when nullptr is given to onSuccess.
+class GetRegistrationCallback : public WebServiceWorkerProvider::WebServiceWorkerGetRegistrationCallbacks {
+public:
+    explicit GetRegistrationCallback(PassRefPtr<ScriptPromiseResolver> resolver)
+        : m_resolver(resolver)
+        , m_adapter(m_resolver) { }
+    virtual ~GetRegistrationCallback() { }
+    virtual void onSuccess(WebServiceWorkerRegistration* registration) OVERRIDE
+    {
+        if (registration)
+            m_adapter.onSuccess(registration);
+        else if (m_resolver->executionContext() && !m_resolver->executionContext()->activeDOMObjectsAreStopped())
+            m_resolver->resolve();
+    }
+    virtual void onError(WebServiceWorkerError* error) OVERRIDE { m_adapter.onError(error); }
+private:
+    RefPtr<ScriptPromiseResolver> m_resolver;
+    CallbackPromiseAdapter<ServiceWorkerRegistration, ServiceWorkerError> m_adapter;
+    WTF_MAKE_NONCOPYABLE(GetRegistrationCallback);
+};
+
 ServiceWorkerContainer* ServiceWorkerContainer::create(ExecutionContext* executionContext)
 {
     return new ServiceWorkerContainer(executionContext);
 }
 
 ServiceWorkerContainer::~ServiceWorkerContainer()
 {
     ASSERT(!m_provider);
 }
 
@@ skipping 89 matching lines @@
     KURL patternURL = scriptState->executionContext()->completeURL(pattern);
     patternURL.removeFragmentIdentifier();
     if (!pattern.isEmpty() && !documentOrigin->canRequest(patternURL)) {
         resolver->reject(DOMException::create(SecurityError, "The scope must match the current origin."));
         return promise;
     }
     m_provider->unregisterServiceWorker(patternURL, new CallbackPromiseAdapter<BooleanValue, ServiceWorkerError>(resolver));
     return promise;
 }
 
+ScriptPromise ServiceWorkerContainer::getRegistration(ScriptState* scriptState, const String& documentURL)
+{
+    ASSERT(RuntimeEnabledFeatures::serviceWorkerEnabled());
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    // FIXME: This should use the container's execution context, not
+    // the callers.
+    ExecutionContext* executionContext = scriptState->executionContext();
+    RefPtr<SecurityOrigin> documentOrigin = executionContext->securityOrigin();
+    String errorMessage;
+    if (!documentOrigin->canAccessFeatureRequiringSecureOrigin(errorMessage)) {
+        resolver->reject(DOMException::create(NotSupportedError, errorMessage));
+        return promise;
+    }
+
+    KURL completedURL = executionContext->completeURL(documentURL);

[nhiroki, 2014/09/10 07:45:04]

(Just to check my understanding) When the document URL is not specified,
|completedURL| represents the caller's document URL. That is,
navigator.serviceWorker.getRegistration() without an argument returns a
registration object whose scope matches the caller's document URL. Okay, this
would be conformed with the spec.

[Kunihiko Sakamoto, 2014/09/10 09:34:51]

Yes. I've added a test case to verify this in ServiceWorkerContainerTest.cpp.

+    if (!documentOrigin->canRequest(completedURL)) {
+        resolver->reject(DOMException::create(SecurityError, "The documentURL must match the current origin."));
+        return promise;
+    }
+    m_provider->getRegistration(completedURL, new GetRegistrationCallback(resolver));
+
+    return promise;
+}
+
 ServiceWorkerContainer::ReadyProperty* ServiceWorkerContainer::createReadyProperty()
 {
     return new ReadyProperty(executionContext(), this, ReadyProperty::Ready);
 }
 
 ScriptPromise ServiceWorkerContainer::ready(ScriptState* callerState)
 {
     if (!executionContext())
         return ScriptPromise();
 
@@ skipping 71 matching lines @@
     m_ready = createReadyProperty();
 
     if (ServiceWorkerContainerClient* client = ServiceWorkerContainerClient::from(executionContext)) {
         m_provider = client->provider();
         if (m_provider)
             m_provider->setClient(this);
     }
 }
 
 } // namespace blink