Attachment #8832152 for bug #1217544

Attachment #8832152: Part 3.1 (interdiff): IPC for bug #1217544

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





    MOZ_ASSERT(mActor);
    if (mActor->IsActorDestroyed()) {
      return NS_OK;
    }

    return mActor->ExecuteOp(mPromise, mOp);
  }

  nsresult Cancel() override
  {
    mActor = nullptr;
    mPromise = nullptr;
    mOp = nullptr;
    return NS_OK;
  }

private:

  {
    MOZ_ASSERT(mActor);
    if (!mActor->IsActorDestroyed()) {
      mActor->SendShutdown();
    }
    return NS_OK;
  }

  nsresult Cancel() override
  {
    mActor = nullptr;
    return NS_OK;
  }

private:
  ~TeardownRunnable() {};


      mManager->Shutdown();
    }
    return true;
  }

private:
  ~BackgroundSyncHolder()
  {
    MOZ_COUNT_DTOR(BackgroundSyncHolder);
  }
};

// BackgroundSync

// static
already_AddRefed<BackgroundSync>
BackgroundSync::CreateOnMainThread(nsIGlobalObject* aGlobal,





  nsresult rv = StorePendingRequest(aPromise, requestId);
  NS_ENSURE_SUCCESS(rv, rv);

  Unused << SendRequest(requestId, *aOp);

  return NS_OK;
}

mozilla::ipc::IPCResult
BackgroundSyncChild::RecvResponse(const nsID& aRequestId,
                                  const SyncOpResponse& aResponse)
{
  Promise* p = GetPendingRequest(aRequestId);
  if (NS_WARN_IF(!p)) {
    // This should never happen.
    return IPC_FAIL_NO_REASON(this);
  }

  switch(aResponse.type()) {
    case SyncOpResponse::TSyncRegisterResponse:
      p->MaybeResolve(true);
      return IPC_OK();
    case SyncOpResponse::TSyncGetTagsResponse:
      p->MaybeResolve(aResponse.get_SyncGetTagsResponse().mTags());
      return IPC_OK();
    case SyncOpResponse::TSyncOpError:
      p->MaybeReject(
          static_cast<nsresult>(aResponse.get_SyncOpError().mCode()));
      return IPC_OK();
    default:
      MOZ_CRASH("Unknown BackgroundSync response");
      return IPC_FAIL(this, "Unknown BackgroundSync response");
  }
}

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






  bool IsActorDestroyed() const
  {
    return mActorDestroyed;
  }

  nsresult ExecuteOp(Promise* aPromise, SyncOp* aOp);

  virtual mozilla::ipc::IPCResult
  RecvResponse(const nsID& aRequestId,
               const SyncOpResponse& aResponse) override;

private:
  BackgroundSyncChild();
  ~BackgroundSyncChild();

  virtual void ActorDestroy(ActorDestroyReason aWhy) override;

  nsresult StorePendingRequest(Promise* aPromise, nsID& aID);





  AssertIsOnBackgroundThread();
}

void BackgroundSyncParent::ActorDestroy(ActorDestroyReason aWhy)
{
  AssertIsOnBackgroundThread();
}

mozilla::ipc::IPCResult
BackgroundSyncParent::RecvRequest(const nsID& aRequestId,
                                  const SyncOp& aOp)
{
  AssertIsOnBackgroundThread();

  switch(aOp.mArgs().type()) {
    case SyncOpArgs::TSyncRegisterArgs:
    {
      // XXX Do registration.
      const SyncRegisterResponse response(true);

      Unused << SendResponse(aRequestId, response);
      break;
    }
    default:
    {
      MOZ_CRASH("Unknown BackgroundSync request");
    }
  }
  return IPC_OK();
}

mozilla::ipc::IPCResult
BackgroundSyncParent::RecvShutdown()
{
  AssertIsOnBackgroundThread();

  Unused << Send__delete__(this);

  return IPC_OK();
}

void
BackgroundSyncParent::NotifyResponse(const nsID& aRequestId,
                                     const SyncOpResponse& aResponse)
{
  AssertIsOnBackgroundThread();






namespace dom {
namespace backgroundsync {

class BackgroundSyncParent final : public PBackgroundSyncParent
{
  friend class mozilla::ipc::BackgroundParentImpl;

public:
  virtual mozilla::ipc::IPCResult
  RecvRequest(const nsID& aRequestId, const SyncOp& aOp) override;

  virtual mozilla::ipc::IPCResult
  RecvShutdown() override;

  void NotifyResponse(const nsID& aRequestId,
                      const SyncOpResponse& aResponse);

private:
  BackgroundSyncParent();
  ~BackgroundSyncParent();


Return to bug 1217544