tor-browser

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

FileSystemAsyncCopy.cpp (2696B)

      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 "fs/FileSystemAsyncCopy.h"
      8 
      9 #include "fs/FileSystemConstants.h"
     10 #include "mozilla/MozPromise.h"
     11 #include "mozilla/dom/Promise.h"
     12 #include "mozilla/dom/quota/QuotaCommon.h"
     13 #include "mozilla/dom/quota/ResultExtensions.h"
     14 
     15 namespace mozilla::dom::fs {
     16 
     17 nsresult AsyncCopy(nsIInputStream* aSource, nsIOutputStream* aSink,
     18                   nsISerialEventTarget* aIOTarget, const nsAsyncCopyMode aMode,
     19                   const bool aCloseSource, const bool aCloseSink,
     20                   std::function<void(uint32_t)>&& aProgressCallback,
     21                   MoveOnlyFunction<void(nsresult)>&& aCompleteCallback) {
     22  struct CallbackClosure {
     23    CallbackClosure(std::function<void(uint32_t)>&& aProgressCallback,
     24                    MoveOnlyFunction<void(nsresult)>&& aCompleteCallback) {
     25      mProgressCallbackWrapper = MakeUnique<std::function<void(uint32_t)>>(
     26          [progressCallback = std::move(aProgressCallback)](uint32_t count) {
     27            progressCallback(count);
     28          });
     29 
     30      mCompleteCallbackWrapper = MakeUnique<MoveOnlyFunction<void(nsresult)>>(
     31          [completeCallback =
     32               std::move(aCompleteCallback)](nsresult rv) mutable {
     33            auto callback = std::move(completeCallback);
     34            callback(rv);
     35          });
     36    }
     37 
     38    UniquePtr<std::function<void(uint32_t)>> mProgressCallbackWrapper;
     39    UniquePtr<MoveOnlyFunction<void(nsresult)>> mCompleteCallbackWrapper;
     40  };
     41 
     42  auto* callbackClosure = new CallbackClosure(std::move(aProgressCallback),
     43                                              std::move(aCompleteCallback));
     44 
     45  QM_TRY(
     46      MOZ_TO_RESULT(NS_AsyncCopy(
     47          aSource, aSink, aIOTarget, aMode, kStreamCopyBlockSize,
     48          [](void* aClosure, nsresult aRv) {
     49            auto* callbackClosure = static_cast<CallbackClosure*>(aClosure);
     50            (*callbackClosure->mCompleteCallbackWrapper)(aRv);
     51            delete callbackClosure;
     52          },
     53          callbackClosure, aCloseSource, aCloseSink, /* aCopierCtx */ nullptr,
     54          [](void* aClosure, uint32_t aCount) {
     55            auto* callbackClosure = static_cast<CallbackClosure*>(aClosure);
     56            (*callbackClosure->mProgressCallbackWrapper)(aCount);
     57          })),
     58      [callbackClosure](nsresult rv) {
     59        delete callbackClosure;
     60        return rv;
     61      });
     62 
     63  return NS_OK;
     64 }
     65 
     66 }  // namespace mozilla::dom::fs