chrome/common/mac/app_mode_chrome_locator.mm

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#import "chrome/common/mac/app_mode_chrome_locator.h"

#import <AppKit/AppKit.h>
#include <CoreFoundation/CoreFoundation.h>

#include <optional>
#include <set>

#include "base/apple/bridging.h"
#include "base/apple/foundation_util.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/strings/sys_string_conversions.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/mac/app_mode_common.h"

namespace app_mode {

namespace {

struct PathAndStructure {
  NSString* __strong framework_dylib_path;
  bool is_new_app_structure;
};

std::optional<PathAndStructure> GetFrameworkDylibPathAndStructure(
    NSString* bundle_path,
    NSString* version) {
  // NEW STYLE:
  // Chromium.app/Contents/Frameworks/Chromium Framework.framework/
  //   Versions/<version>/Chromium Framework
  NSString* path = [NSString pathWithComponents:@[
    bundle_path, @"Contents", @"Frameworks", @(chrome::kFrameworkName),
    @"Versions", version, @(chrome::kFrameworkExecutableName)
  ]];

  if ([NSFileManager.defaultManager fileExistsAtPath:path]) {
    return PathAndStructure{path, true};
  }

  // OLD STYLE:
  // Chromium.app/Contents/Versions/<version>/Chromium Framework.framework/
  //   Versions/A/Chromium Framework
  path = [NSString pathWithComponents:@[
    bundle_path, @"Contents", @"Versions", version, @(chrome::kFrameworkName),
    @"Versions", @"A", @(chrome::kFrameworkExecutableName)
  ]];

  if ([NSFileManager.defaultManager fileExistsAtPath:path]) {
    return PathAndStructure{path, false};
  }

  return std::nullopt;
}

bool IsPathValidForBundle(const base::FilePath& bundle_path,
                          NSString* bundle_id) {
  if (bundle_path.empty())
    return false;

  if (!base::DirectoryExists(bundle_path))
    return false;

  NSString* ns_bundle_path = base::SysUTF8ToNSString(bundle_path.value());
  NSBundle* bundle = [NSBundle bundleWithPath:ns_bundle_path];
  if (!bundle || ![bundle_id isEqualToString:bundle.bundleIdentifier]) {
    return false;
  }

  return true;
}

}  // namespace

bool FindChromeBundle(NSString* bundle_id, base::FilePath* out_bundle) {
  // Retrieve the last-run Chrome bundle location.
  base::FilePath last_run_bundle_path;
  {
    NSString* cr_bundle_path_ns = base::apple::CFToNSOwnershipCast(
        base::apple::CFCastStrict<CFStringRef>(CFPreferencesCopyAppValue(
            base::apple::NSToCFPtrCast(app_mode::kLastRunAppBundlePathPrefsKey),
            base::apple::NSToCFPtrCast(bundle_id))));
    last_run_bundle_path = base::apple::NSStringToFilePath(cr_bundle_path_ns);
  }

  // Look up running instances of the specified bundle ID.
  {
    // Note that IsPathValidForBundle is guaranteed to be true for all elements
    // in `running_bundle_paths` because runningApplicationsWithBundleIdentifier
    // returned them.
    std::set<base::FilePath> running_bundle_paths;
    NSArray<NSRunningApplication*>* running_applications = [NSRunningApplication
        runningApplicationsWithBundleIdentifier:bundle_id];
    for (NSRunningApplication* running_application : running_applications) {
      base::FilePath bundle_path =
          base::apple::NSURLToFilePath(running_application.bundleURL);
      DCHECK(!bundle_path.empty());
      running_bundle_paths.insert(bundle_path);
    }

    // If the last-run instance is still running, then use that instance.
    if (running_bundle_paths.count(last_run_bundle_path)) {
      *out_bundle = last_run_bundle_path;
      return true;
    }

    // Otherwise, select a running bundle path arbitrarily.
    // TODO(crbug.com/40208159): This choice should not be made
    // arbitrarily.
    if (!running_bundle_paths.empty()) {
      *out_bundle = *running_bundle_paths.begin();
      return true;
    }
  }

  // Next, use the last run bundle path, if it is valid.
  if (IsPathValidForBundle(last_run_bundle_path, bundle_id)) {
    *out_bundle = last_run_bundle_path;
    return true;
  }

  // Finally, search the filesystem for a bundle. If several copies of the
  // bundle are present, this will select one arbitrarily.
  {
    // Note that `IsPathValidForBundle` is guaranteed to be true for
    // `bundle_path` because URLForApplicationWithBundleIdentifier returned it.
    NSURL* url = [NSWorkspace.sharedWorkspace
        URLForApplicationWithBundleIdentifier:bundle_id];
    if (url) {
      *out_bundle = base::apple::NSURLToFilePath(url);
      return true;
    }
  }
  return false;
}

bool GetChromeBundleInfo(const base::FilePath& chrome_bundle,
                         const std::string& version_str,
                         base::FilePath* executable_path,
                         base::FilePath* framework_path,
                         base::FilePath* framework_dylib_path) {
  NSString* cr_bundle_path = base::apple::FilePathToNSString(chrome_bundle);
  NSBundle* cr_bundle = [NSBundle bundleWithPath:cr_bundle_path];
  if (!cr_bundle)
    return false;

  // Try to get the version requested, if present.
  std::optional<PathAndStructure> framework_path_and_structure;
  if (!version_str.empty()) {
    framework_path_and_structure = GetFrameworkDylibPathAndStructure(
        cr_bundle_path, base::SysUTF8ToNSString(version_str));
  }

  // If the version requested is not present, or no specific version was
  // requested, fall back to the "current" version. For new-style bundle
  // structures, use the "Current" symlink. (This will intentionally return nil
  // with the old bundle structure.)
  //
  // Note that the scenario where a specific version was requested but is not
  // present is a "should not happen" scenario. Chromium, while it is running,
  // maintains a link to the currently running version, and this function's
  // caller checked to see if the Chromium was still running. However, even in
  // this bizarre case, it's best to find _some_ Chromium.
  if (!framework_path_and_structure) {
    framework_path_and_structure =
        GetFrameworkDylibPathAndStructure(cr_bundle_path, @"Current");
    if (framework_path_and_structure) {
      framework_path_and_structure->framework_dylib_path =
          [framework_path_and_structure
                  ->framework_dylib_path stringByResolvingSymlinksInPath];
    }
  }

  // At this point it is known that it is an old-style bundle structure (or a
  // rather broken new-style bundle). Try explicitly specifying the version of
  // the framework matching the outer bundle version.
  if (!framework_path_and_structure) {
    NSString* cr_version = base::apple::ObjCCast<NSString>([cr_bundle
        objectForInfoDictionaryKey:app_mode::kCFBundleShortVersionStringKey]);
    if (cr_version) {
      framework_path_and_structure =
          GetFrameworkDylibPathAndStructure(cr_bundle_path, cr_version);
    }
  }

  if (!framework_path_and_structure)
    return false;

  // A few sanity checks.
  BOOL is_directory;
  BOOL exists = [NSFileManager.defaultManager
      fileExistsAtPath:framework_path_and_structure->framework_dylib_path
           isDirectory:&is_directory];
  if (!exists || is_directory)
    return false;

  NSString* cr_framework_path;

  if (framework_path_and_structure->is_new_app_structure) {
    // For the path to the framework version itself, remove the framework name.
    cr_framework_path =
        [framework_path_and_structure
                ->framework_dylib_path stringByDeletingLastPathComponent];
  } else {
    // For the path to the framework itself, remove the framework name ...
    cr_framework_path =
        [framework_path_and_structure
                ->framework_dylib_path stringByDeletingLastPathComponent];
    // ... the "A" ...
    cr_framework_path = [cr_framework_path stringByDeletingLastPathComponent];
    // ... and the "Versions" directory.
    cr_framework_path = [cr_framework_path stringByDeletingLastPathComponent];
  }

  // Everything is OK; copy the output parameters.
  *executable_path = base::apple::NSStringToFilePath(cr_bundle.executablePath);
  *framework_path = base::apple::NSStringToFilePath(cr_framework_path);
  *framework_dylib_path = base::apple::NSStringToFilePath(
      framework_path_and_structure->framework_dylib_path);
  return true;
}

}  // namespace app_mode