Quelle BigBuffer.cpp Sprache: C

/* -*- 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 "mozilla/ipc/BigBuffer.h"

#include "chrome/common/ipc_message_utils.h"
#include "mozilla/ipc/SharedMemory.h"
#include "nsDebug.h"

namespace mozilla::ipc {

BigBuffer::BigBuffer(Adopt, SharedMemory* aSharedMemory, size_t aSize)
    : mSize(aSize), mData(AsVariant(RefPtr{aSharedMemory})) {
  MOZ_RELEASE_ASSERT(aSharedMemory && aSharedMemory->Memory(),
                     "shared memory must be non-null and mapped");
  MOZ_RELEASE_ASSERT(mSize <= aSharedMemory->Size(),
                     "shared memory region isn't large enough");
}

BigBuffer::BigBuffer(Adopt, uint8_t* aData, size_t aSize)
    : mSize(aSize), mData(AsVariant(UniqueFreePtr<uint8_t[]>{aData})) {}

uint8_t* BigBuffer::Data() {
  return mData.is<0>() ? mData.as<0>().get()
                       : reinterpret_cast<uint8_t*>(mData.as<1>()->Memory());
}
const uint8_t* BigBuffer::Data() const {
  return mData.is<0>()
             ? mData.as<0>().get()
             : reinterpret_cast<const uint8_t*>(mData.as<1>()->Memory());
}

auto BigBuffer::TryAllocBuffer(size_t aSize) -> Maybe<Storage> {
  if (aSize <= kShmemThreshold) {
    auto mem = UniqueFreePtr<uint8_t[]>{
        reinterpret_cast<uint8_t*>(malloc(aSize))};  // Fallible!
    if (!mem) return {};
    return Some(AsVariant(std::move(mem)));
  }

  RefPtr<SharedMemory> shmem = new SharedMemory();
  size_t capacity = SharedMemory::PageAlignedSize(aSize);
  if (!shmem->Create(capacity) || !shmem->Map(capacity)) {
    return {};
  }
  return Some(AsVariant(shmem));
}

}  // namespace mozilla::ipc

void IPC::ParamTraits<mozilla::ipc::BigBuffer>::Write(MessageWriter* aWriter,
                                                      paramType&& aParam) {
  using namespace mozilla::ipc;
  size_t size = std::exchange(aParam.mSize, 0);
  auto data = std::exchange(aParam.mData, BigBuffer::NoData());

  WriteParam(aWriter, size);
  bool isShmem = data.is<1>();
  WriteParam(aWriter, isShmem);

  if (isShmem) {
    if (!data.as<1>()->WriteHandle(aWriter)) {
      aWriter->FatalError("Failed to write data shmem");
    }
  } else {
    aWriter->WriteBytes(data.as<0>().get(), size);
  }
}

bool IPC::ParamTraits<mozilla::ipc::BigBuffer>::Read(MessageReader* aReader,
                                                     paramType* aResult) {
  using namespace mozilla::ipc;
  size_t size = 0;
  bool isShmem = false;
  if (!ReadParam(aReader, &size) || !ReadParam(aReader, &isShmem)) {
    aReader->FatalError("Failed to read data size and format");
    return false;
  }

  if (isShmem) {
    RefPtr<SharedMemory> shmem = new SharedMemory();
    size_t capacity = SharedMemory::PageAlignedSize(size);
    if (!shmem->ReadHandle(aReader) || !shmem->Map(capacity)) {
      aReader->FatalError("Failed to read data shmem");
      return false;
    }
    *aResult = BigBuffer(BigBuffer::Adopt{}, shmem, size);
    return true;
  }

  mozilla::UniqueFreePtr<uint8_t[]> buf{
      reinterpret_cast<uint8_t*>(malloc(size))};
  if (!buf) {
    aReader->FatalError("Failed to allocate data buffer");
    return false;
  }
  if (!aReader->ReadBytesInto(buf.get(), size)) {
    aReader->FatalError("Failed to read data");
    return false;
  }
  *aResult = BigBuffer(BigBuffer::Adopt{}, buf.release(), size);
  return true;
}

quality100%

¤ Dauer der Verarbeitung: 0.17 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.