Commit 13f1fc0f authored by Eden Chuang's avatar Eden Chuang
Browse files

Bug 1715547 - Remove ServiceWorkerRegistration::Inner r=asuth 

Differential Revision: https://phabricator.services.mozilla.com/D117344
parent d0900f37

dom/serviceworkers/NavigationPreloadManager.cpp

+10 −10
Original line number Diff line number Diff line
@@ -23,7 +23,8 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(NavigationPreloadManager) 
  NS_INTERFACE_MAP_ENTRY(nsISupports)

NS_INTERFACE_MAP_END



NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(NavigationPreloadManager, mGlobal)

NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(NavigationPreloadManager,

                                      mServiceWorkerRegistration)



/* static */

bool NavigationPreloadManager::IsValidHeader(const nsACString& aHeader) {
@@ -36,9 +37,8 @@ bool NavigationPreloadManager::IsEnabled(JSContext* aCx, JSObject* aGlobal) { 
}



NavigationPreloadManager::NavigationPreloadManager(

    nsCOMPtr<nsIGlobalObject>&& aGlobal,

    RefPtr<ServiceWorkerRegistration::Inner>& aInner)

    : mGlobal(aGlobal), mInner(aInner) {}

    RefPtr<ServiceWorkerRegistration>& aServiceWorkerRegistration)

    : mServiceWorkerRegistration(aServiceWorkerRegistration) {}



JSObject* NavigationPreloadManager::WrapObject(

    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
@@ -53,12 +53,12 @@ already_AddRefed<Promise> NavigationPreloadManager::SetEnabled( 
    return nullptr;

  }



  if (!mInner) {

  if (!mServiceWorkerRegistration) {

    promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);

    return promise.forget();

  }



  mInner->SetNavigationPreloadEnabled(

  mServiceWorkerRegistration->SetNavigationPreloadEnabled(

      aEnabled,

      [promise](bool aSuccess) {

        if (aSuccess) {
@@ -95,12 +95,12 @@ already_AddRefed<Promise> NavigationPreloadManager::SetHeaderValue( 
    return promise.forget();

  }



  if (!mInner) {

  if (!mServiceWorkerRegistration) {

    promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);

    return promise.forget();

  }



  mInner->SetNavigationPreloadHeader(

  mServiceWorkerRegistration->SetNavigationPreloadHeader(

      nsAutoCString(aHeader),

      [promise](bool aSuccess) {

        if (aSuccess) {
@@ -122,12 +122,12 @@ already_AddRefed<Promise> NavigationPreloadManager::GetState( 
    return nullptr;

  }



  if (!mInner) {

  if (!mServiceWorkerRegistration) {

    promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);

    return promise.forget();

  }



  mInner->GetNavigationPreloadState(

  mServiceWorkerRegistration->GetNavigationPreloadState(

      [promise](NavigationPreloadState&& aState) {

        promise->MaybeResolve(std::move(aState));

      },

dom/serviceworkers/NavigationPreloadManager.h

+6 −5
Original line number Diff line number Diff line
@@ -30,11 +30,13 @@ class NavigationPreloadManager final : public nsISupports, 


  static bool IsEnabled(JSContext* aCx, JSObject* aGlobal);



  NavigationPreloadManager(nsCOMPtr<nsIGlobalObject>&& aGlobal,

                           RefPtr<ServiceWorkerRegistration::Inner>& aInner);

  explicit NavigationPreloadManager(

      RefPtr<ServiceWorkerRegistration>& aServiceWorkerRegistration);



  // Webidl binding

  nsIGlobalObject* GetParentObject() const { return mGlobal; }

  nsIGlobalObject* GetParentObject() const {

    return mServiceWorkerRegistration->GetParentObject();

  }



  JSObject* WrapObject(JSContext* aCx,

                       JS::Handle<JSObject*> aGivenProto) override;
@@ -55,8 +57,7 @@ class NavigationPreloadManager final : public nsISupports, 
  // General method for Enable()/Disable()

  already_AddRefed<Promise> SetEnabled(bool aEnabled, ErrorResult& aError);



  nsCOMPtr<nsIGlobalObject> mGlobal;

  RefPtr<ServiceWorkerRegistration::Inner> mInner;

  RefPtr<ServiceWorkerRegistration> mServiceWorkerRegistration;

};



}  // namespace mozilla::dom

dom/serviceworkers/RemoteServiceWorkerRegistrationImpl.cpp

deleted100644 → 0
+0 −240
Original line number Diff line number Diff line 
/* -*- 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/. */



#include "RemoteServiceWorkerRegistrationImpl.h"



#include "ServiceWorkerRegistrationChild.h"

#include "mozilla/dom/NavigationPreloadManagerBinding.h"

#include "mozilla/ipc/MessageChannel.h"

#include "mozilla/ipc/PBackgroundChild.h"

#include "mozilla/ipc/BackgroundChild.h"



namespace mozilla::dom {



using mozilla::ipc::IPCResult;

using mozilla::ipc::ResponseRejectReason;



RemoteServiceWorkerRegistrationImpl::~RemoteServiceWorkerRegistrationImpl() {

  MOZ_DIAGNOSTIC_ASSERT(!mOuter);

  Shutdown();

}



void RemoteServiceWorkerRegistrationImpl::Shutdown() {

  if (mShutdown) {

    return;

  }

  mShutdown = true;



  if (mActor) {

    mActor->RevokeOwner(this);

    mActor->MaybeStartTeardown();

    mActor = nullptr;

  }

}



void RemoteServiceWorkerRegistrationImpl::SetServiceWorkerRegistration(

    ServiceWorkerRegistration* aReg) {

  NS_ASSERT_OWNINGTHREAD(RemoteServiceWorkerRegistrationImpl);

  MOZ_DIAGNOSTIC_ASSERT(!mOuter);

  MOZ_DIAGNOSTIC_ASSERT(aReg);

  mOuter = aReg;

}



void RemoteServiceWorkerRegistrationImpl::ClearServiceWorkerRegistration(

    ServiceWorkerRegistration* aReg) {

  NS_ASSERT_OWNINGTHREAD(RemoteServiceWorkerRegistrationImpl);

  MOZ_DIAGNOSTIC_ASSERT(mOuter);

  MOZ_DIAGNOSTIC_ASSERT(aReg == mOuter);

  mOuter = nullptr;

}



void RemoteServiceWorkerRegistrationImpl::Update(

    const nsCString& aNewestWorkerScriptUrl,

    ServiceWorkerRegistrationCallback&& aSuccessCB,

    ServiceWorkerFailureCallback&& aFailureCB) {

  if (!mActor) {

    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

    return;

  }



  mActor->SendUpdate(

      aNewestWorkerScriptUrl,

      [successCB = std::move(aSuccessCB), aFailureCB](

          const IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult&

              aResult) {

        if (aResult.type() ==

            IPCServiceWorkerRegistrationDescriptorOrCopyableErrorResult::

                TCopyableErrorResult) {

          // application layer error

          auto& rv = aResult.get_CopyableErrorResult();

          MOZ_DIAGNOSTIC_ASSERT(rv.Failed());

          aFailureCB(CopyableErrorResult(rv));

          return;

        }

        // success

        auto& ipcDesc = aResult.get_IPCServiceWorkerRegistrationDescriptor();

        successCB(ServiceWorkerRegistrationDescriptor(ipcDesc));

      },

      [aFailureCB](ResponseRejectReason&& aReason) {

        // IPC layer error

        aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

      });

}



void RemoteServiceWorkerRegistrationImpl::Unregister(

    ServiceWorkerBoolCallback&& aSuccessCB,

    ServiceWorkerFailureCallback&& aFailureCB) {

  if (!mActor) {

    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

    return;

  }



  mActor->SendUnregister(

      [successCB = std::move(aSuccessCB),

       aFailureCB](Tuple<bool, CopyableErrorResult>&& aResult) {

        if (Get<1>(aResult).Failed()) {

          // application layer error

          aFailureCB(std::move(Get<1>(aResult)));

          return;

        }

        // success

        successCB(Get<0>(aResult));

      },

      [aFailureCB](ResponseRejectReason&& aReason) {

        // IPC layer error

        aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

      });

}



void RemoteServiceWorkerRegistrationImpl::SetNavigationPreloadEnabled(

    bool aEnabled, ServiceWorkerBoolCallback&& aSuccessCB,

    ServiceWorkerFailureCallback&& aFailureCB) {

  if (!mActor) {

    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

    return;

  }



  mActor->SendSetNavigationPreloadEnabled(

      aEnabled,

      [successCB = std::move(aSuccessCB), aFailureCB](bool aResult) {

        if (!aResult) {

          aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

          return;

        }

        successCB(aResult);

      },

      [aFailureCB](ResponseRejectReason&& aReason) {

        aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

      });

}



void RemoteServiceWorkerRegistrationImpl::SetNavigationPreloadHeader(

    const nsCString& aHeader, ServiceWorkerBoolCallback&& aSuccessCB,

    ServiceWorkerFailureCallback&& aFailureCB) {

  if (!mActor) {

    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

    return;

  }



  mActor->SendSetNavigationPreloadHeader(

      aHeader,

      [successCB = std::move(aSuccessCB), aFailureCB](bool aResult) {

        if (!aResult) {

          aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

          return;

        }

        successCB(aResult);

      },

      [aFailureCB](ResponseRejectReason&& aReason) {

        aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

      });

}



void RemoteServiceWorkerRegistrationImpl::GetNavigationPreloadState(

    NavigationPreloadGetStateCallback&& aSuccessCB,

    ServiceWorkerFailureCallback&& aFailureCB) {

  if (!mActor) {

    aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

    return;

  }



  mActor->SendGetNavigationPreloadState(

      [successCB = std::move(aSuccessCB),

       aFailureCB](Maybe<IPCNavigationPreloadState>&& aState) {

        if (NS_WARN_IF(!aState)) {

          aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

          return;

        }



        NavigationPreloadState state;

        state.mEnabled = aState.ref().enabled();

        state.mHeaderValue.Construct(std::move(aState.ref().headerValue()));

        successCB(std::move(state));

      },

      [aFailureCB](ResponseRejectReason&& aReason) {

        aFailureCB(CopyableErrorResult(NS_ERROR_DOM_INVALID_STATE_ERR));

      });

}



RemoteServiceWorkerRegistrationImpl::RemoteServiceWorkerRegistrationImpl(

    const ServiceWorkerRegistrationDescriptor& aDescriptor)

    : mOuter(nullptr), mShutdown(false) {

  ::mozilla::ipc::PBackgroundChild* parentActor =

      ::mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();

  if (NS_WARN_IF(!parentActor)) {

    Shutdown();

    return;

  }



  auto actor = ServiceWorkerRegistrationChild::Create();

  if (NS_WARN_IF(!actor)) {

    Shutdown();

    return;

  }



  PServiceWorkerRegistrationChild* sentActor =

      parentActor->SendPServiceWorkerRegistrationConstructor(

          actor, aDescriptor.ToIPC());

  if (NS_WARN_IF(!sentActor)) {

    Shutdown();

    return;

  }

  MOZ_DIAGNOSTIC_ASSERT(sentActor == actor);



  mActor = std::move(actor);

  mActor->SetOwner(this);

}



void RemoteServiceWorkerRegistrationImpl::RevokeActor(

    ServiceWorkerRegistrationChild* aActor) {

  MOZ_DIAGNOSTIC_ASSERT(mActor);

  MOZ_DIAGNOSTIC_ASSERT(mActor == aActor);

  mActor->RevokeOwner(this);

  mActor = nullptr;



  mShutdown = true;



  if (mOuter) {

    RefPtr<ServiceWorkerRegistration> outer = mOuter;

    outer->RegistrationCleared();

  }

}



void RemoteServiceWorkerRegistrationImpl::UpdateState(

    const ServiceWorkerRegistrationDescriptor& aDescriptor) {

  if (mOuter) {

    RefPtr<ServiceWorkerRegistration> outer = mOuter;

    outer->UpdateState(aDescriptor);

  }

}



void RemoteServiceWorkerRegistrationImpl::FireUpdateFound() {

  if (mOuter) {

    mOuter->MaybeDispatchUpdateFoundRunnable();

  }

}



}  // namespace mozilla::dom

dom/serviceworkers/RemoteServiceWorkerRegistrationImpl.h

deleted100644 → 0
+0 −65
Original line number Diff line number Diff line 
/* -*- 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_remoteserviceworkerregistrationimpl_h__

#define mozilla_dom_remoteserviceworkerregistrationimpl_h__



#include "ServiceWorkerRegistration.h"



namespace mozilla::dom {



class ServiceWorkerRegistrationChild;



class RemoteServiceWorkerRegistrationImpl final

    : public ServiceWorkerRegistration::Inner {

  RefPtr<ServiceWorkerRegistrationChild> mActor;

  ServiceWorkerRegistration* mOuter;

  bool mShutdown;



  ~RemoteServiceWorkerRegistrationImpl();



  void Shutdown();



  // ServiceWorkerRegistration::Inner implementation

  void SetServiceWorkerRegistration(ServiceWorkerRegistration* aReg) override;



  void ClearServiceWorkerRegistration(ServiceWorkerRegistration* aReg) override;



  void Update(const nsCString& aNewestWorkerScriptUrl,

              ServiceWorkerRegistrationCallback&& aSuccessCB,

              ServiceWorkerFailureCallback&& aFailureCB) override;



  void Unregister(ServiceWorkerBoolCallback&& aSuccessCB,

                  ServiceWorkerFailureCallback&& aFailureCB) override;



  void SetNavigationPreloadEnabled(

      bool aEnabled, ServiceWorkerBoolCallback&& aSuccessCB,

      ServiceWorkerFailureCallback&& aFailureCB) override;



  void SetNavigationPreloadHeader(

      const nsCString& aHeader, ServiceWorkerBoolCallback&& aSuccessCB,

      ServiceWorkerFailureCallback&& aFailureCB) override;



  void GetNavigationPreloadState(

      NavigationPreloadGetStateCallback&& aSuccessCB,

      ServiceWorkerFailureCallback&& aFailureCB) override;



 public:

  explicit RemoteServiceWorkerRegistrationImpl(

      const ServiceWorkerRegistrationDescriptor& aDescriptor);



  void RevokeActor(ServiceWorkerRegistrationChild* aActor);



  void UpdateState(const ServiceWorkerRegistrationDescriptor& aDescriptor);



  void FireUpdateFound();



  NS_INLINE_DECL_REFCOUNTING(RemoteServiceWorkerRegistrationImpl, override)

};



}  // namespace mozilla::dom



#endif  // mozilla_dom_remoteserviceworkerregistrationimpl_h__

dom/serviceworkers/ServiceWorkerEvents.cpp

+4 −4
Original line number Diff line number Diff line
@@ -226,9 +226,9 @@ class BodyCopyHandle final : public nsIInterceptedBodyCallback { 


    nsCOMPtr<nsIRunnable> event;

    if (NS_WARN_IF(NS_FAILED(aRv))) {

      AsyncLog(mClosure->mInterceptedChannel, mClosure->mRespondWithScriptSpec,

               mClosure->mRespondWithLineNumber,

               mClosure->mRespondWithColumnNumber,

      ::AsyncLog(

          mClosure->mInterceptedChannel, mClosure->mRespondWithScriptSpec,

          mClosure->mRespondWithLineNumber, mClosure->mRespondWithColumnNumber,

          "InterceptionFailedWithURL"_ns, mClosure->mRequestURL);

      event = new CancelChannelRunnable(mClosure->mInterceptedChannel,

                                        mClosure->mRegistration,