chrome/browser/ash/guest_os/guest_os_shelf_utils.cc

// Copyright 2020 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/ash/guest_os/guest_os_shelf_utils.h"

#include <string_view>

#include "base/logging.h"
#include "base/no_destructor.h"
#include "base/strings/string_util.h"
#include "chrome/browser/ash/borealis/borealis_window_manager.h"
#include "chrome/browser/ash/guest_os/guest_id.h"
#include "chrome/browser/ash/guest_os/guest_os_pref_names.h"
#include "chrome/browser/ash/guest_os/guest_os_session_tracker.h"
#include "chrome/browser/ash/guest_os/public/types.h"
#include "chrome/browser/profiles/profile.h"
#include "components/prefs/pref_service.h"
#include "components/services/app_service/public/cpp/app_types.h"

namespace guest_os {

namespace {

// This prefix is used as a prefix when generating shelf ids for windows we
// couldn't match to an app. It is also used for crostini web dialogs (e.g.
// crostini installer/upgrader) which need to appear in the shelf.
//
// Note: if the value is changed, you will also need to manually update
// kCrostiniInstallerShelfId and kCrostiniUpgraderShelfId.
constexpr char kCrostiniShelfIdPrefix[] = "crostini:";

// Prefix of the WindowAppId set on exo windows for GuestOS X apps.
constexpr char kGuestOsWindowAppIdPrefix[] = "org.chromium.guest_os.";
// This comes after kGuestOsWindowAppIdPrefix+token for GuestOS Wayland apps.
constexpr char kWaylandPrefix[] = "wayland.";
// This comes after kGuestOsWindowAppIdPrefix+token.
constexpr char kWmClassPrefix[] = "wmclass.";

// TODO(b/267377562): Borealis windows have a hardcoded "borealis" token.
constexpr char kBorealisToken[] = "borealis";

const std::string* GetAppNameForWMClass(std::string_view wmclass) {
  // A hard-coded mapping from WMClass to app names.
  // This is used to deal with the Linux apps that don't specify the correct
  // WMClass in their desktop files so that their aura windows can be identified
  // with their respective app IDs.
  static const base::NoDestructor<std::map<std::string, std::string>>
      kWMClassToNname({{"Octave-gui", "GNU Octave"},
                       {"MuseScore2", "MuseScore 2"},
                       {"XnViewMP", "XnView Multi Platform"}});
  const auto it = kWMClassToNname->find(std::string(wmclass));
  if (it == kWMClassToNname->end())
    return nullptr;
  return &it->second;
}

bool MatchingString(const std::string& search_string,
                    const std::string& value_string,
                    bool ignore_space) {
  std::string search = search_string;
  std::string value = value_string;
  if (ignore_space) {
    base::RemoveChars(search, " ", &search);
    base::RemoveChars(value, " ", &value);
  }
  return base::EqualsCaseInsensitiveASCII(search, value);
}

enum class FindAppIdResult { NoMatch, UniqueMatch, NonUniqueMatch };
// Looks for an app where prefs_key is set to search_value. Returns the apps id
// if there was only one app matching, otherwise returns an empty string.
FindAppIdResult FindAppId(const base::Value::Dict& prefs,
                          std::string_view prefs_key,
                          std::string_view search_value,
                          const std::optional<GuestId>& guest_id,
                          std::string* result,
                          bool require_startup_notify = false,
                          bool need_display = false,
                          bool ignore_space = false) {
  result->clear();
  for (const auto item : prefs) {
    if (require_startup_notify && !*item.second.GetDict().FindBool(
                                      guest_os::prefs::kAppStartupNotifyKey)) {
      continue;
    }

    if (need_display) {
      const std::optional<bool> no_display =
          item.second.GetDict().FindBool(guest_os::prefs::kAppNoDisplayKey);
      if (no_display && *no_display) {
        continue;
      }
    }

    // If guest_id is provided, also check that it matches. The guest_id is
    // considered matched if its vm_name and container_name matches
    // corresponding entries in the dictionary.
    if (guest_id && !MatchContainerDict(item.second, *guest_id)) {
      continue;
    }

    const base::Value* value = item.second.GetDict().Find(prefs_key);
    if (!value)
      continue;
    if (value->is_string()) {
      if (!MatchingString(std::string(search_value), value->GetString(),
                          ignore_space)) {
        continue;
      }
    } else if (value->is_dict()) {
      // Look at the unlocalized name to see if that matches.
      const std::string* str_value = value->GetDict().FindString("");
      if (!str_value || !MatchingString(std::string(search_value), *str_value,
                                        ignore_space)) {
        continue;
      }
    } else {
      continue;
    }

    if (!result->empty())
      return FindAppIdResult::NonUniqueMatch;
    *result = item.first;
  }

  if (!result->empty())
    return FindAppIdResult::UniqueMatch;
  return FindAppIdResult::NoMatch;
}

// For GuestOS |window_app_id|s which match the prefix of
// org.chromium.guest_os.<token>.*, return the guest token.
// The token should be one of the following:
// - For Crostini app windows: it is the container_token
// - For Bruschetta app windows: it is the container_token
// - For Borealis app windows: "borealis"
// - For all other guest app windows: "termina"
// Note that PluginVM does not match this prefix since it has a
// hard-coded window_app_id.
std::string GetGuestTokenForWindowId(const std::string* window_app_id) {
  if (!window_app_id ||
      !base::StartsWith(*window_app_id, kGuestOsWindowAppIdPrefix,
                        base::CompareCase::SENSITIVE)) {
    return std::string();
  }
  const auto token_start = strlen(kGuestOsWindowAppIdPrefix);
  // Find the first "." after the kGuestOsWindowAppIdPrefix
  const auto token_end = window_app_id->find(".", token_start);

  auto token = window_app_id->substr(token_start, token_end - token_start);

  return token;
}

std::string GetUnregisteredAppIdPrefix(const std::optional<std::string> token) {
  if (token == kBorealisToken) {
    return borealis::kBorealisAnonymousPrefix;
  }

  // TODO(b/244651040): We should support other VMs, e.g. bruschetta.
  // For all other unregistered apps, default to "crostini:".
  return kCrostiniShelfIdPrefix;
}

}  // namespace

// The code follows these steps to identify apps and returns the first match:
// 1) If the |window_startup_id| is set, look for a matching desktop file id.
// 2) Ignore windows if the |window_app_id| is not set.
// 3) The |window_app_id| is prefixed by org.chromium.guest_os.<token>., so we
//    should be able to obtain a guest token from it. This will be used to find
//    a guest_id to which the app window belongs to. In the following steps, the
//    container_name and vm_name from the guest_id will be used to find a unique
//    match if available.
// 4) Remove the org.chromium.guest_os.<token>. prefix and use the remaining
//    string (the suffix) for the next steps.
// 5) If the suffix is prefixed by wayland., it's a native Wayland app. Look for
//    a matching desktop file id.
// 6) If the suffix from step 4 is prefixed by wmclass.:
// 6.1) Look for an app where StartupWMClass matches the remaining string.
// 6.2) Look for an app where the desktop file id matches the remaining string.
// 6.3) Look for an app where the unlocalized name matches the remaining
//      string. This handles the xterm & uxterm examples.
// 7) If we couldn't find a match, prefix the |window_app_id| with a generic
//    prefix of 'crostini:' or 'borealis:"', so we can easily identify
//    shelf entries as GuestOs apps. If we could not identify the VM, default
//    to using "crostini:".
std::string GetGuestOsShelfAppId(Profile* profile,
                                 const std::string* window_app_id,
                                 const std::string* window_startup_id) {
  if (!profile || !profile->GetPrefs())
    return std::string();

  const base::Value::Dict& apps =
      profile->GetPrefs()->GetDict(guest_os::prefs::kGuestOsRegistry);

  // TODO(b/244651040): Consider moving the borealis GetBorealisAppId logic
  // here.
  std::string app_id;

  std::string token = GetGuestTokenForWindowId(window_app_id);
  std::optional<GuestId> guest_id =
      GuestOsSessionTracker::GetForProfile(profile)->GetGuestIdForToken(token);

  if (window_startup_id) {
    if (FindAppId(apps, guest_os::prefs::kAppDesktopFileIdKey,
                  *window_startup_id, guest_id, &app_id,
                  true) == FindAppIdResult::UniqueMatch) {
      return app_id;
    }
    LOG(WARNING) << "Startup ID was set to '" << *window_startup_id
                 << "' but not matched. Will attempt to match with window ID.";
  }

  if (!window_app_id) {
    return std::string();
  }

  // If the window_id does not follow the expected format, return a generic id.
  if (!base::StartsWith(*window_app_id, kGuestOsWindowAppIdPrefix,
                        base::CompareCase::SENSITIVE)) {
    LOG(ERROR) << "window_app_id:" << *window_app_id
               << " provided is not prefixed with "
               << kGuestOsWindowAppIdPrefix;
    return GetUnregisteredAppIdPrefix(token) + *window_app_id;
  }

  // Get the suffix by stripping "org.chromium.guest_os.<token>.".
  // token.length() + 1 is used since the '.' separator was not included in the
  // token.
  std::string_view suffix = base::MakeStringPiece(
      window_app_id->begin() + strlen(kGuestOsWindowAppIdPrefix) +
          token.length() + 1,
      window_app_id->end());

  // Wayland apps will have a "wayland." identifier.
  if (base::StartsWith(suffix, kWaylandPrefix, base::CompareCase::SENSITIVE)) {
    const std::string_view wayland_app = suffix.substr(strlen(kWaylandPrefix));
    if (FindAppId(apps, guest_os::prefs::kAppDesktopFileIdKey, wayland_app,
                  guest_id, &app_id) == FindAppIdResult::UniqueMatch) {
      return app_id;
    }
    return GetUnregisteredAppIdPrefix(token) + *window_app_id;
  }

  // If we don't have an id to match to a desktop file, use the window app id.
  if (!base::StartsWith(suffix, kWmClassPrefix, base::CompareCase::SENSITIVE)) {
    return GetUnregisteredAppIdPrefix(token) + *window_app_id;
  }

  // If an app had StartupWMClass set to the given WM class, use that,
  // otherwise look for a desktop file id matching the WM class.
  std::string_view key = suffix.substr(strlen(kWmClassPrefix));
  FindAppIdResult result = FindAppId(
      apps, guest_os::prefs::kAppStartupWMClassKey, key, guest_id, &app_id,
      false /* require_startup_notification */, true /* need_display */);
  if (result == FindAppIdResult::UniqueMatch)
    return app_id;
  if (result == FindAppIdResult::NonUniqueMatch)
    return GetUnregisteredAppIdPrefix(token) + *window_app_id;

  if (FindAppId(apps, guest_os::prefs::kAppDesktopFileIdKey, key, guest_id,
                &app_id) == FindAppIdResult::UniqueMatch) {
    return app_id;
  }

  if (FindAppId(apps, guest_os::prefs::kAppNameKey, key, guest_id, &app_id,
                false /* require_startup_notification */,
                true /* need_display */,
                true /* ignore_space */) == FindAppIdResult::UniqueMatch) {
    return app_id;
  }

  const std::string* app_name = GetAppNameForWMClass(key);
  if (app_name &&
      FindAppId(apps, guest_os::prefs::kAppNameKey, *app_name, guest_id,
                &app_id, false /* require_startup_notification */,
                true /* need_display */) == FindAppIdResult::UniqueMatch) {
    return app_id;
  }

  return GetUnregisteredAppIdPrefix(token) + *window_app_id;
}

bool IsUnregisteredCrostiniShelfAppId(std::string_view shelf_app_id) {
  return base::StartsWith(shelf_app_id, kCrostiniShelfIdPrefix,
                          base::CompareCase::SENSITIVE);
}

bool IsUnregisteredGuestOsShelfAppId(std::string_view shelf_app_id) {
  return IsUnregisteredCrostiniShelfAppId(shelf_app_id) ||
         base::StartsWith(shelf_app_id, borealis::kBorealisAnonymousPrefix,
                          base::CompareCase::SENSITIVE);
}

bool IsCrostiniShelfAppId(const Profile* profile,
                          std::string_view shelf_app_id) {
  if (IsUnregisteredCrostiniShelfAppId(shelf_app_id)) {
    return true;
  }

  if (!profile || !profile->GetPrefs()) {
    return false;
  }
  // TODO(timloh): We need to handle desktop files that have been removed.
  // For example, running windows with a no-longer-valid app id will try to
  // use the ExtensionContextMenuModel.
  const auto& apps =
      profile->GetPrefs()->GetDict(guest_os::prefs::kGuestOsRegistry);
  return apps.contains(shelf_app_id);
}

apps::AppType GetAppType(Profile* profile, std::string_view shelf_app_id) {
  if (shelf_app_id.starts_with(kCrostiniShelfIdPrefix)) {
    shelf_app_id.remove_prefix(strlen(kCrostiniShelfIdPrefix));
  }
  const std::string id(shelf_app_id);
  const std::string token = GetGuestTokenForWindowId(&id);
  std::optional<GuestId> guest_id =
      GuestOsSessionTracker::GetForProfile(profile)->GetGuestIdForToken(token);
  if (guest_id.has_value()) {
    return ToAppType(guest_id->vm_type);
  }
  return ToAppType(vm_tools::apps::UNKNOWN);
}

}  // namespace guest_os