ServiceWorker: Make '.ready' return a promise to be resolved with ServiceWorkerRegistration (1/3)

Source/modules/serviceworkers/ServiceWorkerContainer.h

 /*
  * 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 18 matching lines @@
  */
 
 #ifndef ServiceWorkerContainer_h
 #define ServiceWorkerContainer_h
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseProperty.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/dom/ContextLifecycleObserver.h"
 #include "modules/serviceworkers/ServiceWorker.h"
+#include "modules/serviceworkers/ServiceWorkerRegistration.h"
 #include "platform/heap/Handle.h"
 #include "public/platform/WebServiceWorkerProviderClient.h"
 #include "wtf/Forward.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 class Dictionary;
 class ExecutionContext;
-class ServiceWorker;
 class WebServiceWorker;
 class WebServiceWorkerProvider;
+class WebServiceWorkerRegistration;
 
 class ServiceWorkerContainer FINAL
     : public RefCountedWillBeGarbageCollectedFinalized<ServiceWorkerContainer>
     , public ScriptWrappable
     , public ContextLifecycleObserver
     , public WebServiceWorkerProviderClient {
 public:
     static PassRefPtrWillBeRawPtr<ServiceWorkerContainer> create(ExecutionContext*);
     ~ServiceWorkerContainer();
 
     void willBeDetachedFromFrame();
 
     void trace(Visitor*);
 
     PassRefPtrWillBeRawPtr<ServiceWorker> active() { return m_active.get(); }
     PassRefPtrWillBeRawPtr<ServiceWorker> controller() { return m_controller.get(); }
     PassRefPtrWillBeRawPtr<ServiceWorker> installing() { return m_installing.get(); }
     PassRefPtrWillBeRawPtr<ServiceWorker> waiting() { return m_waiting.get(); }
     ScriptPromise ready(ScriptState*);
     WebServiceWorkerProvider* provider() { return m_provider; }
 
     ScriptPromise registerServiceWorker(ScriptState*, const String& pattern, const Dictionary&);
     ScriptPromise unregisterServiceWorker(ScriptState*, const String& scope);
 
     // WebServiceWorkerProviderClient overrides.
     virtual void setActive(WebServiceWorker*) OVERRIDE;
     virtual void setController(WebServiceWorker*) OVERRIDE;
     virtual void setInstalling(WebServiceWorker*) OVERRIDE;
     virtual void setWaiting(WebServiceWorker*) OVERRIDE;
+    virtual void setReady(WebServiceWorkerRegistration*) OVERRIDE;

[michaeln, 2014/09/03 22:17:48]

Should this method be named setRegistration or maybe setReadyRegistration.

Sry for the naming nit but conventions are not real clear to me in the brave new
world of promises that blend events and attributes, onready is more or less the
event and registration is more or less the attribute. The attribute name is more
meaningful to me at least.

[nhiroki, 2014/09/04 08:55:58]

Sounds reasonable. Replaced 'setReady' with 'setReadyRegistration'.

     virtual void dispatchMessageEvent(const WebString& message, const WebMessagePortChannelArray&) OVERRIDE;
 
 private:
     explicit ServiceWorkerContainer(ExecutionContext*);
 
-    typedef ScriptPromiseProperty<RawPtrWillBeMember<ServiceWorkerContainer>, RefPtrWillBeMember<ServiceWorker>, RefPtrWillBeMember<ServiceWorker> > ReadyProperty;
+    typedef ScriptPromiseProperty<RawPtrWillBeMember<ServiceWorkerContainer>, RefPtrWillBeMember<ServiceWorkerRegistration>, RefPtrWillBeMember<ServiceWorkerRegistration> > ReadyProperty;
     ReadyProperty* createReadyProperty();
-    void checkReadyChanged(PassRefPtrWillBeRawPtr<ServiceWorker> previousReadyWorker);
+    void checkReadyChanged(PassRefPtrWillBeRawPtr<ServiceWorkerRegistration> previousReadyRegistration);
 
     WebServiceWorkerProvider* m_provider;
     RefPtrWillBeMember<ServiceWorker> m_active;
     RefPtrWillBeMember<ServiceWorker> m_controller;
     RefPtrWillBeMember<ServiceWorker> m_installing;
     RefPtrWillBeMember<ServiceWorker> m_waiting;
+    RefPtrWillBeMember<ServiceWorkerRegistration> m_readyRegistration;
     PersistentWillBeMember<ReadyProperty> m_ready;
 };
 
 } // namespace blink
 
 #endif // ServiceWorkerContainer_h