Move content/renderer/background_sync to Blink

third_party/WebKit/Source/modules/serviceworkers/WaitUntilObserver.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef WaitUntilObserver_h
 #define WaitUntilObserver_h
 
 #include "core/dom/ContextLifecycleObserver.h"
 #include "modules/ModulesExport.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScopeClient.h"
 #include "platform/Timer.h"
+#include "public/platform/modules/serviceworker/service_worker_event_status.mojom-shared.h"
 #include "wtf/Forward.h"
+#include <memory>
 
 namespace blink {
 
 class ExceptionState;
 class ExecutionContext;
 class ScriptPromise;
 class ScriptState;
 class ScriptValue;
 
 // Created for each ExtendableEvent instance.
 class MODULES_EXPORT WaitUntilObserver final
     : public GarbageCollectedFinalized<WaitUntilObserver>,
       public ContextLifecycleObserver {
   USING_GARBAGE_COLLECTED_MIXIN(WaitUntilObserver);
+  using Callback = WTF::Function<void(blink::mojom::ServiceWorkerEventStatus,
+                                      const double&)>;

[jbroman, 2016/11/21 21:36:01]

A few nits:
1. "blink::" is unnecessary while in namespace blink
2. Please name the variable here (e.g. "eventDispatchTime") so it's clear what
it gets called with.
3. This last one is more open to debate, but while it's very convenient that
making this const double& makes it match perfectly with what
mojom::blink::BackgroundSyncClient wants, from the perspective of this class
alone a const& to a primitive type seems odd. (And, if this approach is used to
deal with other events in the future, const double& may not make sense to those
clients.)

i.e. I think I'd prefer:
using Callback = WTF::Function<void(mojom::ServiceWorkerEventStatus, double
eventDispatchTime)>;

Regrettably, doing 3 does mean that you'll need an intermediate callback that
just adapts the call signature:

WTF::bind([](SyncCallback callback, mojom::ServiceWorkerEventStatus status,
double eventDispatchTime) {
  callback.Run(status, eventDispatchTime);
}, WTF::passed(std::move(callback)));

So you might want to wait and see what modules/serviceworkers/OWNERS think.

 
  public:
   enum EventType {
     Activate,
     Fetch,
     Install,
     Message,
     NotificationClick,
     NotificationClose,
     Push,
     Sync
   };
 
   static WaitUntilObserver* create(ExecutionContext*, EventType, int eventID);
+  static WaitUntilObserver* create(ExecutionContext*,
+                                   EventType,
+                                   std::unique_ptr<Callback>);
 
   // Must be called before and after dispatching the event.
   void willDispatchEvent();
   void didDispatchEvent(bool errorOccurred);
 
   // Observes the promise and delays calling the continuation until
   // the given promise is resolved or rejected.
   void waitUntil(ScriptState*, ScriptPromise, ExceptionState&);
 
   // These methods can be called when the lifecycle of ExtendableEvent
   // observed by this WaitUntilObserver should be extended by other reason
   // than ExtendableEvent.waitUntil.
   // Note: There is no need to call decrementPendingActivity() after the context
   // is being destroyed.
   void incrementPendingActivity();
   void decrementPendingActivity();
 
+  // Overriden from LifecycleObserver

[jbroman, 2016/11/21 21:36:01]

spelling nit: "Overridden"

+  void contextDestroyed() override;
+
   DECLARE_VIRTUAL_TRACE();
 
  private:
   friend class InternalsServiceWorker;
   class ThenFunction;
 
-  WaitUntilObserver(ExecutionContext*, EventType, int eventID);
+  WaitUntilObserver(ExecutionContext*,
+                    EventType,
+                    int eventID,
+                    std::unique_ptr<Callback>);
 
   void reportError(const ScriptValue&);
 
   void consumeWindowInteraction(TimerBase*);
 
   EventType m_type;
   int m_eventID;
   int m_pendingActivity = 0;
   bool m_hasError = false;
   bool m_eventDispatched = false;
   double m_eventDispatchTime = 0;
   Timer<WaitUntilObserver> m_consumeWindowInteractionTimer;
+  std::unique_ptr<Callback> m_callback;
 };
 
 }  // namespace blink
 
 #endif  // WaitUntilObserver_h