chrome/browser/media_galleries/fileapi/media_file_validator_browsertest.cc - chromium/src.git - Git at Google

 // Copyright 2013 The Chromium Authors
 // 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 <utility>

 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/functional/bind.h"
 #include "base/functional/callback_helpers.h"
 #include "base/location.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/task/task_traits.h"
 #include "base/task/thread_pool.h"
 #include "build/build_config.h"
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/browser_test.h"
 #include "storage/browser/file_system/copy_or_move_file_validator.h"
 #include "storage/browser/file_system/copy_or_move_hook_delegate.h"
 #include "storage/browser/file_system/file_system_backend.h"
 #include "storage/browser/file_system/file_system_context.h"
 #include "storage/browser/file_system/file_system_operation_runner.h"
 #include "storage/browser/file_system/file_system_url.h"
 #include "storage/browser/file_system/isolated_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/test/test_file_system_backend.h"
 #include "storage/browser/test/test_file_system_context.h"
 #include "storage/common/file_system/file_system_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/common/storage_key/storage_key.h"
 #include "url/gurl.h"
 #include "url/origin.h"

 namespace {

 const char kOrigin[] = "http://foo";

 const char kValidImage[] = "RIFF0\0\0\0WEBPVP8 $\0\0\0\xB2\x02\0\x9D\x01\x2A"
                            "\x01\0\x01\0\x2F\x9D\xCE\xE7s\xA8((((\x01\x9CK(\0"
                            "\x05\xCE\xB3l\0\0\xFE\xD8\x80\0\0";

 const char kInvalidMediaFile[] = "Not a media file";

 const int64_t kNoFileSize = -1;

 void HandleCheckFileResult(int64_t expected_size,
                            base::OnceCallback<void(bool success)> callback,
                            base::File::Error result,
                            const base::File::Info& file_info) {
   if (result == base::File::FILE_OK) {
     if (!file_info.is_directory && expected_size != kNoFileSize &&
         file_info.size == expected_size) {
       std::move(callback).Run(true);
       return;
     }
   }

   std::move(callback).Run(expected_size == kNoFileSize);
 }

 base::FilePath GetMediaTestDir() {
   base::FilePath test_file;
   if (!base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &test_file)) {
     return base::FilePath();
   }
   return test_file.AppendASCII("media").AppendASCII("test").AppendASCII("data");
 }

 }  // namespace

 class MediaFileValidatorTest : public InProcessBrowserTest {
  public:
   MediaFileValidatorTest() : test_file_size_(0) {}

   MediaFileValidatorTest(const MediaFileValidatorTest&) = delete;
   MediaFileValidatorTest& operator=(const MediaFileValidatorTest&) = delete;

   ~MediaFileValidatorTest() override = default;

   // Write |content| into |filename| in a test file system and try to move
   // it into a media file system.  The result is compared to |expected_result|.
   void MoveTest(const std::string& filename, const std::string& content,
                 bool expected_result) {
     base::RunLoop run_loop;
     quit_closure_ = run_loop.QuitClosure();
     base::ThreadPool::PostTask(
         FROM_HERE, {base::MayBlock()},
         base::BindOnce(&MediaFileValidatorTest::SetupBlocking,
                        base::Unretained(this), filename, content,
                        expected_result));
     run_loop.Run();
   }

   // Write |source| into |filename| in a test file system and try to move it
   // into a media file system.  The result is compared to |expected_result|.
   void MoveTestFromFile(const std::string& filename,
                         const base::FilePath& source, bool expected_result) {
     base::RunLoop run_loop;
     quit_closure_ = run_loop.QuitClosure();
     base::ThreadPool::PostTask(
         FROM_HERE, {base::MayBlock()},
         base::BindOnce(&MediaFileValidatorTest::SetupFromFileBlocking,
                        base::Unretained(this), filename, source,
                        expected_result));
     run_loop.Run();
   }

  private:
   // BrowserTestBase interface.
   void PostRunTestOnMainThread() override {
     // Trigger release of the FileSystemContext before the IO thread is gone,
     // so it can teardown there correctly.
     file_system_context_ = nullptr;
     InProcessBrowserTest::PostRunTestOnMainThread();
   }

   // Create the test files, filesystem objects, etc.
   void SetupBlocking(const std::string& filename,
                      const std::string& content,
                      bool expected_result) {
     ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
     base::FilePath base = base_dir_.GetPath();
     base::FilePath src_path = base.AppendASCII("src_fs");
     ASSERT_TRUE(base::CreateDirectory(src_path));

     std::vector<std::unique_ptr<storage::FileSystemBackend>>
         additional_providers;
     file_system_runner_ =
         base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
     additional_providers.push_back(
         std::make_unique<storage::TestFileSystemBackend>(
             file_system_runner_.get(), src_path));
     additional_providers.push_back(
         std::make_unique<MediaFileSystemBackend>(base, base::NullCallback()));
     file_system_context_ =
         storage::CreateFileSystemContextWithAdditionalProvidersForTesting(
             content::GetIOThreadTaskRunner({}), file_system_runner_,
             /*quota_manager_proxy=*/nullptr, std::move(additional_providers),
             base);

     move_src_ = file_system_context_->CreateCrackedFileSystemURL(
         blink::StorageKey::CreateFromStringForTesting(kOrigin),
         storage::kFileSystemTypeTest, base::FilePath::FromUTF8Unsafe(filename));

     test_file_size_ = content.size();
     base::FilePath test_file = src_path.AppendASCII(filename);
     ASSERT_TRUE(base::WriteFile(test_file, content));

     base::FilePath dest_path = base.AppendASCII("dest_fs");
     ASSERT_TRUE(base::CreateDirectory(dest_path));
     dest_fs_ =
         storage::IsolatedContext::GetInstance()->RegisterFileSystemForPath(
             storage::kFileSystemTypeLocalMedia, std::string(), dest_path,
             nullptr);

     size_t extension_index = filename.find_last_of(".");
     ASSERT_NE(std::string::npos, extension_index);
     std::string extension = filename.substr(extension_index);
     std::string dest_root_fs_url = storage::GetIsolatedFileSystemRootURIString(
         GURL(kOrigin), dest_fs_.id(), "dest_fs/");
     const GURL crack_url = GURL(dest_root_fs_url + "move_dest" + extension);
     move_dest_ = file_system_context_->CrackURLInFirstPartyContext(crack_url);

     content::GetIOThreadTaskRunner({})->PostTask(
         FROM_HERE,
         base::BindOnce(
             &MediaFileValidatorTest::CheckFiles, base::Unretained(this), true,
             base::BindOnce(&MediaFileValidatorTest::OnTestFilesReady,
                            base::Unretained(this), expected_result)));
   }

   void SetupFromFileBlocking(const std::string& filename,
                              const base::FilePath& source,
                              bool expected_result) {
     std::string content;
     ASSERT_TRUE(base::ReadFileToString(source, &content));
     SetupBlocking(filename, content, expected_result);
   }

   // Check that exactly one of |move_src_| and |move_dest_| exists.
   // |src_expected| indicates which one should exist.  When complete,
   // |callback| is called with success/failure.
   void CheckFiles(bool src_expected,
                   base::OnceCallback<void(bool success)> callback) {
     CheckFile(move_src_, src_expected ? test_file_size_ : kNoFileSize,
               base::BindOnce(&MediaFileValidatorTest::OnCheckFilesFirstResult,
                              base::Unretained(this), !src_expected,
                              std::move(callback)));
   }

   // Helper that checks a file has the |expected_size|, which may be
   // |kNoFileSize| if the file should not exist.  |callback| is called
   // with success/failure.
   void CheckFile(storage::FileSystemURL url,
                  int64_t expected_size,
                  base::OnceCallback<void(bool success)> callback) {
     operation_runner()->GetMetadata(
         url, {storage::FileSystemOperation::GetMetadataField::kSize},
         base::BindOnce(&HandleCheckFileResult, expected_size,
                        std::move(callback)));
   }

   // Helper that checks the result of |move_src_| lookup and then checks
   // |move_dest_| if all is as expected.
   void OnCheckFilesFirstResult(bool dest_expected,
                                base::OnceCallback<void(bool)> callback,
                                bool src_result) {
     EXPECT_TRUE(src_result);
     if (!src_result) {
       std::move(callback).Run(false);
       return;
     }
     CheckFile(move_dest_, dest_expected ? test_file_size_ : kNoFileSize,
               std::move(callback));
   }

   // Assert |test_files_ready| and then do the actual test of moving
   // |move_src_| to |move_dest_|.
   void OnTestFilesReady(bool expected_result, bool test_files_ready) {
     ASSERT_TRUE(test_files_ready);
     operation_runner()->Move(
         move_src_, move_dest_,
         storage::FileSystemOperation::CopyOrMoveOptionSet(),
         storage::FileSystemOperation::ERROR_BEHAVIOR_ABORT,
         std::make_unique<storage::CopyOrMoveHookDelegate>(),
         base::BindOnce(&MediaFileValidatorTest::OnMoveResult,
                        base::Unretained(this), expected_result));
   }

   // Check that the move succeeded/failed based on expectation and then
   // check that the right file exists.
   void OnMoveResult(bool expected_result, base::File::Error result) {
     if (expected_result)
       EXPECT_EQ(base::File::FILE_OK, result);
     else
       EXPECT_EQ(base::File::FILE_ERROR_SECURITY, result);
     CheckFiles(!expected_result,
                base::BindOnce(&MediaFileValidatorTest::OnTestFilesCheckResult,
                               base::Unretained(this)));
   }

   // Check that the correct test file exists and then allow the main-thread
   // RunLoop to quit.
   void OnTestFilesCheckResult(bool result) {
     EXPECT_TRUE(result);
     std::move(quit_closure_).Run();
   }

   storage::FileSystemOperationRunner* operation_runner() {
     return file_system_context_->operation_runner();
   }

   base::ScopedTempDir base_dir_;

   scoped_refptr<storage::FileSystemContext> file_system_context_;

   int test_file_size_;

   storage::FileSystemURL move_src_;
   storage::FileSystemURL move_dest_;
   storage::IsolatedContext::ScopedFSHandle dest_fs_;

   base::OnceClosure quit_closure_;
   scoped_refptr<base::SequencedTaskRunner> file_system_runner_;
 };

 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, UnsupportedExtension) {
   MoveTest("a.txt", std::string(kValidImage, std::size(kValidImage)), false);
 }

 // TODO(crbug.com/40744004): Re-enable. Flaky on Linux.
 #if BUILDFLAG(IS_LINUX)
 #define MAYBE_ValidImage DISABLED_ValidImage
 #else
 #define MAYBE_ValidImage ValidImage
 #endif
 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, MAYBE_ValidImage) {
   MoveTest("a.webp", std::string(kValidImage, std::size(kValidImage)), true);
 }

 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, InvalidImage) {
   MoveTest("a.webp",
            std::string(kInvalidMediaFile, std::size(kInvalidMediaFile)), false);
 }

 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, InvalidAudio) {
   MoveTest("a.ogg",
            std::string(kInvalidMediaFile, std::size(kInvalidMediaFile)), false);
 }

 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, ValidAudio) {
   base::FilePath test_file = GetMediaTestDir();
   ASSERT_FALSE(test_file.empty());
   test_file = test_file.AppendASCII("sfx.ogg");
   MoveTestFromFile("sfx.ogg", test_file, true);
 }

 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, InvalidVideo) {
   base::FilePath test_file = GetMediaTestDir();
   ASSERT_FALSE(test_file.empty());
   test_file = test_file.AppendASCII("no_streams.webm");
   MoveTestFromFile("no_streams.webm", test_file, false);
 }

 IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, ValidVideo) {
   base::FilePath test_file = GetMediaTestDir();
   ASSERT_FALSE(test_file.empty());
   test_file = test_file.AppendASCII("bear-320x240-multitrack.webm");
   MoveTestFromFile("multitrack.webm", test_file, true);
 }
	// Copyright 2013 The Chromium Authors
	// 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 <utility>

	#include "base/files/file_path.h"
	#include "base/files/file_util.h"
	#include "base/files/scoped_temp_dir.h"
	#include "base/functional/bind.h"
	#include "base/functional/callback_helpers.h"
	#include "base/location.h"
	#include "base/path_service.h"
	#include "base/run_loop.h"
	#include "base/task/sequenced_task_runner.h"
	#include "base/task/task_traits.h"
	#include "base/task/thread_pool.h"
	#include "build/build_config.h"
	#include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
	#include "chrome/test/base/in_process_browser_test.h"
	#include "content/public/browser/browser_task_traits.h"
	#include "content/public/browser/browser_thread.h"
	#include "content/public/test/browser_test.h"
	#include "storage/browser/file_system/copy_or_move_file_validator.h"
	#include "storage/browser/file_system/copy_or_move_hook_delegate.h"
	#include "storage/browser/file_system/file_system_backend.h"
	#include "storage/browser/file_system/file_system_context.h"
	#include "storage/browser/file_system/file_system_operation_runner.h"
	#include "storage/browser/file_system/file_system_url.h"
	#include "storage/browser/file_system/isolated_context.h"
	#include "storage/browser/quota/quota_manager_proxy.h"
	#include "storage/browser/test/test_file_system_backend.h"
	#include "storage/browser/test/test_file_system_context.h"
	#include "storage/common/file_system/file_system_types.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/blink/public/common/storage_key/storage_key.h"
	#include "url/gurl.h"
	#include "url/origin.h"

	namespace {

	const char kOrigin[] = "http://foo";

	const char kValidImage[] = "RIFF0\0\0\0WEBPVP8 $\0\0\0\xB2\x02\0\x9D\x01\x2A"
	"\x01\0\x01\0\x2F\x9D\xCE\xE7s\xA8((((\x01\x9CK(\0"
	"\x05\xCE\xB3l\0\0\xFE\xD8\x80\0\0";

	const char kInvalidMediaFile[] = "Not a media file";

	const int64_t kNoFileSize = -1;

	void HandleCheckFileResult(int64_t expected_size,
	base::OnceCallback<void(bool success)> callback,
	base::File::Error result,
	const base::File::Info& file_info) {
	if (result == base::File::FILE_OK) {
	if (!file_info.is_directory && expected_size != kNoFileSize &&
	file_info.size == expected_size) {
	std::move(callback).Run(true);
	return;
	}
	}

	std::move(callback).Run(expected_size == kNoFileSize);
	}

	base::FilePath GetMediaTestDir() {
	base::FilePath test_file;
	if (!base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &test_file)) {
	return base::FilePath();
	}
	return test_file.AppendASCII("media").AppendASCII("test").AppendASCII("data");
	}

	} // namespace

	class MediaFileValidatorTest : public InProcessBrowserTest {
	public:
	MediaFileValidatorTest() : test_file_size_(0) {}

	MediaFileValidatorTest(const MediaFileValidatorTest&) = delete;
	MediaFileValidatorTest& operator=(const MediaFileValidatorTest&) = delete;

	~MediaFileValidatorTest() override = default;

	// Write \|content\| into \|filename\| in a test file system and try to move
	// it into a media file system. The result is compared to \|expected_result\|.
	void MoveTest(const std::string& filename, const std::string& content,
	bool expected_result) {
	base::RunLoop run_loop;
	quit_closure_ = run_loop.QuitClosure();
	base::ThreadPool::PostTask(
	FROM_HERE, {base::MayBlock()},
	base::BindOnce(&MediaFileValidatorTest::SetupBlocking,
	base::Unretained(this), filename, content,
	expected_result));
	run_loop.Run();
	}

	// Write \|source\| into \|filename\| in a test file system and try to move it
	// into a media file system. The result is compared to \|expected_result\|.
	void MoveTestFromFile(const std::string& filename,
	const base::FilePath& source, bool expected_result) {
	base::RunLoop run_loop;
	quit_closure_ = run_loop.QuitClosure();
	base::ThreadPool::PostTask(
	FROM_HERE, {base::MayBlock()},
	base::BindOnce(&MediaFileValidatorTest::SetupFromFileBlocking,
	base::Unretained(this), filename, source,
	expected_result));
	run_loop.Run();
	}

	private:
	// BrowserTestBase interface.
	void PostRunTestOnMainThread() override {
	// Trigger release of the FileSystemContext before the IO thread is gone,
	// so it can teardown there correctly.
	file_system_context_ = nullptr;
	InProcessBrowserTest::PostRunTestOnMainThread();
	}

	// Create the test files, filesystem objects, etc.
	void SetupBlocking(const std::string& filename,
	const std::string& content,
	bool expected_result) {
	ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
	base::FilePath base = base_dir_.GetPath();
	base::FilePath src_path = base.AppendASCII("src_fs");
	ASSERT_TRUE(base::CreateDirectory(src_path));

	std::vector<std::unique_ptr<storage::FileSystemBackend>>
	additional_providers;
	file_system_runner_ =
	base::ThreadPool::CreateSequencedTaskRunner({base::MayBlock()});
	additional_providers.push_back(
	std::make_unique<storage::TestFileSystemBackend>(
	file_system_runner_.get(), src_path));
	additional_providers.push_back(
	std::make_unique<MediaFileSystemBackend>(base, base::NullCallback()));
	file_system_context_ =
	storage::CreateFileSystemContextWithAdditionalProvidersForTesting(
	content::GetIOThreadTaskRunner({}), file_system_runner_,
	/quota_manager_proxy=/nullptr, std::move(additional_providers),
	base);

	move_src_ = file_system_context_->CreateCrackedFileSystemURL(
	blink::StorageKey::CreateFromStringForTesting(kOrigin),
	storage::kFileSystemTypeTest, base::FilePath::FromUTF8Unsafe(filename));

	test_file_size_ = content.size();
	base::FilePath test_file = src_path.AppendASCII(filename);
	ASSERT_TRUE(base::WriteFile(test_file, content));

	base::FilePath dest_path = base.AppendASCII("dest_fs");
	ASSERT_TRUE(base::CreateDirectory(dest_path));
	dest_fs_ =
	storage::IsolatedContext::GetInstance()->RegisterFileSystemForPath(
	storage::kFileSystemTypeLocalMedia, std::string(), dest_path,
	nullptr);

	size_t extension_index = filename.find_last_of(".");
	ASSERT_NE(std::string::npos, extension_index);
	std::string extension = filename.substr(extension_index);
	std::string dest_root_fs_url = storage::GetIsolatedFileSystemRootURIString(
	GURL(kOrigin), dest_fs_.id(), "dest_fs/");
	const GURL crack_url = GURL(dest_root_fs_url + "move_dest" + extension);
	move_dest_ = file_system_context_->CrackURLInFirstPartyContext(crack_url);

	content::GetIOThreadTaskRunner({})->PostTask(
	FROM_HERE,
	base::BindOnce(
	&MediaFileValidatorTest::CheckFiles, base::Unretained(this), true,
	base::BindOnce(&MediaFileValidatorTest::OnTestFilesReady,
	base::Unretained(this), expected_result)));
	}

	void SetupFromFileBlocking(const std::string& filename,
	const base::FilePath& source,
	bool expected_result) {
	std::string content;
	ASSERT_TRUE(base::ReadFileToString(source, &content));
	SetupBlocking(filename, content, expected_result);
	}

	// Check that exactly one of \|move_src_\| and \|move_dest_\| exists.
	// \|src_expected\| indicates which one should exist. When complete,
	// \|callback\| is called with success/failure.
	void CheckFiles(bool src_expected,
	base::OnceCallback<void(bool success)> callback) {
	CheckFile(move_src_, src_expected ? test_file_size_ : kNoFileSize,
	base::BindOnce(&MediaFileValidatorTest::OnCheckFilesFirstResult,
	base::Unretained(this), !src_expected,
	std::move(callback)));
	}

	// Helper that checks a file has the \|expected_size\|, which may be
	// \|kNoFileSize\| if the file should not exist. \|callback\| is called
	// with success/failure.
	void CheckFile(storage::FileSystemURL url,
	int64_t expected_size,
	base::OnceCallback<void(bool success)> callback) {
	operation_runner()->GetMetadata(
	url, {storage::FileSystemOperation::GetMetadataField::kSize},
	base::BindOnce(&HandleCheckFileResult, expected_size,
	std::move(callback)));
	}

	// Helper that checks the result of \|move_src_\| lookup and then checks
	// \|move_dest_\| if all is as expected.
	void OnCheckFilesFirstResult(bool dest_expected,
	base::OnceCallback<void(bool)> callback,
	bool src_result) {
	EXPECT_TRUE(src_result);
	if (!src_result) {
	std::move(callback).Run(false);
	return;
	}
	CheckFile(move_dest_, dest_expected ? test_file_size_ : kNoFileSize,
	std::move(callback));
	}

	// Assert \|test_files_ready\| and then do the actual test of moving
	// \|move_src_\| to \|move_dest_\|.
	void OnTestFilesReady(bool expected_result, bool test_files_ready) {
	ASSERT_TRUE(test_files_ready);
	operation_runner()->Move(
	move_src_, move_dest_,
	storage::FileSystemOperation::CopyOrMoveOptionSet(),
	storage::FileSystemOperation::ERROR_BEHAVIOR_ABORT,
	std::make_unique<storage::CopyOrMoveHookDelegate>(),
	base::BindOnce(&MediaFileValidatorTest::OnMoveResult,
	base::Unretained(this), expected_result));
	}

	// Check that the move succeeded/failed based on expectation and then
	// check that the right file exists.
	void OnMoveResult(bool expected_result, base::File::Error result) {
	if (expected_result)
	EXPECT_EQ(base::File::FILE_OK, result);
	else
	EXPECT_EQ(base::File::FILE_ERROR_SECURITY, result);
	CheckFiles(!expected_result,
	base::BindOnce(&MediaFileValidatorTest::OnTestFilesCheckResult,
	base::Unretained(this)));
	}

	// Check that the correct test file exists and then allow the main-thread
	// RunLoop to quit.
	void OnTestFilesCheckResult(bool result) {
	EXPECT_TRUE(result);
	std::move(quit_closure_).Run();
	}

	storage::FileSystemOperationRunner* operation_runner() {
	return file_system_context_->operation_runner();
	}

	base::ScopedTempDir base_dir_;

	scoped_refptr<storage::FileSystemContext> file_system_context_;

	int test_file_size_;

	storage::FileSystemURL move_src_;
	storage::FileSystemURL move_dest_;
	storage::IsolatedContext::ScopedFSHandle dest_fs_;

	base::OnceClosure quit_closure_;
	scoped_refptr<base::SequencedTaskRunner> file_system_runner_;
	};

	IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, UnsupportedExtension) {
	MoveTest("a.txt", std::string(kValidImage, std::size(kValidImage)), false);
	}

	// TODO(crbug.com/40744004): Re-enable. Flaky on Linux.
	#if BUILDFLAG(IS_LINUX)
	#define MAYBE_ValidImage DISABLED_ValidImage
	#else
	#define MAYBE_ValidImage ValidImage
	#endif
	IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, MAYBE_ValidImage) {
	MoveTest("a.webp", std::string(kValidImage, std::size(kValidImage)), true);
	}

	IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, InvalidImage) {
	MoveTest("a.webp",
	std::string(kInvalidMediaFile, std::size(kInvalidMediaFile)), false);
	}

	IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, InvalidAudio) {
	MoveTest("a.ogg",
	std::string(kInvalidMediaFile, std::size(kInvalidMediaFile)), false);
	}

	IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, ValidAudio) {
	base::FilePath test_file = GetMediaTestDir();
	ASSERT_FALSE(test_file.empty());
	test_file = test_file.AppendASCII("sfx.ogg");
	MoveTestFromFile("sfx.ogg", test_file, true);
	}

	IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, InvalidVideo) {
	base::FilePath test_file = GetMediaTestDir();
	ASSERT_FALSE(test_file.empty());
	test_file = test_file.AppendASCII("no_streams.webm");
	MoveTestFromFile("no_streams.webm", test_file, false);
	}

	IN_PROC_BROWSER_TEST_F(MediaFileValidatorTest, ValidVideo) {
	base::FilePath test_file = GetMediaTestDir();
	ASSERT_FALSE(test_file.empty());
	test_file = test_file.AppendASCII("bear-320x240-multitrack.webm");
	MoveTestFromFile("multitrack.webm", test_file, true);
	}