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

#include "base/mac/launch_application.h"

#include <sys/select.h>

#include "base/apple/foundation_util.h"
#include "base/base_paths.h"
#include "base/compiler_specific.h"
#include "base/containers/span.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/mac/mac_util.h"
#include "base/path_service.h"
#include "base/process/launch.h"
#include "base/strings/string_util.h"
#include "base/strings/sys_string_conversions.h"
#include "base/task/bind_post_task.h"
#include "base/task/thread_pool.h"
#include "base/test/bind.h"
#include "base/test/task_environment.h"
#include "base/test/test_future.h"
#include "base/threading/platform_thread.h"
#include "base/types/expected.h"
#include "base/uuid.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#import "testing/gtest_mac.h"

namespace base::mac {
namespace {

// Reads XML encoded property lists from `fifo_path`, calling `callback` for
// each succesfully parsed dictionary. Loops indefinitely until the string
// "<!FINISHED>" is read from `fifo_path`.
void ReadLaunchEventsFromFifo(
    const FilePath& fifo_path,
    RepeatingCallback<void(NSDictionary* event)> callback) {
  File f(fifo_path, File::FLAG_OPEN | File::FLAG_READ);
  std::string data;
  while (true) {
    char buf[4096];
    std::optional<size_t> read_count =
        f.ReadAtCurrentPosNoBestEffort(base::as_writable_byte_span(buf));
    ASSERT_TRUE(read_count.has_value());
    if (read_count.value()) {
      data += std::string_view(buf, read_count.value());
      // Assume that at any point the beginning of the data buffer is the start
      // of a plist. Search for the first end, and parse that substring.
      size_t end_of_plist;
      while ((end_of_plist = data.find("</plist>")) != std::string::npos) {
        std::string plist = data.substr(0, end_of_plist + 8);
        data = data.substr(plist.length());
        NSDictionary* event = apple::ObjCCastStrict<NSDictionary>(
            SysUTF8ToNSString(TrimWhitespaceASCII(plist, TRIM_ALL))
                .propertyList);
        callback.Run(event);
      }
      // No more plists found, check if the termination marker was send.
      if (data.find("<!FINISHED>") != std::string::npos) {
        break;
      }
    } else {
      // No data was read, wait for the file descriptor to become readable
      // again.
      fd_set fds;
      UNSAFE_TODO(FD_ZERO(&fds));
      FD_SET(f.GetPlatformFile(), &fds);
      select(FD_SETSIZE, &fds, nullptr, nullptr, nullptr);
    }
  }
}

// This test harness creates an app bundle with a random bundle identifier to
// avoid conflicts with concurrently running other tests. The binary in this app
// bundle writes various events to a named pipe, allowing tests here to verify
// that correct events were received by the app.
class LaunchApplicationTest : public testing::Test {
 public:
  void SetUp() override {
    helper_bundle_id_ =
        SysUTF8ToNSString("org.chromium.LaunchApplicationTestHelper." +
                          Uuid::GenerateRandomV4().AsLowercaseString());

    FilePath data_root;
    ASSERT_TRUE(PathService::Get(DIR_OUT_TEST_DATA_ROOT, &data_root));
    const FilePath helper_app_executable =
        data_root.AppendASCII("launch_application_test_helper");

    // Put helper app inside home dir, as the default temp location gets special
    // treatment by launch services, effecting the behavior of some of these
    // tests.
    ASSERT_TRUE(temp_dir_.CreateUniqueTempDirUnderPath(base::GetHomeDir()));

    helper_app_bundle_path_ =
        temp_dir_.GetPath().AppendASCII("launch_application_test_helper.app");

    const base::FilePath destination_contents_path =
        helper_app_bundle_path_.AppendASCII("Contents");
    const base::FilePath destination_executable_path =
        destination_contents_path.AppendASCII("MacOS");

    // First create the .app bundle directory structure.
    // Use NSFileManager so that the permissions can be set appropriately. The
    // base::CreateDirectory() routine forces mode 0700.
    NSError* error = nil;
    ASSERT_TRUE([NSFileManager.defaultManager
               createDirectoryAtURL:base::apple::FilePathToNSURL(
                                        destination_executable_path)
        withIntermediateDirectories:YES
                         attributes:@{
                           NSFilePosixPermissions : @(0755)
                         }
                              error:&error])
        << SysNSStringToUTF8(error.description);

    // Copy the executable file.
    helper_app_executable_path_ =
        destination_executable_path.Append(helper_app_executable.BaseName());
    ASSERT_TRUE(
        base::CopyFile(helper_app_executable, helper_app_executable_path_));

    // Write the PkgInfo file.
    constexpr char kPkgInfoData[] = "APPL????";
    ASSERT_TRUE(base::WriteFile(
        destination_contents_path.AppendASCII("PkgInfo"), kPkgInfoData));

#if defined(ADDRESS_SANITIZER)
    const base::FilePath asan_library_path =
        data_root.AppendASCII("libclang_rt.asan_osx_dynamic.dylib");
    ASSERT_TRUE(base::CopyFile(
        asan_library_path,
        destination_executable_path.Append(asan_library_path.BaseName())));
#endif

#if defined(UNDEFINED_SANITIZER)
    const base::FilePath ubsan_library_path =
        data_root.AppendASCII("libclang_rt.ubsan_osx_dynamic.dylib");
    ASSERT_TRUE(base::CopyFile(
        ubsan_library_path,
        destination_executable_path.Append(ubsan_library_path.BaseName())));
#endif

    // Generate the Plist file
    NSDictionary* plist = @{
      @"CFBundleExecutable" :
          apple::FilePathToNSString(helper_app_executable.BaseName()),
      @"CFBundleIdentifier" : helper_bundle_id_,
    };
    ASSERT_TRUE([plist
        writeToURL:apple::FilePathToNSURL(
                       destination_contents_path.AppendASCII("Info.plist"))
             error:nil]);

    // Register the app with LaunchServices.
    LSRegisterURL(base::apple::FilePathToCFURL(helper_app_bundle_path_).get(),
                  true);

    // Ensure app was registered with LaunchServices. Sometimes it takes a
    // little bit of time for this to happen, and some tests might fail if the
    // app wasn't registered yet.
    while (true) {
      NSArray<NSURL*>* apps = [NSWorkspace.sharedWorkspace
          URLsForApplicationsWithBundleIdentifier:helper_bundle_id_];
      if (apps.count > 0) {
        break;
      }
      PlatformThread::Sleep(Milliseconds(50));
    }

    // Setup fifo to receive logs from the helper app.
    helper_app_fifo_path_ =
        temp_dir_.GetPath().AppendASCII("launch_application_test_helper.fifo");
    ASSERT_EQ(0, mkfifo(helper_app_fifo_path_.value().c_str(),
                        S_IWUSR | S_IRUSR | S_IWGRP | S_IWGRP));

    // Create array to store received events in, and start listening for events.
    launch_events_ = [[NSMutableArray alloc] init];
    base::ThreadPool::PostTask(
        FROM_HERE, {MayBlock()},
        base::BindOnce(
            &ReadLaunchEventsFromFifo, helper_app_fifo_path_,
            BindPostTaskToCurrentDefault(BindRepeating(
                &LaunchApplicationTest::OnLaunchEvent, Unretained(this)))));
  }

  void TearDown() override {
    if (temp_dir_.IsValid()) {
      // Make sure fifo reading task stops reading/waiting.
      WriteFile(helper_app_fifo_path_, "<!FINISHED>");

      // Make sure all apps that were launched by this test are terminated.
      NSArray<NSRunningApplication*>* apps =
          NSWorkspace.sharedWorkspace.runningApplications;
      for (NSRunningApplication* app in apps) {
        if (temp_dir_.GetPath().IsParent(
                apple::NSURLToFilePath(app.bundleURL)) ||
            [app.bundleIdentifier isEqualToString:helper_bundle_id_]) {
          [app forceTerminate];
        }
      }

      // And make sure the temp dir was successfully deleted.
      EXPECT_TRUE(temp_dir_.Delete());
    }
  }

  // Calls `LaunchApplication` with the given parameters, expecting the launch
  // to succeed. Returns the `NSRunningApplication*` the callback passed to
  // `LaunchApplication` was called with.
  NSRunningApplication* LaunchApplicationSyncExpectSuccess(
      const FilePath& app_bundle_path,
      const CommandLineArgs& command_line_args,
      const std::vector<std::string>& url_specs,
      LaunchApplicationOptions options) {
    test::TestFuture<NSRunningApplication*, NSError*> result;
    LaunchApplication(app_bundle_path, command_line_args, url_specs, options,
                      result.GetCallback());
    EXPECT_FALSE(result.Get<1>());
    EXPECT_TRUE(result.Get<0>());
    return result.Get<0>();
  }

  // Similar to the above method, except that this version expects the launch to
  // fail, returning the error.
  NSError* LaunchApplicationSyncExpectError(
      const FilePath& app_bundle_path,
      const CommandLineArgs& command_line_args,
      const std::vector<std::string>& url_specs,
      LaunchApplicationOptions options) {
    test::TestFuture<NSRunningApplication*, NSError*> result;
    LaunchApplication(app_bundle_path, command_line_args, url_specs, options,
                      result.GetCallback());
    EXPECT_FALSE(result.Get<0>());
    EXPECT_TRUE(result.Get<1>());
    return result.Get<1>();
  }

  // Waits for the total number of received launch events to reach at least
  // `expected_count`.
  void WaitForLaunchEvents(unsigned expected_count) {
    if (LaunchEventCount() >= expected_count) {
      return;
    }
    base::RunLoop loop;
    launch_event_callback_ = BindLambdaForTesting([&] {
      if (LaunchEventCount() >= expected_count) {
        launch_event_callback_ = NullCallback();
        loop.Quit();
      }
    });
    loop.Run();
  }

  unsigned LaunchEventCount() { return launch_events_.count; }
  NSString* LaunchEventName(unsigned i) {
    if (i >= launch_events_.count) {
      return nil;
    }
    return apple::ObjCCastStrict<NSString>(launch_events_[i][@"name"]);
  }
  NSDictionary* LaunchEventData(unsigned i) {
    if (i >= launch_events_.count) {
      return nil;
    }
    return apple::ObjCCastStrict<NSDictionary>(launch_events_[i][@"data"]);
  }

 protected:
  ScopedTempDir temp_dir_;

  NSString* helper_bundle_id_;
  FilePath helper_app_bundle_path_;
  FilePath helper_app_executable_path_;
  FilePath helper_app_fifo_path_;

  NSMutableArray<NSDictionary*>* launch_events_;
  RepeatingClosure launch_event_callback_;

  test::TaskEnvironment task_environment_{
      test::TaskEnvironment::MainThreadType::UI};

 private:
  void OnLaunchEvent(NSDictionary* event) {
    NSLog(@"Event: %@", event);
    [launch_events_ addObject:event];
    if (launch_event_callback_) {
      launch_event_callback_.Run();
    }
  }
};

TEST_F(LaunchApplicationTest, Basic) {
  std::vector<std::string> command_line_args;
  NSRunningApplication* app = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {}, {});
  ASSERT_TRUE(app);
  EXPECT_NSEQ(app.bundleIdentifier, helper_bundle_id_);
  EXPECT_EQ(apple::NSURLToFilePath(app.bundleURL), helper_app_bundle_path_);

  WaitForLaunchEvents(1);
  EXPECT_NSEQ(LaunchEventName(0), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(0)[@"activationPolicy"],
              @(NSApplicationActivationPolicyRegular));
  EXPECT_EQ(app.activationPolicy, NSApplicationActivationPolicyRegular);
  EXPECT_NSEQ(LaunchEventData(0)[@"commandLine"],
              (@[ apple::FilePathToNSString(helper_app_executable_path_) ]));
  EXPECT_NSEQ(LaunchEventData(0)[@"processIdentifier"],
              @(app.processIdentifier));
}

TEST_F(LaunchApplicationTest, BundleDoesntExist) {
  std::vector<std::string> command_line_args;
  NSError* err = LaunchApplicationSyncExpectError(
      temp_dir_.GetPath().AppendASCII("notexists.app"), command_line_args, {},
      {});
  ASSERT_TRUE(err);
  err = LaunchApplicationSyncExpectError(
      temp_dir_.GetPath().AppendASCII("notexists.app"), command_line_args, {},
      {.hidden_in_background = true});
  ASSERT_TRUE(err);
}

TEST_F(LaunchApplicationTest, BundleCorrupt) {
  base::DeleteFile(helper_app_executable_path_);
  std::vector<std::string> command_line_args;
  NSError* err = LaunchApplicationSyncExpectError(helper_app_bundle_path_,
                                                  command_line_args, {}, {});
  ASSERT_TRUE(err);
  err = LaunchApplicationSyncExpectError(helper_app_bundle_path_,
                                         command_line_args, {},
                                         {.hidden_in_background = true});
  ASSERT_TRUE(err);
}

TEST_F(LaunchApplicationTest, CommandLineArgs_StringVector) {
  std::vector<std::string> command_line_args = {"--foo", "bar", "-v"};
  NSRunningApplication* app = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {}, {});
  ASSERT_TRUE(app);

  WaitForLaunchEvents(1);
  EXPECT_NSEQ(LaunchEventName(0), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(0)[@"commandLine"], (@[
                apple::FilePathToNSString(helper_app_executable_path_),
                @"--foo", @"bar", @"-v"
              ]));
}

TEST_F(LaunchApplicationTest, CommandLineArgs_BaseCommandLine) {
  CommandLine command_line(CommandLine::NO_PROGRAM);
  command_line.AppendSwitchASCII("foo", "bar");
  command_line.AppendSwitch("v");
  command_line.AppendSwitchPath("path", FilePath("/tmp"));

  NSRunningApplication* app = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line, {}, {});
  ASSERT_TRUE(app);

  WaitForLaunchEvents(1);
  EXPECT_NSEQ(LaunchEventName(0), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(0)[@"commandLine"], (@[
                apple::FilePathToNSString(helper_app_executable_path_),
                @"--foo=bar", @"--v", @"--path=/tmp"
              ]));
}

TEST_F(LaunchApplicationTest, UrlSpecs) {
  std::vector<std::string> command_line_args;
  std::vector<std::string> urls = {"https://example.com",
                                   "x-chrome-launch://1"};
  NSRunningApplication* app = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, urls, {});
  ASSERT_TRUE(app);
  WaitForLaunchEvents(3);

  EXPECT_NSEQ(LaunchEventName(0), @"openURLs");
  EXPECT_NSEQ(LaunchEventName(1), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventName(2), @"openURLs");

  EXPECT_NSEQ(LaunchEventData(0)[@"urls"], @[ @"https://example.com" ]);
  EXPECT_NSEQ(LaunchEventData(2)[@"urls"], @[ @"x-chrome-launch://1" ]);
}

TEST_F(LaunchApplicationTest, CreateNewInstance) {
  std::vector<std::string> command_line_args;
  NSRunningApplication* app1 = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {},
      {.create_new_instance = false});
  WaitForLaunchEvents(1);
  EXPECT_NSEQ(LaunchEventName(0), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(0)[@"processIdentifier"],
              @(app1.processIdentifier));

  NSRunningApplication* app2 = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {"x-chrome-launch://0"},
      {.create_new_instance = false});
  EXPECT_NSEQ(app1, app2);
  EXPECT_EQ(app1.processIdentifier, app2.processIdentifier);
  WaitForLaunchEvents(2);
  EXPECT_NSEQ(LaunchEventName(1), @"openURLs");
  EXPECT_NSEQ(LaunchEventData(1)[@"processIdentifier"],
              @(app2.processIdentifier));

  NSRunningApplication* app3 = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {"x-chrome-launch://1"},
      {.create_new_instance = true});
  EXPECT_NSNE(app1, app3);
  EXPECT_NE(app1.processIdentifier, app3.processIdentifier);
  WaitForLaunchEvents(4);
  EXPECT_NSEQ(LaunchEventName(2), @"openURLs");
  EXPECT_NSEQ(LaunchEventName(3), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(3)[@"processIdentifier"],
              @(app3.processIdentifier));
}

TEST_F(LaunchApplicationTest, HiddenInBackground) {
  std::vector<std::string> command_line_args = {"--test", "--foo"};
  NSRunningApplication* app = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {},
      {.hidden_in_background = true});
  ASSERT_TRUE(app);
  EXPECT_NSEQ(app.bundleIdentifier, helper_bundle_id_);
  EXPECT_EQ(helper_app_bundle_path_, apple::NSURLToFilePath(app.bundleURL));

  WaitForLaunchEvents(1);
  EXPECT_NSEQ(LaunchEventName(0), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(0)[@"activationPolicy"],
              @(NSApplicationActivationPolicyProhibited));
  EXPECT_EQ(app.activationPolicy, NSApplicationActivationPolicyProhibited);
  EXPECT_NSEQ(LaunchEventData(0)[@"commandLine"], (@[
                apple::FilePathToNSString(helper_app_executable_path_),
                @"--test", @"--foo"
              ]));
  EXPECT_NSEQ(LaunchEventData(0)[@"processIdentifier"],
              @(app.processIdentifier));

  NSRunningApplication* app2 = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {},
      {.create_new_instance = false, .hidden_in_background = true});
  EXPECT_NSEQ(app, app2);
  EXPECT_EQ(app.processIdentifier, app2.processIdentifier);
  EXPECT_EQ(app.activationPolicy, NSApplicationActivationPolicyProhibited);
  EXPECT_EQ(app2.activationPolicy, NSApplicationActivationPolicyProhibited);
  // Launching without opening anything should not trigger any launch events.

  // Opening a URL in a new instance, should leave both instances in the
  // background.
  NSRunningApplication* app3 = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {"x-chrome-launch://2"},
      {.create_new_instance = true, .hidden_in_background = true});
  EXPECT_NSNE(app, app3);
  EXPECT_NE(app.processIdentifier, app3.processIdentifier);
  WaitForLaunchEvents(3);
  EXPECT_NSEQ(LaunchEventName(1), @"openURLs");
  EXPECT_NSEQ(LaunchEventName(2), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(2)[@"processIdentifier"],
              @(app3.processIdentifier));
  EXPECT_EQ(app.activationPolicy, NSApplicationActivationPolicyProhibited);
  EXPECT_EQ(app2.activationPolicy, NSApplicationActivationPolicyProhibited);
  EXPECT_EQ(app3.activationPolicy, NSApplicationActivationPolicyProhibited);
}

TEST_F(LaunchApplicationTest,
       HiddenInBackground_OpenUrlChangesActivationPolicy) {
  std::vector<std::string> command_line_args = {"--test", "--foo"};
  NSRunningApplication* app = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {},
      {.hidden_in_background = true});
  ASSERT_TRUE(app);
  EXPECT_NSEQ(app.bundleIdentifier, helper_bundle_id_);
  EXPECT_EQ(helper_app_bundle_path_, apple::NSURLToFilePath(app.bundleURL));

  WaitForLaunchEvents(1);
  EXPECT_NSEQ(LaunchEventName(0), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(0)[@"activationPolicy"],
              @(NSApplicationActivationPolicyProhibited));
  EXPECT_EQ(app.activationPolicy, NSApplicationActivationPolicyProhibited);
  EXPECT_NSEQ(LaunchEventData(0)[@"commandLine"], (@[
                apple::FilePathToNSString(helper_app_executable_path_),
                @"--test", @"--foo"
              ]));
  EXPECT_NSEQ(LaunchEventData(0)[@"processIdentifier"],
              @(app.processIdentifier));

  NSRunningApplication* app2 = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {"chrome://app-launch/0"},
      {.create_new_instance = false, .hidden_in_background = true});
  EXPECT_NSEQ(app, app2);
  EXPECT_EQ(app.processIdentifier, app2.processIdentifier);
  // Unexpected to me, but opening a URL seems to always change the activation
  // policy.
  EXPECT_EQ(app.activationPolicy, NSApplicationActivationPolicyRegular);
  EXPECT_EQ(app2.activationPolicy, NSApplicationActivationPolicyRegular);
  WaitForLaunchEvents(3);
  EXPECT_THAT(
      std::vector<std::string>({SysNSStringToUTF8(LaunchEventName(1)),
                                SysNSStringToUTF8(LaunchEventName(2))}),
      testing::UnorderedElementsAre("activationPolicyChanged", "openURLs"));
}

TEST_F(LaunchApplicationTest, HiddenInBackground_TransitionToForeground) {
  std::vector<std::string> command_line_args;
  NSRunningApplication* app = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {"x-chrome-launch://1"},
      {.hidden_in_background = true});
  ASSERT_TRUE(app);

  WaitForLaunchEvents(2);
  EXPECT_NSEQ(LaunchEventName(0), @"openURLs");
  EXPECT_NSEQ(LaunchEventName(1), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(1)[@"activationPolicy"],
              @(NSApplicationActivationPolicyProhibited));
  EXPECT_EQ(app.activationPolicy, NSApplicationActivationPolicyProhibited);
  EXPECT_NSEQ(LaunchEventData(1)[@"processIdentifier"],
              @(app.processIdentifier));

  // Second launch with hidden_in_background set to false should cause the first
  // app to switch activation policy.
  NSRunningApplication* app2 = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {},
      {.hidden_in_background = false});
  EXPECT_NSEQ(app, app2);
  WaitForLaunchEvents(3);
  EXPECT_NSEQ(LaunchEventName(2), @"activationPolicyChanged");
  EXPECT_NSEQ(LaunchEventData(2)[@"activationPolicy"],
              @(NSApplicationActivationPolicyRegular));
  EXPECT_EQ(app2.activationPolicy, NSApplicationActivationPolicyRegular);
}

TEST_F(LaunchApplicationTest, HiddenInBackground_AlreadyInForeground) {
  std::vector<std::string> command_line_args;
  NSRunningApplication* app = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {"x-chrome-launch://1"},
      {.hidden_in_background = false});
  ASSERT_TRUE(app);

  WaitForLaunchEvents(2);
  EXPECT_NSEQ(LaunchEventName(0), @"openURLs");
  EXPECT_NSEQ(LaunchEventName(1), @"applicationDidFinishLaunching");
  EXPECT_NSEQ(LaunchEventData(1)[@"activationPolicy"],
              @(NSApplicationActivationPolicyRegular));
  EXPECT_EQ(app.activationPolicy, NSApplicationActivationPolicyRegular);
  EXPECT_NSEQ(LaunchEventData(1)[@"processIdentifier"],
              @(app.processIdentifier));

  // Second (and third) launch with hidden_in_background set to true should
  // reuse the existing app and keep it visible.
  NSRunningApplication* app2 = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {},
      {.hidden_in_background = true});
  EXPECT_NSEQ(app, app2);
  EXPECT_EQ(app2.activationPolicy, NSApplicationActivationPolicyRegular);
  NSRunningApplication* app3 = LaunchApplicationSyncExpectSuccess(
      helper_app_bundle_path_, command_line_args, {"x-chrome-launch://23"},
      {.hidden_in_background = true});
  EXPECT_NSEQ(app, app3);
  WaitForLaunchEvents(3);
  EXPECT_NSEQ(LaunchEventName(2), @"openURLs");
  EXPECT_NSEQ(LaunchEventData(2)[@"processIdentifier"],
              @(app.processIdentifier));
  EXPECT_EQ(app3.activationPolicy, NSApplicationActivationPolicyRegular);
}

}  // namespace
}  // namespace base::mac
