TestRemoteImageHolder.cpp

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* 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 "ImageContainer.h"

#include "gtest/gtest.h"

#include "mozilla/RemoteImageHolder.h"

#include "mozilla/gfx/Types.h"

#include "mozilla/ipc/Shmem.h"

#include "mozilla/layers/BufferTexture.h"

#include "mozilla/layers/ImageDataSerializer.h"

#include "mozilla/layers/LayersSurfaces.h"

using namespace mozilla;

using namespace mozilla::gfx;

using namespace mozilla::ipc;

using namespace mozilla::layers;

static YCbCrDescriptor MakeInvalidDescriptor() {

  return YCbCrDescriptor(IntRect(0, 0, 4, 4), IntSize(1, 1), 4u, IntSize(1, 1),

                         4u, 8192u, 1u, 9192u, StereoMode::MONO,

                         ColorDepth::COLOR_8, YUVColorSpace::BT601,

                         ColorRange::LIMITED, TransferFunction::BT709,

                         ChromaSubsampling::HALF_WIDTH_AND_HEIGHT, Nothing());

static YCbCrDescriptor MakeValidDescriptor() {

  return YCbCrDescriptor(IntRect(0, 0, 4, 4), IntSize(4, 4), 4u, IntSize(2, 2),

                         2u, 0u, 16u, 20u, StereoMode::MONO,

                         ColorDepth::COLOR_8, YUVColorSpace::BT601,

                         ColorRange::LIMITED, TransferFunction::BT709,

                         ChromaSubsampling::HALF_WIDTH_AND_HEIGHT, Nothing());

// Valid plane layout but display rect extends beyond ySize.

static YCbCrDescriptor MakeOversizedDisplayDescriptor() {

  return YCbCrDescriptor(IntRect(0, 0, 64, 200), IntSize(64, 2), 64u,

                         IntSize(32, 1), 32u, 0u, 128u, 160u, StereoMode::MONO,

                         ColorDepth::COLOR_8, YUVColorSpace::BT601,

                         ColorRange::LIMITED, TransferFunction::BT709,

                         ChromaSubsampling::HALF_WIDTH_AND_HEIGHT, Nothing());

// cbCrSize is smaller than what chromaSubsampling implies.

static YCbCrDescriptor MakeInvalidChromaDimensionsDescriptor() {

  return YCbCrDescriptor(IntRect(0, 0, 64, 2), IntSize(64, 2), 64u,

                         IntSize(64, 1), 64u, 0u, 128u, 192u, StereoMode::MONO,

                         ColorDepth::COLOR_8, YUVColorSpace::BT601,

                         ColorRange::LIMITED, TransferFunction::BT709,

                         ChromaSubsampling::FULL, Nothing());

TEST(TestRemoteImageHolder, InvalidDescriptorValidation)

  auto desc = MakeInvalidDescriptor();

  Maybe<uint32_t> descriptorSize = ImageDataSerializer::ComputeYCbCrBufferSize(

      desc.display(), desc.ySize(), desc.yStride(), desc.cbCrSize(),

      desc.cbCrStride(), desc.yOffset(), desc.cbOffset(), desc.crOffset(),

      desc.colorDepth(), desc.chromaSubsampling());

  ASSERT_TRUE(descriptorSize.isNothing());

TEST(TestRemoteImageHolder, ValidDescriptorPassesValidation)

  auto desc = MakeValidDescriptor();

  Maybe<uint32_t> descriptorSize = ImageDataSerializer::ComputeYCbCrBufferSize(

      desc.display(), desc.ySize(), desc.yStride(), desc.cbCrSize(),

      desc.cbCrStride(), desc.yOffset(), desc.cbOffset(), desc.crOffset(),

      desc.colorDepth(), desc.chromaSubsampling());

  ASSERT_GT(descriptorSize.extract(), 0u);

TEST(TestRemoteImageHolder, RejectsInvalidShmemDescriptor)

  auto shmemBuilder = Shmem::Builder(128);

  ASSERT_TRUE(shmemBuilder)

  << "Failed to create Shmem::Builder";

  auto [msg, shmem] = shmemBuilder.Build(1, false, 0);

  ASSERT_TRUE(shmem.IsWritable())

  << "Shmem should be writable";

  ASSERT_EQ(shmem.Size<uint8_t>(), 128u) << "Shmem should be 128 bytes";

  auto invalidDesc = MakeInvalidDescriptor();

  BufferDescriptor bufferDesc(invalidDesc);

  MemoryOrShmem memOrShmem(shmem);

  SurfaceDescriptorBuffer sdBuffer(bufferDesc, memOrShmem);

  SurfaceDescriptor sd(sdBuffer);

  RemoteImageHolder holder(std::move(sd));

  RefPtr<BufferRecycleBin> recycleBin = new BufferRecycleBin();

  RefPtr<layers::Image> image = holder.TransferToImage(recycleBin);

  EXPECT_TRUE(image == nullptr) << "RemoteImageHolder::TransferToImage should "

                                   "return null for invalid descriptors";

TEST(TestRemoteImageHolder, AcceptsValidShmemDescriptor)

  auto shmemBuilder = Shmem::Builder(128);

  ASSERT_TRUE(shmemBuilder)

  << "Failed to create Shmem::Builder";

  auto [msg, shmem] = shmemBuilder.Build(2, false, 0);

  ASSERT_TRUE(shmem.IsWritable())

  << "Shmem should be writable";

  ASSERT_EQ(shmem.Size<uint8_t>(), 128u) << "Shmem should be 128 bytes";

  auto validDesc = MakeValidDescriptor();

  uint8_t* buffer = shmem.get<uint8_t>();

  memset(buffer, 0, 128);

  BufferDescriptor bufferDesc(validDesc);

  MemoryOrShmem memOrShmem(shmem);

  SurfaceDescriptorBuffer sdBuffer(bufferDesc, memOrShmem);

  SurfaceDescriptor sd(sdBuffer);

  RemoteImageHolder holder(std::move(sd));

  RefPtr<BufferRecycleBin> recycleBin = new BufferRecycleBin();

  RefPtr<layers::Image> image = holder.TransferToImage(recycleBin);

  EXPECT_TRUE(image != nullptr) << "RemoteImageHolder::TransferToImage should "

                                   "return a valid image for valid descriptors";

TEST(TestRemoteImageHolder, RejectsOversizedDisplayRect)

  auto desc = MakeOversizedDisplayDescriptor();

  // ComputeYCbCrBufferSize itself rejects the oversized display rect, so size

  // a Shmem big enough to hold the planes from the descriptor's offsets.

  uint32_t descriptorSize =

      desc.crOffset() + desc.cbCrStride() * desc.cbCrSize().height;

  auto shmemBuilder = Shmem::Builder(descriptorSize);

  ASSERT_TRUE(shmemBuilder)

  << "Failed to create Shmem::Builder";

  auto [msg, shmem] = shmemBuilder.Build(3, false, 0);

  ASSERT_TRUE(shmem.IsWritable())

  << "Shmem should be writable";

  ASSERT_GE(shmem.Size<uint8_t>(), descriptorSize)

      << "Shmem should fit descriptor";

  memset(shmem.get<uint8_t>(), 0, descriptorSize);

  BufferDescriptor bufferDesc(desc);

  MemoryOrShmem memOrShmem(shmem);

  SurfaceDescriptorBuffer sdBuffer(bufferDesc, memOrShmem);

  SurfaceDescriptor sd(sdBuffer);

  RemoteImageHolder holder(std::move(sd));

  RefPtr<BufferRecycleBin> recycleBin = new BufferRecycleBin();

  RefPtr<layers::Image> image = holder.TransferToImage(recycleBin);

  EXPECT_TRUE(image == nullptr)

      << "TransferToImage should reject descriptor whose display rect exceeds "

         "plane dimensions";

TEST(TestRemoteImageHolder, RejectsInvalidChromaDimensions)

  auto desc = MakeInvalidChromaDimensionsDescriptor();

  // ComputeYCbCrBufferSize itself rejects mismatched chroma dimensions, so

  // size a Shmem big enough to hold the planes from the descriptor's offsets.

  uint32_t descriptorSize =

      desc.crOffset() + desc.cbCrStride() * desc.cbCrSize().height;

  auto shmemBuilder = Shmem::Builder(descriptorSize);

  ASSERT_TRUE(shmemBuilder)

  << "Failed to create Shmem::Builder";

  auto [msg, shmem] = shmemBuilder.Build(4, false, 0);

  ASSERT_TRUE(shmem.IsWritable())

  << "Shmem should be writable";

  ASSERT_GE(shmem.Size<uint8_t>(), descriptorSize)

      << "Shmem should fit descriptor";

  memset(shmem.get<uint8_t>(), 0, descriptorSize);

  BufferDescriptor bufferDesc(desc);

  MemoryOrShmem memOrShmem(shmem);

  SurfaceDescriptorBuffer sdBuffer(bufferDesc, memOrShmem);

  SurfaceDescriptor sd(sdBuffer);

  RemoteImageHolder holder(std::move(sd));

  RefPtr<BufferRecycleBin> recycleBin = new BufferRecycleBin();

  RefPtr<layers::Image> image = holder.TransferToImage(recycleBin);

  EXPECT_TRUE(image == nullptr)

      << "TransferToImage should reject descriptor with inconsistent chroma "

         "dimensions";