// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/metrics/perf/profile_provider_chromeos.h"
#include <stdint.h>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "base/test/bind.h"
#include "base/test/power_monitor_test.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "base/time/time.h"
#include "chrome/browser/metrics/perf/metric_collector.h"
#include "chrome/browser/metrics/perf/metric_provider.h"
#include "chrome/browser/metrics/perf/windowed_incognito_observer.h"
#include "chromeos/ash/components/login/login_state/login_state.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/test/browser_task_environment.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/metrics_proto/sampled_profile.pb.h"
namespace metrics {
namespace {
// Returns sample PerfDataProtos with custom timestamps. The contents don't have
// to make sense. They just need to constitute a semantically valid protobuf.
// |proto| is an output parameter that will contain the created protobuf.
PerfDataProto GetExamplePerfDataProto(int tstamp_sec) {
PerfDataProto proto;
proto.set_timestamp_sec(tstamp_sec); // Time since epoch in seconds.
PerfDataProto_PerfFileAttr* file_attr = proto.add_file_attrs();
file_attr->add_ids(61);
file_attr->add_ids(62);
file_attr->add_ids(63);
PerfDataProto_PerfEventAttr* attr = file_attr->mutable_attr();
attr->set_type(1);
attr->set_size(2);
attr->set_config(3);
attr->set_sample_period(4);
attr->set_sample_freq(5);
PerfDataProto_PerfEventStats* stats = proto.mutable_stats();
stats->set_num_events_read(100);
stats->set_num_sample_events(200);
stats->set_num_mmap_events(300);
stats->set_num_fork_events(400);
stats->set_num_exit_events(500);
return proto;
}
// Custome metric collectors to register with the profile provider for testing.
template <int TSTAMP>
class TestMetricCollector : public internal::MetricCollector {
public:
TestMetricCollector() : TestMetricCollector(CollectionParams()) {}
explicit TestMetricCollector(const CollectionParams& collection_params)
: internal::MetricCollector("UMA.CWP.TestData", collection_params) {}
TestMetricCollector(const TestMetricCollector&) = delete;
TestMetricCollector& operator=(const TestMetricCollector&) = delete;
const char* ToolName() const override { return "test"; }
base::WeakPtr<internal::MetricCollector> GetWeakPtr() override {
return weak_factory_.GetWeakPtr();
}
void CollectProfile(
std::unique_ptr<SampledProfile> sampled_profile) override {
PerfDataProto perf_data_proto = GetExamplePerfDataProto(TSTAMP);
// Create an incognito observer to test initialization on the UI thread.
auto observer = WindowedIncognitoMonitor::CreateObserver();
if (!observer->IncognitoActive()) {
SaveSerializedPerfProto(std::move(sampled_profile),
perf_data_proto.SerializeAsString());
}
}
private:
base::WeakPtrFactory<TestMetricCollector> weak_factory_{this};
};
const base::TimeDelta kPeriodicCollectionInterval = base::Hours(1);
const base::TimeDelta kMaxCollectionDelay = base::Seconds(1);
// Allows access to some private methods for testing.
class TestProfileProvider : public ProfileProvider {
public:
TestProfileProvider() {
// Add a couple of metric collectors. We differentiate between them using
// different time stamps for profiles. Set sampling factors for triggers
// to 1, so we always trigger collection.
CollectionParams test_params;
test_params.resume_from_suspend.sampling_factor = 1;
test_params.resume_from_suspend.max_collection_delay = kMaxCollectionDelay;
test_params.restore_session.sampling_factor = 1;
test_params.restore_session.max_collection_delay = kMaxCollectionDelay;
test_params.periodic_interval = kPeriodicCollectionInterval;
collectors_.clear();
collectors_.push_back(std::make_unique<MetricProvider>(
std::make_unique<TestMetricCollector<100>>(test_params), nullptr));
collectors_.push_back(std::make_unique<MetricProvider>(
std::make_unique<TestMetricCollector<200>>(test_params), nullptr));
}
using ProfileProvider::collectors_;
using ProfileProvider::jank_monitor;
using ProfileProvider::jankiness_collection_min_interval;
using ProfileProvider::LoggedInStateChanged;
using ProfileProvider::OnJankStarted;
using ProfileProvider::OnSessionRestoreDone;
using ProfileProvider::SuspendDone;
TestProfileProvider(const TestProfileProvider&) = delete;
TestProfileProvider& operator=(const TestProfileProvider&) = delete;
};
void ExpectTwoStoredPerfProfiles(
const std::vector<SampledProfile>& stored_profiles,
SampledProfile_TriggerEvent want_trigger_type,
ThermalState want_thermal_state_type,
int want_speed_limit) {
ASSERT_EQ(2U, stored_profiles.size());
// Both profiles must be of the given type and include perf data.
const SampledProfile& profile1 = stored_profiles[0];
const SampledProfile& profile2 = stored_profiles[1];
EXPECT_EQ(want_trigger_type, profile1.trigger_event());
ASSERT_TRUE(profile1.has_perf_data());
EXPECT_EQ(want_trigger_type, profile2.trigger_event());
ASSERT_TRUE(profile2.has_perf_data());
// Both profiles must include the given thermal state,
EXPECT_EQ(want_thermal_state_type, profile1.thermal_state());
EXPECT_EQ(want_thermal_state_type, profile2.thermal_state());
// ... and CPU speed limit.
EXPECT_EQ(want_speed_limit, profile1.cpu_speed_limit_percent());
EXPECT_EQ(want_speed_limit, profile2.cpu_speed_limit_percent());
// We must have received a profile from each of the collectors.
EXPECT_EQ(100u, profile1.perf_data().timestamp_sec());
EXPECT_EQ(200u, profile2.perf_data().timestamp_sec());
}
} // namespace
class ProfileProviderTest : public testing::Test {
public:
ProfileProviderTest()
: task_environment_(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
ProfileProviderTest(const ProfileProviderTest&) = delete;
ProfileProviderTest& operator=(const ProfileProviderTest&) = delete;
void SetUp() override {
// ProfileProvider requires ash::LoginState and
// chromeos::PowerManagerClient to be initialized.
chromeos::PowerManagerClient::InitializeFake();
ash::LoginState::Initialize();
test_power_monitor_source_.GenerateThermalThrottlingEvent(
base::PowerThermalObserver::DeviceThermalState::kNominal);
profile_provider_ = std::make_unique<TestProfileProvider>();
profile_provider_->Init();
}
void TearDown() override {
profile_provider_.reset();
ash::LoginState::Shutdown();
chromeos::PowerManagerClient::Shutdown();
}
protected:
// task_environment_ must be the first member (or at least before
// any member that cares about tasks) to be initialized first and destroyed
// last.
content::BrowserTaskEnvironment task_environment_;
base::test::ScopedPowerMonitorTestSource test_power_monitor_source_;
std::unique_ptr<TestProfileProvider> profile_provider_;
};
TEST_F(ProfileProviderTest, CheckSetup) {
EXPECT_EQ(2U, profile_provider_->collectors_.size());
// No profiles should be collected on start.
std::vector<SampledProfile> stored_profiles;
EXPECT_FALSE(profile_provider_->GetSampledProfiles(&stored_profiles));
EXPECT_TRUE(stored_profiles.empty());
}
TEST_F(ProfileProviderTest, UserLoginLogout) {
// No user is logged in, so no collection is scheduled to run.
task_environment_.FastForwardBy(kPeriodicCollectionInterval);
std::vector<SampledProfile> stored_profiles;
EXPECT_FALSE(profile_provider_->GetSampledProfiles(&stored_profiles));
EXPECT_TRUE(stored_profiles.empty());
// Simulate a user log in, which should activate periodic collection for all
// collectors.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_ACTIVE,
ash::LoginState::LOGGED_IN_USER_REGULAR);
// Run all pending tasks. SetLoggedInState has activated timers for periodic
// collection causing timer based pending tasks.
task_environment_.FastForwardBy(kPeriodicCollectionInterval);
// We should find two profiles, one for each collector.
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
ExpectTwoStoredPerfProfiles(
stored_profiles, SampledProfile::PERIODIC_COLLECTION,
THERMAL_STATE_NOMINAL, base::PowerThermalObserver::kSpeedLimitMax);
// Periodic collection is deactivated when user logs out. Simulate a user
// logout event.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_NONE, ash::LoginState::LOGGED_IN_USER_NONE);
// Run all pending tasks.
task_environment_.FastForwardBy(kPeriodicCollectionInterval);
// We should find no new profiles.
stored_profiles.clear();
EXPECT_FALSE(profile_provider_->GetSampledProfiles(&stored_profiles));
ASSERT_TRUE(stored_profiles.empty());
}
TEST_F(ProfileProviderTest, SuspendDone_NoUserLoggedIn_NoCollection) {
// No user is logged in, so no collection is done on resume from suspend.
profile_provider_->SuspendDone(base::Minutes(10));
// Run all pending tasks.
task_environment_.FastForwardBy(kMaxCollectionDelay);
std::vector<SampledProfile> stored_profiles;
EXPECT_FALSE(profile_provider_->GetSampledProfiles(&stored_profiles));
EXPECT_TRUE(stored_profiles.empty());
}
TEST_F(ProfileProviderTest, CanceledSuspend_NoCollection) {
// Set user state as logged in. This activates periodic collection, but we can
// deactivate it for each collector.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_ACTIVE,
ash::LoginState::LOGGED_IN_USER_REGULAR);
for (auto& collector : profile_provider_->collectors_) {
collector->Deactivate();
}
// Trigger a canceled suspend (zero sleep duration).
profile_provider_->SuspendDone(base::Seconds(0));
// Run all pending tasks.
task_environment_.FastForwardBy(kMaxCollectionDelay);
// We should find no profiles.
std::vector<SampledProfile> stored_profiles;
EXPECT_FALSE(profile_provider_->GetSampledProfiles(&stored_profiles));
ASSERT_TRUE(stored_profiles.empty());
}
TEST_F(ProfileProviderTest, SuspendDone) {
// Set user state as logged in. This activates periodic collection, but other
// triggers like SUSPEND_DONE take precedence.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_ACTIVE,
ash::LoginState::LOGGED_IN_USER_REGULAR);
// Trigger a resume from suspend.
profile_provider_->SuspendDone(base::Minutes(10));
// Run all pending tasks.
task_environment_.FastForwardBy(kMaxCollectionDelay);
// We should find two profiles, one for each collector.
std::vector<SampledProfile> stored_profiles;
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
ExpectTwoStoredPerfProfiles(
stored_profiles, SampledProfile::RESUME_FROM_SUSPEND,
THERMAL_STATE_NOMINAL, base::PowerThermalObserver::kSpeedLimitMax);
}
TEST_F(ProfileProviderTest, OnSessionRestoreDone_NoUserLoggedIn_NoCollection) {
// No user is logged in, so no collection is done on session restore.
profile_provider_->OnSessionRestoreDone(nullptr, 10);
// Run all pending tasks.
task_environment_.FastForwardBy(kMaxCollectionDelay);
std::vector<SampledProfile> stored_profiles;
EXPECT_FALSE(profile_provider_->GetSampledProfiles(&stored_profiles));
EXPECT_TRUE(stored_profiles.empty());
}
TEST_F(ProfileProviderTest, OnSessionRestoreDone) {
// Set user state as logged in. This activates periodic collection, but we can
// deactivate it for each collector.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_ACTIVE,
ash::LoginState::LOGGED_IN_USER_REGULAR);
for (auto& collector : profile_provider_->collectors_) {
collector->Deactivate();
}
// Trigger a session restore.
profile_provider_->OnSessionRestoreDone(nullptr, 10);
// Run all pending tasks.
task_environment_.FastForwardBy(kMaxCollectionDelay);
// We should find two profiles, one for each collector.
std::vector<SampledProfile> stored_profiles;
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
ExpectTwoStoredPerfProfiles(stored_profiles, SampledProfile::RESTORE_SESSION,
THERMAL_STATE_NOMINAL,
base::PowerThermalObserver::kSpeedLimitMax);
}
TEST_F(ProfileProviderTest, ThermalStateChangesAreCaptured) {
// Simulate a user log in, which should activate periodic collection for all
// collectors.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_ACTIVE,
ash::LoginState::LOGGED_IN_USER_REGULAR);
test_power_monitor_source_.GenerateThermalThrottlingEvent(
base::PowerThermalObserver::DeviceThermalState::kCritical);
// Run all pending tasks. SetLoggedInState has activated timers for periodic
// collection causing timer based pending tasks.
task_environment_.FastForwardBy(kPeriodicCollectionInterval);
// We should find two profiles, one for each collector.
std::vector<SampledProfile> stored_profiles;
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
ExpectTwoStoredPerfProfiles(
stored_profiles, SampledProfile::PERIODIC_COLLECTION,
THERMAL_STATE_CRITICAL, base::PowerThermalObserver::kSpeedLimitMax);
}
TEST_F(ProfileProviderTest, CpuSpeedChangesAreCaptured) {
// Simulate a user log in, which should activate periodic collection for all
// collectors.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_ACTIVE,
ash::LoginState::LOGGED_IN_USER_REGULAR);
test_power_monitor_source_.GenerateSpeedLimitEvent(50);
// Run all pending tasks. SetLoggedInState has activated timers for periodic
// collection causing timer based pending tasks.
task_environment_.FastForwardBy(kPeriodicCollectionInterval);
// We should find two profiles, one for each collector.
std::vector<SampledProfile> stored_profiles;
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
ExpectTwoStoredPerfProfiles(stored_profiles,
SampledProfile::PERIODIC_COLLECTION,
THERMAL_STATE_NOMINAL, 50);
}
// Test profile collection triggered when a jank starts.
TEST_F(ProfileProviderTest, JankMonitorCallbacks) {
// Jankiness collection requires that the user is logged in.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_ACTIVE,
ash::LoginState::LOGGED_IN_USER_REGULAR);
// Trigger a jankiness collection.
profile_provider_->OnJankStarted();
task_environment_.RunUntilIdle();
// We should find two profiles, one for each collector.
std::vector<SampledProfile> stored_profiles;
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
EXPECT_EQ(2U, stored_profiles.size());
ExpectTwoStoredPerfProfiles(stored_profiles, SampledProfile::JANKY_TASK,
THERMAL_STATE_NOMINAL,
base::PowerThermalObserver::kSpeedLimitMax);
}
// Test throttling of JANKY_TASK collections: no consecutive collections within
// jankiness_collection_min_interval().
TEST_F(ProfileProviderTest, JankinessCollectionThrottled) {
// Jankiness collection requires that the user is logged in.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_ACTIVE,
ash::LoginState::LOGGED_IN_USER_REGULAR);
// The first JANKY_TASK collection should succeed.
profile_provider_->OnJankStarted();
task_environment_.RunUntilIdle();
std::vector<SampledProfile> stored_profiles;
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
EXPECT_EQ(2U, stored_profiles.size());
ExpectTwoStoredPerfProfiles(stored_profiles, SampledProfile::JANKY_TASK,
THERMAL_STATE_NOMINAL,
base::PowerThermalObserver::kSpeedLimitMax);
stored_profiles.clear();
// We are about to fast forward the clock a lot. Deactivate all collectors
// to disable periodic collections.
for (auto& collector : profile_provider_->collectors_) {
collector->Deactivate();
}
// Fast forward time to 1 second before the throttling duration is over.
task_environment_.FastForwardBy(
profile_provider_->jankiness_collection_min_interval() -
base::Seconds(1));
// This collection within the minimum interval should be throttled.
profile_provider_->OnJankStarted();
task_environment_.RunUntilIdle();
EXPECT_FALSE(profile_provider_->GetSampledProfiles(&stored_profiles));
stored_profiles.clear();
// Move the clock forward past the throttling duration. The next JANKY_TASK
// collection should succeed.
task_environment_.FastForwardBy(base::Seconds(1));
profile_provider_->OnJankStarted();
task_environment_.RunUntilIdle();
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
EXPECT_EQ(2U, stored_profiles.size());
ExpectTwoStoredPerfProfiles(stored_profiles, SampledProfile::JANKY_TASK,
THERMAL_STATE_NOMINAL,
base::PowerThermalObserver::kSpeedLimitMax);
}
// This class enables the jank monitor to test collections triggered by jank
// callbacks from the jank monitor.
class ProfileProviderJankinessTest : public ProfileProviderTest {
public:
void SetUp() override {
ProfileProviderTest::SetUp();
// Jankiness collection requires that the user is logged in.
ash::LoginState::Get()->SetLoggedInState(
ash::LoginState::LOGGED_IN_ACTIVE,
ash::LoginState::LOGGED_IN_USER_REGULAR);
// Deactivate each collectors to disable periodic collections.
for (auto& collector : profile_provider_->collectors_) {
collector->Deactivate();
}
}
};
// Test profile collection triggered by a UI thread jank.
TEST_F(ProfileProviderJankinessTest, JankMonitor_UI) {
EXPECT_TRUE(profile_provider_->jank_monitor());
// Post a janky task to the UI thread.
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindLambdaForTesting([&]() {
// This is a janky task that runs for 2 seconds.
task_environment_.FastForwardBy(base::Seconds(2));
}));
task_environment_.RunUntilIdle();
std::vector<SampledProfile> stored_profiles;
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
EXPECT_EQ(2U, stored_profiles.size());
ExpectTwoStoredPerfProfiles(stored_profiles, SampledProfile::JANKY_TASK,
THERMAL_STATE_NOMINAL,
base::PowerThermalObserver::kSpeedLimitMax);
}
// Test profile collection triggered by an IO thread jank.
TEST_F(ProfileProviderJankinessTest, JankMonitor_IO) {
EXPECT_TRUE(profile_provider_->jank_monitor());
// Post a janky task to the IO thread.
content::GetIOThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindLambdaForTesting([&]() {
// This is a janky task that runs for 2 seconds.
task_environment_.FastForwardBy(base::Seconds(2));
}));
task_environment_.RunUntilIdle();
std::vector<SampledProfile> stored_profiles;
EXPECT_TRUE(profile_provider_->GetSampledProfiles(&stored_profiles));
EXPECT_EQ(2U, stored_profiles.size());
ExpectTwoStoredPerfProfiles(stored_profiles, SampledProfile::JANKY_TASK,
THERMAL_STATE_NOMINAL,
base::PowerThermalObserver::kSpeedLimitMax);
}
namespace {
class TestStockProfileProvider : public ProfileProvider {
public:
TestStockProfileProvider() = default;
using ProfileProvider::collectors_;
TestStockProfileProvider(const TestStockProfileProvider&) = delete;
TestStockProfileProvider& operator=(const TestStockProfileProvider&) = delete;
};
} // namespace
class ProfileProviderStockTest : public testing::Test {
public:
ProfileProviderStockTest() = default;
ProfileProviderStockTest(const ProfileProviderStockTest&) = delete;
ProfileProviderStockTest& operator=(const ProfileProviderStockTest&) = delete;
void SetUp() override {
// ProfileProvider requires ash::LoginState and
// chromeos::PowerManagerClient to be initialized.
chromeos::PowerManagerClient::InitializeFake();
ash::LoginState::Initialize();
}
void TearDown() override {
ash::LoginState::Shutdown();
chromeos::PowerManagerClient::Shutdown();
}
protected:
content::BrowserTaskEnvironment task_environment_;
};
TEST_F(ProfileProviderStockTest, CheckSetup) {
TestStockProfileProvider profile_provider;
// We should have one collector registered.
EXPECT_EQ(1u, profile_provider.collectors_.size());
// After initialization, we should still have a single collector.
profile_provider.Init();
EXPECT_EQ(1u, profile_provider.collectors_.size());
}
} // namespace metrics
Codebase Browser
chromium