blob: babb4b03aa90f4771b0a6919b0e9a289a5044cd6 [file] [log] [blame]
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <map>
#include <memory>
#include "base/bind.h"
#include "base/callback.h"
#include "base/callback_helpers.h"
#include "base/check.h"
#include "base/files/file_path.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/simple_test_clock.h"
#include "base/test/task_environment.h"
#include "components/leveldb_proto/testing/fake_db.h"
#include "media/base/media_switches.h"
#include "media/base/test_data_util.h"
#include "media/base/video_codecs.h"
#include "media/capabilities/webrtc_video_stats.pb.h"
#include "media/capabilities/webrtc_video_stats_db_impl.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/gfx/geometry/size.h"
using leveldb_proto::test::FakeDB;
using testing::_;
using testing::Eq;
using testing::Pointee;
namespace media {
class WebrtcVideoStatsDBImplTest : public ::testing::Test {
public:
using VideoDescKey = WebrtcVideoStatsDB::VideoDescKey;
using VideoStats = WebrtcVideoStatsDB::VideoStats;
using VideoStatsEntry = WebrtcVideoStatsDB::VideoStatsEntry;
WebrtcVideoStatsDBImplTest()
: kDecodeStatsKeyVp9(
VideoDescKey::MakeBucketedKey(/*is_decode_stats=*/true,
VP9PROFILE_PROFILE3,
/*hardware_accelerated=*/false,
1280 * 720)),
kDecodeStatsKeyVp9Hw(
VideoDescKey::MakeBucketedKey(/*is_decode_stats=*/true,
VP9PROFILE_PROFILE3,
/*hardware_accelerated=*/true,
1280 * 720)),
kDecodeStatsKeyVp9FullHd(
VideoDescKey::MakeBucketedKey(/*is_decode_stats=*/true,
VP9PROFILE_PROFILE3,
/*hardware_accelerated=*/false,
1920 * 1080)),
kDecodeStatsKeyVp94K(
VideoDescKey::MakeBucketedKey(/*is_decode_stats=*/true,
VP9PROFILE_PROFILE3,
/*hardware_accelerated=*/false,
3840 * 2160)),
kDecodeStatsKeyH264(
VideoDescKey::MakeBucketedKey(/*is_decode_stats=*/true,
H264PROFILE_MIN,
/*hardware_accelerated=*/false,
1920 * 1080)),
kEncodeStatsKeyVp9(
VideoDescKey::MakeBucketedKey(/*is_decode_stats=*/false,
VP9PROFILE_PROFILE3,
/*hardware_accelerated=*/false,
1280 * 720)) {
// Fake DB simply wraps a std::map with the LevelDB interface. We own the
// map and will delete it in TearDown().
fake_db_map_ =
std::make_unique<FakeDB<WebrtcVideoStatsEntryProto>::EntryMap>();
// `stats_db_` will own this pointer, but we hold a reference to control
// its behavior.
fake_db_ = new FakeDB<WebrtcVideoStatsEntryProto>(fake_db_map_.get());
// Wrap the fake proto DB with our interface.
stats_db_ = base::WrapUnique(new WebrtcVideoStatsDBImpl(
std::unique_ptr<FakeDB<WebrtcVideoStatsEntryProto>>(fake_db_)));
}
WebrtcVideoStatsDBImplTest(const WebrtcVideoStatsDBImplTest&) = delete;
WebrtcVideoStatsDBImplTest& operator=(const WebrtcVideoStatsDBImplTest&) =
delete;
~WebrtcVideoStatsDBImplTest() override {
// Tests should always complete any pending operations
VerifyNoPendingOps();
}
void VerifyOnePendingOp(std::string op_name) {
EXPECT_EQ(stats_db_->pending_operations_.get_pending_ops_for_test().size(),
1u);
PendingOperations::PendingOperation* pending_op =
stats_db_->pending_operations_.get_pending_ops_for_test()
.begin()
->second.get();
EXPECT_EQ(pending_op->uma_str_, op_name);
}
void VerifyNoPendingOps() {
EXPECT_TRUE(
stats_db_->pending_operations_.get_pending_ops_for_test().empty());
}
base::TimeDelta GetMaxTimeToKeepStats() {
return WebrtcVideoStatsDBImpl::GetMaxTimeToKeepStats();
}
int GetMaxEntriesPerConfig() {
return WebrtcVideoStatsDBImpl::GetMaxEntriesPerConfig();
}
void SetDBClock(base::Clock* clock) {
stats_db_->set_wall_clock_for_test(clock);
}
void InitializeDB() {
stats_db_->Initialize(base::BindOnce(
&WebrtcVideoStatsDBImplTest::OnInitialize, base::Unretained(this)));
EXPECT_CALL(*this, OnInitialize(true));
fake_db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
testing::Mock::VerifyAndClearExpectations(this);
}
void AppendStats(const VideoDescKey& key, const VideoStats& entry) {
EXPECT_CALL(*this, MockAppendVideoStatsCb(true));
stats_db_->AppendVideoStats(
key, entry,
base::BindOnce(&WebrtcVideoStatsDBImplTest::MockAppendVideoStatsCb,
base::Unretained(this)));
VerifyOnePendingOp("Read");
fake_db_->GetCallback(true);
VerifyOnePendingOp("Write");
fake_db_->UpdateCallback(true);
testing::Mock::VerifyAndClearExpectations(this);
}
void VerifyReadStats(const VideoDescKey& key,
const VideoStatsEntry& expected) {
EXPECT_CALL(*this,
MockGetVideoStatsCb(true, absl::make_optional(expected)));
stats_db_->GetVideoStats(
key, base::BindOnce(&WebrtcVideoStatsDBImplTest::MockGetVideoStatsCb,
base::Unretained(this)));
VerifyOnePendingOp("Read");
fake_db_->GetCallback(true);
testing::Mock::VerifyAndClearExpectations(this);
}
void VerifyReadStatsCollection(
const VideoDescKey& key,
const WebrtcVideoStatsDB::VideoStatsCollection& expected) {
EXPECT_CALL(*this, MockGetVideoStatsCollectionCb(
true, absl::make_optional(expected)));
stats_db_->GetVideoStatsCollection(
key, base::BindOnce(
&WebrtcVideoStatsDBImplTest::MockGetVideoStatsCollectionCb,
base::Unretained(this)));
VerifyOnePendingOp("Read");
fake_db_->LoadCallback(true);
testing::Mock::VerifyAndClearExpectations(this);
}
void VerifyEmptyStats(const VideoDescKey& key) {
EXPECT_CALL(*this,
MockGetVideoStatsCb(true, absl::optional<VideoStatsEntry>()));
stats_db_->GetVideoStats(
key, base::BindOnce(&WebrtcVideoStatsDBImplTest::MockGetVideoStatsCb,
base::Unretained(this)));
VerifyOnePendingOp("Read");
fake_db_->GetCallback(true);
testing::Mock::VerifyAndClearExpectations(this);
}
void AppendToProtoDB(const VideoDescKey& key,
const WebrtcVideoStatsEntryProto* const proto) {
base::RunLoop run_loop;
base::OnceCallback<void(bool)> update_done_cb = base::BindOnce(
[](base::RunLoop* run_loop, bool success) {
ASSERT_TRUE(success);
run_loop->Quit();
},
Unretained(&run_loop));
using DBType = leveldb_proto::ProtoDatabase<WebrtcVideoStatsEntryProto>;
std::unique_ptr<DBType::KeyEntryVector> entries =
std::make_unique<DBType::KeyEntryVector>();
entries->emplace_back(key.Serialize(), *proto);
fake_db_->UpdateEntries(std::move(entries),
std::make_unique<leveldb_proto::KeyVector>(),
std::move(update_done_cb));
fake_db_->UpdateCallback(true);
run_loop.Run();
}
MOCK_METHOD1(OnInitialize, void(bool success));
MOCK_METHOD2(MockGetVideoStatsCb,
void(bool success, absl::optional<VideoStatsEntry> entry));
MOCK_METHOD2(MockGetVideoStatsCollectionCb,
void(bool success,
absl::optional<WebrtcVideoStatsDB::VideoStatsCollection>
collection));
MOCK_METHOD1(MockAppendVideoStatsCb, void(bool success));
MOCK_METHOD0(MockClearStatsCb, void());
protected:
base::test::TaskEnvironment task_environment_{
base::test::TaskEnvironment::TimeSource::MOCK_TIME};
const VideoDescKey kDecodeStatsKeyVp9;
const VideoDescKey kDecodeStatsKeyVp9Hw;
const VideoDescKey kDecodeStatsKeyVp9FullHd;
const VideoDescKey kDecodeStatsKeyVp94K;
const VideoDescKey kDecodeStatsKeyH264;
const VideoDescKey kEncodeStatsKeyVp9;
// See documentation in SetUp()
std::unique_ptr<FakeDB<WebrtcVideoStatsEntryProto>::EntryMap> fake_db_map_;
raw_ptr<FakeDB<WebrtcVideoStatsEntryProto>> fake_db_;
std::unique_ptr<WebrtcVideoStatsDBImpl> stats_db_;
};
TEST_F(WebrtcVideoStatsDBImplTest, InitializeFailed) {
stats_db_->Initialize(base::BindOnce(
&WebrtcVideoStatsDBImplTest::OnInitialize, base::Unretained(this)));
EXPECT_CALL(*this, OnInitialize(false));
fake_db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kError);
}
TEST_F(WebrtcVideoStatsDBImplTest, InitializeTimedOut) {
// Queue up an Initialize.
stats_db_->Initialize(base::BindOnce(
&WebrtcVideoStatsDBImplTest::OnInitialize, base::Unretained(this)));
VerifyOnePendingOp("Initialize");
// Move time forward enough to trigger timeout.
EXPECT_CALL(*this, OnInitialize(_)).Times(0);
task_environment_.FastForwardBy(base::Seconds(100));
task_environment_.RunUntilIdle();
// Verify we didn't get an init callback and task is no longer considered
// pending (because it timed out).
testing::Mock::VerifyAndClearExpectations(this);
VerifyNoPendingOps();
// Verify callback still works if init completes very late.
EXPECT_CALL(*this, OnInitialize(false));
fake_db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kError);
}
TEST_F(WebrtcVideoStatsDBImplTest, ReadExpectingNothing) {
InitializeDB();
VerifyEmptyStats(kDecodeStatsKeyVp9);
}
TEST_F(WebrtcVideoStatsDBImplTest, WriteReadAndClear) {
InitializeDB();
// Set test clock.
base::SimpleTestClock clock;
SetDBClock(&clock);
clock.SetNow(base::Time::Now());
// Append and read back some VP9 stats.
VideoStats stats1(clock.Now().ToJsTimeIgnoringNull(), 240, 6, 7.2);
VideoStatsEntry entry{stats1};
AppendStats(kDecodeStatsKeyVp9, stats1);
VerifyReadStats(kDecodeStatsKeyVp9, entry);
// Reading with the wrong key (different codec) should still return nothing.
VerifyEmptyStats(kDecodeStatsKeyH264);
VerifyEmptyStats(kEncodeStatsKeyVp9);
// Appending new VP9 stats.
clock.Advance(base::Hours(1));
VideoStats stats2(clock.Now().ToJsTimeIgnoringNull(), 1000, 14, 6.8);
AppendStats(kDecodeStatsKeyVp9, stats2);
VideoStatsEntry aggregate_entry{stats2, stats1};
VerifyReadStats(kDecodeStatsKeyVp9, aggregate_entry);
// Clear all stats from the DB.
EXPECT_CALL(*this, MockClearStatsCb);
stats_db_->ClearStats(base::BindOnce(
&WebrtcVideoStatsDBImplTest::MockClearStatsCb, base::Unretained(this)));
VerifyOnePendingOp("Clear");
fake_db_->UpdateCallback(true);
// Database is now empty. Expect null entry.
VerifyEmptyStats(kDecodeStatsKeyVp9);
}
TEST_F(WebrtcVideoStatsDBImplTest, ExpiredStatsAreNotReturned) {
InitializeDB();
// Set test clock.
base::SimpleTestClock clock;
SetDBClock(&clock);
clock.SetNow(base::Time::Now());
// Append and read back some VP9 stats.
VideoStats stats1(clock.Now().ToJsTimeIgnoringNull(), 240, 6, 7.2);
VideoStatsEntry entry{stats1};
AppendStats(kDecodeStatsKeyVp9, stats1);
VerifyReadStats(kDecodeStatsKeyVp9, entry);
// Appending new VP9 stats.
clock.Advance(base::Days(2));
VideoStats stats2(clock.Now().ToJsTimeIgnoringNull(), 1000, 14, 6.8);
clock.SetNow(base::Time::FromJsTime(stats2.timestamp));
AppendStats(kDecodeStatsKeyVp9, stats2);
VideoStatsEntry aggregate_entry{stats2, stats1};
VerifyReadStats(kDecodeStatsKeyVp9, aggregate_entry);
// Set the clock to a date so that the first entry is expired.
clock.SetNow(base::Time::FromJsTime(stats1.timestamp) + base::Days(1) +
GetMaxTimeToKeepStats());
VideoStatsEntry nonexpired_entry{stats2};
VerifyReadStats(kDecodeStatsKeyVp9, nonexpired_entry);
// Set the clock so that all data have expired.
clock.SetNow(base::Time::FromJsTime(stats2.timestamp) + base::Days(1) +
GetMaxTimeToKeepStats());
// All stats are expired. Expect null entry.
VerifyEmptyStats(kDecodeStatsKeyVp9);
}
TEST_F(WebrtcVideoStatsDBImplTest, ConfigureExpireDays) {
base::test::ScopedFeatureList scoped_feature_list;
std::unique_ptr<base::FieldTrialList> field_trial_list;
base::TimeDelta previous_max_days_to_keep_stats = GetMaxTimeToKeepStats();
constexpr int kNewMaxDaysToKeepStats = 4;
ASSERT_LT(base::Days(kNewMaxDaysToKeepStats),
previous_max_days_to_keep_stats);
// Override field trial.
base::FieldTrialParams params;
params["db_days_to_keep_stats"] =
base::NumberToString(kNewMaxDaysToKeepStats);
scoped_feature_list.InitAndEnableFeatureWithParameters(
media::kWebrtcMediaCapabilitiesParameters, params);
EXPECT_EQ(base::Days(kNewMaxDaysToKeepStats), GetMaxTimeToKeepStats());
InitializeDB();
// Inject a test clock and initialize with the current time.
base::SimpleTestClock clock;
SetDBClock(&clock);
clock.SetNow(base::Time::Now());
// Append and verify read-back.
VideoStats stats1(clock.Now().ToJsTimeIgnoringNull(), 240, 6, 7.2);
VideoStatsEntry entry{stats1};
AppendStats(kDecodeStatsKeyVp9, stats1);
VerifyReadStats(kDecodeStatsKeyVp9, entry);
// Some simple math to avoid troubles of integer division.
int half_days_to_keep_stats = kNewMaxDaysToKeepStats / 2;
int remaining_days_to_keep_stats =
kNewMaxDaysToKeepStats - half_days_to_keep_stats;
// Advance time half way through grace period. Verify stats not expired.
clock.Advance(base::Days(half_days_to_keep_stats));
VerifyReadStats(kDecodeStatsKeyVp9, entry);
// Advance time 1 day beyond grace period, verify stats are expired.
clock.Advance(base::Days(remaining_days_to_keep_stats + 1));
VerifyEmptyStats(kDecodeStatsKeyVp9);
// Advance the clock 100 extra days. Verify stats still expired.
clock.Advance(base::Days(100));
VerifyEmptyStats(kDecodeStatsKeyVp9);
}
TEST_F(WebrtcVideoStatsDBImplTest, NewStatsReplaceOldStats) {
InitializeDB();
// Inject a test clock and initialize with the current time.
base::SimpleTestClock clock;
SetDBClock(&clock);
clock.SetNow(base::Time::Now());
// Append and verify read-back.
constexpr int kNumberOfStatsToAdd = 30;
EXPECT_GT(kNumberOfStatsToAdd, GetMaxEntriesPerConfig());
VideoStatsEntry entry;
for (int i = 0; i < kNumberOfStatsToAdd; ++i) {
VideoStats stats(clock.Now().ToJsTimeIgnoringNull(), 240 + i, 6,
7.2 + i % 3);
AppendStats(kDecodeStatsKeyVp9, stats);
// Start popping the last stats entry if the number of entries has reached
// the limit.
if (i >= GetMaxEntriesPerConfig()) {
entry.pop_back();
}
entry.insert(entry.begin(), stats);
VerifyReadStats(kDecodeStatsKeyVp9, entry);
clock.Advance(base::Days(1));
}
}
TEST_F(WebrtcVideoStatsDBImplTest, ConfigureMaxEntriesPerConfig) {
base::test::ScopedFeatureList scoped_feature_list;
std::unique_ptr<base::FieldTrialList> field_trial_list;
int previous_max_entries_per_config = GetMaxEntriesPerConfig();
constexpr int kNewMaxEntriesPerConfig = 3;
ASSERT_LT(kNewMaxEntriesPerConfig, previous_max_entries_per_config);
// Override field trial.
base::FieldTrialParams params;
params["db_max_entries_per_cpnfig"] =
base::NumberToString(kNewMaxEntriesPerConfig);
scoped_feature_list.InitAndEnableFeatureWithParameters(
media::kWebrtcMediaCapabilitiesParameters, params);
EXPECT_EQ(kNewMaxEntriesPerConfig, GetMaxEntriesPerConfig());
InitializeDB();
// Inject a test clock and initialize with the current time.
base::SimpleTestClock clock;
SetDBClock(&clock);
clock.SetNow(base::Time::Now());
// Append and verify read-back.
constexpr int kNumberOfStatsToAdd = 30;
EXPECT_GT(kNumberOfStatsToAdd, GetMaxEntriesPerConfig());
VideoStatsEntry entry;
for (int i = 0; i < kNumberOfStatsToAdd; ++i) {
VideoStats stats(clock.Now().ToJsTimeIgnoringNull(), 240 + i, 6,
7.2 + i % 3);
AppendStats(kDecodeStatsKeyVp9, stats);
// Start popping the last stats entry if the number of entries has reached
// the limit.
if (i >= GetMaxEntriesPerConfig()) {
entry.pop_back();
}
entry.insert(entry.begin(), stats);
VerifyReadStats(kDecodeStatsKeyVp9, entry);
clock.Advance(base::Days(1));
}
}
TEST_F(WebrtcVideoStatsDBImplTest, OutOfOrderTimestampClearsOldStats) {
InitializeDB();
// Inject a test clock and initialize with the current time.
base::SimpleTestClock clock;
SetDBClock(&clock);
clock.SetNow(base::Time::Now());
// Append and verify read-back.
constexpr int kNumberOfStatsToAdd = 5;
VideoStatsEntry entry;
for (int i = 0; i < kNumberOfStatsToAdd; ++i) {
VideoStats stats(clock.Now().ToJsTimeIgnoringNull(), 240 + i, 6,
7.2 + i % 3);
AppendStats(kDecodeStatsKeyVp9, stats);
entry.insert(entry.begin(), stats);
VerifyReadStats(kDecodeStatsKeyVp9, entry);
clock.Advance(base::Days(1));
}
// Go back in time and add a new stats entry.
clock.Advance(-base::Days(20));
VideoStats stats(clock.Now().ToJsTimeIgnoringNull(), 123, 5, 11.2);
AppendStats(kDecodeStatsKeyVp9, stats);
// Only the last appended stats should be in the database now.
entry = {stats};
VerifyReadStats(kDecodeStatsKeyVp9, entry);
}
TEST_F(WebrtcVideoStatsDBImplTest, FailedWrite) {
InitializeDB();
// Expect the callback to indicate success = false when the write fails.
EXPECT_CALL(*this, MockAppendVideoStatsCb(false));
// Append stats, but fail the internal DB update.
stats_db_->AppendVideoStats(
kDecodeStatsKeyVp9, VideoStats(1234, 240, 6, 7.2),
base::BindOnce(&WebrtcVideoStatsDBImplTest::MockAppendVideoStatsCb,
base::Unretained(this)));
fake_db_->GetCallback(true);
fake_db_->UpdateCallback(false);
}
TEST_F(WebrtcVideoStatsDBImplTest, DiscardCorruptedDBData) {
InitializeDB();
// Inject a test clock and initialize with the current time.
base::SimpleTestClock clock;
SetDBClock(&clock);
clock.SetNow(base::Time::Now());
// Start with a proto that represents a valid uncorrupted and unexpired entry.
WebrtcVideoStatsEntryProto valid_proto;
WebrtcVideoStatsProto* valid_entry = valid_proto.add_stats();
valid_entry->set_timestamp(clock.Now().ToJsTimeIgnoringNull());
valid_entry->set_frames_processed(300);
valid_entry->set_key_frames_processed(8);
valid_entry->set_p99_processing_time_ms(11.3);
// Append it and read it back without issue.
AppendToProtoDB(kEncodeStatsKeyVp9, &valid_proto);
VerifyReadStats(
kEncodeStatsKeyVp9,
{VideoStats{valid_entry->timestamp(), valid_entry->frames_processed(),
valid_entry->key_frames_processed(),
valid_entry->p99_processing_time_ms()}});
WebrtcVideoStatsEntryProto invalid_proto;
WebrtcVideoStatsProto* invalid_entry = invalid_proto.add_stats();
// Invalid because number of frames processed is too low Verify
// you can't read it back (filtered for corruption).
*invalid_entry = *valid_entry;
invalid_entry->set_frames_processed(30);
AppendToProtoDB(kDecodeStatsKeyVp9, &invalid_proto);
VerifyEmptyStats(kDecodeStatsKeyVp9);
// Invalid because number of frames processed is too high. Verify
// you can't read it back (filtered for corruption).
*invalid_entry = *valid_entry;
invalid_entry->set_frames_processed(1000000);
AppendToProtoDB(kDecodeStatsKeyVp9, &invalid_proto);
VerifyEmptyStats(kDecodeStatsKeyVp9);
// Invalid because number of key frames is higher than number of frames
// processed. Verify you can't read it back (filtered for corruption).
*invalid_entry = *valid_entry;
invalid_entry->set_key_frames_processed(valid_entry->frames_processed() + 1);
AppendToProtoDB(kDecodeStatsKeyVp9, &invalid_proto);
VerifyEmptyStats(kDecodeStatsKeyVp9);
// Invalid processing time. Verify
// you can't read it back (filtered for corruption).
*invalid_entry = *valid_entry;
invalid_entry->set_p99_processing_time_ms(-1.0);
AppendToProtoDB(kDecodeStatsKeyVp9, &invalid_proto);
VerifyEmptyStats(kDecodeStatsKeyVp9);
*invalid_entry = *valid_entry;
invalid_entry->set_p99_processing_time_ms(20000.0);
AppendToProtoDB(kDecodeStatsKeyVp9, &invalid_proto);
VerifyEmptyStats(kDecodeStatsKeyVp9);
}
TEST_F(WebrtcVideoStatsDBImplTest, WriteAndReadCollection) {
InitializeDB();
// Set test clock.
base::SimpleTestClock clock;
SetDBClock(&clock);
clock.SetNow(base::Time::Now());
// Append stats for multiple resolutions.
VideoStats stats1(clock.Now().ToJsTimeIgnoringNull(), 240, 6, 7.2);
VideoStatsEntry entry1{stats1};
AppendStats(kDecodeStatsKeyVp9, stats1);
VideoStats stats2(clock.Now().ToJsTimeIgnoringNull(), 360, 7, 9.2);
VideoStatsEntry entry2{stats2};
AppendStats(kDecodeStatsKeyVp9FullHd, stats2);
VideoStats stats3(clock.Now().ToJsTimeIgnoringNull(), 480, 11, 13.3);
VideoStatsEntry entry3{stats3};
AppendStats(kDecodeStatsKeyVp94K, stats3);
// Add elements that should not be returned.
VideoStats stats4(clock.Now().ToJsTimeIgnoringNull(), 490, 13, 15.3);
AppendStats(kEncodeStatsKeyVp9, stats4);
AppendStats(kDecodeStatsKeyVp9Hw, stats4);
// Created the expected collection that should be returned.
WebrtcVideoStatsDB::VideoStatsCollection expected;
expected.insert({kDecodeStatsKeyVp9.pixels, entry1});
expected.insert({kDecodeStatsKeyVp9FullHd.pixels, entry2});
expected.insert({kDecodeStatsKeyVp94K.pixels, entry3});
// The same collection is returned for all keys that are associated to the
// collection.
VerifyReadStatsCollection(kDecodeStatsKeyVp9, expected);
VerifyReadStatsCollection(kDecodeStatsKeyVp9FullHd, expected);
VerifyReadStatsCollection(kDecodeStatsKeyVp94K, expected);
}
} // namespace media