ServiceWorker: Make "ready" fetches registration from browser process(1/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 63 matching lines @@
         else if (m_resolver->executionContext() && !m_resolver->executionContext()->activeDOMObjectsAreStopped())
             m_resolver->resolve();
     }
     virtual void onError(WebServiceWorkerError* error) override { m_adapter.onError(error); }
 private:
     RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
     CallbackPromiseAdapter<ServiceWorkerRegistration, ServiceWorkerError> m_adapter;
     WTF_MAKE_NONCOPYABLE(GetRegistrationCallback);
 };
 
+class ServiceWorkerContainer::GetRegistrationForReadyCallback : public WebServiceWorkerProvider::WebServiceWorkerGetRegistrationForReadyCallbacks {
+public:
+    explicit GetRegistrationForReadyCallback(ReadyProperty* ready)
+        : m_ready(ready) { }
+    ~GetRegistrationForReadyCallback() { }
+    void onSuccess(WebServiceWorkerRegistration* registration) override
+    {
+        ASSERT(registration);
+        ASSERT(m_ready->state() == ReadyProperty::Pending);
+        if (m_ready->executionContext() && !m_ready->executionContext()->activeDOMObjectsAreStopped())
+            m_ready->resolve(ServiceWorkerRegistration::from(m_ready->executionContext(), registration));
+    }
+private:
+    Persistent<ReadyProperty> m_ready;
+    WTF_MAKE_NONCOPYABLE(GetRegistrationForReadyCallback);
+};
+
 ServiceWorkerContainer* ServiceWorkerContainer::create(ExecutionContext* executionContext)
 {
     return new ServiceWorkerContainer(executionContext);
 }
 
 ServiceWorkerContainer::~ServiceWorkerContainer()
 {
     ASSERT(!m_provider);
 }
 
@@ skipping 132 matching lines @@
 {
     if (!executionContext())
         return ScriptPromise();
 
     if (!callerState->world().isMainWorld()) {
         // FIXME: Support .ready from isolated worlds when
         // ScriptPromiseProperty can vend Promises in isolated worlds.
         return ScriptPromise::rejectWithDOMException(callerState, DOMException::create(NotSupportedError, "'ready' is only supported in pages."));
     }
 
+    if (!m_ready) {
+        m_ready = createReadyProperty();
+        if (m_provider)
+            m_provider->getRegistrationForReady(new GetRegistrationForReadyCallback(m_ready.get()));
+    }
+
     return m_ready->promise(callerState->world());
 }
 
 // If the WebServiceWorker is up for adoption (does not have a
 // WebServiceWorkerProxy owner), rejects the adoption by deleting the
 // WebServiceWorker.
 static void deleteIfNoExistingOwner(WebServiceWorker* serviceWorker)
 {
     if (serviceWorker && !serviceWorker->proxy())
         delete serviceWorker;
 }
 
 void ServiceWorkerContainer::setController(WebServiceWorker* serviceWorker, bool shouldNotifyControllerChange)
 {
     if (!executionContext()) {
         deleteIfNoExistingOwner(serviceWorker);
         return;
     }
     m_controller = ServiceWorker::from(executionContext(), serviceWorker);
     if (shouldNotifyControllerChange)
         dispatchEvent(Event::create(EventTypeNames::controllerchange));
 }
 
+// FIXME: Remove this after Chrome side CL landed.
 void ServiceWorkerContainer::setReadyRegistration(WebServiceWorkerRegistration* registration)
 {
     if (!executionContext()) {
         ServiceWorkerRegistration::dispose(registration);
         return;
     }
 
     ServiceWorkerRegistration* readyRegistration = ServiceWorkerRegistration::from(executionContext(), registration);
     ASSERT(readyRegistration->active());
 
@@ skipping 42 matching lines @@
 }
 
 ServiceWorkerContainer::ServiceWorkerContainer(ExecutionContext* executionContext)
     : ContextLifecycleObserver(executionContext)
     , m_provider(0)
 {
 
     if (!executionContext)
         return;
 
+    // FIXME: Remove this after Chrome side CL landed.
     m_ready = createReadyProperty();
 
     if (ServiceWorkerContainerClient* client = ServiceWorkerContainerClient::from(executionContext)) {
         m_provider = client->provider();
         if (m_provider)
             m_provider->setClient(this);
     }
 }
 
 } // namespace blink