// Copyright 2021 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/apps/app_service/metrics/app_platform_metrics.h"

#include <memory>
#include <set>
#include <string_view>

#include "base/check_deref.h"
#include "base/containers/fixed_flat_set.h"
#include "base/json/values_util.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/string_number_conversions.h"
#include "base/time/time.h"
#include "base/unguessable_token.h"
#include "chrome/browser/apps/app_service/app_service_proxy.h"
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
#include "chrome/browser/apps/app_service/metrics/app_platform_metrics_utils.h"
#include "chrome/browser/apps/app_service/metrics/app_service_metrics.h"
#include "chrome/browser/ash/borealis/borealis_util.h"
#include "chrome/browser/ash/guest_os/guest_os_registry_service.h"
#include "chrome/browser/ash/guest_os/guest_os_registry_service_factory.h"
#include "chrome/browser/ash/guest_os/guest_os_shelf_utils.h"
#include "chrome/browser/ash/login/demo_mode/demo_session.h"
#include "chrome/browser/ash/profiles/profile_helper.h"
#include "chrome/browser/profiles/profile.h"
#include "chromeos/ash/components/demo_mode/utils/demo_session_utils.h"
#include "chromeos/components/mgs/managed_guest_session_utils.h"
#include "components/app_constants/constants.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/scoped_user_pref_update.h"
#include "components/services/app_service/public/cpp/app_launch_util.h"
#include "components/services/app_service/public/cpp/app_update.h"
#include "components/services/app_service/public/cpp/instance.h"
#include "components/services/app_service/public/cpp/types_util.h"
#include "components/ukm/app_source_url_recorder.h"
#include "components/user_manager/user_manager.h"
#include "services/metrics/public/cpp/ukm_builders.h"
#include "services/metrics/public/cpp/ukm_recorder.h"
#include "services/metrics/public/cpp/ukm_source_id.h"
#include "ui/aura/window.h"

namespace {

// UMA metrics for a snapshot count of installed apps.
constexpr char kAppsCountHistogramPrefix[] = "Apps.AppsCount.";
constexpr char kAppsCountPerInstallReasonHistogramPrefix[] =
    "Apps.AppsCountPerInstallReason.";
constexpr char kAppsRunningDurationHistogramPrefix[] = "Apps.RunningDuration.";
constexpr char kAppsRunningPercentageHistogramPrefix[] =
    "Apps.RunningPercentage.";
constexpr char kAppsActivatedCountHistogramPrefix[] = "Apps.ActivatedCount.";
constexpr char kAppsUsageTimeHistogramPrefix[] = "Apps.UsageTime.";
constexpr char kAppsUsageTimeHistogramPrefixV2[] = "Apps.UsageTimeV2.";

constexpr base::TimeDelta kMaxDuration = base::Days(1);

constexpr auto kAppTypeNameSet = base::MakeFixedFlatSet<apps::AppTypeName>({
    apps::AppTypeName::kArc,
    apps::AppTypeName::kCrostini,
    apps::AppTypeName::kChromeApp,
    apps::AppTypeName::kWeb,
    apps::AppTypeName::kPluginVm,
    apps::AppTypeName::kRemote,
    apps::AppTypeName::kBorealis,
    apps::AppTypeName::kSystemWeb,
    apps::AppTypeName::kChromeBrowser,
    apps::AppTypeName::kExtension,
    apps::AppTypeName::kBruschetta,
});

// Returns AppTypeNameV2 used for app running metrics.
apps::AppTypeNameV2 GetAppTypeNameV2(Profile* profile,
                                     apps::AppType app_type,
                                     const std::string& app_id,
                                     aura::Window* window) {
  switch (app_type) {
    case apps::AppType::kUnknown:
      return apps::AppTypeNameV2::kUnknown;
    case apps::AppType::kArc:
      return apps::AppTypeNameV2::kArc;
    case apps::AppType::kCrostini:
      return apps::AppTypeNameV2::kCrostini;
    case apps::AppType::kChromeApp:
      return app_id == app_constants::kChromeAppId
                 ? apps::AppTypeNameV2::kChromeBrowser
             : apps::IsAshBrowserWindow(window)
                 ? apps::AppTypeNameV2::kChromeAppTab
                 : apps::AppTypeNameV2::kChromeAppWindow;
    case apps::AppType::kWeb: {
      apps::AppTypeName app_type_name =
          apps::GetAppTypeNameForWebAppWindow(profile, app_id, window);
      if (app_type_name == apps::AppTypeName::kChromeBrowser) {
        return apps::AppTypeNameV2::kWebTab;
      } else if (app_type_name == apps::AppTypeName::kSystemWeb) {
        return apps::AppTypeNameV2::kSystemWeb;
      } else {
        return apps::AppTypeNameV2::kWebWindow;
      }
    }
    case apps::AppType::kPluginVm:
      return apps::AppTypeNameV2::kPluginVm;
    case apps::AppType::kRemote:
      return apps::AppTypeNameV2::kRemote;
    case apps::AppType::kBorealis:
      return apps::AppTypeNameV2::kBorealis;
    case apps::AppType::kSystemWeb:
      return apps::AppTypeNameV2::kSystemWeb;
    case apps::AppType::kExtension:
      return apps::AppTypeNameV2::kExtension;
    case apps::AppType::kBruschetta:
      return apps::AppTypeNameV2::kBruschetta;
  }
}

// Returns AppTypeNameV2 used for app launch metrics.
apps::AppTypeNameV2 GetAppTypeNameV2(Profile* profile,
                                     apps::AppType app_type,
                                     const std::string& app_id,
                                     apps::LaunchContainer container) {
  switch (app_type) {
    case apps::AppType::kUnknown:
      return apps::AppTypeNameV2::kUnknown;
    case apps::AppType::kArc:
      return apps::AppTypeNameV2::kArc;
    case apps::AppType::kCrostini:
      return apps::AppTypeNameV2::kCrostini;
    case apps::AppType::kChromeApp:
      return container == apps::LaunchContainer::kLaunchContainerWindow
                 ? apps::AppTypeNameV2::kChromeAppWindow
                 : apps::AppTypeNameV2::kChromeAppTab;
    case apps::AppType::kWeb: {
      apps::AppTypeName app_type_name =
          apps::GetAppTypeNameForWebApp(profile, app_id, container);
      if (app_type_name == apps::AppTypeName::kChromeBrowser) {
        return apps::AppTypeNameV2::kWebTab;
      } else if (app_type_name == apps::AppTypeName::kSystemWeb) {
        return apps::AppTypeNameV2::kSystemWeb;
      } else {
        return apps::AppTypeNameV2::kWebWindow;
      }
    }
    case apps::AppType::kPluginVm:
      return apps::AppTypeNameV2::kPluginVm;
    case apps::AppType::kRemote:
      return apps::AppTypeNameV2::kRemote;
    case apps::AppType::kBorealis:
      return apps::AppTypeNameV2::kBorealis;
    case apps::AppType::kSystemWeb:
      return apps::AppTypeNameV2::kSystemWeb;
    case apps::AppType::kBruschetta:
      return apps::AppTypeNameV2::kBruschetta;
    case apps::AppType::kExtension:
      return apps::AppTypeNameV2::kExtension;
  }
}

// Records the number of times Chrome OS apps are launched grouped by the launch
// source.
void RecordAppLaunchSource(apps::LaunchSource launch_source) {
  base::UmaHistogramEnumeration("Apps.AppLaunchSource", launch_source);
}

// Records the number of times Chrome OS apps are launched grouped by the app
// type.
void RecordAppLaunchPerAppType(apps::AppTypeName app_type_name) {
  if (app_type_name == apps::AppTypeName::kUnknown) {
    return;
  }

  base::UmaHistogramEnumeration(apps::kAppLaunchPerAppTypeHistogramName,
                                app_type_name);
}

// Records the number of times Chrome OS apps are launched grouped by the app
// type V2.
void RecordAppLaunchPerAppTypeV2(apps::AppTypeNameV2 app_type_name_v2) {
  if (app_type_name_v2 == apps::AppTypeNameV2::kUnknown) {
    return;
  }

  base::UmaHistogramEnumeration(apps::kAppLaunchPerAppTypeV2HistogramName,
                                app_type_name_v2);
}

base::TimeDelta GetDurationAndResetStartTime(base::TimeTicks& start_time) {
  base::TimeDelta duration = base::TimeTicks::Now() - start_time;
  start_time = base::TimeTicks::Now();
  return duration;
}

}  // namespace

namespace apps {

constexpr char kAppRunningDuration[] =
    "app_platform_metrics.app_running_duration";
constexpr char kAppActivatedCount[] =
    "app_platform_metrics.app_activated_count";
constexpr char kAppUsageTime[] = "app_platform_metrics.app_usage_time";

constexpr char kAppLaunchPerAppTypeHistogramName[] = "Apps.AppLaunchPerAppType";
constexpr char kAppLaunchPerAppTypeV2HistogramName[] =
    "Apps.AppLaunchPerAppTypeV2";

constexpr char kChromeAppTabHistogramName[] = "ChromeAppTab";
constexpr char kChromeAppWindowHistogramName[] = "ChromeAppWindow";
constexpr char kWebAppTabHistogramName[] = "WebAppTab";
constexpr char kWebAppWindowHistogramName[] = "WebAppWindow";

constexpr char kUsageTimeAppIdKey[] = "app_id";
constexpr char kUsageTimeAppPublisherIdKey[] = "app_publisher_id";
constexpr char kUsageTimeAppTypeKey[] = "app_type";
constexpr char kUsageTimeDurationKey[] = "time";
constexpr char kReportingUsageTimeDurationKey[] = "reporting_usage_time";

std::string GetAppTypeHistogramNameV2(apps::AppTypeNameV2 app_type_name) {
  switch (app_type_name) {
    case apps::AppTypeNameV2::kUnknown:
      return std::string();
    case apps::AppTypeNameV2::kArc:
      return kArcHistogramName;
    case apps::AppTypeNameV2::kCrostini:
      return kCrostiniHistogramName;
    case apps::AppTypeNameV2::kChromeAppWindow:
      return kChromeAppWindowHistogramName;
    case apps::AppTypeNameV2::kChromeAppTab:
      return kChromeAppTabHistogramName;
    case apps::AppTypeNameV2::kWebWindow:
      return kWebAppWindowHistogramName;
    case apps::AppTypeNameV2::kWebTab:
      return kWebAppTabHistogramName;
    case apps::AppTypeNameV2::kPluginVm:
      return kPluginVmHistogramName;
    case apps::AppTypeNameV2::kRemote:
      return kRemoteHistogramName;
    case apps::AppTypeNameV2::kBorealis:
      return kBorealisHistogramName;
    case apps::AppTypeNameV2::kSystemWeb:
      return kSystemWebAppHistogramName;
    case apps::AppTypeNameV2::kChromeBrowser:
      return kChromeBrowserHistogramName;
    case apps::AppTypeNameV2::kExtension:
      return kExtensionHistogramName;
    case apps::AppTypeNameV2::kBruschetta:
      return kBruschettaHistogramName;
  }
}

ApplicationInstallTime ConvertInstallTimeToProtoApplicationInstallTime(
    InstallTime install_time) {
  switch (install_time) {
    case InstallTime::kInit:
      return ApplicationInstallTime::APPLICATION_INSTALL_TIME_INIT;
    case InstallTime::kRunning:
      return ApplicationInstallTime::APPLICATION_INSTALL_TIME_RUNNING;
    default:
      return ApplicationInstallTime::APPLICATION_INSTALL_TIME_UNKNOWN;
  }
}

void RecordAppLaunchMetrics(Profile* profile,
                            AppType app_type,
                            const std::string& app_id,
                            apps::LaunchSource launch_source,
                            apps::LaunchContainer container) {
  if (app_type == AppType::kUnknown) {
    return;
  }

  RecordAppLaunchSource(launch_source);
  RecordAppLaunchPerAppType(
      GetAppTypeName(profile, app_type, app_id, container));
  RecordAppLaunchPerAppTypeV2(
      GetAppTypeNameV2(profile, app_type, app_id, container));

  // TODO(b/356937112): Refactor the metrics DemoMode.AppLaunchSource
  if (ash::demo_mode::IsDeviceInDemoMode()) {
    ash::DemoSession::AppLaunchSource source;
    bool will_report = true;
    // Apps launched from the demo mode app has the launch source of
    // kFromOtherApp, but we do not report it here since there could be other
    // places that launch apps with the same launch source of kFromOtherApp. So,
    // to be more accurate, we report it in
    // [chrome_demo_mode_app_delegate.cc]ChromeDemoModeAppDelegate::LaunchApp.
    // Additionally, we report only the following types of launch source based
    // on the need of demo mode.
    switch (launch_source) {
      case apps::LaunchSource::kFromAppListGrid:
        source = ash::DemoSession::AppLaunchSource::kAppList;
        break;
      case apps::LaunchSource::kFromAppListQuery:
        source = ash::DemoSession::AppLaunchSource::kAppListQuery;
        break;
      case apps::LaunchSource::kFromShelf:
        source = ash::DemoSession::AppLaunchSource::kShelf;
        break;
      default:
        will_report = false;
    }
    if (will_report) {
      ash::DemoSession::RecordAppLaunchSource(source);
    }
  }

  auto* proxy = apps::AppServiceProxyFactory::GetForProfile(profile);
  if (proxy && proxy->AppPlatformMetrics()) {
    proxy->AppPlatformMetrics()->RecordAppLaunchUkm(app_type, app_id,
                                                    launch_source, container);
  }
}

AppPlatformMetrics::UsageTime::UsageTime() = default;

AppPlatformMetrics::UsageTime::~UsageTime() = default;

AppPlatformMetrics::UsageTime::UsageTime(const base::Value& value) {
  const base::Value::Dict* data_dict = value.GetIfDict();
  if (!data_dict) {
    return;
  }

  const std::string* const app_id_value =
      data_dict->FindString(kUsageTimeAppIdKey);
  if (!app_id_value) {
    return;
  }

  const std::string* const app_publisher_id_value =
      data_dict->FindString(kUsageTimeAppPublisherIdKey);
  if (app_publisher_id_value) {
    app_publisher_id = *app_publisher_id_value;
  }

  const std::string* const app_type_value =
      data_dict->FindString(kUsageTimeAppTypeKey);
  if (!app_type_value) {
    return;
  }

  const std::optional<const base::TimeDelta> running_time_value =
      base::ValueToTimeDelta(data_dict->Find(kUsageTimeDurationKey));
  const std::optional<const base::TimeDelta> reporting_usage_time_value =
      base::ValueToTimeDelta(data_dict->Find(kReportingUsageTimeDurationKey));
  if (!running_time_value.has_value() &&
      !reporting_usage_time_value.has_value()) {
    return;
  }

  if (running_time_value.has_value()) {
    running_time = running_time_value.value();
  }

  if (reporting_usage_time_value.has_value()) {
    reporting_usage_time = reporting_usage_time_value.value();
  }

  app_id = *app_id_value;
  app_type_name = GetAppTypeNameFromString(*app_type_value);

  // We normally use this as we load data from the pref store at the
  // beginning of a new session which is when windows are normally closed.
  window_is_closed = true;
}

base::Value::Dict AppPlatformMetrics::UsageTime::ConvertToDict() const {
  base::Value::Dict usage_time_dict;
  usage_time_dict.Set(kUsageTimeAppIdKey, app_id);
  usage_time_dict.Set(kUsageTimeAppPublisherIdKey, app_publisher_id);
  usage_time_dict.Set(kUsageTimeAppTypeKey,
                      GetAppTypeHistogramName(app_type_name));
  usage_time_dict.Set(kUsageTimeDurationKey,
                      base::TimeDeltaToValue(running_time));
  usage_time_dict.Set(kReportingUsageTimeDurationKey,
                      base::TimeDeltaToValue(reporting_usage_time));
  return usage_time_dict;
}

AppPlatformMetrics::AppPlatformMetrics(
    Profile* profile,
    apps::AppRegistryCache& app_registry_cache,
    InstanceRegistry& instance_registry)
    : profile_(profile), app_registry_cache_(app_registry_cache) {
  app_registry_cache_observer_.Observe(&app_registry_cache);
  instance_registry_observation_.Observe(&instance_registry);
  if (chromeos::IsManagedGuestSession()) {
    CHECK(ukm::UkmRecorder::Get());
    ukm_recorder_observer_.Observe(ukm::UkmRecorder::Get());
  }
  user_type_by_device_type_ = GetUserTypeByDeviceTypeMetrics();
  InitRunningDuration();
  LoadAppsUsageTimeUkmFromPref();
  ReadInstalledApps();
}

AppPlatformMetrics::~AppPlatformMetrics() {
  UpdateMetricsBeforeShutdown();
  OnTenMinutes();

  // Notify registered observers.
  for (auto& observer : observers_) {
    observer.OnAppPlatformMetricsDestroyed();
  }
}

// static
ukm::SourceId AppPlatformMetrics::GetSourceId(Profile* profile,
                                              const std::string& app_id) {
  if (!AppServiceProxyFactory::IsAppServiceAvailableForProfile(profile)) {
    return ukm::kInvalidSourceId;
  }

  AppType app_type = GetAppType(profile, app_id);
  if (!ShouldRecordAppKMForAppTypeName(app_type)) {
    return ukm::kInvalidSourceId;
  }

  GURL url = GetURLForApp(profile, app_id);
  if (url.is_empty()) {
    return ukm::kInvalidSourceId;
  }

  switch (app_type) {
    case AppType::kChromeApp:
    case AppType::kExtension:
    case AppType::kSystemWeb:
      return ukm::AppSourceUrlRecorder::GetSourceIdForUrl(
          url, ukm::AppType::kChromeApp);
    case AppType::kArc:
      return ukm::AppSourceUrlRecorder::GetSourceIdForUrl(url,
                                                          ukm::AppType::kArc);
    case AppType::kWeb: {
      // Some system web-apps may be PWAs.
      if (IsSystemWebApp(profile, app_id)) {
        return ukm::AppSourceUrlRecorder::GetSourceIdForUrl(
            url, ukm::AppType::kChromeApp);
      }
      return ukm::AppSourceUrlRecorder::GetSourceIdForUrl(url,
                                                          ukm::AppType::kPWA);
    }
    case AppType::kCrostini:
      return ukm::AppSourceUrlRecorder::GetSourceIdForUrl(
          url, ukm::AppType::kCrostini);
    case AppType::kBorealis:
      return ukm::AppSourceUrlRecorder::GetSourceIdForUrl(
          url, ukm::AppType::kBorealis);
    // App types that are not supported by UKM.
    default:
      return ukm::kInvalidSourceId;
  }
}

// static
GURL AppPlatformMetrics::GetURLForApp(Profile* profile,
                                      const std::string& app_id) {
  AppType app_type = GetAppType(profile, app_id);

  // If the app should not be recorded, then emit an empty URL so the URL is not
  // recorded for the associated app.
  if (!ShouldRecordAppKMForAppTypeName(app_type)) {
    return GURL();
  }

  switch (app_type) {
    // |app_id| is already hashed for these apps and are of the format
    // app://{app_id}.
    case AppType::kChromeApp:
    case AppType::kExtension:
    // For system web apps, call GetSourceIdForChromeApp to record the app
    // id because the url could be filtered by the server side.
    case AppType::kSystemWeb:
      return ukm::AppSourceUrlRecorder::GetURLForChromeApp(app_id);
    // ARC apps contain the app package name and the URL generated is of the
    // format app://{package_name}. The package name will be populated if it is
    // a properly registered ARC app.
    case AppType::kArc: {
      std::string package_name = GetPublisherId(profile, app_id);
      // Empty package name ID indicates that the ARC app is not properly
      // registered application.
      if (package_name.empty() || app_id.empty()) {
        return GURL();
      }
      return ukm::AppSourceUrlRecorder::GetURLForArcPackageName(package_name);
    }
    case AppType::kWeb: {
      // Some PWAs can be categorized as system web apps. System web apps should
      // be encoded as a ChromeApp hash.
      if (IsSystemWebApp(profile, app_id)) {
        return ukm::AppSourceUrlRecorder::GetURLForChromeApp(app_id);
      }

      std::string publisher_id = GetPublisherId(profile, app_id);
      // Empty publisher ID indicates that the app is not a properly registered
      // PWA.
      if (publisher_id.empty() || app_id.empty()) {
        return GURL();
      }

      return ukm::AppSourceUrlRecorder::GetURLForPWA(GURL(publisher_id));
    }
    case AppType::kCrostini: {
      auto crostini_app_id = GetIdForCrostini(profile, app_id);
      return ukm::AppSourceUrlRecorder::GetURLForCrostini(
          crostini_app_id.desktop_id, crostini_app_id.registration_name);
    }
    case AppType::kBorealis:
      return GetURLForBorealis(profile, app_id);
    // Other app types should not be logged. Return empty GURL so that
    // these app types are not recorded.
    default:
      return GURL();
  }
}

// static
std::string AppPlatformMetrics::GetPublisherId(Profile* profile,
                                               const std::string& app_id) {
  std::string publisher_id;
  apps::AppServiceProxyFactory::GetForProfile(profile)
      ->AppRegistryCache()
      .ForOneApp(app_id, [&publisher_id](const apps::AppUpdate& update) {
        publisher_id = update.PublisherId();
      });
  return publisher_id;
}

// static
GURL AppPlatformMetrics::GetURLForBorealis(Profile* profile,
                                           const std::string& app_id) {
  // Most Borealis apps are identified by a numeric ID, except these.
  if (app_id == borealis::kClientAppId) {
    return ukm::AppSourceUrlRecorder::GetURLForBorealis("client");
  } else if (app_id == borealis::kInstallerAppId) {
    return ukm::AppSourceUrlRecorder::GetURLForBorealis("installer");
  } else if (app_id.find(borealis::kIgnoredAppIdPrefix) != std::string::npos) {
    // These are not real apps from a user's point of view, so it doesn't make
    // sense to record metrics for them.
    return GURL();
  }

  // For most borealis apps, we convert to the "steam app id", which is a unique
  // number valve assigns to each game.
  //
  // This is more robust, as it handles some unidentified apps (if they have a
  // steam id).
  std::optional<int> borealis_id = borealis::SteamGameId(profile, app_id);
  if (borealis_id.has_value()) {
    return ukm::AppSourceUrlRecorder::GetURLForBorealis(
        base::NumberToString(borealis_id.value()));
  }

  // If there's no steam id then we're not allowed to record anything that
  // could identify the app (and we don't know the app name anyway), but
  // recording every unregistered app in one big bucket is fine.
  //
  // In general all Borealis apps should have a steam id, so if we do see this
  // Source ID being reported, that's a bug.
  LOG(WARNING) << "Couldn't get Borealis ID for UNREGISTERED app " << app_id;
  return ukm::AppSourceUrlRecorder::GetURLForBorealis("UNREGISTERED");
}

// static
CrostiniAppId AppPlatformMetrics::GetIdForCrostini(Profile* profile,
                                                   const std::string& app_id) {
  auto* registry =
      guest_os::GuestOsRegistryServiceFactory::GetForProfile(profile);
  auto registration = registry->GetRegistration(app_id);
  if (!registration) {
    // If there's no registration then we're not allowed to record anything
    // that could identify the app (and we don't know the app name anyway),
    // but recording every unregistered app in one big bucket is fine.
    return CrostiniAppId{
        .desktop_id = "UNREGISTERED",
        .registration_name = "UNREGISTERED",
    };
  }
  auto desktop_id = registration->DesktopFileId() == ""
                        ? "NoId"
                        : registration->DesktopFileId();
  return CrostiniAppId{
      .desktop_id = desktop_id,
      .registration_name = registration->Name(),

  };
}

// static
void AppPlatformMetrics::RemoveSourceId(ukm::SourceId source_id) {
  ukm::AppSourceUrlRecorder::MarkSourceForDeletion(source_id);
}

// static
std::string AppPlatformMetrics::GetAppsCountHistogramNameForTest(
    AppTypeName app_type_name) {
  return kAppsCountHistogramPrefix + GetAppTypeHistogramName(app_type_name);
}

// static
std::string
AppPlatformMetrics::GetAppsCountPerInstallReasonHistogramNameForTest(
    AppTypeName app_type_name,
    apps::InstallReason install_reason) {
  return kAppsCountPerInstallReasonHistogramPrefix +
         GetAppTypeHistogramName(app_type_name) + "." +
         GetInstallReason(install_reason);
}

// static
std::string AppPlatformMetrics::GetAppsRunningDurationHistogramNameForTest(
    AppTypeName app_type_name) {
  return kAppsRunningDurationHistogramPrefix +
         GetAppTypeHistogramName(app_type_name);
}

// static
std::string AppPlatformMetrics::GetAppsRunningPercentageHistogramNameForTest(
    AppTypeName app_type_name) {
  return kAppsRunningPercentageHistogramPrefix +
         GetAppTypeHistogramName(app_type_name);
}

// static
std::string AppPlatformMetrics::GetAppsActivatedCountHistogramNameForTest(
    AppTypeName app_type_name) {
  return kAppsActivatedCountHistogramPrefix +
         GetAppTypeHistogramName(app_type_name);
}

std::string AppPlatformMetrics::GetAppsUsageTimeHistogramNameForTest(
    AppTypeName app_type_name) {
  return kAppsUsageTimeHistogramPrefix + GetAppTypeHistogramName(app_type_name);
}

std::string AppPlatformMetrics::GetAppsUsageTimeHistogramNameForTest(
    AppTypeNameV2 app_type_name) {
  return kAppsUsageTimeHistogramPrefixV2 +
         GetAppTypeHistogramNameV2(app_type_name);
}

void AppPlatformMetrics::OnNewDay() {
  should_record_metrics_on_new_day_ = true;
  RecordAppsCount(AppType::kUnknown);
  RecordAppsRunningDuration();
}

void AppPlatformMetrics::OnTenMinutes() {
  if (should_refresh_activated_count_pref) {
    should_refresh_activated_count_pref = false;
    ScopedDictPrefUpdate activated_count_update(profile_->GetPrefs(),
                                                kAppActivatedCount);
    for (auto it : activated_count_) {
      std::string app_type_name = GetAppTypeHistogramName(it.first);
      DCHECK(!app_type_name.empty());
      activated_count_update->Set(app_type_name, it.second);
    }
  }

  if (should_refresh_duration_pref) {
    should_refresh_duration_pref = false;
    ScopedDictPrefUpdate running_duration_update(profile_->GetPrefs(),
                                                 kAppRunningDuration);
    for (auto it : running_duration_) {
      std::string app_type_name = GetAppTypeHistogramName(it.first);
      DCHECK(!app_type_name.empty());
      running_duration_update->SetByDottedPath(
          app_type_name, base::TimeDeltaToValue(it.second));
    }
  }
}

void AppPlatformMetrics::OnFiveMinutes() {
  // If there is app usage time loaded from the user pref for previous login,
  // record the AppKM.
  if (!usage_times_from_pref_.empty()) {
    RecordAppsUsageTimeUkmFromPref();
    usage_times_from_pref_.clear();
  }
  RecordAppsUsageTime();
  SaveUsageTime();
}

void AppPlatformMetrics::OnTwoHours() {
  RecordAppsUsageTimeUkm();
}

void AppPlatformMetrics::RecordAppLaunchUkm(AppType app_type,
                                            const std::string& app_id,
                                            apps::LaunchSource launch_source,
                                            apps::LaunchContainer container) {
  // We do not tie observers to local app sync settings, so we notify them
  // first. It is the responsibility of observers to enforce appropriate checks
  // and restrictions with something appropriate before using this data.
  for (auto& observer : observers_) {
    observer.OnAppLaunched(app_id, app_type, launch_source);
  }

  if (app_type == AppType::kUnknown ||
      !ShouldRecordAppKMForAppId(profile_, app_registry_cache_.get(), app_id)) {
    return;
  }

  apps::AppTypeName app_type_name =
      GetAppTypeName(profile_, app_type, app_id, container);

  ukm::SourceId source_id = GetSourceId(profile_, app_id);
  if (source_id == ukm::kInvalidSourceId) {
    return;
  }

  ukm::builders::ChromeOSApp_Launch builder(source_id);
  builder.SetAppType((int)app_type_name)
      .SetLaunchSource((int)launch_source)
      .SetUserDeviceMatrix(GetUserTypeByDeviceTypeMetrics())
      .Record(ukm::UkmRecorder::Get());
  RemoveSourceId(source_id);
}

void AppPlatformMetrics::RecordAppUninstallUkm(
    AppType app_type,
    const std::string& app_id,
    UninstallSource uninstall_source) {
  // We do not tie observers to local app sync settings, so we notify them
  // first. It is the responsibility of observers to enforce appropriate checks
  // and restrictions with something appropriate before using this data.
  for (auto& observer : observers_) {
    observer.OnAppUninstalled(app_id, app_type, uninstall_source);
  }
  if (!ShouldRecordAppKMForAppId(profile_, app_registry_cache_.get(), app_id)) {
    return;
  }

  AppTypeName app_type_name = GetAppTypeName(
      profile_, app_type, app_id, apps::LaunchContainer::kLaunchContainerNone);

  ukm::SourceId source_id = GetSourceId(profile_, app_id);
  if (source_id == ukm::kInvalidSourceId) {
    return;
  }

  ukm::builders::ChromeOSApp_UninstallApp builder(source_id);
  builder.SetAppType((int)app_type_name)
      .SetUninstallSource((int)uninstall_source)
      .SetUserDeviceMatrix(user_type_by_device_type_)
      .Record(ukm::UkmRecorder::Get());
  RemoveSourceId(source_id);
}

void AppPlatformMetrics::AddObserver(Observer* observer) {
  observers_.AddObserver(observer);
}

void AppPlatformMetrics::RemoveObserver(Observer* observer) {
  observers_.RemoveObserver(observer);
}

void AppPlatformMetrics::OnAppTypeInitialized(AppType app_type) {
  if (should_record_metrics_on_new_day_) {
    RecordAppsCount(app_type);
  }
}

void AppPlatformMetrics::OnAppRegistryCacheWillBeDestroyed(
    apps::AppRegistryCache* cache) {
  app_registry_cache_observer_.Reset();
}

void AppPlatformMetrics::OnAppUpdate(const apps::AppUpdate& update) {
  if (!update.ReadinessChanged() ||
      update.Readiness() != apps::Readiness::kReady ||
      apps_util::IsInstalled(update.PriorReadiness())) {
    return;
  }

  InstallTime install_time =
      app_registry_cache_->IsAppTypeInitialized(update.AppType())
          ? InstallTime::kRunning
          : InstallTime::kInit;

  // We do not tie observers to local app sync settings, so we notify them
  // first. It is the responsibility of observers to enforce appropriate checks
  // and restrictions with something appropriate before using this data.
  for (auto& observer : observers_) {
    observer.OnAppInstalled(update.AppId(), update.AppType(),
                            update.InstallSource(), update.InstallReason(),
                            install_time);
  }

  if (!ShouldRecordAppKMForAppId(profile_, app_registry_cache_.get(),
                                 update.AppId())) {
    return;
  }

  RecordAppsInstallUkm(update, install_time);
}

void AppPlatformMetrics::OnInstanceUpdate(const apps::InstanceUpdate& update) {
  if (!update.StateChanged()) {
    return;
  }

  auto app_id = update.AppId();
  auto app_type = GetAppType(profile_, app_id);
  if (app_type == AppType::kUnknown) {
    return;
  }

  bool is_active = update.State() & apps::InstanceState::kActive;
  if (is_active) {
    AppTypeName app_type_name =
        GetAppTypeNameForWindow(profile_, app_type, app_id, update.Window());
    if (app_type_name == apps::AppTypeName::kUnknown) {
      return;
    }

    apps::InstanceState kInActivated = static_cast<apps::InstanceState>(
        apps::InstanceState::kVisible | apps::InstanceState::kRunning);

    // For the browser window, if a tab of the browser is activated, we don't
    // need to calculate the browser window running time.
    if ((app_id == app_constants::kChromeAppId) &&
        browser_to_tab_list_.HasActivatedTab(update.Window())) {
      SetWindowInActivated(app_id, update.InstanceId(), kInActivated);
      return;
    }

    // For web apps open in tabs, set the top browser window as inactive to stop
    // calculating the browser window running time.
    if (IsAppOpenedInTab(app_type_name, app_id)) {
      // When the tab is pulled to a separate browser window, the instance id is
      // not changed, but the parent browser window is changed. So remove the
      // tab window instance from previous browser window, and add it to the new
      // browser window.
      auto* browser_window = update.Window()->GetToplevelWindow();
      browser_to_tab_list_.RemoveActivatedTab(update.InstanceId());
      browser_to_tab_list_.AddActivatedTab(browser_window, update.InstanceId(),
                                           update.AppId());
      InstanceState state;
      base::UnguessableToken browser_id;
      std::string browser_app_id;
      GetBrowserInstanceInfo(browser_window, browser_id, browser_app_id, state);
      if (browser_id) {
        SetWindowInActivated(browser_app_id, browser_id, kInActivated);
      }
    }

    AppTypeNameV2 app_type_name_v2 =
        GetAppTypeNameV2(profile_, app_type, app_id, update.Window());

    SetWindowActivated(app_type, app_type_name, app_type_name_v2, app_id,
                       update.InstanceId());
    return;
  }

  AppTypeName app_type_name = AppTypeName::kUnknown;
  auto it = running_start_time_.find(update.InstanceId());
  if (it != running_start_time_.end()) {
    app_type_name = it->second.app_type_name;
  }

  if (IsAppOpenedInTab(app_type_name, app_id)) {
    UpdateBrowserWindowStatus(update);
  }

  SetWindowInActivated(app_id, update.InstanceId(), update.State());
}

void AppPlatformMetrics::OnInstanceRegistryWillBeDestroyed(
    apps::InstanceRegistry* cache) {
  instance_registry_observation_.Reset();
}

void AppPlatformMetrics::OnStartingShutdown() {
  CHECK(chromeos::IsManagedGuestSession());
  UpdateMetricsBeforeShutdown();
  RecordAppsUsageTimeUkm();
}

void AppPlatformMetrics::GetBrowserInstanceInfo(
    const aura::Window* browser_window,
    base::UnguessableToken& browser_id,
    std::string& browser_app_id,
    InstanceState& state) const {
  auto* proxy = apps::AppServiceProxyFactory::GetForProfile(profile_);
  DCHECK(proxy);
  browser_id = base::UnguessableToken();
  browser_app_id = std::string();
  state = InstanceState::kUnknown;
  proxy->InstanceRegistry().ForInstancesWithWindow(
      browser_window, [&](const InstanceUpdate& browser_update) {
        if (browser_update.AppId() == app_constants::kChromeAppId) {
          browser_id = browser_update.InstanceId();
          browser_app_id = browser_update.AppId();
          state = browser_update.State();
        }
      });
}

void AppPlatformMetrics::UpdateBrowserWindowStatus(
    const InstanceUpdate& update) {
  const base::UnguessableToken& tab_id = update.InstanceId();
  const auto* browser_window = browser_to_tab_list_.GetBrowserWindow(tab_id);
  if (!browser_window) {
    return;
  }

  // Remove the tab id from `active_browser_to_tabs_`.
  browser_to_tab_list_.RemoveActivatedTab(tab_id);

  // If there are other activated web app tab, we don't need to set the browser
  // window as activated.
  if (browser_to_tab_list_.HasActivatedTab(browser_window)) {
    return;
  }

  auto* proxy = apps::AppServiceProxyFactory::GetForProfile(profile_);
  DCHECK(proxy);
  InstanceState state;
  base::UnguessableToken browser_id;
  std::string browser_app_id;
  GetBrowserInstanceInfo(browser_window, browser_id, browser_app_id, state);
  if (state & InstanceState::kActive) {
    // The browser window is activated, start calculating the browser window
    // running time.
    SetWindowActivated(AppType::kChromeApp, AppTypeName::kChromeBrowser,
                       AppTypeNameV2::kChromeBrowser, browser_app_id,
                       browser_id);
  }
}

void AppPlatformMetrics::SetWindowActivated(
    AppType app_type,
    AppTypeName app_type_name,
    AppTypeNameV2 app_type_name_v2,
    const std::string& app_id,
    const base::UnguessableToken& instance_id) {
  auto it = running_start_time_.find(instance_id);
  if (it != running_start_time_.end()) {
    return;
  }

  running_start_time_[instance_id].start_time = base::TimeTicks::Now();
  running_start_time_[instance_id].app_type_name = app_type_name;
  running_start_time_[instance_id].app_type_name_v2 = app_type_name_v2;

  ++activated_count_[app_type_name];
  should_refresh_activated_count_pref = true;

  start_time_per_five_minutes_[instance_id].start_time = base::TimeTicks::Now();
  start_time_per_five_minutes_[instance_id].app_type_name = app_type_name;
  start_time_per_five_minutes_[instance_id].app_type_name_v2 = app_type_name_v2;
  start_time_per_five_minutes_[instance_id].app_id = app_id;
}

void AppPlatformMetrics::SetWindowInActivated(
    const std::string& app_id,
    const base::UnguessableToken& instance_id,
    apps::InstanceState state) {
  bool is_close = state & apps::InstanceState::kDestroyed;
  auto two_hours_it = usage_time_per_two_hours_.find(instance_id);
  if (is_close && two_hours_it != usage_time_per_two_hours_.end()) {
    two_hours_it->second.window_is_closed = true;
  }

  auto it = running_start_time_.find(instance_id);
  if (it == running_start_time_.end()) {
    return;
  }

  AppTypeName app_type_name = it->second.app_type_name;
  AppTypeNameV2 app_type_name_v2 = it->second.app_type_name_v2;

  running_duration_[app_type_name] +=
      base::TimeTicks::Now() - it->second.start_time;

  base::TimeDelta running_time =
      base::TimeTicks::Now() -
      start_time_per_five_minutes_[instance_id].start_time;
  app_type_running_time_per_five_minutes_[app_type_name] += running_time;
  app_type_v2_running_time_per_five_minutes_[app_type_name_v2] += running_time;

  UpdateUsageTime(instance_id, app_id, app_type_name, running_time);

  running_start_time_.erase(it);
  start_time_per_five_minutes_.erase(instance_id);

  should_refresh_duration_pref = true;
}

void AppPlatformMetrics::InitRunningDuration() {
  ScopedDictPrefUpdate running_duration_update(profile_->GetPrefs(),
                                               kAppRunningDuration);
  ScopedDictPrefUpdate activated_count_update(profile_->GetPrefs(),
                                              kAppActivatedCount);

  for (auto app_type_name : kAppTypeNameSet) {
    std::string key = GetAppTypeHistogramName(app_type_name);
    if (key.empty()) {
      continue;
    }

    std::optional<base::TimeDelta> unreported_duration =
        base::ValueToTimeDelta(running_duration_update->FindByDottedPath(key));
    if (unreported_duration.has_value()) {
      running_duration_[app_type_name] = unreported_duration.value();
    }

    std::optional<int> count = activated_count_update->FindIntByDottedPath(key);
    if (count.has_value()) {
      activated_count_[app_type_name] = count.value();
    }
  }
}

void AppPlatformMetrics::ClearRunningDuration() {
  running_duration_.clear();
  activated_count_.clear();

  profile_->GetPrefs()->SetDict(kAppRunningDuration, base::Value::Dict());
  profile_->GetPrefs()->SetDict(kAppActivatedCount, base::Value::Dict());
}

void AppPlatformMetrics::ReadInstalledApps() {
  app_registry_cache_->ForEachApp([this](const apps::AppUpdate& update) {
    if (ShouldRecordAppKMForAppId(profile_, app_registry_cache_.get(),
                                  update.AppId())) {
      RecordAppsInstallUkm(update, InstallTime::kInit);
    }
  });
}

void AppPlatformMetrics::RecordAppsCount(AppType app_type) {
  std::map<AppTypeName, int> app_count;
  std::map<AppTypeName, std::map<apps::InstallReason, int>>
      app_count_per_install_reason;

  app_registry_cache_->ForEachApp(
      [app_type, this, &app_count,
       &app_count_per_install_reason](const apps::AppUpdate& update) {
        if (app_type != apps::AppType::kUnknown &&
            (update.AppType() != app_type ||
             update.AppId() == app_constants::kChromeAppId)) {
          return;
        }

        AppTypeName app_type_name =
            GetAppTypeName(profile_, update.AppType(), update.AppId(),
                           apps::LaunchContainer::kLaunchContainerNone);

        if (app_type_name == AppTypeName::kChromeBrowser ||
            app_type_name == AppTypeName::kUnknown) {
          return;
        }

        ++app_count[app_type_name];
        ++app_count_per_install_reason[app_type_name][update.InstallReason()];
      });

  for (auto it : app_count) {
    std::string histogram_name = GetAppTypeHistogramName(it.first);
    if (!histogram_name.empty() &&
        histogram_name != kChromeBrowserHistogramName) {
      // If there are more than a thousand apps installed, then that count is
      // going into an overflow bucket. We don't expect this scenario to happen
      // often.
      base::UmaHistogramCounts1000(kAppsCountHistogramPrefix + histogram_name,
                                   it.second);
      for (auto install_reason_it : app_count_per_install_reason[it.first]) {
        base::UmaHistogramCounts1000(
            kAppsCountPerInstallReasonHistogramPrefix + histogram_name + "." +
                GetInstallReason(install_reason_it.first),
            install_reason_it.second);
      }
    }
  }
}

void AppPlatformMetrics::RecordAppsRunningDuration() {
  for (auto& it : running_start_time_) {
    running_duration_[it.second.app_type_name] +=
        GetDurationAndResetStartTime(it.second.start_time);
  }

  base::TimeDelta total_running_duration;
  for (auto it : running_duration_) {
    base::UmaHistogramCustomTimes(
        kAppsRunningDurationHistogramPrefix + GetAppTypeHistogramName(it.first),
        it.second, kMinDuration, kMaxDuration, kDurationBuckets);
    total_running_duration += it.second;
  }

  if (!total_running_duration.is_zero()) {
    for (auto it : running_duration_) {
      base::UmaHistogramPercentage(kAppsRunningPercentageHistogramPrefix +
                                       GetAppTypeHistogramName(it.first),
                                   100 * (it.second / total_running_duration));
    }
  }

  for (auto it : activated_count_) {
    base::UmaHistogramCounts10000(
        kAppsActivatedCountHistogramPrefix + GetAppTypeHistogramName(it.first),
        it.second);
  }

  ClearRunningDuration();
}

void AppPlatformMetrics::RecordAppsUsageTime() {
  for (auto& it : start_time_per_five_minutes_) {
    base::TimeDelta running_time =
        GetDurationAndResetStartTime(it.second.start_time);
    app_type_running_time_per_five_minutes_[it.second.app_type_name] +=
        running_time;
    app_type_v2_running_time_per_five_minutes_[it.second.app_type_name_v2] +=
        running_time;
    UpdateUsageTime(it.first, it.second.app_id, it.second.app_type_name,
                    running_time);
  }

  for (auto it : app_type_running_time_per_five_minutes_) {
    base::UmaHistogramCustomTimes(
        kAppsUsageTimeHistogramPrefix + GetAppTypeHistogramName(it.first),
        it.second, kMinDuration, kMaxUsageDuration, kUsageTimeBuckets);
  }

  for (auto it : app_type_v2_running_time_per_five_minutes_) {
    base::UmaHistogramCustomTimes(
        kAppsUsageTimeHistogramPrefixV2 + GetAppTypeHistogramNameV2(it.first),
        it.second, kMinDuration, kMaxUsageDuration, kUsageTimeBuckets);
  }

  app_type_running_time_per_five_minutes_.clear();
  app_type_v2_running_time_per_five_minutes_.clear();
}

void AppPlatformMetrics::RecordAppsUsageTimeUkm() {
  if (!ShouldRecordAppKM(profile_)) {
    // Attempt to clean up pre-existing data in the pref store. This is useful
    // (and harmless) because we routinely clean up usage data that has already
    // been reported.
    CleanUpAppsUsageInfoInPrefStore();
    return;
  }

  std::vector<base::UnguessableToken> closed_instance_ids;
  for (auto& it : usage_time_per_two_hours_) {
    apps::AppTypeName app_type_name = it.second.app_type_name;
    ukm::SourceId source_id = it.second.source_id;
    DCHECK_NE(source_id, ukm::kInvalidSourceId);
    if (!it.second.running_time.is_zero()) {
      if (ShouldRecordAppKMForAppId(profile_, app_registry_cache_.get(),
                                    it.second.app_id)) {
        auto new_source_id = GetSourceId(profile_, it.second.app_id);
        if (new_source_id != ukm::kInvalidSourceId) {
          ukm::builders::ChromeOSApp_UsageTime builder(new_source_id);
          builder.SetAppType((int)it.second.app_type_name)
              .SetDuration(it.second.running_time.InMilliseconds())
              .SetUserDeviceMatrix(user_type_by_device_type_)
              .Record(ukm::UkmRecorder::Get());
          RemoveSourceId(new_source_id);
        }

        // Preserve a copy of UsageTime UKM to investigate the null app id
        // issue.
        ukm::builders::ChromeOSApp_UsageTimeReusedSourceId builder(source_id);
        builder.SetAppType((int)app_type_name)
            .SetDuration(it.second.running_time.InMilliseconds())
            .SetUserDeviceMatrix(user_type_by_device_type_)
            .Record(ukm::UkmRecorder::Get());
      }

      // UMA for Mall app.
      if (AppIdToName(it.second.app_id) == DefaultAppName::kMall) {
        base::UmaHistogramCustomTimes("Apps.AppDiscovery.MallUsageTime",
                                      it.second.running_time, base::Seconds(1),
                                      base::Hours(2), 100);
      }

      // Also reset time in the pref store now that we have reported this data.
      ClearAppsUsageTimeForInstance(it.first.ToString());
    }
    if (it.second.window_is_closed) {
      closed_instance_ids.push_back(it.first);
      RemoveSourceId(source_id);
    } else {
      it.second.running_time = base::TimeDelta();
    }
  }

  // `usage_time_per_two_hours_` can't be cleared to reuse the source id for
  // open windows. So only closed window records can be deleted from
  // `usage_time_per_two_hours_`.
  for (const auto& instance_id : closed_instance_ids) {
    usage_time_per_two_hours_.erase(instance_id);
  }

  CleanUpAppsUsageInfoInPrefStore();
}

void AppPlatformMetrics::RecordAppsInstallUkm(const apps::AppUpdate& update,
                                              InstallTime install_time) {
  AppTypeName app_type_name =
      GetAppTypeName(profile_, update.AppType(), update.AppId(),
                     apps::LaunchContainer::kLaunchContainerNone);

  ukm::SourceId source_id = GetSourceId(profile_, update.AppId());
  if (source_id == ukm::kInvalidSourceId) {
    return;
  }

  ukm::builders::ChromeOSApp_InstalledApp builder(source_id);
  builder.SetAppType((int)app_type_name)
      .SetInstallReason((int)update.InstallReason())
      .SetInstallSource2((int)update.InstallSource())
      .SetInstallTime((int)install_time)
      .SetUserDeviceMatrix(user_type_by_device_type_)
      .Record(ukm::UkmRecorder::Get());
  RemoveSourceId(source_id);
}

void AppPlatformMetrics::UpdateUsageTime(
    const base::UnguessableToken& instance_id,
    const std::string& app_id,
    AppTypeName app_type_name,
    const base::TimeDelta& running_time) {
  // Notify registered observers.
  for (auto& observer : observers_) {
    observer.OnAppUsage(app_id, GetAppType(profile_, app_id), instance_id,
                        running_time);
  }
  if (!ShouldRecordAppKM(profile_)) {
    // Avoid incrementing app usage counters if it cannot be reported. This
    // ensures we only track usage for the period the user has sync enabled.
    return;
  }

  auto usage_time_it = usage_time_per_two_hours_.find(instance_id);
  if (usage_time_it == usage_time_per_two_hours_.end()) {
    auto source_id = GetSourceId(profile_, app_id);
    if (source_id != ukm::kInvalidSourceId) {
      usage_time_per_two_hours_[instance_id].source_id = source_id;
      usage_time_per_two_hours_[instance_id].app_id = app_id;
      usage_time_it = usage_time_per_two_hours_.find(instance_id);
    }
  }
  if (usage_time_it != usage_time_per_two_hours_.end()) {
    usage_time_it->second.app_type_name = app_type_name;
    usage_time_it->second.running_time += running_time;
  }
}

void AppPlatformMetrics::SaveUsageTime() {
  if (!ShouldRecordAppKM(profile_)) {
    // Do not persist usage data to the pref store if it cannot be reported.
    // This will prevent unnecessary disk space usage.
    return;
  }

  ScopedDictPrefUpdate usage_dict_pref(profile_->GetPrefs(), kAppUsageTime);
  for (const auto& it : usage_time_per_two_hours_) {
    const std::string& instance_id = it.first.ToString();
    auto* const usage_info = usage_dict_pref->FindDictByDottedPath(instance_id);
    if (!usage_info) {
      // No entry in the pref store for this instance, so we create a new one.
      usage_dict_pref->SetByDottedPath(instance_id, it.second.ConvertToDict());
      continue;
    }

    // Only override the fields tracked by this component so we do not override
    // the reporting usage time.
    usage_info->Set(kUsageTimeAppIdKey, it.second.app_id);
    usage_info->Set(kUsageTimeAppTypeKey,
                    GetAppTypeHistogramName(it.second.app_type_name));
    usage_info->Set(kUsageTimeDurationKey,
                    base::TimeDeltaToValue(it.second.running_time));
  }
}

void AppPlatformMetrics::LoadAppsUsageTimeUkmFromPref() {
  const base::Value::Dict& usage_time_dict =
      profile_->GetPrefs()->GetDict(kAppUsageTime);

  for (auto it : usage_time_dict) {
    std::unique_ptr<UsageTime> usage_time =
        std::make_unique<UsageTime>(it.second);
    if (!usage_time->running_time.is_zero()) {
      usage_times_from_pref_.push_back(std::move(usage_time));
    }
  }
}

void AppPlatformMetrics::RecordAppsUsageTimeUkmFromPref() {
  if (!ShouldRecordAppKM(profile_) || usage_times_from_pref_.empty()) {
    return;
  }

  for (auto& it : usage_times_from_pref_) {
    if (ShouldRecordAppKMForAppId(profile_, app_registry_cache_.get(),
                                  it->app_id)) {
      auto source_id = GetSourceId(profile_, it->app_id);
      if (source_id != ukm::kInvalidSourceId) {
        ukm::builders::ChromeOSApp_UsageTime builder(source_id);
        builder.SetAppType((int)it->app_type_name)
            .SetDuration(it->running_time.InMilliseconds())
            .SetUserDeviceMatrix(user_type_by_device_type_)
            .Record(ukm::UkmRecorder::Get());
        RemoveSourceId(source_id);
      }

      // All windows read from the user pref have been closed before login, so
      // create a new source id here, since we don't have previous source ids
      // for them. This UKM record should not have the null app id issue. Still
      // preserve a copy of UsageTime UKM to investigate the null app id issue
      // for consistency.
      source_id = GetSourceId(profile_, it->app_id);
      if (source_id != ukm::kInvalidSourceId) {
        ukm::builders::ChromeOSApp_UsageTimeReusedSourceId builder(source_id);
        builder.SetAppType((int)it->app_type_name)
            .SetDuration(it->running_time.InMilliseconds())
            .SetUserDeviceMatrix(user_type_by_device_type_)
            .Record(ukm::UkmRecorder::Get());
        RemoveSourceId(source_id);
      }
    }

    // Clear app UKM usage from the pref store now that we have reported this
    // data.
    for (const auto usage_it : profile_->GetPrefs()->GetDict(kAppUsageTime)) {
      if (CHECK_DEREF(usage_it.second.GetDict().FindString(
              kUsageTimeAppIdKey)) == it->app_id) {
        ClearAppsUsageTimeForInstance(usage_it.first);
      }
    }
  }
}

void AppPlatformMetrics::CleanUpAppsUsageInfoInPrefStore() {
  ScopedDictPrefUpdate usage_time_pref_update(profile_->GetPrefs(),
                                              kAppUsageTime);
  auto usage_it = usage_time_pref_update->begin();
  while (usage_it != usage_time_pref_update->end()) {
    UsageTime usage_time(usage_it->second);
    if (usage_time.reporting_usage_time.is_zero() &&
        usage_time.running_time.is_zero()) {
      usage_it = usage_time_pref_update->erase(usage_it);
      continue;
    }
    usage_it++;
  }
}

void AppPlatformMetrics::ClearAppsUsageTimeForInstance(
    std::string_view instance_id) {
  ScopedDictPrefUpdate usage_time_pref_update(profile_->GetPrefs(),
                                              kAppUsageTime);
  auto* instance_dict =
      usage_time_pref_update->FindDictByDottedPath(instance_id);
  if (instance_dict) {
    instance_dict->Set(kUsageTimeDurationKey, base::Int64ToValue(0));
  }
}

void AppPlatformMetrics::UpdateMetricsBeforeShutdown() {
  for (auto& it : running_start_time_) {
    running_duration_[it.second.app_type_name] +=
        GetDurationAndResetStartTime(it.second.start_time);
  }

  RecordAppsUsageTime();
}

}  // namespace apps