mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-23 21:01:08 +00:00
9aff8c3b36
Differential Revision: https://phabricator.services.mozilla.com/D59007 --HG-- extra : moz-landing-system : lando
127 lines
4.3 KiB
C++
127 lines
4.3 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/. */
|
|
|
|
#ifndef mozilla_dom_serviceworkerjob_h
|
|
#define mozilla_dom_serviceworkerjob_h
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsString.h"
|
|
#include "nsTArray.h"
|
|
|
|
class nsIPrincipal;
|
|
|
|
namespace mozilla {
|
|
|
|
class ErrorResult;
|
|
|
|
namespace dom {
|
|
|
|
class ServiceWorkerJob {
|
|
public:
|
|
// Implement this interface to receive notification when a job completes or
|
|
// is discarded.
|
|
class Callback {
|
|
public:
|
|
// Called once when the job completes. If the job is started, then this
|
|
// will be called. If a job is never executed due to browser shutdown,
|
|
// then this method will never be called. This method is always called
|
|
// on the main thread asynchronously after Start() completes.
|
|
virtual void JobFinished(ServiceWorkerJob* aJob, ErrorResult& aStatus) = 0;
|
|
|
|
// If the job has not started and will never start, then this will be
|
|
// called; either JobFinished or JobDiscarded will be called, but not both.
|
|
virtual void JobDiscarded(ErrorResult& aStatus) = 0;
|
|
|
|
NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
|
|
};
|
|
|
|
enum class Type { Register, Update, Unregister };
|
|
|
|
enum class State { Initial, Started, Finished };
|
|
|
|
Type GetType() const;
|
|
|
|
State GetState() const;
|
|
|
|
// Determine if the job has been canceled. This does not change the
|
|
// current State, but indicates that the job should progress to Finished
|
|
// as soon as possible.
|
|
bool Canceled() const;
|
|
|
|
// Determine if the result callbacks have already been called. This is
|
|
// equivalent to the spec checked to see if the job promise has settled.
|
|
bool ResultCallbacksInvoked() const;
|
|
|
|
bool IsEquivalentTo(ServiceWorkerJob* aJob) const;
|
|
|
|
// Add a callback that will be invoked when the job's result is available.
|
|
// Some job types will invoke this before the job is actually finished.
|
|
// If an early callback does not occur, then it will be called automatically
|
|
// when Finish() is called. These callbacks will be invoked while the job
|
|
// state is Started.
|
|
void AppendResultCallback(Callback* aCallback);
|
|
|
|
// This takes ownership of any result callbacks associated with the given job
|
|
// and then appends them to this job's callback list.
|
|
void StealResultCallbacksFrom(ServiceWorkerJob* aJob);
|
|
|
|
// Start the job. All work will be performed asynchronously on
|
|
// the main thread. The Finish() method must be called exactly
|
|
// once after this point. A final callback must be provided. It
|
|
// will be invoked after all other callbacks have been processed.
|
|
void Start(Callback* aFinalCallback);
|
|
|
|
// Set an internal flag indicating that a started job should finish as
|
|
// soon as possible.
|
|
void Cancel();
|
|
|
|
protected:
|
|
ServiceWorkerJob(Type aType, nsIPrincipal* aPrincipal,
|
|
const nsACString& aScope, nsCString aScriptSpec);
|
|
|
|
virtual ~ServiceWorkerJob();
|
|
|
|
// Invoke the result callbacks immediately. The job must be in the
|
|
// Started state or be canceled and in the Initial state. The callbacks are
|
|
// cleared after being invoked, so subsequent method calls have no effect.
|
|
void InvokeResultCallbacks(ErrorResult& aRv);
|
|
|
|
// Convenience method that converts to ErrorResult and calls real method.
|
|
void InvokeResultCallbacks(nsresult aRv);
|
|
|
|
// Indicate that the job has completed. The must be called exactly
|
|
// once after Start() has initiated job execution. It may not be
|
|
// called until Start() has returned.
|
|
void Finish(ErrorResult& aRv);
|
|
|
|
// Convenience method that converts to ErrorResult and calls real method.
|
|
void Finish(nsresult aRv);
|
|
|
|
// Specific job types should define AsyncExecute to begin their work.
|
|
// All errors and successes must result in Finish() being called.
|
|
virtual void AsyncExecute() = 0;
|
|
|
|
const Type mType;
|
|
nsCOMPtr<nsIPrincipal> mPrincipal;
|
|
const nsCString mScope;
|
|
const nsCString mScriptSpec;
|
|
|
|
private:
|
|
RefPtr<Callback> mFinalCallback;
|
|
nsTArray<RefPtr<Callback>> mResultCallbackList;
|
|
State mState;
|
|
bool mCanceled;
|
|
bool mResultCallbacksInvoked;
|
|
|
|
public:
|
|
NS_INLINE_DECL_REFCOUNTING(ServiceWorkerJob)
|
|
};
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_dom_serviceworkerjob_h
|