Move content/renderer/background_sync to Blink

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

 // 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.
 
 #include "modules/serviceworkers/WaitUntilObserver.h"
 
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
@@ skipping 62 matching lines @@
     return value;
   }
 
   Member<WaitUntilObserver> m_observer;
   ResolveType m_resolveType;
 };
 
 WaitUntilObserver* WaitUntilObserver::create(ExecutionContext* context,
                                              EventType type,
                                              int eventID) {
-  return new WaitUntilObserver(context, type, eventID);
+  return new WaitUntilObserver(context, type, eventID, nullptr);
+}
+
+WaitUntilObserver* WaitUntilObserver::create(
+    ExecutionContext* context,
+    EventType type,
+    std::unique_ptr<Callback> callback) {
+  return new WaitUntilObserver(context, type, -1, std::move(callback));
 }
 
 void WaitUntilObserver::willDispatchEvent() {
   m_eventDispatchTime = WTF::currentTime();
   // When handling a notificationclick event, we want to allow one window to
   // be focused or opened. These calls are allowed between the call to
   // willDispatchEvent() and the last call to decrementPendingActivity(). If
   // waitUntil() isn't called, that means between willDispatchEvent() and
   // didDispatchEvent().
   if (m_type == NotificationClick)
@@ skipping 31 matching lines @@
                                                  BLINK_FROM_HERE);
 
   incrementPendingActivity();
   scriptPromise.then(
       ThenFunction::createFunction(scriptState, this, ThenFunction::Fulfilled),
       ThenFunction::createFunction(scriptState, this, ThenFunction::Rejected));
 }
 
 WaitUntilObserver::WaitUntilObserver(ExecutionContext* context,
                                      EventType type,
-                                     int eventID)
+                                     int eventID,
+                                     std::unique_ptr<Callback> callback)
     : ContextLifecycleObserver(context),
       m_type(type),
       m_eventID(eventID),
       m_consumeWindowInteractionTimer(
           this,
-          &WaitUntilObserver::consumeWindowInteraction) {}
+          &WaitUntilObserver::consumeWindowInteraction),
+      m_callback(std::move(callback)) {}
 
 void WaitUntilObserver::reportError(const ScriptValue& value) {
   // FIXME: Propagate error message to the client for onerror handling.
   NOTIMPLEMENTED();
 
   m_hasError = true;
 }
 
 void WaitUntilObserver::incrementPendingActivity() {
   ++m_pendingActivity;
@@ skipping 30 matching lines @@
       consumeWindowInteraction(nullptr);
       break;
     case NotificationClose:
       client->didHandleNotificationCloseEvent(m_eventID, result,
                                               m_eventDispatchTime);
       break;
     case Push:
       client->didHandlePushEvent(m_eventID, result, m_eventDispatchTime);
       break;
     case Sync:
-      client->didHandleSyncEvent(m_eventID, result, m_eventDispatchTime);
+      DCHECK(m_callback);
+      (*m_callback)(m_hasError
+                        ? blink::mojom::ServiceWorkerEventStatus::REJECTED
+                        : blink::mojom::ServiceWorkerEventStatus::COMPLETED,
+                    m_eventDispatchTime);
       break;
   }
   setContext(nullptr);
 }
 
 void WaitUntilObserver::consumeWindowInteraction(TimerBase*) {
   if (!getExecutionContext())
     return;
   getExecutionContext()->consumeWindowInteraction();
 }
 
+void WaitUntilObserver::contextDestroyed() {
+  if (m_type == Sync && !m_eventDispatched) {
+    DCHECK(m_callback);
+    (*m_callback)(blink::mojom::ServiceWorkerEventStatus::ABORTED,
+                  WTF::currentTime());
+    m_eventDispatched = true;
+  }
+  ContextLifecycleObserver::contextDestroyed();
+}
+
 DEFINE_TRACE(WaitUntilObserver) {
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink