tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

FetchEventOpParent.cpp (3205B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "FetchEventOpParent.h"
      8 
      9 #include "mozilla/Assertions.h"
     10 #include "mozilla/RefPtr.h"
     11 #include "mozilla/dom/FetchEventOpProxyParent.h"
     12 #include "mozilla/dom/FetchStreamUtils.h"
     13 #include "mozilla/dom/FetchTypes.h"
     14 #include "mozilla/dom/InternalResponse.h"
     15 #include "mozilla/dom/RemoteWorkerControllerParent.h"
     16 #include "mozilla/dom/RemoteWorkerParent.h"
     17 #include "mozilla/dom/RemoteWorkerServiceParent.h"
     18 #include "mozilla/ipc/BackgroundParent.h"
     19 #include "nsDebug.h"
     20 
     21 namespace mozilla {
     22 
     23 using namespace ipc;
     24 
     25 namespace dom {
     26 
     27 std::tuple<Maybe<ParentToParentInternalResponse>, Maybe<ResponseEndArgs>>
     28 FetchEventOpParent::OnStart(
     29    MovingNotNull<RefPtr<FetchEventOpProxyParent>> aFetchEventOpProxyParent) {
     30  Maybe<ParentToParentInternalResponse> preloadResponse =
     31      std::move(mState.as<Pending>().mPreloadResponse);
     32  Maybe<ResponseEndArgs> preloadResponseEndArgs =
     33      std::move(mState.as<Pending>().mEndArgs);
     34  mState = AsVariant(Started{std::move(aFetchEventOpProxyParent)});
     35  return std::make_tuple(preloadResponse, preloadResponseEndArgs);
     36 }
     37 
     38 void FetchEventOpParent::OnFinish() {
     39  MOZ_ASSERT(mState.is<Started>());
     40  mState = AsVariant(Finished());
     41 }
     42 
     43 mozilla::ipc::IPCResult FetchEventOpParent::RecvPreloadResponse(
     44    ParentToParentInternalResponse&& aResponse) {
     45  AssertIsOnBackgroundThread();
     46 
     47  mState.match(
     48      [&aResponse](Pending& aPending) {
     49        MOZ_ASSERT(aPending.mPreloadResponse.isNothing());
     50        aPending.mPreloadResponse = Some(std::move(aResponse));
     51      },
     52      [&aResponse](Started& aStarted) {
     53        (void)aStarted.mFetchEventOpProxyParent->SendPreloadResponse(
     54            ToParentToChild(aResponse));
     55      },
     56      [](const Finished&) {});
     57 
     58  return IPC_OK();
     59 }
     60 
     61 mozilla::ipc::IPCResult FetchEventOpParent::RecvPreloadResponseTiming(
     62    ResponseTiming&& aTiming) {
     63  AssertIsOnBackgroundThread();
     64 
     65  mState.match(
     66      [&aTiming](Pending& aPending) {
     67        MOZ_ASSERT(aPending.mTiming.isNothing());
     68        aPending.mTiming = Some(std::move(aTiming));
     69      },
     70      [&aTiming](Started& aStarted) {
     71        (void)aStarted.mFetchEventOpProxyParent->SendPreloadResponseTiming(
     72            std::move(aTiming));
     73      },
     74      [](const Finished&) {});
     75 
     76  return IPC_OK();
     77 }
     78 
     79 mozilla::ipc::IPCResult FetchEventOpParent::RecvPreloadResponseEnd(
     80    ResponseEndArgs&& aArgs) {
     81  AssertIsOnBackgroundThread();
     82 
     83  mState.match(
     84      [&aArgs](Pending& aPending) {
     85        MOZ_ASSERT(aPending.mEndArgs.isNothing());
     86        aPending.mEndArgs = Some(std::move(aArgs));
     87      },
     88      [&aArgs](Started& aStarted) {
     89        (void)aStarted.mFetchEventOpProxyParent->SendPreloadResponseEnd(
     90            std::move(aArgs));
     91      },
     92      [](const Finished&) {});
     93 
     94  return IPC_OK();
     95 }
     96 
     97 void FetchEventOpParent::ActorDestroy(ActorDestroyReason) {
     98  AssertIsOnBackgroundThread();
     99 }
    100 
    101 }  // namespace dom
    102 }  // namespace mozilla