New LaunchModeRecorder implementation

Record launch mode based on the command line, i.e., the user's
intention, not on what window(s)/tabs Chrome opened. Adds
Launch.Mode2 metric which will replace Launch.Modes metric.

Bug: 1366137,1380458, 1356222
Change-Id: Ib8c5cbad7a5b4279f82c3aa85adcb32f1d3d8aa8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3975976
Reviewed-by: Luc Nguyen <lucnguyen@google.com>
Reviewed-by: Greg Thompson <grt@chromium.org>
Commit-Queue: David Bienvenu <davidbienvenu@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1069806}

chrome/browser/ui/startup/launch_mode_recorder.cc

@@ -4,38 +4,47 @@
 
 #include "chrome/browser/ui/startup/launch_mode_recorder.h"
 
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "base/base_paths.h"
 #include "base/bind.h"
+#include "base/command_line.h"
+#include "base/functional/callback.h"
 #include "base/i18n/case_conversion.h"
-#include "base/location.h"
 #include "base/metrics/histogram_functions.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/thread_pool.h"
-#include "build/build_config.h"
+#include "components/url_formatter/url_formatter.h"
+#include "url/gurl.h"
 
 #if BUILDFLAG(IS_MAC)
 #include "base/mac/mac_util.h"
 #include "chrome/browser/mac/dock.h"
 #include "chrome/browser/mac/install_from_dmg.h"
-#endif
+#endif  // BUILDFLAG(IS_MAC)
 
 #if BUILDFLAG(IS_WIN)
+#include "base/containers/fixed_flat_map.h"
 #include "base/files/file_path.h"
 #include "base/win/startup_information.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/taskbar_util.h"
-#endif
+#include "components/url_formatter/url_fixer.h"
+#endif  // BUILDFLAG(IS_WIN)
 
 namespace {
 
-// Returns a LaunchMode value if one can be determined with low overhead, or
-// kToBeDecided if a call to GetLaunchModeSlow is required.
-OldLaunchMode GetLaunchModeFast();
+// Returns an OldLaunchMode value if one can be determined with low overhead, or
+// kToBeDecided if a call to GetOldLaunchModeSlow is required.
+OldLaunchMode GetOldLaunchModeFast();
 
-// Returns a LaunchMode value; may require a bit of extra work. This will be
+// Returns an OldLaunchMode value; may require a bit of extra work. This will be
 // called on a background thread outside of the critical startup path.
-OldLaunchMode GetLaunchModeSlow();
+OldLaunchMode GetOldLaunchModeSlow();
 
 #if BUILDFLAG(IS_WIN)
 // Returns the path to the shortcut from which Chrome was launched, or null if
@@ -48,7 +57,7 @@ absl::optional<const wchar_t*> GetShortcutPath() {
   return absl::optional<const wchar_t*>(si.lpTitle);
 }
 
-OldLaunchMode GetLaunchModeFast() {
+OldLaunchMode GetOldLaunchModeFast() {
   auto shortcut_path = GetShortcutPath();
   if (!shortcut_path)
     return OldLaunchMode::kOther;
@@ -57,7 +66,7 @@ OldLaunchMode GetLaunchModeFast() {
   return OldLaunchMode::kToBeDecided;
 }
 
-OldLaunchMode GetLaunchModeSlow() {
+OldLaunchMode GetOldLaunchModeSlow() {
   auto shortcut_path = GetShortcutPath();
   DCHECK(shortcut_path);
   DCHECK(shortcut_path.value());
@@ -92,7 +101,7 @@ OldLaunchMode GetLaunchModeSlow() {
   return OldLaunchMode::kShortcutUnknown;
 }
 #elif BUILDFLAG(IS_MAC)  // BUILDFLAG(IS_WIN)
-OldLaunchMode GetLaunchModeFast() {
+OldLaunchMode GetOldLaunchModeFast() {
   DiskImageStatus dmg_launch_status =
       IsAppRunningFromReadOnlyDiskImage(nullptr);
   dock::ChromeInDockStatus dock_launch_status = dock::ChromeIsInTheDock();
@@ -122,17 +131,16 @@ OldLaunchMode GetLaunchModeFast() {
   return OldLaunchMode::kMacUndockedDiskLaunch;
 }
 
-OldLaunchMode GetLaunchModeSlow() {
+OldLaunchMode GetOldLaunchModeSlow() {
   NOTREACHED();
   return OldLaunchMode::kToBeDecided;
 }
 #else                    // BUILDFLAG(IS_WIN)
-// TODO(cpu): Port to other platforms.
-OldLaunchMode GetLaunchModeFast() {
+OldLaunchMode GetOldLaunchModeFast() {
   return OldLaunchMode::kOtherOS;
 }
 
-OldLaunchMode GetLaunchModeSlow() {
+OldLaunchMode GetOldLaunchModeSlow() {
   NOTREACHED();
   return OldLaunchMode::kOtherOS;
 }
@@ -155,19 +163,83 @@ void RecordOldLaunchMode(OldLaunchMode mode) {
 // LaunchMode enum for the actual values of the buckets.
 void RecordOldLaunchModeHistogram(OldLaunchMode mode) {
   if (mode == OldLaunchMode::kToBeDecided &&
-      (mode = GetLaunchModeFast()) == OldLaunchMode::kToBeDecided) {
+      (mode = GetOldLaunchModeFast()) == OldLaunchMode::kToBeDecided) {
     // The mode couldn't be determined with a fast path. Perform a more
     // expensive evaluation out of the critical startup path.
     base::ThreadPool::PostTask(
         FROM_HERE,
         {base::TaskPriority::BEST_EFFORT,
          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-        base::BindOnce(&RecordOldLaunchMode, GetLaunchModeSlow()));
+        base::BindOnce(&RecordOldLaunchMode, GetOldLaunchModeSlow()));
   } else {
     RecordOldLaunchMode(mode);
   }
 }
 
+#if BUILDFLAG(IS_WIN)
+
+enum class ArgType { kFile, kProtocol, kInvalid };
+
+// Returns the dir enum defined in base/base_paths_win.h that corresponds to the
+// path of `shortcut_path` if any, nullopt if no match found.
+absl::optional<int> GetShortcutLocation(const std::wstring& shortcut_path) {
+  // The windows quick launch path is not localized.
+  const std::u16string shortcut(
+      base::i18n::ToLower(base::AsStringPiece16(shortcut_path)));
+  if (shortcut.find(u"\\quick launch\\") != base::StringPiece16::npos)
+    return base::DIR_TASKBAR_PINS;
+
+  // Check the common shortcut locations.
+  constexpr int kPathKeys[] = {base::DIR_COMMON_START_MENU,
+                               base::DIR_START_MENU, base::DIR_COMMON_DESKTOP,
+                               base::DIR_USER_DESKTOP};
+  base::FilePath candidate;
+  for (int path_key : kPathKeys) {
+    if (base::PathService::Get(path_key, &candidate) &&
+        base::StartsWith(
+            shortcut,
+            base::i18n::ToLower(base::AsStringPiece16(candidate.value())),
+            base::CompareCase::SENSITIVE)) {
+      return path_key;
+    }
+  }
+  return absl::nullopt;
+}
+
+// Returns kFile if `arg` is a file, kProtocol if it's a protocol, and
+// kInvalid if it does not seem to be either.
+// This should be called off the UI thread because it can cause disk access.
+ArgType GetArgType(const std::wstring& arg) {
+  GURL url(base::AsStringPiece16(arg));
+  if (url.is_valid() && !url.SchemeIsFile())
+    return ArgType::kProtocol;
+  // This handles the case of "chrome.exe foo.html".
+  if (!url.is_valid()) {
+    url =
+        url_formatter::FixupRelativeFile(base::FilePath(), base::FilePath(arg));
+    if (!url.is_valid())
+      return ArgType::kInvalid;
+  }
+  return url.SchemeIsFile() ? ArgType::kFile : ArgType::kProtocol;
+}
+
+// Gets the path of the shortcut that launched Chrome, either from the
+// command line switch --shortcut_path in the case of a rendezvous to an
+// existing process, or ::GetStartupInfoW.
+// Returns the empty string if Chrome wasn't launched from a shortcut.
+// This can be expensive and shouldn't be called from the UI thread.
+absl::optional<std::wstring> GetShortcutPath(
+    const base::CommandLine& command_line) {
+  if (command_line.HasSwitch(switches::kSourceShortcut))
+    return command_line.GetSwitchValueNative(switches::kSourceShortcut);
+  STARTUPINFOW si = {sizeof(si)};
+  GetStartupInfoW(&si);
+  return si.dwFlags & STARTF_TITLEISLINKNAME
+             ? absl::optional<std::wstring>(si.lpTitle)
+             : absl::nullopt;
+}
+
+#endif  // BUIDFLAG(IS_WIN)
 }  // namespace
 
 OldLaunchModeRecorder::OldLaunchModeRecorder() = default;
@@ -181,3 +253,197 @@ void OldLaunchModeRecorder::SetLaunchMode(OldLaunchMode mode) {
   if (!mode_.has_value())
     mode_ = mode;
 }
+
+// new LaunchMode implementation below.
+
+namespace {
+
+void RecordLaunchMode(absl::optional<LaunchMode> mode) {
+  if (mode.value_or(LaunchMode::kNone) == LaunchMode::kNone)
+    return;
+  base::UmaHistogramEnumeration("Launch.Mode2", mode.value());
+#if BUILDFLAG(IS_WIN)
+  if (mode == LaunchMode::kShortcutTaskbar) {
+    absl::optional<bool> installer_pinned = GetInstallerPinnedChromeToTaskbar();
+    if (installer_pinned.has_value()) {
+      base::UmaHistogramBoolean("Windows.Launch.TaskbarInstallerPinned",
+                                installer_pinned.value());
+    }
+  }
+#endif  // BUILDFLAG(IS_WIN)
+}
+
+#if BUILDFLAG(IS_WIN)
+// Gets LaunchMode from `command_line`, potentially using some functions that
+// might be slow, e.g., involve disk access, and hence, this should not be
+// used on the UI thread.
+absl::optional<LaunchMode> GetLaunchModeSlow(
+    const base::CommandLine command_line) {
+  absl::optional<std::wstring> shortcut_path = GetShortcutPath(command_line);
+  bool is_app_launch = command_line.HasSwitch(switches::kApp) ||
+                       command_line.HasSwitch(switches::kAppId);
+  if (!shortcut_path.has_value()) {
+    // Not launched from a shortcut. Check if we're launched as a registered
+    // file or protocol handler.
+    bool single_argument_switch = command_line.HasSingleArgumentSwitch();
+    // Single argument switch means we were registered with the shell as a
+    // handler for a file extension or a protocol/url. Then, determine if
+    // Chrome or a web app is handling the argument.
+    std::vector<base::CommandLine::StringType> args = command_line.GetArgs();
+    if (args.size() < 1)
+      return is_app_launch ? LaunchMode::kWebAppOther : LaunchMode::kOther;
+    auto arg_type = GetArgType(args[0]);
+    if (!is_app_launch) {
+      if (arg_type == ArgType::kFile) {
+        return single_argument_switch ? LaunchMode::kFileTypeHandler
+                                      : LaunchMode::kWithFile;
+      }
+      if (arg_type == ArgType::kProtocol) {
+        return single_argument_switch ? LaunchMode::kProtocolHandler
+                                      : LaunchMode::kWithUrl;
+      }
+    } else {
+      // Should we check if single_argument_switch is present?
+      if (arg_type == ArgType::kFile)
+        return LaunchMode::kWebAppFileTypeHandler;
+      if (arg_type == ArgType::kProtocol)
+        return LaunchMode::kWebAppProtocolHandler;
+    }
+  } else {
+    if (shortcut_path.value().empty())
+      return LaunchMode::kShortcutNoName;
+    absl::optional<int> shortcut_location =
+        GetShortcutLocation(shortcut_path.value());
+    if (!shortcut_location.has_value()) {
+      return is_app_launch ? LaunchMode::kWebAppShortcutUnknown
+                           : LaunchMode::kShortcutUnknown;
+    }
+    if (!is_app_launch) {
+      static constexpr auto kDirToLaunchModeMap =
+          base::MakeFixedFlatMap<int, LaunchMode>({
+              {base::DIR_TASKBAR_PINS, LaunchMode::kShortcutTaskbar},
+              {base::DIR_COMMON_START_MENU, LaunchMode::kShortcutStartMenu},
+              {base::DIR_START_MENU, LaunchMode::kShortcutStartMenu},
+              {base::DIR_COMMON_DESKTOP, LaunchMode::kShortcutDesktop},
+              {base::DIR_USER_DESKTOP, LaunchMode::kShortcutDesktop},
+          });
+      return kDirToLaunchModeMap.at(shortcut_location.value());
+    }
+    static constexpr auto kDirToWebAppLaunchModeMap =
+        base::MakeFixedFlatMap<int, LaunchMode>({
+            {base::DIR_TASKBAR_PINS, LaunchMode::kWebAppShortcutTaskbar},
+            {base::DIR_COMMON_START_MENU, LaunchMode::kWebAppShortcutStartMenu},
+            {base::DIR_START_MENU, LaunchMode::kWebAppShortcutStartMenu},
+            {base::DIR_COMMON_DESKTOP, LaunchMode::kWebAppShortcutDesktop},
+            {base::DIR_USER_DESKTOP, LaunchMode::kWebAppShortcutDesktop},
+        });
+    return kDirToWebAppLaunchModeMap.at(shortcut_location.value());
+  }
+  return LaunchMode::kOther;
+}
+
+// Computes the launch mode from the command line. If other information is
+// required that is potentially expensive to get, returns absl::nullopt and
+// defers to `GetLaunchModeSlow`.
+absl::optional<LaunchMode> GetLaunchModeFast(
+    const base::CommandLine& command_line) {
+  // These are the switches for which there is a 1:1 mapping to a launch mode.
+  static constexpr std::pair<const char*, LaunchMode> switch_to_mode[] = {
+      {switches::kRestart, LaunchMode::kNone},
+      {switches::kNoStartupWindow, LaunchMode::kNone},
+      {switches::kUninstallAppId, LaunchMode::kNone},
+      {switches::kListApps, LaunchMode::kNone},
+      {switches::kInstallChromeApp, LaunchMode::kNone},
+      {switches::kFromInstaller, LaunchMode::kNone},
+      {switches::kUninstall, LaunchMode::kNone},
+      {switches::kTryChromeAgain, LaunchMode::kUserExperiment},
+      {switches::kNotificationLaunchId, LaunchMode::kWinPlatformNotification},
+  };
+  for (const auto& [switch_val, mode] : switch_to_mode) {
+    if (command_line.HasSwitch(switch_val))
+      return mode;
+  }
+  return absl::nullopt;
+}
+
+#elif BUILDFLAG(IS_MAC)
+absl::optional<LaunchMode> GetLaunchModeSlow(
+    const base::CommandLine command_line) {
+  NOTREACHED();
+  return absl::nullopt;
+}
+
+absl::optional<LaunchMode> GetLaunchModeFast(
+    const base::CommandLine& command_line) {
+  DiskImageStatus dmg_launch_status =
+      IsAppRunningFromReadOnlyDiskImage(nullptr);
+  dock::ChromeInDockStatus dock_launch_status = dock::ChromeIsInTheDock();
+
+  if (dock_launch_status == dock::ChromeInDockFailure &&
+      dmg_launch_status == DiskImageStatusFailure) {
+    return LaunchMode::kMacDockDMGStatusError;
+  }
+
+  if (dock_launch_status == dock::ChromeInDockFailure)
+    return LaunchMode::kMacDockStatusError;
+
+  if (dmg_launch_status == DiskImageStatusFailure)
+    return LaunchMode::kMacDMGStatusError;
+
+  bool dmg_launch = dmg_launch_status == DiskImageStatusTrue;
+  bool dock_launch = dock_launch_status == dock::ChromeInDockTrue;
+
+  if (dmg_launch && dock_launch)
+    return LaunchMode::kMacDockedDMGLaunch;
+
+  if (dmg_launch)
+    return LaunchMode::kMacUndockedDMGLaunch;
+
+  if (dock_launch)
+    return LaunchMode::kMacDockedDiskLaunch;
+
+  return LaunchMode::kMacUndockedDiskLaunch;
+}
+#else  //  !IS_WIN && !IS_MAC
+absl::optional<LaunchMode> GetLaunchModeSlow(
+    const base::CommandLine command_line) {
+  NOTREACHED();
+  return absl::nullopt;
+}
+
+absl::optional<LaunchMode> GetLaunchModeFast(
+    const base::CommandLine& command_line) {
+  return LaunchMode::kOtherOS;
+}
+
+#endif  // BUILDFLAG(IS_WIN)
+
+}  // namespace
+
+void ComputeAndRecordLaunchMode(const base::CommandLine& command_line) {
+  ComputeLaunchMode(command_line, base::BindOnce(&RecordLaunchMode));
+}
+
+// Computes the launch mode based on `command_line` and process state. Runs
+// `result_callback` with the result either synchronously or asynchronously on
+// the caller's sequence.
+void ComputeLaunchMode(
+    const base::CommandLine& command_line,
+    base::OnceCallback<void(absl::optional<LaunchMode>)> result_callback) {
+  if (auto mode = GetLaunchModeFast(command_line); mode.has_value()) {
+    std::move(result_callback).Run(mode);
+    return;
+  }
+  auto split = base::SplitOnceCallback(std::move(result_callback));
+  if (!base::ThreadPool::PostTaskAndReplyWithResult(
+          FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
+          base::BindOnce(&GetLaunchModeSlow, command_line),
+          std::move(split.first))) {
+    std::move(split.second).Run(absl::nullopt);
+  }
+}
+
+base::OnceCallback<void(absl::optional<LaunchMode>)>
+GetRecordLaunchModeForTesting() {
+  return base::BindOnce(&RecordLaunchMode);
+}