// 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 <memory>
#include "base/memory/raw_ptr.h"
#include "chrome/browser/metrics/chrome_metrics_service_client.h"

#include "base/test/metrics/user_action_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "chrome/browser/ash/login/demo_mode/demo_session.h"
#include "chrome/browser/ash/multidevice_setup/multidevice_setup_client_factory.h"
#include "chrome/browser/metrics/chrome_metrics_services_manager_client.h"
#include "chrome/browser/unified_consent/unified_consent_service_factory.h"
#include "chrome/common/chrome_features.h"
#include "chrome/test/base/testing_browser_process.h"
#include "chrome/test/base/testing_profile_manager.h"
#include "chromeos/ash/components/login/login_state/login_state.h"
#include "chromeos/ash/components/system/fake_statistics_provider.h"
#include "chromeos/ash/components/system/statistics_provider.h"
#include "chromeos/ash/services/multidevice_setup/public/cpp/fake_multidevice_setup_client.h"
#include "chromeos/ash/services/multidevice_setup/public/cpp/multidevice_setup_client.h"
#include "chromeos/ash/services/multidevice_setup/public/cpp/multidevice_setup_client_impl.h"
#include "chromeos/dbus/power/power_manager_client.h"
#include "chromeos/dbus/tpm_manager/tpm_manager_client.h"
#include "components/metrics/content/subprocess_metrics_provider.h"
#include "components/metrics/log_decoder.h"
#include "components/metrics/metrics_logs_event_manager.h"
#include "components/metrics/metrics_service.h"
#include "components/metrics/metrics_state_manager.h"
#include "components/metrics/test/test_enabled_state_provider.h"
#include "components/metrics/unsent_log_store.h"
#include "components/prefs/testing_pref_service.h"
#include "components/sync/protocol/sync_enums.pb.h"
#include "components/sync/test/test_sync_service.h"
#include "components/sync_preferences/testing_pref_service_syncable.h"
#include "components/ukm/ukm_pref_names.h"
#include "components/ukm/ukm_service.h"
#include "components/ukm/unsent_log_store_metrics_impl.h"
#include "components/unified_consent/pref_names.h"
#include "components/unified_consent/unified_consent_service.h"
#include "components/variations/synthetic_trial_registry.h"
#include "content/public/test/browser_task_environment.h"
#include "services/metrics/public/cpp/ukm_entry_builder.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/metrics_proto/ukm/report.pb.h"

namespace {
using TestEvent1 = ukm::builders::PageLoad;

// Needed to fake System Profile which is provided when ukm report is generated.
// TODO(crbug.com/40249492): Refactor to remove the classes needed to fake
// SystemProfile.
class FakeMultiDeviceSetupClientImplFactory
    : public ash::multidevice_setup::MultiDeviceSetupClientImpl::Factory {
 public:
  explicit FakeMultiDeviceSetupClientImplFactory(
      std::unique_ptr<ash::multidevice_setup::FakeMultiDeviceSetupClient>
          fake_multidevice_setup_client)
      : fake_multidevice_setup_client_(
            std::move(fake_multidevice_setup_client)) {}

  ~FakeMultiDeviceSetupClientImplFactory() override = default;

  // ash::multidevice_setup::MultiDeviceSetupClientImpl::Factory:
  std::unique_ptr<ash::multidevice_setup::MultiDeviceSetupClient>
  CreateInstance(
      mojo::PendingRemote<ash::multidevice_setup::mojom::MultiDeviceSetup>)
      override {
    // NOTE: At most, one client should be created per-test.
    EXPECT_TRUE(fake_multidevice_setup_client_);
    return std::move(fake_multidevice_setup_client_);
  }

 private:
  std::unique_ptr<ash::multidevice_setup::FakeMultiDeviceSetupClient>
      fake_multidevice_setup_client_;
};

class ChromeMetricsServiceClientTestWithoutUKMProviders
    : public ChromeMetricsServiceClient {
 public:
  // Equivalent to ChromeMetricsServiceClient::Create
  static std::unique_ptr<ChromeMetricsServiceClientTestWithoutUKMProviders>
  Create(metrics::MetricsStateManager* metrics_state_manager,
         variations::SyntheticTrialRegistry* synthetic_trial_registry) {
    // Needed because RegisterMetricsServiceProviders() checks for this.
    metrics::SubprocessMetricsProvider::CreateInstance();

    std::unique_ptr<ChromeMetricsServiceClientTestWithoutUKMProviders> client(
        new ChromeMetricsServiceClientTestWithoutUKMProviders(
            metrics_state_manager, synthetic_trial_registry));
    client->Initialize();

    return client;
  }

  bool notified_not_idle() const { return notified_not_idle_; }

 private:
  explicit ChromeMetricsServiceClientTestWithoutUKMProviders(
      metrics::MetricsStateManager* state_manager,
      variations::SyntheticTrialRegistry* synthetic_trial_registry)
      : ChromeMetricsServiceClient(state_manager, synthetic_trial_registry) {}

  void RegisterUKMProviders() override {}
  void NotifyApplicationNotIdle() override { notified_not_idle_ = true; }

  bool notified_not_idle_ = false;
};

class MockSyncService : public syncer::TestSyncService {
 public:
  MockSyncService() {
    SetMaxTransportState(TransportState::INITIALIZING);
    SetLastCycleSnapshot(syncer::SyncCycleSnapshot());
  }

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

  ~MockSyncService() override { Shutdown(); }

  void SetStatus(bool has_passphrase, bool history_enabled, bool active) {
    SetMaxTransportState(active ? TransportState::ACTIVE
                                : TransportState::INITIALIZING);
    SetIsUsingExplicitPassphrase(has_passphrase);

    GetUserSettings()->SetSelectedTypes(
        /*sync_everything=*/false,
        /*types=*/history_enabled ? syncer::UserSelectableTypeSet(
                                        {syncer::UserSelectableType::kHistory})
                                  : syncer::UserSelectableTypeSet());

    // It doesn't matter what exactly we set here, it's only relevant that the
    // SyncCycleSnapshot is initialized at all.
    SetLastCycleSnapshot(syncer::SyncCycleSnapshot(
        /*birthday=*/std::string(), /*bag_of_chips=*/std::string(),
        syncer::ModelNeutralState(), syncer::ProgressMarkerMap(), false, 0,
        true, base::Time::Now(), base::Time::Now(),
        sync_pb::SyncEnums::UNKNOWN_ORIGIN, base::Minutes(1), false));

    NotifyObserversOfStateChanged();

    SetAppSync(false);
  }

  void Shutdown() override {
    for (auto& observer : observers_) {
      observer.OnSyncShutdown(this);
    }
  }

  void SetAppSync(bool enabled) {
    auto selected_os_types = GetUserSettings()->GetSelectedOsTypes();

    if (enabled)
      selected_os_types.Put(syncer::UserSelectableOsType::kOsApps);
    else
      selected_os_types.Remove(syncer::UserSelectableOsType::kOsApps);

    GetUserSettings()->SetSelectedOsTypes(false, selected_os_types);

    NotifyObserversOfStateChanged();
  }

 private:
  // syncer::TestSyncService:
  void AddObserver(syncer::SyncServiceObserver* observer) override {
    observers_.AddObserver(observer);
  }
  void RemoveObserver(syncer::SyncServiceObserver* observer) override {
    observers_.RemoveObserver(observer);
  }

  void NotifyObserversOfStateChanged() {
    for (auto& observer : observers_) {
      observer.OnStateChanged(this);
    }
  }

  // The list of observers of the SyncService state.
  base::ObserverList<syncer::SyncServiceObserver>::Unchecked observers_;
};

struct IndependentAppMetricsTestParams {
  IndependentAppMetricsTestParams(ukm::UkmConsentType purged,
                                  ukm::UkmConsentType remaining)
      : tested_type(purged), other_type(remaining) {}

  ukm::UkmConsentType tested_type;
  ukm::UkmConsentType other_type;
};

}  // namespace

class ChromeMetricsServiceClientTestIgnoredForAppMetrics
    : public testing::TestWithParam<IndependentAppMetricsTestParams> {
 public:
  ChromeMetricsServiceClientTestIgnoredForAppMetrics()
      : profile_manager_(std::make_unique<TestingProfileManager>(
            TestingBrowserProcess::GetGlobal())),
        enabled_state_provider_(false /* consent */, false /* enabled */) {}

  void SetUp() override {
    testing::Test::SetUp();
    metrics::MetricsService::RegisterPrefs(prefs_.registry());
    metrics_state_manager_ = metrics::MetricsStateManager::Create(
        &prefs_, &enabled_state_provider_, std::wstring(), base::FilePath());
    metrics_state_manager_->InstantiateFieldTrialList();
    synthetic_trial_registry_ =
        std::make_unique<variations::SyntheticTrialRegistry>();
    ASSERT_TRUE(profile_manager_->SetUp());
    scoped_feature_list_.InitAndEnableFeature(features::kUmaStorageDimensions);

    // ChromeOs Metrics Provider require g_login_state and power manager client
    // initialized before they can be instantiated.
    chromeos::PowerManagerClient::InitializeFake();
    ash::LoginState::Initialize();
    chromeos::TpmManagerClient::InitializeFake();

    SetupMultiDeviceFactory();

    testing_profile_ = profile_manager_->CreateTestingProfile("test_name");

    // Set statistic provider for hardware class tests.
    ash::system::StatisticsProvider::SetTestProvider(
        &fake_statistics_provider_);
  }

  void TearDown() override {
    ash::LoginState::Shutdown();
    chromeos::PowerManagerClient::Shutdown();

    ash::multidevice_setup::MultiDeviceSetupClientImpl::Factory::
        SetFactoryForTesting(nullptr);

    // ChromeMetricsServiceClient::Initialize() initializes
    // IdentifiabilityStudySettings as part of creating the
    // PrivacyBudgetUkmEntryFilter. Reset them after the test.
    blink::IdentifiabilityStudySettings::ResetStateForTesting();
    profile_manager_.reset();
  }

  std::unique_ptr<ChromeMetricsServiceClientTestWithoutUKMProviders> Init(
      sync_preferences::TestingPrefServiceSyncable& prefs) {
    ChromeMetricsServiceClient::RegisterPrefs(prefs.registry());
    RegisterUrlKeyedAnonymizedDataCollectionPref(prefs);
    SetUrlKeyedAnonymizedDataCollectionEnabled(prefs, /*enabled=*/true);

    auto chrome_metrics_service_client =
        ChromeMetricsServiceClientTestWithoutUKMProviders::Create(
            metrics_state_manager_.get(), synthetic_trial_registry_.get());
    chrome_metrics_service_client->StartObserving(&sync_service_, &prefs);

    chrome_metrics_service_client_ = chrome_metrics_service_client.get();

    auto* ukm_service = chrome_metrics_service_client_->GetUkmService();
    ukm_service->SetSamplingForTesting(true);
    ukm_service->EnableRecording();
    ukm_service->EnableReporting();

    return chrome_metrics_service_client;
  }

  ChromeMetricsServiceClient& GetChromeMetricsServiceClient() {
    return *chrome_metrics_service_client_;
  }

  ukm::UkmService* GetUkmService() {
    return chrome_metrics_service_client_->GetUkmService();
  }

  std::vector<ukm::SourceId> GetSourceIdsForConsentType(
      ukm::UkmConsentType consent_type) {
    const auto filter_id_type =
        GetAppOrNavigationSourceIdTypeForConsent(consent_type);
    std::vector<ukm::SourceId> result;

    for (const auto& source_id : source_ids_) {
      if (ukm::GetSourceIdType(source_id) == filter_id_type) {
        result.push_back(source_id);
      }
    }

    return result;
  }

  static ukm::SourceIdType GetAppOrNavigationSourceIdTypeForConsent(
      ukm::UkmConsentType consent_type) {
    return consent_type == ukm::UkmConsentType::APPS
               ? ukm::SourceIdType::APP_ID
               : ukm::SourceIdType::NAVIGATION_ID;
  }

  void RegisterUrlKeyedAnonymizedDataCollectionPref(
      sync_preferences::TestingPrefServiceSyncable& prefs) {
    unified_consent::UnifiedConsentService::RegisterPrefs(prefs.registry());
  }

  void SetUrlKeyedAnonymizedDataCollectionEnabled(
      sync_preferences::TestingPrefServiceSyncable& prefs,
      bool enabled) {
    prefs.SetBoolean(
        unified_consent::prefs::kUrlKeyedAnonymizedDataCollectionEnabled,
        enabled);
  }

  ukm::Report GetUkmReport() {
    metrics::UnsentLogStore* log_store =
        GetUkmService()->reporting_service_for_testing().ukm_log_store();
    EXPECT_GE(log_store->size(), 1ul);
    log_store->StageNextLog();

    ukm::Report report;
    EXPECT_TRUE(
        metrics::DecodeLogDataToProto(log_store->staged_log(), &report));
    return report;
  }

 protected:
  void SetupMultiDeviceFactory() {
    ash::multidevice_setup::MultiDeviceSetupClientFactory::GetInstance()
        ->SetServiceIsNULLWhileTestingForTesting(false);
    auto fake_multidevice_setup_client =
        std::make_unique<ash::multidevice_setup::FakeMultiDeviceSetupClient>();
    fake_multidevice_setup_client_ = fake_multidevice_setup_client.get();
    fake_multidevice_setup_client_impl_factory_ =
        std::make_unique<FakeMultiDeviceSetupClientImplFactory>(
            std::move(fake_multidevice_setup_client));
    ash::multidevice_setup::MultiDeviceSetupClientImpl::Factory::
        SetFactoryForTesting(fake_multidevice_setup_client_impl_factory_.get());
  }

  ukm::SourceId AddSourceId(ukm::SourceIdType source_id_type) {
    const auto source_id =
        ukm::ConvertToSourceId(source_ids_.size(), source_id_type);
    UpdateSourceUrl(source_id, source_id_type);
    source_ids_.push_back(source_id);
    return source_id;
  }

  void UpdateSourceUrl(ukm::SourceId source_id,
                       ukm::SourceIdType source_id_type) {
    GetUkmService()->UpdateSourceURL(
        source_id,
        source_id_type == ukm::SourceIdType::APP_ID ? kAppURL : kURL);
  }

  void RecordTestEvent1(ukm::SourceIdType source_id_type) {
    const auto source_id = AddSourceId(source_id_type);
    TestEvent1(source_id).Record(GetUkmService());
  }

  GURL kURL = GURL("https://google.com/foobar");
  GURL kAppURL = GURL("app://google.com/foobar");

  content::BrowserTaskEnvironment task_environment_;
  TestingPrefServiceSimple prefs_;
  std::unique_ptr<TestingProfileManager> profile_manager_;
  base::UserActionTester user_action_runner_;
  std::unique_ptr<metrics::MetricsStateManager> metrics_state_manager_;
  std::unique_ptr<variations::SyntheticTrialRegistry> synthetic_trial_registry_;
  metrics::TestEnabledStateProvider enabled_state_provider_;
  base::test::ScopedFeatureList scoped_feature_list_;

  std::vector<ukm::SourceId> source_ids_;
  raw_ptr<ChromeMetricsServiceClient, DanglingUntriaged>
      chrome_metrics_service_client_;

  MockSyncService sync_service_;
  ash::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
  raw_ptr<TestingProfile, DanglingUntriaged> testing_profile_ = nullptr;
  raw_ptr<ash::multidevice_setup::FakeMultiDeviceSetupClient, DanglingUntriaged>
      fake_multidevice_setup_client_;
  std::unique_ptr<FakeMultiDeviceSetupClientImplFactory>
      fake_multidevice_setup_client_impl_factory_;
};

TEST_P(ChromeMetricsServiceClientTestIgnoredForAppMetrics,
       NotifyNotIdleOnUserActivity) {
  sync_preferences::TestingPrefServiceSyncable prefs;
  auto chrome_metrics_service_client = Init(prefs);
  EXPECT_FALSE(chrome_metrics_service_client->notified_not_idle());

  ui::UserActivityDetector::Get()->HandleExternalUserActivity();
  EXPECT_TRUE(chrome_metrics_service_client->notified_not_idle());
}

TEST_P(ChromeMetricsServiceClientTestIgnoredForAppMetrics,
       VerifyPurgeOnConsentChange) {
  sync_preferences::TestingPrefServiceSyncable prefs;
  auto chrome_metrics_service_client = Init(prefs);

  // Get the params for this test.
  const auto purged_consent = GetParam().tested_type;
  const auto remaining_consent = GetParam().other_type;

  auto ukm_consent_state = GetChromeMetricsServiceClient().GetUkmConsentState();

  EXPECT_TRUE(ukm_consent_state.Has(ukm::MSBB));
  EXPECT_TRUE(ukm_consent_state.Has(ukm::APPS));

  // Record a mix of SourceId's and Events.
  RecordTestEvent1(ukm::SourceIdType::NAVIGATION_ID);
  RecordTestEvent1(ukm::SourceIdType::NAVIGATION_ID);
  RecordTestEvent1(ukm::SourceIdType::APP_ID);
  RecordTestEvent1(ukm::SourceIdType::NAVIGATION_ID);
  RecordTestEvent1(ukm::SourceIdType::APP_ID);

  GetUkmService()->Flush(
      metrics::MetricsLogsEventManager::CreateReason::kUnknown);

  // Remove the consent for |purged_consent|. This will cause
  // UKM metrics associated with this type to be purged.
  if (purged_consent == ukm::UkmConsentType::APPS)
    sync_service_.SetAppSync(false);
  else
    SetUrlKeyedAnonymizedDataCollectionEnabled(prefs, /*enabled=*/false);

  // Verify the update has propagated by checking the current consent state.
  ukm_consent_state = GetChromeMetricsServiceClient().GetUkmConsentState();

  EXPECT_TRUE(ukm_consent_state.Has(remaining_consent));
  EXPECT_FALSE(ukm_consent_state.Has(purged_consent));

  // Generate the ukm report to valid its contents.
  ukm::Report report = GetUkmReport();

  const auto remaining_source_ids =
      GetSourceIdsForConsentType(remaining_consent);
  const int num_elements = remaining_source_ids.size();

  // Expected |num_elements| entries and sources. Only |remaining_consent|
  // entries and sources should remain. Entries and sources for |purged_consent|
  // were purged.
  EXPECT_EQ(num_elements, report.sources_size());
  EXPECT_EQ(num_elements, report.entries_size());

  const auto expected_source_id_type =
      GetAppOrNavigationSourceIdTypeForConsent(remaining_consent);
  std::vector<ukm::SourceId> report_source_ids;

  // Verify the SourceIdType associated with |remaining_consent| are the only
  // entries and sources remaining.
  for (int i = 0; i < num_elements; ++i) {
    report_source_ids.push_back(report.entries(i).source_id());
    EXPECT_EQ(expected_source_id_type,
              ukm::GetSourceIdType(report.entries(i).source_id()));
  }

  EXPECT_THAT(report_source_ids,
              testing::UnorderedElementsAreArray(remaining_source_ids));
}

INSTANTIATE_TEST_SUITE_P(
    ChromeMetricsServiceClientTestIgnoredForAppMetricsGroup,
    ChromeMetricsServiceClientTestIgnoredForAppMetrics,
    testing::Values(IndependentAppMetricsTestParams(ukm::UkmConsentType::APPS,
                                                    ukm::UkmConsentType::MSBB),
                    IndependentAppMetricsTestParams(ukm::UkmConsentType::MSBB,
                                                    ukm::UkmConsentType::APPS)),
    [](const testing::TestParamInfo<
        ChromeMetricsServiceClientTestIgnoredForAppMetrics::ParamType>& info) {
      if (info.param.tested_type == ukm::UkmConsentType::APPS)
        return "TestApps";
      else
        return "TestMSBB";
    });

TEST_P(ChromeMetricsServiceClientTestIgnoredForAppMetrics,
       VerifyRecordingWhenConsentAdded) {
  // The consent type that will be off. Events associated with this type will be
  // ignored when events are initially recorded.
  const auto ignored_consent = GetParam().tested_type;

  // The consent type that will remain on. Events associated with this type will
  // be successfully recorded.
  const auto existing_consent = GetParam().other_type;

  sync_preferences::TestingPrefServiceSyncable prefs;
  auto chrome_metrics_service_client = Init(prefs);

  // Make sure the consents are set as expected for the test.
  SetUrlKeyedAnonymizedDataCollectionEnabled(
      prefs, existing_consent == ukm::UkmConsentType::MSBB);
  sync_service_.SetAppSync(existing_consent == ukm::UkmConsentType::APPS);

  auto ukm_consent_state = chrome_metrics_service_client->GetUkmConsentState();

  EXPECT_TRUE(ukm_consent_state.Has(existing_consent));
  EXPECT_FALSE(ukm_consent_state.Has(ignored_consent));

  // Record a mix of SourceId's and Events.
  RecordTestEvent1(ukm::SourceIdType::NAVIGATION_ID);
  RecordTestEvent1(ukm::SourceIdType::NAVIGATION_ID);
  RecordTestEvent1(ukm::SourceIdType::APP_ID);
  RecordTestEvent1(ukm::SourceIdType::NAVIGATION_ID);
  RecordTestEvent1(ukm::SourceIdType::APP_ID);

  // Turn on the ignored consent type and make sure the events are
  // recorded.
  if (ignored_consent == ukm::UkmConsentType::APPS)
    sync_service_.SetAppSync(true);
  else
    SetUrlKeyedAnonymizedDataCollectionEnabled(prefs, /*enabled=*/true);

  ukm_consent_state = chrome_metrics_service_client->GetUkmConsentState();

  // Verify the both consents are granted.
  EXPECT_TRUE(ukm_consent_state.Has(existing_consent));
  EXPECT_TRUE(ukm_consent_state.Has(ignored_consent));

  // Re-add events and sources of ignored type.
  auto ignored_ids = GetSourceIdsForConsentType(ignored_consent);
  for (auto id : ignored_ids) {
    UpdateSourceUrl(id,
                    GetAppOrNavigationSourceIdTypeForConsent(ignored_consent));
    TestEvent1(id).Record(GetUkmService());
  }

  GetUkmService()->Flush(
      metrics::MetricsLogsEventManager::CreateReason::kUnknown);

  // Build UKM report to verify that all of the events and sources have been
  // recorded.
  ukm::Report report = GetUkmReport();

  // Expect that all events and sources originally recorded are present.
  EXPECT_EQ(report.sources_size(), static_cast<int>(source_ids_.size()));
  EXPECT_EQ(report.entries_size(), static_cast<int>(source_ids_.size()));

  // The source type of the events that were not ignored.
  const auto remaining_source_id_type =
      GetAppOrNavigationSourceIdTypeForConsent(existing_consent);
  const auto remaining_source_ids =
      GetSourceIdsForConsentType(existing_consent);

  // The source type of the events that were ignored.
  const auto added_source_id_type =
      GetAppOrNavigationSourceIdTypeForConsent(ignored_consent);
  const auto added_source_ids = GetSourceIdsForConsentType(ignored_consent);

  // Sources that were in the report.
  std::vector<ukm::SourceId> actual_source_ids;

  // Verify the sources ids are the expected value.
  // Events and sources associated with |existing_consent| will be first because
  // the events and sources associated with |ignored_consent| were
  // dropped/ignored when recorded the first time.
  for (size_t i = 0; i < remaining_source_ids.size(); ++i) {
    actual_source_ids.push_back(report.entries(i).source_id());
    EXPECT_EQ(remaining_source_id_type,
              ukm::GetSourceIdType(report.entries(i).source_id()));
  }

  // Verify that the source id's are of the expected type.
  EXPECT_THAT(actual_source_ids,
              testing::UnorderedElementsAreArray(remaining_source_ids));
  actual_source_ids.clear();

  // The events that were re-recorded once the tested consent was added are the
  // remaining elements.
  for (size_t i = 0; i < added_source_ids.size(); ++i) {
    const auto source_id =
        report.entries(i + remaining_source_ids.size()).source_id();
    actual_source_ids.push_back(source_id);
    EXPECT_EQ(added_source_id_type, ukm::GetSourceIdType(source_id));
  }

  // Verify that the source id's are of the expected type.
  EXPECT_THAT(actual_source_ids,
              testing::UnorderedElementsAreArray(added_source_ids));
}

class ChromeMetricsServiceClientTestDemoModeRecordAppMetrics
    : public ChromeMetricsServiceClientTestIgnoredForAppMetrics {
 public:
  ChromeMetricsServiceClientTestDemoModeRecordAppMetrics() = default;

  void SetUp() override {
    ChromeMetricsServiceClientTestIgnoredForAppMetrics::SetUp();
    ash::DemoSession::SetDemoConfigForTesting(
        ash::DemoSession::DemoModeConfig::kOnline);
    testing_profile_->ScopedCrosSettingsTestHelper()
        ->InstallAttributes()
        ->SetDemoMode();
  }

  void TearDown() override {
    ash::DemoSession::ResetDemoConfigForTesting();
    ChromeMetricsServiceClientTestIgnoredForAppMetrics::TearDown();
  }
};

TEST_F(ChromeMetricsServiceClientTestDemoModeRecordAppMetrics,
       VerifyRecordingInDemoSession) {
  sync_preferences::TestingPrefServiceSyncable prefs;
  auto chrome_metrics_service_client = Init(prefs);

  // Make sure the MSBB consent is set to false initially.
  SetUrlKeyedAnonymizedDataCollectionEnabled(prefs, false);

  // Make sure the APP consent is set to false for sync service.
  sync_service_.SetAppSync(false);

  auto ukm_consent_state = GetChromeMetricsServiceClient().GetUkmConsentState();

  // Assert that UKM consent state contains only APPS in DemoSession.
  EXPECT_FALSE(ukm_consent_state.Has(ukm::UkmConsentType::MSBB));
  EXPECT_TRUE(ukm_consent_state.Has(ukm::UkmConsentType::APPS));

  // Record a mix of SourceId's and Events.
  RecordTestEvent1(ukm::SourceIdType::NAVIGATION_ID);
  RecordTestEvent1(ukm::SourceIdType::NAVIGATION_ID);
  RecordTestEvent1(ukm::SourceIdType::APP_ID);
  RecordTestEvent1(ukm::SourceIdType::NAVIGATION_ID);
  RecordTestEvent1(ukm::SourceIdType::APP_ID);

  GetUkmService()->Flush(
      metrics::MetricsLogsEventManager::CreateReason::kUnknown);

  // Build UKM report to verify that all of the events and sources have been
  // recorded for Demo Session.
  ukm::Report report = GetUkmReport();

  // Expect that only APP events and sources originally recorded are present.
  EXPECT_EQ(report.sources_size(), 2);
  EXPECT_EQ(report.entries_size(), 2);
}