chrome/browser/lacros/lacros_extension_apps_publisher.cc

// 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/lacros/lacros_extension_apps_publisher.h"

#include <set>
#include <utility>

#include "base/check.h"
#include "base/containers/extend.h"
#include "base/files/file_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/not_fatal_until.h"
#include "base/scoped_observation.h"
#include "chrome/browser/apps/app_service/app_icon/app_icon_factory.h"
#include "chrome/browser/apps/app_service/extension_apps_utils.h"
#include "chrome/browser/apps/app_service/intent_util.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/chromeos/extensions/web_file_handlers/intent_util.h"
#include "chrome/browser/extensions/extension_ui_util.h"
#include "chrome/browser/extensions/launch_util.h"
#include "chrome/browser/lacros/lacros_extensions_util.h"
#include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
#include "chrome/browser/policy/system_features_disable_list_policy_handler.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/browser/ui/lacros/window_utility.h"
#include "chrome/browser/web_applications/web_app_tab_helper.h"
#include "chromeos/crosapi/mojom/app_window_tracker.mojom.h"
#include "chromeos/lacros/lacros_service.h"
#include "components/app_constants/constants.h"
#include "components/policy/core/common/policy_pref_names.h"
#include "components/prefs/pref_change_registrar.h"
#include "components/services/app_service/public/cpp/app_capability_access_cache.h"
#include "components/services/app_service/public/cpp/app_types.h"
#include "components/services/app_service/public/cpp/icon_types.h"
#include "components/services/app_service/public/cpp/intent_filter.h"
#include "components/services/app_service/public/cpp/package_id.h"
#include "content/public/browser/web_contents.h"
#include "extensions/browser/app_window/app_window.h"
#include "extensions/browser/app_window/app_window_registry.h"
#include "extensions/browser/extension_file_task_runner.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_prefs_observer.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/browser/extension_registry_observer.h"
#include "extensions/browser/extension_system.h"
#include "extensions/browser/management_policy.h"
#include "extensions/browser/path_util.h"
#include "extensions/browser/unloaded_extension_reason.h"
#include "extensions/common/constants.h"
#include "extensions/common/manifest_handlers/app_display_info.h"
#include "extensions/common/manifest_handlers/web_file_handlers_info.h"

namespace {

apps::InstallReason GetInstallReason(const extensions::Extension* extension) {
  if (extensions::Manifest::IsComponentLocation(extension->location()))
    return apps::InstallReason::kSystem;

  if (extensions::Manifest::IsPolicyLocation(extension->location()))
    return apps::InstallReason::kPolicy;

  if (extension->was_installed_by_oem())
    return apps::InstallReason::kOem;

  if (extension->was_installed_by_default())
    return apps::InstallReason::kDefault;

  return apps::InstallReason::kUser;
}

}  // namespace

// This class tracks all extension apps associated with a given Profile*. The
// observation of ExtensionPrefsObserver and ExtensionRegistryObserver is used
// to track AppService publisher events. The observation of AppsWindowRegistry
// is used to track window creation and destruction.
class LacrosExtensionAppsPublisher::ProfileTracker
    : public extensions::ExtensionPrefsObserver,
      public extensions::ExtensionRegistryObserver,
      public extensions::AppWindowRegistry::Observer {
  using Readiness = apps::Readiness;

 public:
  ProfileTracker(Profile* profile,
                 LacrosExtensionAppsPublisher* publisher,
                 const ForWhichExtensionType& which_type)
      : profile_(profile), publisher_(publisher), which_type_(which_type) {
    // Start observing for relevant events.
    prefs_observation_.Observe(extensions::ExtensionPrefs::Get(profile_));
    registry_observation_.Observe(extensions::ExtensionRegistry::Get(profile_));
    app_window_registry_observation_.Observe(
        extensions::AppWindowRegistry::Get(profile_));
    if (auto* local_state = g_browser_process->local_state()) {
      local_state_pref_change_registrar_.Init(local_state);
      local_state_pref_change_registrar_.Add(
          policy::policy_prefs::kSystemFeaturesDisableList,
          base::BindRepeating(&LacrosExtensionAppsPublisher::ProfileTracker::
                                  OnSystemFeaturesPrefChanged,
                              weak_factory_.GetWeakPtr()));
      local_state_pref_change_registrar_.Add(
          policy::policy_prefs::kSystemFeaturesDisableMode,
          base::BindRepeating(&LacrosExtensionAppsPublisher::ProfileTracker::
                                  OnSystemFeaturesPrefChanged,
                              weak_factory_.GetWeakPtr()));
      OnSystemFeaturesPrefChanged();
    }

    // Populate initial conditions [e.g. installed apps prior to starting
    // observation].
    std::vector<apps::AppPtr> apps;
    extensions::ExtensionRegistry* registry =
        extensions::ExtensionRegistry::Get(profile_);
    for (const scoped_refptr<const extensions::Extension> extension :
         registry->enabled_extensions()) {
      if (which_type_.Matches(extension.get())) {
        apps.push_back(MakeApp(extension.get(), Readiness::kReady));
      }
    }
    for (const scoped_refptr<const extensions::Extension> extension :
         registry->disabled_extensions()) {
      if (which_type_.Matches(extension.get())) {
        apps.push_back(MakeApp(extension.get(), Readiness::kDisabledByUser));
      }
    }
    for (const scoped_refptr<const extensions::Extension> extension :
         registry->terminated_extensions()) {
      if (which_type_.Matches(extension.get())) {
        apps.push_back(MakeApp(extension.get(), Readiness::kTerminated));
      }
    }
    if (!apps.empty())
      Publish(std::move(apps));

    if (which_type_.IsChromeApps()) {
      // Populate initial conditions [e.g. app windows created prior to starting
      // observation].
      for (extensions::AppWindow* app_window :
           extensions::AppWindowRegistry::Get(profile_)->app_windows()) {
        OnAppWindowAdded(app_window);
      }
    }
  }

  void Publish(const extensions::Extension* extension, Readiness readiness) {
    Publish(MakeApp(extension, readiness));
  }

  ~ProfileTracker() override = default;

 private:
  // extensions::ExtensionPrefsObserver overrides.
  void OnExtensionLastLaunchTimeChanged(
      const std::string& app_id,
      const base::Time& last_launch_time) override {
    const auto* extension =
        lacros_extensions_util::MaybeGetExtension(profile_, app_id);
    if (!extension || !which_type_.Matches(extension))
      return;

    Publish(MakeApp(extension, Readiness::kReady));
  }

  void OnExtensionPrefsWillBeDestroyed(
      extensions::ExtensionPrefs* prefs) override {
    DCHECK(prefs_observation_.IsObservingSource(prefs));
    prefs_observation_.Reset();
  }

  // extensions::ExtensionRegistryObserver overrides.
  void OnExtensionLoaded(content::BrowserContext* browser_context,
                         const extensions::Extension* extension) override {
    if (!which_type_.Matches(extension))
      return;
    Publish(MakeApp(extension, Readiness::kReady));
  }

  void OnExtensionUnloaded(
      content::BrowserContext* browser_context,
      const extensions::Extension* extension,
      extensions::UnloadedExtensionReason reason) override {
    if (!which_type_.Matches(extension))
      return;

    Readiness readiness = Readiness::kUnknown;

    switch (reason) {
      case extensions::UnloadedExtensionReason::DISABLE:
        readiness = Readiness::kDisabledByUser;
        break;
      case extensions::UnloadedExtensionReason::BLOCKLIST:
        readiness = Readiness::kDisabledByBlocklist;
        break;
      case extensions::UnloadedExtensionReason::TERMINATE:
        readiness = Readiness::kTerminated;
        break;
      case extensions::UnloadedExtensionReason::UNINSTALL:
        // App readiness will be updated by OnExtensionUninstalled(). We defer
        // to that method.
        return;
      case extensions::UnloadedExtensionReason::UNDEFINED:
      case extensions::UnloadedExtensionReason::UPDATE:
      case extensions::UnloadedExtensionReason::PROFILE_SHUTDOWN:
      case extensions::UnloadedExtensionReason::LOCK_ALL:
      case extensions::UnloadedExtensionReason::MIGRATED_TO_COMPONENT:
        return;
    }
    Publish(MakeApp(extension, readiness));
  }

  void OnExtensionInstalled(content::BrowserContext* browser_context,
                            const extensions::Extension* extension,
                            bool is_update) override {
    if (!which_type_.Matches(extension))
      return;
    Publish(MakeApp(extension, Readiness::kReady));
  }

  void OnExtensionUninstalled(content::BrowserContext* browser_context,
                              const extensions::Extension* extension,
                              extensions::UninstallReason reason) override {
    if (!which_type_.Matches(extension))
      return;
    apps::AppPtr app =
        MakeApp(extension, reason == extensions::UNINSTALL_REASON_MIGRATED
                               ? Readiness::kUninstalledByNonUser
                               : Readiness::kUninstalledByUser);
    Publish(std::move(app));
  }

  void OnShutdown(extensions::ExtensionRegistry* registry) override {
    registry_observation_.Reset();
  }

  // AppWindowRegistry::Observer overrides.
  void OnAppWindowAdded(extensions::AppWindow* app_window) override {
    // Only chrome app windows are added to the dock.
    if (!which_type_.IsChromeApps())
      return;
    // The extension also has to match.
    if (!which_type_.Matches(app_window->GetExtension()))
      return;
    std::string window_id = lacros_window_utility::GetRootWindowUniqueId(
        app_window->GetNativeWindow());
    app_window_id_cache_[app_window] = window_id;

    publisher_->OnAppWindowAdded(app_window->GetExtension()->id(), window_id);
  }

  void OnAppWindowRemoved(extensions::AppWindow* app_window) override {
    // Only chrome app windows are added to the dock.
    if (!which_type_.IsChromeApps())
      return;
    // The extension also has to match. As the extension may be destroyed at
    // this point, we use presence in app_window_id_cache_ to decide whether to
    // continue.
    auto it = app_window_id_cache_.find(app_window);
    if (it == app_window_id_cache_.end())
      return;

    std::string window_id = it->second;
    publisher_->OnAppWindowRemoved(app_window->extension_id(), window_id);

    app_window_id_cache_.erase(app_window);
  }

  // Publishes a differential update to the app service.
  void Publish(apps::AppPtr app) {
    std::vector<apps::AppPtr> apps;
    apps.push_back(std::move(app));
    Publish(std::move(apps));
  }

  // Publishes a vector of differential updates to the app service.
  void Publish(std::vector<apps::AppPtr> apps) {
    publisher_->Publish(std::move(apps));
  }

  // Whether the app should be shown in the launcher, shelf, etc.
  bool ShouldShow(const extensions::Extension* extension) {
    if (which_type_.IsExtensions())
      return false;
    extensions::ExtensionRegistry* registry =
        extensions::ExtensionRegistry::Get(profile_);
    const std::string& app_id = extension->id();
    // These three extension sets are the same three consulted by the
    // constructor. Importantly, it will exclude previously installed but
    // currently uninstalled extensions.
    bool connected = registry->enabled_extensions().Contains(app_id) ||
                     registry->disabled_extensions().Contains(app_id) ||
                     registry->terminated_extensions().Contains(app_id);
    if (!connected)
      return false;

    return extensions::ui_util::ShouldDisplayInAppLauncher(extension, profile_);
  }

  // Creates an AppPtr from an extension.
  apps::AppPtr MakeApp(const extensions::Extension* extension,
                       Readiness readiness) {
    DCHECK(which_type_.Matches(extension));
    apps::AppType app_type = which_type_.ChooseForChromeAppOrExtension(
        apps::AppType::kStandaloneBrowserChromeApp,
        apps::AppType::kStandaloneBrowserExtension);
    auto app = std::make_unique<apps::App>(app_type, extension->id());

    const bool is_app_disabled =
        base::Contains(disabled_apps_, extension->id());
    app->readiness = is_app_disabled ? Readiness::kDisabledByPolicy : readiness;
    app->name = extension->name();
    app->short_name = extension->short_name();
    app->installer_package_id =
        apps::PackageId(apps::PackageType::kChromeApp, extension->id());

    // TODO(crbug.com/40240007): Work out how pinning interacts with Lacros
    // multi-profile support once there is a product decision on what that looks
    // like.
    app->policy_ids = {extension->id()};

    app->icon_key = apps::IconKey(GetIconEffects(extension));

    auto* prefs = extensions::ExtensionPrefs::Get(profile_);
    if (prefs) {
      app->last_launch_time = prefs->GetLastLaunchTime(extension->id());
      app->install_time = prefs->GetLastUpdateTime(extension->id());
    } else {
      app->last_launch_time = base::Time();
      app->install_time = base::Time();
    }

    app->install_reason = GetInstallReason(extension);
    app->recommendable = true;
    app->searchable = true;
    app->paused = false;

    if (is_app_disabled && is_disabled_apps_mode_hidden_) {
      app->show_in_launcher = false;
      app->show_in_search = false;
      app->show_in_shelf = false;
      app->handles_intents = false;
      app->show_in_management = false;
    } else {
      bool show = ShouldShow(extension);
      app->show_in_launcher = show;
      app->show_in_shelf = show;
      app->show_in_search = show;
      app->show_in_management =
          extensions::AppDisplayInfo::ShouldDisplayInAppLauncher(*extension);
      app->handles_intents = which_type_.IsExtensions() || show;
    }

    if (which_type_.IsChromeApps()) {
      app->is_platform_app = extension->is_platform_app();

      if (extension->is_hosted_app()) {
        app->window_mode =
            extensions::GetLaunchType(extensions::ExtensionPrefs::Get(profile_),
                                      extension) ==
                    extensions::LaunchType::LAUNCH_TYPE_WINDOW
                ? apps::WindowMode::kWindow
                : apps::WindowMode::kBrowser;
      }
    }

    const extensions::ManagementPolicy* policy =
        extensions::ExtensionSystem::Get(profile_)->management_policy();
    app->allow_uninstall = (policy->UserMayModifySettings(extension, nullptr) &&
                            !policy->MustRemainInstalled(extension, nullptr));

    app->allow_close = true;

    // Add file_handlers for either of the following:
    //   a) Chrome Apps and quickoffice.
    //   b) Web File Handlers or file_browser_handler for Extensions.
    base::Extend(app->intent_filters,
                 which_type_.ChooseIntentFilter(
                     extensions::IsLegacyQuickOfficeExtension(*extension),
                     apps_util::CreateIntentFiltersForChromeApp,
                     apps_util::CreateIntentFiltersForExtension)(extension));
    return app;
  }

  apps::IconEffects GetIconEffects(const extensions::Extension* extension) {
    apps::IconEffects icon_effects = apps::IconEffects::kNone;
    icon_effects = static_cast<apps::IconEffects>(
        icon_effects | apps::IconEffects::kCrOsStandardIcon);

    if (base::Contains(disabled_apps_, extension->id())) {
      icon_effects = static_cast<apps::IconEffects>(
          icon_effects | apps::IconEffects::kBlocked);
    }
    return icon_effects;
  }

  void OnSystemFeaturesPrefChanged() {
    PrefService* const local_state = g_browser_process->local_state();
    if (!local_state || !local_state->FindPreference(
                            policy::policy_prefs::kSystemFeaturesDisableList)) {
      return;
    }

    const base::Value::List& disabled_system_features =
        local_state->GetList(policy::policy_prefs::kSystemFeaturesDisableList);

    const bool is_pref_disabled_mode_hidden =
        local_state->GetString(
            policy::policy_prefs::kSystemFeaturesDisableMode) ==
        policy::kHiddenDisableMode;
    const bool is_disabled_mode_changed =
        (is_pref_disabled_mode_hidden != is_disabled_apps_mode_hidden_);
    is_disabled_apps_mode_hidden_ = is_pref_disabled_mode_hidden;

    UpdateAppDisabledState(disabled_system_features,
                           static_cast<int>(policy::SystemFeature::kWebStore),
                           extensions::kWebStoreAppId,
                           is_disabled_mode_changed);
  }

  void UpdateAppDisabledState(
      const base::Value::List& disabled_system_features_pref,
      int feature,
      const std::string& app_id,
      bool is_disabled_mode_changed) {
    const bool is_disabled =
        base::Contains(disabled_system_features_pref, base::Value(feature));
    // Sometimes the policy is updated before the app is installed, so this way
    // the disabled_apps_ is updated regardless the Publish should happen or not
    // and the app will be published with the correct readiness upon its
    // installation.
    const bool should_publish =
        (base::Contains(disabled_apps_, app_id) != is_disabled) ||
        is_disabled_mode_changed;

    if (is_disabled) {
      disabled_apps_.insert(app_id);
    } else {
      disabled_apps_.erase(app_id);
    }

    if (!should_publish) {
      return;
    }

    const auto* extension =
        lacros_extensions_util::MaybeGetExtension(profile_, app_id);
    if (!extension) {
      return;
    }

    Publish(extension,
            is_disabled ? Readiness::kDisabledByPolicy : Readiness::kReady);
  }

  // This pointer is guaranteed to be valid and to outlive this object.
  const raw_ptr<Profile> profile_;

  // This pointer is guaranteed to be valid and to outlive this object.
  const raw_ptr<LacrosExtensionAppsPublisher> publisher_;

  // State to decide which extension type (e.g., Chrome Apps vs. Extensions)
  // to support.
  const ForWhichExtensionType which_type_;

  // Tracks apps that have been disabled from installing by enterprise policy.
  // The values come from local state and are set by updating the
  // SystemFeaturesDisableList policy.
  std::set<std::string> disabled_apps_;

  // Boolean signifying whether the preferred user experience mode of disabled
  // apps is hidden (true) or blocked (false). The value comes from local state
  // and is set by updating the SystemFeaturesDisableMode policy.
  bool is_disabled_apps_mode_hidden_ = false;

  // Registrar used to monitor the local state prefs.
  PrefChangeRegistrar local_state_pref_change_registrar_;

  // Observes both extension prefs and registry for events that affect
  // extensions.
  base::ScopedObservation<extensions::ExtensionPrefs,
                          extensions::ExtensionPrefsObserver>
      prefs_observation_{this};
  base::ScopedObservation<extensions::ExtensionRegistry,
                          extensions::ExtensionRegistryObserver>
      registry_observation_{this};

  // Observes AppWindowRegistry for app window creation and destruction.
  base::ScopedObservation<extensions::AppWindowRegistry,
                          extensions::AppWindowRegistry::Observer>
      app_window_registry_observation_{this};

  // Records the window id associated with an app window. This is needed since
  // the app window destruction callback occurs after the window is destroyed.
  std::map<extensions::AppWindow*, std::string> app_window_id_cache_;

  base::WeakPtrFactory<LacrosExtensionAppsPublisher::ProfileTracker>
      weak_factory_{this};
};

// static
std::unique_ptr<LacrosExtensionAppsPublisher>
LacrosExtensionAppsPublisher::MakeForChromeApps() {
  return std::make_unique<LacrosExtensionAppsPublisher>(InitForChromeApps());
}

// static
std::unique_ptr<LacrosExtensionAppsPublisher>
LacrosExtensionAppsPublisher::MakeForExtensions() {
  return std::make_unique<LacrosExtensionAppsPublisher>(InitForExtensions());
}

LacrosExtensionAppsPublisher::LacrosExtensionAppsPublisher(
    const ForWhichExtensionType& which_type)
    : which_type_(which_type) {}

LacrosExtensionAppsPublisher::~LacrosExtensionAppsPublisher() = default;

void LacrosExtensionAppsPublisher::Initialize() {
  if (!InitializeCrosapi())
    return;
  profile_manager_observation_.Observe(g_browser_process->profile_manager());
  auto profiles = g_browser_process->profile_manager()->GetLoadedProfiles();
  for (auto* profile : profiles) {
    // TODO(crbug.com/40199791): The app id is not stable for secondary
    // profiles and cannot be stored in sync. Thus, the app cannot be published
    // at all.
    if (!profile->IsMainProfile())
      continue;
    profile_trackers_[profile] =
        std::make_unique<ProfileTracker>(profile, this, which_type_);
  }

  // Only track the media usage for the chrome apps.
  if (which_type_.IsChromeApps()) {
    media_dispatcher_.Observe(MediaCaptureDevicesDispatcher::GetInstance()
                                  ->GetMediaStreamCaptureIndicator()
                                  .get());
  }
}

bool LacrosExtensionAppsPublisher::InitializeCrosapi() {
  // Ash is too old to support the chrome app publisher interface.
  int crosapiVersion = chromeos::LacrosService::Get()
                           ->GetInterfaceVersion<crosapi::mojom::Crosapi>();
  int minRequiredVersion =
      static_cast<int>(which_type_.ChooseForChromeAppOrExtension(
          crosapi::mojom::Crosapi::kBindChromeAppPublisherMinVersion,
          crosapi::mojom::Crosapi::kBindExtensionPublisherMinVersion));
  if (crosapiVersion < minRequiredVersion)
    return false;

  // Ash is too old to support the chrome app window tracker interface.
  if (!chromeos::LacrosService::Get()
           ->IsAvailable<crosapi::mojom::AppWindowTracker>()) {
    return false;
  }

  if (which_type_.IsChromeApps()) {
    chromeos::LacrosService::Get()
        ->BindPendingReceiverOrRemote<
            mojo::PendingReceiver<crosapi::mojom::AppPublisher>,
            &crosapi::mojom::Crosapi::BindChromeAppPublisher>(
            publisher_.BindNewPipeAndPassReceiver());
  } else if (which_type_.IsExtensions()) {
    chromeos::LacrosService::Get()
        ->BindPendingReceiverOrRemote<
            mojo::PendingReceiver<crosapi::mojom::AppPublisher>,
            &crosapi::mojom::Crosapi::BindExtensionPublisher>(
            publisher_.BindNewPipeAndPassReceiver());
  }
  return true;
}

void LacrosExtensionAppsPublisher::Publish(std::vector<apps::AppPtr> apps) {
  publisher_->OnApps(std::move(apps));
}

void LacrosExtensionAppsPublisher::PublishCapabilityAccesses(
    std::vector<apps::CapabilityAccessPtr> accesses) {
  publisher_->OnCapabilityAccesses(std::move(accesses));
}

void LacrosExtensionAppsPublisher::OnAppWindowAdded(
    const std::string& app_id,
    const std::string& window_id) {
  chromeos::LacrosService::Get()
      ->GetRemote<crosapi::mojom::AppWindowTracker>()
      ->OnAppWindowAdded(app_id, window_id);
}

void LacrosExtensionAppsPublisher::OnAppWindowRemoved(
    const std::string& app_id,
    const std::string& window_id) {
  chromeos::LacrosService::Get()
      ->GetRemote<crosapi::mojom::AppWindowTracker>()
      ->OnAppWindowRemoved(app_id, window_id);
}

void LacrosExtensionAppsPublisher::OnProfileAdded(Profile* profile) {
  // TODO(crbug.com/40199791): The app id is not stable for secondary
  // profiles and cannot be stored in sync. Thus, the app cannot be published
  // at all.
  if (!profile->IsMainProfile())
    return;
  profile_trackers_[profile] =
      std::make_unique<ProfileTracker>(profile, this, which_type_);
}

void LacrosExtensionAppsPublisher::OnProfileMarkedForPermanentDeletion(
    Profile* profile) {
  profile_trackers_.erase(profile);
}

void LacrosExtensionAppsPublisher::OnProfileManagerDestroying() {
  profile_trackers_.clear();
  profile_manager_observation_.Reset();
}

void LacrosExtensionAppsPublisher::UpdateAppWindowMode(
    const std::string& app_id,
    apps::WindowMode window_mode) {
  Profile* profile = nullptr;
  const extensions::Extension* extension = nullptr;
  bool success = lacros_extensions_util::GetProfileAndExtension(
      app_id, &profile, &extension);
  if (!success)
    return;

  DCHECK(extension->is_hosted_app());

  // Persist hosted app's launch preference.
  extensions::SetLaunchType(profile, extension->id(),
                            window_mode == apps::WindowMode::kWindow
                                ? extensions::LAUNCH_TYPE_WINDOW
                                : extensions::LAUNCH_TYPE_REGULAR);

  // Republish the app.
  auto matched = profile_trackers_.find(profile);
  CHECK(matched != profile_trackers_.end(), base::NotFatalUntil::M130);
  matched->second->Publish(extension, apps::Readiness::kReady);
}

void LacrosExtensionAppsPublisher::UpdateAppSize(const std::string& app_id) {
  Profile* profile = nullptr;
  const extensions::Extension* extension = nullptr;
  bool success = lacros_extensions_util::GetProfileAndExtension(
      app_id, &profile, &extension);
  if (!success) {
    return;
  }

  extensions::path_util::CalculateExtensionDirectorySize(
      extension->path(),
      base::BindOnce(&LacrosExtensionAppsPublisher::OnSizeCalculated,
                     weak_ptr_factory_.GetWeakPtr(), extension->id()));
}

void LacrosExtensionAppsPublisher::OnIsCapturingVideoChanged(
    content::WebContents* web_contents,
    bool is_capturing_video) {
  auto app_id = MaybeGetAppId(web_contents);
  if (!app_id.has_value()) {
    return;
  }

  auto result = media_requests_.UpdateCameraState(app_id.value(), web_contents,
                                                  is_capturing_video);
  ModifyCapabilityAccess(app_id.value(), result.camera, result.microphone);
}

void LacrosExtensionAppsPublisher::OnIsCapturingAudioChanged(
    content::WebContents* web_contents,
    bool is_capturing_audio) {
  auto app_id = MaybeGetAppId(web_contents);
  if (!app_id.has_value()) {
    return;
  }

  auto result = media_requests_.UpdateMicrophoneState(
      app_id.value(), web_contents, is_capturing_audio);
  ModifyCapabilityAccess(app_id.value(), result.camera, result.microphone);
}

void LacrosExtensionAppsPublisher::OnSizeCalculated(const std::string& app_id,
                                                    int64_t size) {
  std::vector<apps::AppPtr> apps;
  apps::AppType app_type = which_type_.ChooseForChromeAppOrExtension(
      apps::AppType::kStandaloneBrowserChromeApp,
      apps::AppType::kStandaloneBrowserExtension);
  auto app = std::make_unique<apps::App>(app_type, app_id);
  app->app_size_in_bytes = size;
  apps.push_back(std::move(app));
  Publish(std::move(apps));
}

std::optional<std::string> LacrosExtensionAppsPublisher::MaybeGetAppId(
    content::WebContents* web_contents) {
  // The web app publisher is responsible to handle `web_contents` for web
  // apps.
  const webapps::AppId* web_app_id =
      web_app::WebAppTabHelper::GetAppId(web_contents);
  if (web_app_id) {
    return std::nullopt;
  }

  const auto* extension =
      lacros_extensions_util::MaybeGetExtension(web_contents);
  return (extension && which_type_.Matches(extension))
             ? std::make_optional<std::string>(extension->id())
             : std::nullopt;
}

void LacrosExtensionAppsPublisher::ModifyCapabilityAccess(
    const std::string& app_id,
    std::optional<bool> accessing_camera,
    std::optional<bool> accessing_microphone) {
  if (!accessing_camera.has_value() && !accessing_microphone.has_value()) {
    return;
  }

  std::vector<apps::CapabilityAccessPtr> capability_accesses;
  auto capability_access = std::make_unique<apps::CapabilityAccess>(app_id);
  capability_access->camera = accessing_camera;
  capability_access->microphone = accessing_microphone;
  capability_accesses.push_back(std::move(capability_access));

  PublishCapabilityAccesses(std::move(capability_accesses));
}