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/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";
 }
 
+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(this));

[michaeln, 2013/10/07 20:09:54]

I'm glad my comments made sense and you bought that view of how to stitch this
together. With that in mind, maybe instead of deriving NavigatorServiceWorker
from WebServiceWorkerProviderClient and passing 'this' here, declare a
datamember and pass &m_emptyProviderClient to the create call.

WebServiceWorkerProviderClient m_emptyProviderClient;

And, we'll take it as a FIXME to hook those up properly deeper in the loader.

The reason is, that deriviation is not going to stick and there is no burning
need for the didFailToStart() method doing anything right now, whereas there is
a burning need to get registerServiceWorker() to actually do something.

Does that make sense?

+    }
+    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();
 }
 
+void NavigatorServiceWorker::didFailToStart(const WebString& message)
+{
+    // 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 WebCore