Attachment #8788562 for bug #1217544

Attachment #8788562: Part 4: Sync event for bug #1217544

View | Details | Raw Unified | Return to bug 1217544
Collapse All | Expand All





};

// BackgroundSync

// static
already_AddRefed<BackgroundSync>
BackgroundSync::CreateOnMainThread(nsIGlobalObject* aGlobal,
                                   nsIPrincipal* aPrincipal,
                                   const nsAString& aScope,
                                   ErrorResult& aRv)
{
  MOZ_ASSERT(aGlobal);
  MOZ_ASSERT(aPrincipal);
  MOZ_ASSERT(!aScope.IsEmpty());
  MOZ_ASSERT(NS_IsMainThread());

  PrincipalInfo principalInfo;
  aRv = PrincipalToPrincipalInfo(aPrincipal, &principalInfo);
  if (NS_WARN_IF(aRv.Failed())) {
    return nullptr;
  }

  RefPtr<BackgroundSync> ref = new BackgroundSync(aGlobal, principalInfo,
                                                  aScope);

  // Register as observer for inner-window-destroyed.
  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
  if (obs) {
    aRv = obs->AddObserver(ref, "inner-window-destroyed",
                           false /* ownsWeak */);
    if (NS_WARN_IF(aRv.Failed())) {
      return nullptr;

  ref->mInnerID = window->WindowID();

  return ref.forget();
}

// static
already_AddRefed<BackgroundSync>
BackgroundSync::CreateOnWorker(nsIGlobalObject* aGlobal,
                               WorkerPrivate* aWorkerPrivate,
                               const nsAString& aScope)
{
  MOZ_ASSERT(aWorkerPrivate);
  MOZ_ASSERT(!aScope.IsEmpty());
  aWorkerPrivate->AssertIsOnWorkerThread();

  const PrincipalInfo& principalInfo = aWorkerPrivate->GetPrincipalInfo();

  RefPtr<BackgroundSync> ref = new BackgroundSync(aGlobal,
                                                  principalInfo,
                                                  aScope);

  ref->mWorkerHolder = new BackgroundSyncHolder(ref);
  if (NS_WARN_IF(!ref->mWorkerHolder->HoldWorker(aWorkerPrivate, Terminating))) {
    ref->mWorkerHolder = nullptr;
    return nullptr;
  }

  return ref.forget();
}

BackgroundSync::BackgroundSync(nsIGlobalObject* aGlobal,
                               const PrincipalInfo& aPrincipalInfo,
                               const nsAString& aScope)
  : mInnerID(0)
  , mGlobal(aGlobal)
  , mShuttingDown(false)
  , mPrincipalInfo(MakeUnique<PrincipalInfo>(aPrincipalInfo))
  , mScope(aScope)
{
#ifdef DEBUG
  mThread = do_GetCurrentThread();
#endif

  MOZ_ASSERT(aGlobal);

  // Register this component to PBackground.


// WebIDL interface methods.

already_AddRefed<Promise>
BackgroundSync::Register(const nsAString& aTag, ErrorResult& aRv)
{
  MOZ_ASSERT(IsBackgroundSyncThread());

  const SyncRegisterArgs args(mScope, (nsString(aTag)));
  return ExecuteOp(SyncOpArgs(args), aRv);
}

already_AddRefed<Promise>
BackgroundSync::GetTags(ErrorResult& aRv)
{
  MOZ_ASSERT(IsBackgroundSyncThread());






public:
  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(
      BackgroundSync, nsIIPCBackgroundChildCreateCallback)

  static already_AddRefed<BackgroundSync>
  CreateOnMainThread(nsIGlobalObject* aGlobal,
                     nsIPrincipal* aPrincipal,
                     const nsAString& aScope,
                     ErrorResult& aRv);

  static already_AddRefed<BackgroundSync>
  CreateOnWorker(nsIGlobalObject* aGlobal,
                 workers::WorkerPrivate* aWorkerPrivate,
                 const nsAString& aScope);

  // Binding methods.

  nsIGlobalObject*
  GetParentObject() const
  {
    return mGlobal;
  }

  Register(const nsAString& aTag, ErrorResult& aRv);

  already_AddRefed<Promise>
  GetTags(ErrorResult& aRv);

  void Shutdown();
private:
  BackgroundSync(nsIGlobalObject* aGlobal,
                 const mozilla::ipc::PrincipalInfo& aPrincipalInfo,
                 const nsAString& aScope);

  ~BackgroundSync();

  already_AddRefed<Promise>
  ExecuteOp(const SyncOpArgs& aArgs, ErrorResult& aRv);

  uint64_t mInnerID;


  bool mShuttingDown;

  UniquePtr<mozilla::ipc::PrincipalInfo> mPrincipalInfo;

  nsCOMPtr<nsIThread> mThread;

  nsTArray<RefPtr<SyncOpRunnable>> mPendingOperations;

  nsString mScope;

#ifdef DEBUG
  bool IsBackgroundSyncThread();
#endif
};

} // namespace backgroundsync
} // namespace dom
} // namespace mozilla






include PBackgroundSharedTypes;

namespace mozilla {
namespace dom {

struct SyncRegisterArgs
{
  nsString mScope;
  nsString mTag;
};

struct SyncGetTagsArgs
{
};

union SyncOpArgs





    },
},

'BackgroundSync': {
    'nativeType': 'mozilla::dom::backgroundsync::BackgroundSync',
    'headerFile': 'mozilla/dom/backgroundsync/BackgroundSync.h',
},

'BackgroundSyncEvent': {
    'headerFile': 'mozilla/dom/ServiceWorkerEvents.h',
    'nativeType': 'mozilla::dom::workers::BackgroundSyncEvent',
    'workers': True
},

'BarProp': {
    'headerFile': 'mozilla/dom/BarProps.h',
},

'Blob': {
    'headerFile': 'mozilla/dom/File.h',
},






                                  in AString aBehavior);

  [optional_argc] void sendPushEvent(in ACString aOriginAttributes,
                                     in ACString aScope,
                                     [optional] in uint32_t aDataLength,
                                     [optional, array, size_is(aDataLength)] in uint8_t aDataBytes);
  void sendPushSubscriptionChangeEvent(in ACString aOriginAttributes,
                                       in ACString scope);

  void addListener(in nsIServiceWorkerManagerListener aListener);

  void removeListener(in nsIServiceWorkerManagerListener aListener);

  bool shouldReportToWindow(in mozIDOMWindowProxy aWindow, in ACString aScope);

  void sendBackgroundSyncEvent(in ACString aOriginAttributes,
                               in ACString scope,
                               in AString aTag,
                               in boolean aLastChance);
};

%{ C++
#define SERVICEWORKERMANAGER_CONTRACTID "@mozilla.org/serviceworkers/manager;1"
%}

-      Line
+  Link Here
-      Line 0
+  Link Here
+/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * The origin of this IDL file is
+ * https://wicg.github.io/BackgroundSync/spec/
+ */
+[Constructor(DOMString type, optional BackgroundSyncEventInit eventInitDict),
+ Exposed=ServiceWorker]
+interface BackgroundSyncEvent : ExtendableEvent {
+  readonly attribute DOMString tag;
+  readonly attribute boolean lastChance;
+};
+dictionary BackgroundSyncEventInit : ExtendableEventInit {
+  required DOMString tag;
+  boolean lastChance = false;
+};





    'AudioParam.webidl',
    'AudioProcessingEvent.webidl',
    'AudioStreamTrack.webidl',
    'AudioTrack.webidl',
    'AudioTrackList.webidl',
    'AutocompleteInfo.webidl',
    'AVInputPort.webidl',
    'BackgroundSync.webidl',
    'BackgroundSyncEvent.webidl',
    'BarProp.webidl',
    'BaseKeyframeTypes.webidl',
    'BatteryManager.webidl',
    'BeforeAfterKeyboardEvent.webidl',
    'BeforeUnloadEvent.webidl',
    'BiquadFilterNode.webidl',
    'Blob.webidl',
    'BoxObject.webidl',





  async PropagateRemove(nsCString host);

  async PropagateRemoveAll();

  async Shutdown();

child:
  async NotifyRegister(ServiceWorkerRegistrationData data);
  async NotifySoftUpdate(PrincipalOriginAttributes originAttributes,
                         nsString scope);
  async NotifyUnregister(PrincipalInfo principalInfo, nsString scope);
  async NotifyRemove(nsCString host);
  async NotifyRemoveAll();
  async NotifyBackgroundSyncEvent(PrincipalInfo principalInfo,
                                  nsString scope,
                                  nsString tag,
                                  bool lastChance);
  async __delete__();
};

} // namespace dom
} // namespace mozilla





    return NS_OK;
  }
  if (aDataInit.IsUSVString()) {
    return ExtractBytesFromUSVString(aDataInit.GetAsUSVString(), aBytes);
  }
  NS_NOTREACHED("Unexpected push message data");
  return NS_ERROR_FAILURE;
}
} // anonymous namespace

PushMessageData::PushMessageData(nsISupports* aOwner,
                                 nsTArray<uint8_t>&& aBytes)
  : mOwner(aOwner), mBytes(Move(aBytes)) {}

PushMessageData::~PushMessageData()
{
}

NS_IMPL_CYCLE_COLLECTION_INHERITED(PushEvent, ExtendableEvent, mData)

JSObject*
PushEvent::WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
  return mozilla::dom::PushEventBinding::Wrap(aCx, this, aGivenProto);
}

// Background Sync

BackgroundSyncEvent::BackgroundSyncEvent(EventTarget* aOwner)
  : ExtendableEvent(aOwner)
{
}

already_AddRefed<BackgroundSyncEvent>
BackgroundSyncEvent::Constructor(mozilla::dom::EventTarget* aOwner,
                       const nsAString& aType,
                       const BackgroundSyncEventInit& aOptions,
                       ErrorResult& aRv)
{
  RefPtr<BackgroundSyncEvent> e = new BackgroundSyncEvent(aOwner);
  bool trusted = e->Init(aOwner);
  e->InitEvent(aType, aOptions.mBubbles, aOptions.mCancelable);
  e->SetTrusted(trusted);
  e->mTag = aOptions.mTag;
  e->mLastChance = aOptions.mLastChance;
  return e.forget();
}

NS_IMPL_ADDREF_INHERITED(BackgroundSyncEvent, ExtendableEvent)
NS_IMPL_RELEASE_INHERITED(BackgroundSyncEvent, ExtendableEvent)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(BackgroundSyncEvent)
NS_INTERFACE_MAP_END_INHERITING(ExtendableEvent)

NS_IMPL_CYCLE_COLLECTION_CLASS(BackgroundSyncEvent)
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(BackgroundSyncEvent, ExtendableEvent)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(BackgroundSyncEvent, ExtendableEvent)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

ExtendableMessageEvent::ExtendableMessageEvent(EventTarget* aOwner)
  : ExtendableEvent(aOwner)
  , mData(JS::UndefinedValue())
{
  mozilla::HoldJSObjects(this);
}

ExtendableMessageEvent::~ExtendableMessageEvent()





#include "mozilla/dom/ExtendableEventBinding.h"
#include "mozilla/dom/ExtendableMessageEventBinding.h"
#include "mozilla/dom/FetchEventBinding.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/dom/Response.h"
#include "mozilla/dom/workers/bindings/ServiceWorker.h"

#include "mozilla/dom/BackgroundSyncEventBinding.h"

#include "nsProxyRelease.h"
#include "nsContentUtils.h"

class nsIInterceptedChannel;

namespace mozilla {
namespace dom {
class Blob;


  void SetPorts(MessagePortList* aPorts);

  void SetSource(ServiceWorkerClient* aClient);

  void SetSource(ServiceWorker* aServiceWorker);
};

class BackgroundSyncEvent final : public ExtendableEvent
{
  nsString mTag;
  bool mLastChance;

protected:
  explicit BackgroundSyncEvent(mozilla::dom::EventTarget* aOwner);
  ~BackgroundSyncEvent() {}

public:
  NS_DECL_ISUPPORTS_INHERITED
  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(BackgroundSyncEvent, ExtendableEvent)
  NS_FORWARD_TO_EVENT

  virtual JSObject* WrapObjectInternal(JSContext* aCx,
                                       JS::Handle<JSObject*> aGivenProto) override
  {
    return mozilla::dom::BackgroundSyncEventBinding::Wrap(aCx, this,
                                                          aGivenProto);
  }

  static already_AddRefed<BackgroundSyncEvent>
  Constructor(mozilla::dom::EventTarget* aOwner,
              const nsAString& aType,
              const BackgroundSyncEventInit& aOptions,
              ErrorResult& aRv);

  static already_AddRefed<BackgroundSyncEvent>
  Constructor(const GlobalObject& aGlobal,
              const nsAString& aType,
              const BackgroundSyncEventInit& aOptions,
              ErrorResult& aRv)
  {
    nsCOMPtr<EventTarget> owner = do_QueryInterface(aGlobal.GetAsSupports());
    return Constructor(owner, aType, aOptions, aRv);
  }

  void
  GetTag(nsAString& aTag)
  {
    aTag = mTag;
  }

  bool
  LastChance()
  {
    return mLastChance;
  }
};

END_WORKERS_NAMESPACE

#endif /* mozilla_dom_workers_serviceworkerevents_h__ */





                                                 const nsAString& aBehavior)
{
  return SendNotificationEvent(NS_LITERAL_STRING(NOTIFICATION_CLOSE_EVENT_NAME),
                               aOriginSuffix, aScope, aID, aTitle, aDir, aLang,
                               aBody, aTag, aIcon, aData, aBehavior);
}

NS_IMETHODIMP
ServiceWorkerManager::SendBackgroundSyncEvent(const nsACString& aOriginAttributes,
                                              const nsACString& aScope,
                                              const nsAString& aTag,
                                              const bool aLastChance)
{
  PrincipalOriginAttributes attrs;
  if (!attrs.PopulateFromSuffix(aOriginAttributes)) {
    return NS_ERROR_INVALID_ARG;
  }

  ServiceWorkerInfo* serviceWorker =
    GetActiveWorkerInfoForScope(attrs, aScope);
  if (NS_WARN_IF(!serviceWorker)) {
    return NS_ERROR_FAILURE;
  }

  RefPtr<ServiceWorkerRegistrationInfo> registration =
    GetRegistration(serviceWorker->GetPrincipal(), aScope);

  return serviceWorker->WorkerPrivate()->SendBackgroundSyncEvent(aTag,
                                                                 aLastChance,
                                                                 registration);
}

NS_IMETHODIMP
ServiceWorkerManager::GetReadyPromise(mozIDOMWindow* aWindow,
                                      nsISupports** aPromise)
{
  AssertIsOnMainThread();

  if (NS_WARN_IF(!aWindow)) {
    return NS_ERROR_DOM_INVALID_STATE_ERR;
  }






  RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
  MOZ_ASSERT(swm);

  swm->RemoveAll();
  return true;
}

bool
ServiceWorkerManagerChild::RecvNotifyBackgroundSyncEvent(
    const PrincipalInfo& aPrincipalInfo, const nsString& aScope,
    const nsString& aTag, const bool& aLastChance)
{
  if (mShuttingDown) {
    return true;
  }

  nsCOMPtr<nsIPrincipal> principal = PrincipalInfoToPrincipal(aPrincipalInfo);
  if (NS_WARN_IF(!principal)) {
    return true;
  }

  nsAutoCString originSuffix;
  nsresult rv = principal->GetOriginSuffix(originSuffix);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return true;
  }

  RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
  MOZ_ASSERT(swm);

  swm->SendBackgroundSyncEvent(originSuffix,
                               NS_ConvertUTF16toUTF8(aScope),
                               aTag, aLastChance);
  return true;
}

} // namespace workers
} // namespace dom
} // namespace mozilla






  virtual bool RecvNotifyUnregister(const PrincipalInfo& aPrincipalInfo,
                                    const nsString& aScope) override;

  virtual bool RecvNotifyRemove(const nsCString& aHost) override;

  virtual bool RecvNotifyRemoveAll() override;

  virtual bool RecvNotifyBackgroundSyncEvent(const PrincipalInfo& aPrincipalInfo,
                                             const nsString& aScope,
                                             const nsString& aTag,
                                             const bool& aLastChance) override;

private:
  ServiceWorkerManagerChild()
    : mShuttingDown(false)
  {}

  ~ServiceWorkerManagerChild() {}

  bool mShuttingDown;

-      Line
+  Link Here
-       Lines 1645-1660
      ServiceWorkerPrivate::SendFetchEvent(nsI
+  Link Here
   if (NS_WARN_IF(!r->Dispatch())) {
     return NS_ERROR_FAILURE;
+  }
   return NS_OK;
+}
+namespace {
+class SendSyncEventRunnable final : public ExtendableFunctionalEventWorkerRunnable
+{
+  nsString mTag;
+  bool mLastChance;
+public:
+  SendSyncEventRunnable(WorkerPrivate* aWorkerPrivate,
+                        KeepAliveToken* aKeepAliveToken,
+                        const nsAString& aTag,
+                        const bool aLastChance,
+                        nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> aRegistration)
+    : ExtendableFunctionalEventWorkerRunnable(
+        aWorkerPrivate, aKeepAliveToken, aRegistration)
+    , mTag(aTag)
+    , mLastChance(aLastChance)
+  {
+    AssertIsOnMainThread();
+    MOZ_ASSERT(aWorkerPrivate);
+    MOZ_ASSERT(aWorkerPrivate->IsServiceWorker());
+  }
+  bool
+  WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
+  {
+    MOZ_ASSERT(aWorkerPrivate);
+    GlobalObject globalObj(aCx, aWorkerPrivate->GlobalScope()->GetWrapper());
+    BackgroundSyncEventInit sei;
+    sei.mTag = mTag;
+    sei.mLastChance = mLastChance;
+    sei.mBubbles = false;
+    sei.mCancelable = false;
+    ErrorResult result;
+    RefPtr<BackgroundSyncEvent> event =
+      BackgroundSyncEvent::Constructor(globalObj, NS_LITERAL_STRING("sync"),
+                                       sei, result);
+    if (NS_WARN_IF(result.Failed())) {
+      result.SuppressException();
+      return false;
+    }
+    event->SetTrusted(true);
+    DispatchExtendableEventOnWorkerScope(aCx, aWorkerPrivate->GlobalScope(),
+                                         event, nullptr);
+    return true;
+  }
+};
+} // anonymous namespace
+nsresult
+ServiceWorkerPrivate::SendBackgroundSyncEvent(const nsAString& aTag,
+                                              const bool aLastChance,
+                                              ServiceWorkerRegistrationInfo* aRegistration)
+{
+  nsresult rv = SpawnWorkerIfNeeded(BackgroundSyncEvent, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+  RefPtr<KeepAliveToken> token = CreateEventKeepAliveToken();
+  nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> regInfo(
+      new nsMainThreadPtrHolder<ServiceWorkerRegistrationInfo>(aRegistration, false));
+  RefPtr<WorkerRunnable> runnable = new SendSyncEventRunnable(mWorkerPrivate,
+                                                              token,
+                                                              aTag,
+                                                              aLastChance,
+                                                              regInfo);
+  if (mInfo->State() == ServiceWorkerState::Activating) {
+    mPendingFunctionalEvents.AppendElement(runnable.forget());
+    return NS_OK;
+  }
+  MOZ_ASSERT(mInfo->State() == ServiceWorkerState::Activated);
+  if (NS_WARN_IF(!runnable->Dispatch())) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
 nsresult
 ServiceWorkerPrivate::SpawnWorkerIfNeeded(WakeUpReason aWhy,
                                           nsIRunnable* aLoadFailedRunnable,
                                           nsILoadGroup* aLoadGroup)
+{
   AssertIsOnMainThread();
   // XXXcatalinb: We need to have a separate load group that's linked to





                        const nsAString& aScope);

  nsresult
  SendFetchEvent(nsIInterceptedChannel* aChannel,
                 nsILoadGroup* aLoadGroup,
                 const nsAString& aDocumentId,
                 bool aIsReload);

  nsresult
  SendBackgroundSyncEvent(const nsAString& aTag,
                          const bool aLastChance,
                          ServiceWorkerRegistrationInfo* aRegistration);

  void
  StoreISupports(nsISupports* aSupports);

  void
  RemoveISupports(nsISupports* aSupports);

  // This will terminate the current running worker thread and drop the
  // workerPrivate reference.

  enum WakeUpReason {
    FetchEvent = 0,
    PushEvent,
    PushSubscriptionChangeEvent,
    MessageEvent,
    NotificationClickEvent,
    NotificationCloseEvent,
    LifeCycleEvent,
    AttachEvent,
    BackgroundSyncEvent
  };

  // Timer callbacks
  static void
  NoteIdleWorkerCallback(nsITimer* aTimer, void* aPrivate);

  static void
  TerminateWorkerCallback(nsITimer* aTimer, void *aPrivate);






    nsCOMPtr<nsIPrincipal> principal = document->NodePrincipal();
    if (!principal) {
      aRv.Throw(NS_ERROR_FAILURE);
      return nullptr;
    }

    mBackgroundSync = BackgroundSync::CreateOnMainThread(globalObject, principal,
                                                         mScope, aRv);
  }

  return mBackgroundSync;
}

////////////////////////////////////////////////////
// Worker Thread implementation


  return ret.forget();
}

BackgroundSync*
ServiceWorkerRegistrationWorkerThread::GetSync(ErrorResult& aRv)
{
  if (!mBackgroundSync) {
    mBackgroundSync = BackgroundSync::CreateOnWorker(
        mWorkerPrivate->GlobalScope(), mWorkerPrivate, mScope);
  }

  return mBackgroundSync;
}

////////////////////////////////////////////////////
// Base class implementation


Return to bug 1217544