gecko-dev/dom/serviceworkers/ServiceWorkerRegistrationIn...

291 строка
6.8 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_serviceworkerregistrationinfo_h
#define mozilla_dom_serviceworkerregistrationinfo_h
#include "mozilla/dom/ServiceWorkerInfo.h"
#include "mozilla/dom/ServiceWorkerRegistrationBinding.h"
#include "mozilla/dom/ServiceWorkerRegistrationDescriptor.h"
#include "nsProxyRelease.h"
#include "nsTObserverArray.h"
namespace mozilla {
namespace dom {
class ServiceWorkerRegistrationListener;
class ServiceWorkerRegistrationInfo final
: public nsIServiceWorkerRegistrationInfo
{
nsCOMPtr<nsIPrincipal> mPrincipal;
ServiceWorkerRegistrationDescriptor mDescriptor;
nsTArray<nsCOMPtr<nsIServiceWorkerRegistrationInfoListener>> mListeners;
nsTObserverArray<ServiceWorkerRegistrationListener*> mInstanceList;
struct VersionEntry
{
const ServiceWorkerRegistrationDescriptor mDescriptor;
TimeStamp mTimeStamp;
explicit VersionEntry(const ServiceWorkerRegistrationDescriptor& aDescriptor)
: mDescriptor(aDescriptor)
, mTimeStamp(TimeStamp::Now())
{
}
};
nsTArray<UniquePtr<VersionEntry>> mVersionList;
uint32_t mControlledClientsCounter;
uint32_t mDelayMultiplier;
enum
{
NoUpdate,
NeedTimeCheckAndUpdate,
NeedUpdate
} mUpdateState;
// Timestamp to track SWR's last update time
PRTime mCreationTime;
TimeStamp mCreationTimeStamp;
// The time of update is 0, if SWR've never been updated yet.
PRTime mLastUpdateTime;
RefPtr<ServiceWorkerInfo> mEvaluatingWorker;
RefPtr<ServiceWorkerInfo> mActiveWorker;
RefPtr<ServiceWorkerInfo> mWaitingWorker;
RefPtr<ServiceWorkerInfo> mInstallingWorker;
virtual ~ServiceWorkerRegistrationInfo();
// When unregister() is called on a registration, it is not immediately
// removed since documents may be controlled. It is marked as
// pendingUninstall and when all controlling documents go away, removed.
bool mPendingUninstall;
bool mCorrupt;
public:
NS_DECL_ISUPPORTS
NS_DECL_NSISERVICEWORKERREGISTRATIONINFO
ServiceWorkerRegistrationInfo(const nsACString& aScope,
nsIPrincipal* aPrincipal,
ServiceWorkerUpdateViaCache aUpdateViaCache);
void
AddInstance(ServiceWorkerRegistrationListener* aInstance,
const ServiceWorkerRegistrationDescriptor& aDescriptor);
void
RemoveInstance(ServiceWorkerRegistrationListener* aInstance);
const nsCString&
Scope() const;
nsIPrincipal*
Principal() const;
bool
IsPendingUninstall() const;
void
SetPendingUninstall();
void
ClearPendingUninstall();
already_AddRefed<ServiceWorkerInfo>
Newest() const
{
RefPtr<ServiceWorkerInfo> newest;
if (mInstallingWorker) {
newest = mInstallingWorker;
} else if (mWaitingWorker) {
newest = mWaitingWorker;
} else {
newest = mActiveWorker;
}
return newest.forget();
}
already_AddRefed<ServiceWorkerInfo>
GetServiceWorkerInfoById(uint64_t aId);
void
StartControllingClient()
{
++mControlledClientsCounter;
mDelayMultiplier = 0;
}
void
StopControllingClient()
{
MOZ_ASSERT(mControlledClientsCounter);
--mControlledClientsCounter;
}
bool
IsControllingClients() const
{
return mActiveWorker && mControlledClientsCounter;
}
void
Clear();
void
ClearAsCorrupt();
bool
IsCorrupt() const;
void
TryToActivateAsync();
void
TryToActivate();
void
Activate();
void
FinishActivate(bool aSuccess);
void
RefreshLastUpdateCheckTime();
bool
IsLastUpdateCheckTimeOverOneDay() const;
void
MaybeScheduleTimeCheckAndUpdate();
void
MaybeScheduleUpdate();
bool
CheckAndClearIfUpdateNeeded();
ServiceWorkerInfo*
GetEvaluating() const;
ServiceWorkerInfo*
GetInstalling() const;
ServiceWorkerInfo*
GetWaiting() const;
ServiceWorkerInfo*
GetActive() const;
ServiceWorkerInfo*
GetByDescriptor(const ServiceWorkerDescriptor& aDescriptor) const;
// Set the given worker as the evaluating service worker. The worker
// state is not changed.
void
SetEvaluating(ServiceWorkerInfo* aServiceWorker);
// Remove an existing evaluating worker, if present. The worker will
// be transitioned to the Redundant state.
void
ClearEvaluating();
// Remove an existing installing worker, if present. The worker will
// be transitioned to the Redundant state.
void
ClearInstalling();
// Transition the current evaluating worker to be the installing worker. The
// worker's state is update to Installing.
void
TransitionEvaluatingToInstalling();
// Transition the current installing worker to be the waiting worker. The
// worker's state is updated to Installed.
void
TransitionInstallingToWaiting();
// Override the current active worker. This is used during browser
// initialization to load persisted workers. Its also used to propagate
// active workers across child processes in e10s. This second use will
// go away once the ServiceWorkerManager moves to the parent process.
// The worker is transitioned to the Activated state.
void
SetActive(ServiceWorkerInfo* aServiceWorker);
// Transition the current waiting worker to be the new active worker. The
// worker is updated to the Activating state.
void
TransitionWaitingToActive();
// Determine if the registration is actively performing work.
bool
IsIdle() const;
ServiceWorkerUpdateViaCache
GetUpdateViaCache() const;
void
SetUpdateViaCache(ServiceWorkerUpdateViaCache aUpdateViaCache);
int64_t
GetLastUpdateTime() const;
void
SetLastUpdateTime(const int64_t aTime);
const ServiceWorkerRegistrationDescriptor&
Descriptor() const;
uint64_t
Id() const;
uint64_t
Version() const;
uint32_t
GetUpdateDelay();
void
FireUpdateFound();
void
NotifyRemoved();
private:
// Roughly equivalent to [[Update Registration State algorithm]]. Make sure
// this is called *before* updating SW instances' state, otherwise they
// may get CC-ed.
void
UpdateRegistrationState();
void
UpdateRegistrationState(ServiceWorkerUpdateViaCache aUpdateViaCache);
// Used by devtools to track changes to the properties of *nsIServiceWorkerRegistrationInfo*.
// Note, this doesn't necessarily need to be in sync with the DOM registration objects, but
// it does need to be called in the same task that changed |mInstallingWorker|,
// |mWaitingWorker| or |mActiveWorker|.
void
NotifyChromeRegistrationListeners();
static uint64_t
GetNextId();
static uint64_t
GetNextVersion();
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_serviceworkerregistrationinfo_h