media/gpu/vaapi/vaapi_image_decode_accelerator_worker_unittest.cc - cobalt - Git at Google

 // Copyright 2019 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <stddef.h>
 #include <stdint.h>
 #include <va/va.h>

 #include <memory>
 #include <utility>
 #include <vector>

 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 #include "base/bind.h"
 #include "base/check_op.h"
 #include "base/containers/span.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/notreached.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/task_environment.h"
 #include "gpu/config/gpu_finch_features.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/ipc/service/image_decode_accelerator_worker.h"
 #include "media/gpu/vaapi/vaapi_image_decode_accelerator_worker.h"
 #include "media/gpu/vaapi/vaapi_image_decoder.h"
 #include "media/gpu/vaapi/vaapi_wrapper.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/linux/native_pixmap_dmabuf.h"
 #include "ui/gfx/native_pixmap_handle.h"

 using testing::_;
 using testing::AllOf;
 using testing::InSequence;
 using testing::IsNull;
 using testing::NotNull;
 using testing::Property;
 using testing::Return;
 using testing::StrictMock;

 namespace media {
 namespace {

 constexpr gfx::BufferFormat kFormatForDecodes = gfx::BufferFormat::YVU_420;

 constexpr gfx::Size kVaSurfaceResolution(128, 256);

 constexpr gfx::Size kVisibleSize(120, 250);

 constexpr size_t kWebPFileAndVp8ChunkHeaderSizeInBytes = 20u;

 // clang-format off
 constexpr uint8_t kJpegPFileHeader[] = {0xFF, 0xD8, 0xFF};

 constexpr uint8_t kLossyWebPFileHeader[] = {
     'R', 'I', 'F', 'F',
     0x0c, 0x00, 0x00, 0x00,  // == 12 (little endian)
     'W', 'E', 'B', 'P',
     'V', 'P', '8', ' ',
     0x00, 0x00, 0x00, 0x00  // == 0
 };
 // clang-format on

 constexpr base::span<const uint8_t, 3u> kJpegEncodedData = kJpegPFileHeader;

 constexpr base::span<const uint8_t, kWebPFileAndVp8ChunkHeaderSizeInBytes>
     kLossyWebPEncodedData = kLossyWebPFileHeader;

 class MockNativePixmapDmaBuf : public gfx::NativePixmapDmaBuf {
  public:
   MockNativePixmapDmaBuf(const gfx::Size& size)
       : gfx::NativePixmapDmaBuf(size,
                                 kFormatForDecodes,
                                 gfx::NativePixmapHandle()) {}

   gfx::NativePixmapHandle ExportHandle() override {
     gfx::NativePixmapHandle handle{};
     DCHECK_EQ(gfx::BufferFormat::YVU_420, GetBufferFormat());
     handle.planes = std::vector<gfx::NativePixmapPlane>(3u);
     return handle;
   }

  protected:
   ~MockNativePixmapDmaBuf() override = default;
 };

 class MockVaapiImageDecoder : public VaapiImageDecoder {
  public:
   MockVaapiImageDecoder(gpu::ImageDecodeAcceleratorType type)
       : VaapiImageDecoder(VAProfileNone), type_(type) {}
   ~MockVaapiImageDecoder() override = default;

   gpu::ImageDecodeAcceleratorType GetType() const override { return type_; }
   SkYUVColorSpace GetYUVColorSpace() const override {
     switch (type_) {
       case gpu::ImageDecodeAcceleratorType::kJpeg:
         return SkYUVColorSpace::kJPEG_SkYUVColorSpace;
       case gpu::ImageDecodeAcceleratorType::kWebP:
         return SkYUVColorSpace::kRec601_SkYUVColorSpace;
       case gpu::ImageDecodeAcceleratorType::kUnknown:
         NOTREACHED();
         return SkYUVColorSpace::kIdentity_SkYUVColorSpace;
     }
   }

   gpu::ImageDecodeAcceleratorSupportedProfile GetSupportedProfile()
       const override {
     return gpu::ImageDecodeAcceleratorSupportedProfile();
   }

   MOCK_METHOD1(Initialize, bool(const ReportErrorToUMACB&));
   MOCK_METHOD1(Decode, VaapiImageDecodeStatus(base::span<const uint8_t>));
   MOCK_CONST_METHOD0(GetScopedVASurface, const ScopedVASurface*());
   MOCK_METHOD1(
       ExportAsNativePixmapDmaBuf,
       std::unique_ptr<NativePixmapAndSizeInfo>(VaapiImageDecodeStatus*));
   MOCK_METHOD1(AllocateVASurfaceAndSubmitVABuffers,
                VaapiImageDecodeStatus(base::span<const uint8_t>));

  private:
   const gpu::ImageDecodeAcceleratorType type_;
 };

 }  // namespace

 class VaapiImageDecodeAcceleratorWorkerTest : public testing::Test {
  public:
   VaapiImageDecodeAcceleratorWorkerTest() {
     feature_list_.InitWithFeatures(
         {features::kVaapiJpegImageDecodeAcceleration,
          features::kVaapiWebPImageDecodeAcceleration} /* enabled_features */,
         {} /* disabled_features */);
     VaapiImageDecoderVector decoders;
     decoders.push_back(std::make_unique<StrictMock<MockVaapiImageDecoder>>(
         gpu::ImageDecodeAcceleratorType::kJpeg));
     decoders.push_back(std::make_unique<StrictMock<MockVaapiImageDecoder>>(
         gpu::ImageDecodeAcceleratorType::kWebP));
     worker_ = base::WrapUnique(
         new VaapiImageDecodeAcceleratorWorker(std::move(decoders)));
   }

   MockVaapiImageDecoder* GetJpegDecoder() const {
     auto result =
         worker_->decoders_.find(gpu::ImageDecodeAcceleratorType::kJpeg);
     return result == worker_->decoders_.end()
                ? nullptr
                : static_cast<MockVaapiImageDecoder*>(result->second.get());
   }

   MockVaapiImageDecoder* GetWebPDecoder() const {
     auto result =
         worker_->decoders_.find(gpu::ImageDecodeAcceleratorType::kWebP);
     return result == worker_->decoders_.end()
                ? nullptr
                : static_cast<MockVaapiImageDecoder*>(result->second.get());
   }

   MOCK_METHOD1(
       OnDecodeCompleted,
       void(std::unique_ptr<gpu::ImageDecodeAcceleratorWorker::DecodeResult>));

  protected:
   base::test::TaskEnvironment task_environment_;
   base::test::ScopedFeatureList feature_list_;
   std::unique_ptr<VaapiImageDecodeAcceleratorWorker> worker_;

   DISALLOW_COPY_AND_ASSIGN(VaapiImageDecodeAcceleratorWorkerTest);
 };

 ACTION_P2(ExportAsNativePixmapDmaBufSuccessfully,
           va_surface_resolution,
           visible_size) {
   *arg0 = VaapiImageDecodeStatus::kSuccess;
   auto exported_pixmap = std::make_unique<NativePixmapAndSizeInfo>();
   exported_pixmap->va_surface_resolution = va_surface_resolution;
   exported_pixmap->byte_size = 1u;
   exported_pixmap->pixmap =
       base::MakeRefCounted<MockNativePixmapDmaBuf>(visible_size);
   return exported_pixmap;
 }

 TEST_F(VaapiImageDecodeAcceleratorWorkerTest, ImageDecodeSucceeds) {
   std::vector<uint8_t> jpeg_encoded_data(kJpegEncodedData.begin(),
                                          kJpegEncodedData.end());
   std::vector<uint8_t> webp_encoded_data(kLossyWebPEncodedData.begin(),
                                          kLossyWebPEncodedData.end());
   {
     InSequence sequence;
     MockVaapiImageDecoder* jpeg_decoder = GetJpegDecoder();
     ASSERT_TRUE(jpeg_decoder);
     EXPECT_CALL(
         *jpeg_decoder,
         Decode(AllOf(Property(&base::span<const uint8_t>::data,
                               jpeg_encoded_data.data()),
                      Property(&base::span<const uint8_t>::size,
                               jpeg_encoded_data.size())) /* encoded_data */))
         .WillOnce(Return(VaapiImageDecodeStatus::kSuccess));
     EXPECT_CALL(*jpeg_decoder,
                 ExportAsNativePixmapDmaBuf(NotNull() /* status */))
         .WillOnce(ExportAsNativePixmapDmaBufSuccessfully(kVaSurfaceResolution,
                                                          kVisibleSize));
     EXPECT_CALL(*this, OnDecodeCompleted(NotNull()));

     MockVaapiImageDecoder* webp_decoder = GetWebPDecoder();
     ASSERT_TRUE(webp_decoder);
     EXPECT_CALL(
         *webp_decoder,
         Decode(AllOf(Property(&base::span<const uint8_t>::data,
                               webp_encoded_data.data()),
                      Property(&base::span<const uint8_t>::size,
                               webp_encoded_data.size())) /* encoded_data */))
         .WillOnce(Return(VaapiImageDecodeStatus::kSuccess));
     EXPECT_CALL(*webp_decoder,
                 ExportAsNativePixmapDmaBuf(NotNull() /* status */))
         .WillOnce(ExportAsNativePixmapDmaBufSuccessfully(kVaSurfaceResolution,
                                                          kVisibleSize));
     EXPECT_CALL(*this, OnDecodeCompleted(NotNull()));
   }

   worker_->Decode(
       std::move(jpeg_encoded_data), kVisibleSize,
       base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
                      base::Unretained(this)));

   worker_->Decode(
       std::move(webp_encoded_data), kVisibleSize,
       base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
                      base::Unretained(this)));
   task_environment_.RunUntilIdle();
 }

 TEST_F(VaapiImageDecodeAcceleratorWorkerTest, ImageDecodeFails) {
   std::vector<uint8_t> jpeg_encoded_data(kJpegEncodedData.begin(),
                                          kJpegEncodedData.end());
   std::vector<uint8_t> webp_encoded_data(kLossyWebPEncodedData.begin(),
                                          kLossyWebPEncodedData.end());
   {
     InSequence sequence;
     MockVaapiImageDecoder* jpeg_decoder = GetJpegDecoder();
     ASSERT_TRUE(jpeg_decoder);
     EXPECT_CALL(
         *jpeg_decoder,
         Decode(AllOf(Property(&base::span<const uint8_t>::data,
                               jpeg_encoded_data.data()),
                      Property(&base::span<const uint8_t>::size,
                               jpeg_encoded_data.size())) /* encoded_data */))
         .WillOnce(Return(VaapiImageDecodeStatus::kExecuteDecodeFailed));
     EXPECT_CALL(*this, OnDecodeCompleted(IsNull()));

     MockVaapiImageDecoder* webp_decoder = GetWebPDecoder();
     ASSERT_TRUE(webp_decoder);
     EXPECT_CALL(
         *webp_decoder,
         Decode(AllOf(Property(&base::span<const uint8_t>::data,
                               webp_encoded_data.data()),
                      Property(&base::span<const uint8_t>::size,
                               webp_encoded_data.size())) /* encoded_data */))
         .WillOnce(Return(VaapiImageDecodeStatus::kExecuteDecodeFailed));
     EXPECT_CALL(*this, OnDecodeCompleted(IsNull()));
   }

   worker_->Decode(
       std::move(jpeg_encoded_data), kVisibleSize,
       base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
                      base::Unretained(this)));

   worker_->Decode(
       std::move(webp_encoded_data), kVisibleSize,
       base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
                      base::Unretained(this)));
   task_environment_.RunUntilIdle();
 }

 TEST_F(VaapiImageDecodeAcceleratorWorkerTest, UnknownImageDecodeFails) {
   std::vector<uint8_t> encoded_data = {1u, 2u, 3u};
   EXPECT_CALL(*this, OnDecodeCompleted(IsNull()));
   worker_->Decode(
       std::move(encoded_data), kVisibleSize,
       base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
                      base::Unretained(this)));
   task_environment_.RunUntilIdle();
 }

 }  // namespace media
	// Copyright 2019 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <stddef.h>
	#include <stdint.h>
	#include <va/va.h>

	#include <memory>
	#include <utility>
	#include <vector>

	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	#include "base/bind.h"
	#include "base/check_op.h"
	#include "base/containers/span.h"
	#include "base/macros.h"
	#include "base/memory/ptr_util.h"
	#include "base/memory/scoped_refptr.h"
	#include "base/notreached.h"
	#include "base/test/scoped_feature_list.h"
	#include "base/test/task_environment.h"
	#include "gpu/config/gpu_finch_features.h"
	#include "gpu/config/gpu_info.h"
	#include "gpu/ipc/service/image_decode_accelerator_worker.h"
	#include "media/gpu/vaapi/vaapi_image_decode_accelerator_worker.h"
	#include "media/gpu/vaapi/vaapi_image_decoder.h"
	#include "media/gpu/vaapi/vaapi_wrapper.h"
	#include "third_party/skia/include/core/SkImageInfo.h"
	#include "ui/gfx/buffer_types.h"
	#include "ui/gfx/geometry/size.h"
	#include "ui/gfx/linux/native_pixmap_dmabuf.h"
	#include "ui/gfx/native_pixmap_handle.h"

	using testing::_;
	using testing::AllOf;
	using testing::InSequence;
	using testing::IsNull;
	using testing::NotNull;
	using testing::Property;
	using testing::Return;
	using testing::StrictMock;

	namespace media {
	namespace {

	constexpr gfx::BufferFormat kFormatForDecodes = gfx::BufferFormat::YVU_420;

	constexpr gfx::Size kVaSurfaceResolution(128, 256);

	constexpr gfx::Size kVisibleSize(120, 250);

	constexpr size_t kWebPFileAndVp8ChunkHeaderSizeInBytes = 20u;

	// clang-format off
	constexpr uint8_t kJpegPFileHeader[] = {0xFF, 0xD8, 0xFF};

	constexpr uint8_t kLossyWebPFileHeader[] = {
	'R', 'I', 'F', 'F',
	0x0c, 0x00, 0x00, 0x00, // == 12 (little endian)
	'W', 'E', 'B', 'P',
	'V', 'P', '8', ' ',
	0x00, 0x00, 0x00, 0x00 // == 0
	};
	// clang-format on

	constexpr base::span<const uint8_t, 3u> kJpegEncodedData = kJpegPFileHeader;

	constexpr base::span<const uint8_t, kWebPFileAndVp8ChunkHeaderSizeInBytes>
	kLossyWebPEncodedData = kLossyWebPFileHeader;

	class MockNativePixmapDmaBuf : public gfx::NativePixmapDmaBuf {
	public:
	MockNativePixmapDmaBuf(const gfx::Size& size)
	: gfx::NativePixmapDmaBuf(size,
	kFormatForDecodes,
	gfx::NativePixmapHandle()) {}

	gfx::NativePixmapHandle ExportHandle() override {
	gfx::NativePixmapHandle handle{};
	DCHECK_EQ(gfx::BufferFormat::YVU_420, GetBufferFormat());
	handle.planes = std::vector<gfx::NativePixmapPlane>(3u);
	return handle;
	}

	protected:
	~MockNativePixmapDmaBuf() override = default;
	};

	class MockVaapiImageDecoder : public VaapiImageDecoder {
	public:
	MockVaapiImageDecoder(gpu::ImageDecodeAcceleratorType type)
	: VaapiImageDecoder(VAProfileNone), type_(type) {}
	~MockVaapiImageDecoder() override = default;

	gpu::ImageDecodeAcceleratorType GetType() const override { return type_; }
	SkYUVColorSpace GetYUVColorSpace() const override {
	switch (type_) {
	case gpu::ImageDecodeAcceleratorType::kJpeg:
	return SkYUVColorSpace::kJPEG_SkYUVColorSpace;
	case gpu::ImageDecodeAcceleratorType::kWebP:
	return SkYUVColorSpace::kRec601_SkYUVColorSpace;
	case gpu::ImageDecodeAcceleratorType::kUnknown:
	NOTREACHED();
	return SkYUVColorSpace::kIdentity_SkYUVColorSpace;
	}
	}

	gpu::ImageDecodeAcceleratorSupportedProfile GetSupportedProfile()
	const override {
	return gpu::ImageDecodeAcceleratorSupportedProfile();
	}

	MOCK_METHOD1(Initialize, bool(const ReportErrorToUMACB&));
	MOCK_METHOD1(Decode, VaapiImageDecodeStatus(base::span<const uint8_t>));
	MOCK_CONST_METHOD0(GetScopedVASurface, const ScopedVASurface*());
	MOCK_METHOD1(
	ExportAsNativePixmapDmaBuf,
	std::unique_ptr<NativePixmapAndSizeInfo>(VaapiImageDecodeStatus*));
	MOCK_METHOD1(AllocateVASurfaceAndSubmitVABuffers,
	VaapiImageDecodeStatus(base::span<const uint8_t>));

	private:
	const gpu::ImageDecodeAcceleratorType type_;
	};

	} // namespace

	class VaapiImageDecodeAcceleratorWorkerTest : public testing::Test {
	public:
	VaapiImageDecodeAcceleratorWorkerTest() {
	feature_list_.InitWithFeatures(
	{features::kVaapiJpegImageDecodeAcceleration,
	features::kVaapiWebPImageDecodeAcceleration} /* enabled_features */,
	{} /* disabled_features */);
	VaapiImageDecoderVector decoders;
	decoders.push_back(std::make_unique<StrictMock<MockVaapiImageDecoder>>(
	gpu::ImageDecodeAcceleratorType::kJpeg));
	decoders.push_back(std::make_unique<StrictMock<MockVaapiImageDecoder>>(
	gpu::ImageDecodeAcceleratorType::kWebP));
	worker_ = base::WrapUnique(
	new VaapiImageDecodeAcceleratorWorker(std::move(decoders)));
	}

	MockVaapiImageDecoder* GetJpegDecoder() const {
	auto result =
	worker_->decoders_.find(gpu::ImageDecodeAcceleratorType::kJpeg);
	return result == worker_->decoders_.end()
	? nullptr
	: static_cast<MockVaapiImageDecoder*>(result->second.get());
	}

	MockVaapiImageDecoder* GetWebPDecoder() const {
	auto result =
	worker_->decoders_.find(gpu::ImageDecodeAcceleratorType::kWebP);
	return result == worker_->decoders_.end()
	? nullptr
	: static_cast<MockVaapiImageDecoder*>(result->second.get());
	}

	MOCK_METHOD1(
	OnDecodeCompleted,
	void(std::unique_ptr<gpu::ImageDecodeAcceleratorWorker::DecodeResult>));

	protected:
	base::test::TaskEnvironment task_environment_;
	base::test::ScopedFeatureList feature_list_;
	std::unique_ptr<VaapiImageDecodeAcceleratorWorker> worker_;

	DISALLOW_COPY_AND_ASSIGN(VaapiImageDecodeAcceleratorWorkerTest);
	};

	ACTION_P2(ExportAsNativePixmapDmaBufSuccessfully,
	va_surface_resolution,
	visible_size) {
	*arg0 = VaapiImageDecodeStatus::kSuccess;
	auto exported_pixmap = std::make_unique<NativePixmapAndSizeInfo>();
	exported_pixmap->va_surface_resolution = va_surface_resolution;
	exported_pixmap->byte_size = 1u;
	exported_pixmap->pixmap =
	base::MakeRefCounted<MockNativePixmapDmaBuf>(visible_size);
	return exported_pixmap;
	}

	TEST_F(VaapiImageDecodeAcceleratorWorkerTest, ImageDecodeSucceeds) {
	std::vector<uint8_t> jpeg_encoded_data(kJpegEncodedData.begin(),
	kJpegEncodedData.end());
	std::vector<uint8_t> webp_encoded_data(kLossyWebPEncodedData.begin(),
	kLossyWebPEncodedData.end());
	{
	InSequence sequence;
	MockVaapiImageDecoder* jpeg_decoder = GetJpegDecoder();
	ASSERT_TRUE(jpeg_decoder);
	EXPECT_CALL(
	*jpeg_decoder,
	Decode(AllOf(Property(&base::span<const uint8_t>::data,
	jpeg_encoded_data.data()),
	Property(&base::span<const uint8_t>::size,
	jpeg_encoded_data.size())) /* encoded_data */))
	.WillOnce(Return(VaapiImageDecodeStatus::kSuccess));
	EXPECT_CALL(*jpeg_decoder,
	ExportAsNativePixmapDmaBuf(NotNull() /* status */))
	.WillOnce(ExportAsNativePixmapDmaBufSuccessfully(kVaSurfaceResolution,
	kVisibleSize));
	EXPECT_CALL(*this, OnDecodeCompleted(NotNull()));

	MockVaapiImageDecoder* webp_decoder = GetWebPDecoder();
	ASSERT_TRUE(webp_decoder);
	EXPECT_CALL(
	*webp_decoder,
	Decode(AllOf(Property(&base::span<const uint8_t>::data,
	webp_encoded_data.data()),
	Property(&base::span<const uint8_t>::size,
	webp_encoded_data.size())) /* encoded_data */))
	.WillOnce(Return(VaapiImageDecodeStatus::kSuccess));
	EXPECT_CALL(*webp_decoder,
	ExportAsNativePixmapDmaBuf(NotNull() /* status */))
	.WillOnce(ExportAsNativePixmapDmaBufSuccessfully(kVaSurfaceResolution,
	kVisibleSize));
	EXPECT_CALL(*this, OnDecodeCompleted(NotNull()));
	}

	worker_->Decode(
	std::move(jpeg_encoded_data), kVisibleSize,
	base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
	base::Unretained(this)));

	worker_->Decode(
	std::move(webp_encoded_data), kVisibleSize,
	base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
	base::Unretained(this)));
	task_environment_.RunUntilIdle();
	}

	TEST_F(VaapiImageDecodeAcceleratorWorkerTest, ImageDecodeFails) {
	std::vector<uint8_t> jpeg_encoded_data(kJpegEncodedData.begin(),
	kJpegEncodedData.end());
	std::vector<uint8_t> webp_encoded_data(kLossyWebPEncodedData.begin(),
	kLossyWebPEncodedData.end());
	{
	InSequence sequence;
	MockVaapiImageDecoder* jpeg_decoder = GetJpegDecoder();
	ASSERT_TRUE(jpeg_decoder);
	EXPECT_CALL(
	*jpeg_decoder,
	Decode(AllOf(Property(&base::span<const uint8_t>::data,
	jpeg_encoded_data.data()),
	Property(&base::span<const uint8_t>::size,
	jpeg_encoded_data.size())) /* encoded_data */))
	.WillOnce(Return(VaapiImageDecodeStatus::kExecuteDecodeFailed));
	EXPECT_CALL(*this, OnDecodeCompleted(IsNull()));

	MockVaapiImageDecoder* webp_decoder = GetWebPDecoder();
	ASSERT_TRUE(webp_decoder);
	EXPECT_CALL(
	*webp_decoder,
	Decode(AllOf(Property(&base::span<const uint8_t>::data,
	webp_encoded_data.data()),
	Property(&base::span<const uint8_t>::size,
	webp_encoded_data.size())) /* encoded_data */))
	.WillOnce(Return(VaapiImageDecodeStatus::kExecuteDecodeFailed));
	EXPECT_CALL(*this, OnDecodeCompleted(IsNull()));
	}

	worker_->Decode(
	std::move(jpeg_encoded_data), kVisibleSize,
	base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
	base::Unretained(this)));

	worker_->Decode(
	std::move(webp_encoded_data), kVisibleSize,
	base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
	base::Unretained(this)));
	task_environment_.RunUntilIdle();
	}

	TEST_F(VaapiImageDecodeAcceleratorWorkerTest, UnknownImageDecodeFails) {
	std::vector<uint8_t> encoded_data = {1u, 2u, 3u};
	EXPECT_CALL(*this, OnDecodeCompleted(IsNull()));
	worker_->Decode(
	std::move(encoded_data), kVisibleSize,
	base::BindOnce(&VaapiImageDecodeAcceleratorWorkerTest::OnDecodeCompleted,
	base::Unretained(this)));
	task_environment_.RunUntilIdle();
	}

	} // namespace media