Rename WebServiceWorkerRegistry to WebServiceWorkerProvider

Source/modules/serviceworkers/NavigatorServiceWorker.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 23 matching lines @@
 #include "V8ServiceWorker.h"
 #include "bindings/v8/ScriptPromiseResolver.h"
 #include "core/dom/Document.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/Frame.h"
 #include "core/page/Navigator.h"
 #include "core/workers/SharedWorker.h"
 #include "modules/serviceworkers/CallbackPromiseAdapter.h"
 #include "modules/serviceworkers/ServiceWorker.h"
-#include "public/platform/WebServiceWorkerRegistry.h"
+#include "public/platform/WebServiceWorkerProvider.h"
+#include "public/platform/WebServiceWorkerProviderClient.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 
+using WebKit::WebServiceWorkerProvider;
+using WebKit::WebString;
+
 namespace WebCore {
 
 NavigatorServiceWorker::NavigatorServiceWorker(Navigator* navigator)
     : m_navigator(navigator)
 {
 }
 
 NavigatorServiceWorker::~NavigatorServiceWorker()
 {
 }
 
 const char* NavigatorServiceWorker::supplementName()
 {
     return "NavigatorServiceWorker";
 }
 
+namespace {
+
+class ServiceWorkerProviderClientLogger : public WebKit::WebServiceWorkerProviderClient {
+public:
+    // WebServiceWorkerProviderClient implementation
+    virtual void didFailToStart(const WebString& message) OVERRIDE
+    {
+        // FIXME: Move this to a handler that can forward this to the dev console.
+        LOG_ERROR("Service worker failed to start: %s", message.utf8().data());
+    }
+};
+} // namespace
+
+WebServiceWorkerProvider* NavigatorServiceWorker::serviceWorkerProvider()
+{
+    if (!m_provider) {
+        FrameLoaderClient* client = m_navigator->frame()->loader()->client();
+        // FIXME: This is temporarily hooked up here until we hook up to the loading process.
+        m_provider = adoptPtr(client->createServiceWorkerProvider(new ServiceWorkerProviderClientLogger()));

[michaeln, 2013/10/07 21:08:06]

The ownership doesn't look right. Who is responsible for deleting the 'client'
object? Let's get that nailed down and spelled out clearly up in the webkit API.

I'd suggest that 'blink' is responsible for deleting the 'client' and the
embedder should NOT call delete on it. Those are the semantics your first
earlier snapshots suggested, so i was surprised by this new snapshot which
inverted things.

To express these semantics in the webkit API, let's add a protected virtual
destructor to WebKit::WebServiceWorkerProviderClient... so the embedder can't
delete it and if somebody tries to write code that does so, the compiler will
complain at them.

We'll have to new/delete the stub 'client' object in this class.

+    }
+    return m_provider.get();
+}
+
 NavigatorServiceWorker* NavigatorServiceWorker::from(Navigator* navigator)
 {
     NavigatorServiceWorker* supplement = toNavigatorServiceWorker(navigator);
     if (!supplement) {
         supplement = new NavigatorServiceWorker(navigator);
         provideTo(navigator, supplementName(), adoptPtr(supplement));
     }
     return supplement;
 }
 
 ScriptPromise NavigatorServiceWorker::registerServiceWorker(ScriptExecutionContext* context, Navigator* navigator, const String& pattern, const String& url, ExceptionState& es)
 {
     return from(navigator)->registerServiceWorker(context, pattern, url, es);
 }
 
-
 ScriptPromise NavigatorServiceWorker::registerServiceWorker(ScriptExecutionContext* scriptExecutionContext, const String& pattern, const String& scriptSrc, ExceptionState& es)
 {
     ASSERT(RuntimeEnabledFeatures::serviceWorkerEnabled());
-    FrameLoaderClient* client = m_navigator->frame()->loader()->client();
     // WTF? Surely there's a better way to resolve a url?
     KURL scriptUrl = m_navigator->frame()->document()->completeURL(scriptSrc);
-    WebKit::WebServiceWorkerRegistry* peer = client->serviceWorkerRegistry();
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptExecutionContext);
 
-    if (peer)
-        peer->registerServiceWorker(pattern, scriptUrl, new CallbackPromiseAdapter(resolver, scriptExecutionContext));
+    WebKit::WebServiceWorkerProvider* provider = serviceWorkerProvider();
+    if (provider)
+        provider->registerServiceWorker(pattern, scriptUrl, new CallbackPromiseAdapter(resolver, scriptExecutionContext));
     else
         resolver->reject(PassRefPtr<ServiceWorker>(0));
     // call here?
     return resolver->promise();
 }
 
 ScriptPromise NavigatorServiceWorker::unregisterServiceWorker(ScriptExecutionContext* context, Navigator* navigator, const String& pattern, ExceptionState& es)
 {
     return from(navigator)->unregisterServiceWorker(context, pattern, es);
 }
 
 ScriptPromise NavigatorServiceWorker::unregisterServiceWorker(ScriptExecutionContext* scriptExecutionContext, const String& pattern, ExceptionState& es)
 {
     ASSERT(RuntimeEnabledFeatures::serviceWorkerEnabled());
     FrameLoaderClient* client = m_navigator->frame()->loader()->client();
-    WebKit::WebServiceWorkerRegistry* peer = client->serviceWorkerRegistry();
+    WebKit::WebServiceWorkerProvider* provider = serviceWorkerProvider();
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptExecutionContext);
-    if (peer)
-        peer->unregisterServiceWorker(pattern, new CallbackPromiseAdapter(resolver, scriptExecutionContext));
+    if (provider)
+        provider->unregisterServiceWorker(pattern, new CallbackPromiseAdapter(resolver, scriptExecutionContext));
     else
         resolver->reject(PassRefPtr<ServiceWorker>(0));
     return resolver->promise();
 }
 
 } // namespace WebCore