Push API: define push event on Service Worker.

public/web/WebServiceWorkerContextProxy.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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebServiceWorkerContextProxy_h
 #define WebServiceWorkerContextProxy_h
 
 #include "public/platform/WebMessagePortChannel.h"
 
 namespace blink {
 
+class WebServiceWorkerPushEventCallback;
 class WebString;
 
 // A proxy interface to talk to the worker's GlobalScope implementation.
 // All methods of this class must be called on the worker thread.
 class WebServiceWorkerContextProxy {
 public:
     virtual ~WebServiceWorkerContextProxy() { }
 
     virtual void dispatchActivateEvent(int eventID) = 0;
     // FIXME: This needs to pass the active service worker info.
     virtual void dispatchInstallEvent(int installEventID) = 0;
     // FIXME: This needs to pass the fetch request info.
     virtual void dispatchFetchEvent(int fetchEventID) = 0;
 
     virtual void dispatchMessageEvent(const WebString& message, const WebMessagePortChannelArray& channels) = 0;
 
     // Once the ServiceWorker has finished handling the sync event
     // didHandleSyncEvent is called on the context client.
     virtual void dispatchSyncEvent(int syncEventID) = 0;
+
+    // Once the ServiceWorker has finished handling the push event
+    // the callback is run.
+    virtual void dispatchPushEvent(int eventID, const WebString& data, const WebServiceWorkerPushEventCallback&) = 0;

[kinuko, 2014/05/22 04:33:19]

nit: this callback interface doesn't look particularly useful to me at least in
the current code, especially if it's always called at the end of
dispatchPushEvent method.  Will there be a case where we call the given callback
asyncly, with additional status info like success or failure?  (I guess the same
comment applies to SyncEvent one)

[Michael van Ouwerkerk, 2014/05/23 18:32:03]

I hoped you would know what this is for, this is the existing pattern. It seems
ServiceWorkerVersion likes to track these callbacks in the browser process.

In future, this may be relevant in context of limiting execution time. The
callback value would be different if the script is killed:
https://code.google.com/p/chromium/issues/detail?id=372436

For now, the callback is an interesting problem to be solved for modular
addition of API's that live in Service Worker.

[kinuko, 2014/05/26 04:03:00]

Two questions:

* I know this is from the existing pattern, I just wonder if we could just do
something like below in the chromium side (in service_worker_script_context.cc)
if it doesn't need to be called back asyncly:

dispatchPushEvent();
DidHandlePushEvent(request_id);

* If this follows the existing pattern should we really want to apply a callback
pattern only for this method now?  I can see some benefits for using the pattern
here (it removes some additional plumbing for calling back to chromium side),
but I also feel it'd make these interfaces a bit  inconsistent.  In other words,
say, if we want to convert all the dispatch*Event() stuff into this pattern do
we need to define new callback types for each of them?

 };
 
 } // namespace blink
 
 #endif // WebServiceWorkerContextProxy_h