mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Backed out changeset 77fc6f341fef (bug 1346247)

This commit is contained in:
Sebastian Hengst 2017-03-24 15:04:23 +01:00
Родитель 40632b3650
Коммит 5b2cf78b72
4 изменённых файлов: 60 добавлений и 173 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

199
dom/workers/ServiceWorkerManager.cpp
Просмотреть файл

@ -509,46 +509,6 @@ private:
{}
};
class PromiseResolverCallback final : public ServiceWorkerUpdateFinishCallback
{
public:
PromiseResolverCallback(ServiceWorkerUpdateFinishCallback* aCallback,
GenericPromise::Private* aPromise)
: mCallback(aCallback)
, mPromise(aPromise)
{
MOZ_DIAGNOSTIC_ASSERT(mPromise);
}
void UpdateSucceeded(ServiceWorkerRegistrationInfo* aInfo) override
{
MOZ_DIAGNOSTIC_ASSERT(mPromise);
if (mCallback) {
mCallback->UpdateSucceeded(aInfo);
}
mPromise->Resolve(true, __func__);
mPromise = nullptr;
}
void UpdateFailed(ErrorResult& aStatus) override
{
MOZ_DIAGNOSTIC_ASSERT(mPromise);
if (mCallback) {
mCallback->UpdateFailed(aStatus);
}
mPromise->Resolve(true, __func__);
mPromise = nullptr;
}
private:
RefPtr<ServiceWorkerUpdateFinishCallback> mCallback;
RefPtr<GenericPromise::Private> mPromise;
};
// This runnable is used for 2 different tasks:
// - to postpone the SoftUpdate() until the IPC SWM actor is created
// (aInternalMethod == false)
@ -558,12 +518,10 @@ class SoftUpdateRunnable final : public Runnable
{
public:
SoftUpdateRunnable(const OriginAttributes& aOriginAttributes,
const nsACString& aScope, bool aInternalMethod,
GenericPromise::Private* aPromise)
const nsACString& aScope, bool aInternalMethod)
: mAttrs(aOriginAttributes)
, mScope(aScope)
, mInternalMethod(aInternalMethod)
, mPromise(aPromise)
{}
NS_IMETHOD Run() override
@ -576,10 +534,7 @@ public:
}
if (mInternalMethod) {
RefPtr<PromiseResolverCallback> callback =
new PromiseResolverCallback(nullptr, mPromise);
swm->SoftUpdateInternal(mAttrs, mScope, callback);
swm->SoftUpdateInternal(mAttrs, mScope);
} else {
swm->SoftUpdate(mAttrs, mScope);
}
@ -594,8 +549,6 @@ private:
const OriginAttributes mAttrs;
const nsCString mScope;
bool mInternalMethod;
RefPtr<GenericPromise::Private> mPromise;
};
// This runnable is used for 3 different tasks:
@ -616,13 +569,11 @@ public:
UpdateRunnable(nsIPrincipal* aPrincipal,
const nsACString& aScope,
ServiceWorkerUpdateFinishCallback* aCallback,
Type aType,
GenericPromise::Private* aPromise)
Type aType)
: mPrincipal(aPrincipal)
, mScope(aScope)
, mCallback(aCallback)
, mType(aType)
, mPromise(aPromise)
{}
NS_IMETHOD Run() override
@ -639,18 +590,13 @@ public:
return NS_OK;
}
MOZ_ASSERT(mPromise);
RefPtr<PromiseResolverCallback> callback =
new PromiseResolverCallback(mCallback, mPromise);
if (mType == eSuccess) {
swm->UpdateInternal(mPrincipal, mScope, callback);
swm->UpdateInternal(mPrincipal, mScope, mCallback);
return NS_OK;
}
ErrorResult error(NS_ERROR_DOM_ABORT_ERR);
callback->UpdateFailed(error);
mCallback->UpdateFailed(error);
return NS_OK;
}
@ -662,26 +608,6 @@ private:
const nsCString mScope;
RefPtr<ServiceWorkerUpdateFinishCallback> mCallback;
Type mType;
RefPtr<GenericPromise::Private> mPromise;
};
class ResolvePromiseRunnable final : public Runnable
{
public:
explicit ResolvePromiseRunnable(GenericPromise::Private* aPromise)
: mPromise(aPromise)
{}
NS_IMETHOD
Run() override
{
mPromise->Resolve(true, __func__);
return NS_OK;
}
private:
RefPtr<GenericPromise::Private> mPromise;
};
} // namespace
@ -2904,73 +2830,25 @@ ServiceWorkerManager::SoftUpdate(const OriginAttributes& aOriginAttributes,
if (!mActor) {
RefPtr<Runnable> runnable =
new SoftUpdateRunnable(aOriginAttributes, aScope, false, nullptr);
new SoftUpdateRunnable(aOriginAttributes, aScope, false);
AppendPendingOperation(runnable);
return;
}
RefPtr<GenericPromise::Private> promise =
new GenericPromise::Private(__func__);
RefPtr<Runnable> successRunnable =
new SoftUpdateRunnable(aOriginAttributes, aScope, true, promise);
RefPtr<Runnable> failureRunnable =
new ResolvePromiseRunnable(promise);
RefPtr<Runnable> runnable =
new SoftUpdateRunnable(aOriginAttributes, aScope, true);
ServiceWorkerUpdaterChild* actor =
new ServiceWorkerUpdaterChild(promise, successRunnable, failureRunnable);
new ServiceWorkerUpdaterChild(runnable, nullptr);
mActor->SendPServiceWorkerUpdaterConstructor(actor, aOriginAttributes,
nsCString(aScope));
}
namespace {
class UpdateJobCallback final : public ServiceWorkerJob::Callback
{
RefPtr<ServiceWorkerUpdateFinishCallback> mCallback;
~UpdateJobCallback() = default;
public:
explicit UpdateJobCallback(ServiceWorkerUpdateFinishCallback* aCallback)
: mCallback(aCallback)
{
AssertIsOnMainThread();
MOZ_ASSERT(mCallback);
}
void
JobFinished(ServiceWorkerJob* aJob, ErrorResult& aStatus)
{
AssertIsOnMainThread();
MOZ_ASSERT(aJob);
if (aStatus.Failed()) {
mCallback->UpdateFailed(aStatus);
return;
}
MOZ_DIAGNOSTIC_ASSERT(aJob->GetType() == ServiceWorkerJob::Type::Update);
RefPtr<ServiceWorkerUpdateJob> updateJob =
static_cast<ServiceWorkerUpdateJob*>(aJob);
RefPtr<ServiceWorkerRegistrationInfo> reg = updateJob->GetRegistration();
mCallback->UpdateSucceeded(reg);
}
NS_INLINE_DECL_REFCOUNTING(UpdateJobCallback)
};
} // anonymous namespace
void
ServiceWorkerManager::SoftUpdateInternal(const OriginAttributes& aOriginAttributes,
const nsACString& aScope,
ServiceWorkerUpdateFinishCallback* aCallback)
const nsACString& aScope)
{
AssertIsOnMainThread();
MOZ_ASSERT(aCallback);
if (mShuttingDown) {
return;
@ -3029,13 +2907,50 @@ ServiceWorkerManager::SoftUpdateInternal(const OriginAttributes& aOriginAttribut
new ServiceWorkerUpdateJob(principal, registration->mScope,
newest->ScriptSpec(), nullptr,
registration->GetLoadFlags());
RefPtr<UpdateJobCallback> cb = new UpdateJobCallback(aCallback);
job->AppendResultCallback(cb);
queue->ScheduleJob(job);
}
namespace {
class UpdateJobCallback final : public ServiceWorkerJob::Callback
{
RefPtr<ServiceWorkerUpdateFinishCallback> mCallback;
~UpdateJobCallback()
{
}
public:
explicit UpdateJobCallback(ServiceWorkerUpdateFinishCallback* aCallback)
: mCallback(aCallback)
{
AssertIsOnMainThread();
MOZ_ASSERT(mCallback);
}
void
JobFinished(ServiceWorkerJob* aJob, ErrorResult& aStatus)
{
AssertIsOnMainThread();
MOZ_ASSERT(aJob);
if (aStatus.Failed()) {
mCallback->UpdateFailed(aStatus);
return;
}
MOZ_ASSERT(aJob->GetType() == ServiceWorkerJob::Type::Update);
RefPtr<ServiceWorkerUpdateJob> updateJob =
static_cast<ServiceWorkerUpdateJob*>(aJob);
RefPtr<ServiceWorkerRegistrationInfo> reg = updateJob->GetRegistration();
mCallback->UpdateSucceeded(reg);
}
NS_INLINE_DECL_REFCOUNTING(UpdateJobCallback)
};
} // anonymous namespace
void
ServiceWorkerManager::Update(nsIPrincipal* aPrincipal,
const nsACString& aScope,
@ -3046,25 +2961,21 @@ ServiceWorkerManager::Update(nsIPrincipal* aPrincipal,
if (!mActor) {
RefPtr<Runnable> runnable =
new UpdateRunnable(aPrincipal, aScope, aCallback,
UpdateRunnable::ePostpone, nullptr);
UpdateRunnable::ePostpone);
AppendPendingOperation(runnable);
return;
}
RefPtr<GenericPromise::Private> promise =
new GenericPromise::Private(__func__);
RefPtr<Runnable> successRunnable =
new UpdateRunnable(aPrincipal, aScope, aCallback,
UpdateRunnable::eSuccess, promise);
UpdateRunnable::eSuccess);
RefPtr<Runnable> failureRunnable =
new UpdateRunnable(aPrincipal, aScope, aCallback,
UpdateRunnable::eFailure, promise);
UpdateRunnable::eFailure);
ServiceWorkerUpdaterChild* actor =
new ServiceWorkerUpdaterChild(promise, successRunnable, failureRunnable);
new ServiceWorkerUpdaterChild(successRunnable, failureRunnable);
mActor->SendPServiceWorkerUpdaterConstructor(actor,
aPrincipal->OriginAttributesRef(),
nsCString(aScope));

3
dom/workers/ServiceWorkerManager.h
Просмотреть файл

@ -175,8 +175,7 @@ public:
void
SoftUpdateInternal(const OriginAttributes& aOriginAttributes,
const nsACString& aScope,
ServiceWorkerUpdateFinishCallback* aCallback);
const nsACString& aScope);
void

22
dom/workers/ServiceWorkerUpdaterChild.cpp
Просмотреть файл

@ -10,43 +10,27 @@ namespace mozilla {
namespace dom {
namespace workers {
ServiceWorkerUpdaterChild::ServiceWorkerUpdaterChild(GenericPromise* aPromise,
Runnable* aSuccessRunnable,
ServiceWorkerUpdaterChild::ServiceWorkerUpdaterChild(Runnable* aSuccessRunnable,
Runnable* aFailureRunnable)
: mSuccessRunnable(aSuccessRunnable)
, mFailureRunnable(aFailureRunnable)
{
MOZ_ASSERT(aPromise);
MOZ_ASSERT(aSuccessRunnable);
MOZ_ASSERT(aFailureRunnable);
aPromise->Then(AbstractThread::GetCurrent(), __func__,
[this]() {
mPromiseHolder.Complete();
Unused << Send__delete__(this);
}).Track(mPromiseHolder);
}
mozilla::ipc::IPCResult
ServiceWorkerUpdaterChild::RecvProceed(const bool& aAllowed)
{
// If we have a callback, it will resolve the promise.
if (aAllowed) {
mSuccessRunnable->Run();
} else {
} else if (mFailureRunnable) {
mFailureRunnable->Run();
}
Unused << Send__delete__(this);
return IPC_OK();
}
void
ServiceWorkerUpdaterChild::ActorDestroy(ActorDestroyReason aWhy)
{
mPromiseHolder.DisconnectIfExists();
}
} // namespace workers
} // namespace dom
} // namespace mozilla

9
dom/workers/ServiceWorkerUpdaterChild.h
Просмотреть файл

@ -9,7 +9,6 @@
#include "mozilla/dom/PServiceWorkerUpdaterChild.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/MozPromise.h"
namespace mozilla {
namespace dom {
@ -18,19 +17,13 @@ namespace workers {
class ServiceWorkerUpdaterChild final : public PServiceWorkerUpdaterChild
{
public:
ServiceWorkerUpdaterChild(GenericPromise* aPromise,
Runnable* aSuccessRunnable,
ServiceWorkerUpdaterChild(Runnable* aSuccessRunnable,
Runnable* aFailureRunnable);
mozilla::ipc::IPCResult
RecvProceed(const bool& aAllowed) override;
private:
void
ActorDestroy(ActorDestroyReason aWhy) override;
MozPromiseRequestHolder<GenericPromise> mPromiseHolder;
RefPtr<Runnable> mSuccessRunnable;
RefPtr<Runnable> mFailureRunnable;
};