Removed "chrome::" namespace from "chrome/*" and "apps/*"

Following things have been moved from chrome namespace to the global
namespace:
1)enum ResultCode
2)bool IsNormalResultCode(ResultCode code)

Also, the import "chromeos/startup/startup.h" has been removed from
"chrome/common/chrome_result_codes.h" as the file is deleted.

Bug: 41050580
Change-Id: Iac197606d10e2741c83a03c1de66134f59bb507b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6196899
Commit-Queue: David Roger <droger@chromium.org>
Reviewed-by: Stefan Kuhne <skuhne@chromium.org>
Reviewed-by: David Roger <droger@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1416829}

apps/load_and_launch_browsertest.cc

@@ -83,7 +83,7 @@ IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest,
   int exit_code;
   ASSERT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_timeout(),
                                              &exit_code));
-  ASSERT_EQ(chrome::RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED, exit_code);
+  ASSERT_EQ(CHROME_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED, exit_code);
 }
 
 // TODO(jackhou): Enable this test once it works on OSX. It currently does not
@@ -124,7 +124,7 @@ IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest,
   int exit_code;
   ASSERT_TRUE(process.WaitForExitWithTimeout(TestTimeouts::action_timeout(),
                                              &exit_code));
-  ASSERT_EQ(chrome::RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED, exit_code);
+  ASSERT_EQ(CHROME_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED, exit_code);
 }
 
 #endif  // !BUILDFLAG(IS_CHROMEOS_LACROS)

chrome/app/chrome_main.cc

@@ -200,7 +200,7 @@ int ChromeMain(int argc, const char** argv) {
   if (headless::IsHeadlessMode()) {
     if (command_line->GetArgs().size() > 1) {
       LOG(ERROR) << "Multiple targets are not supported in headless mode.";
-      return chrome::RESULT_CODE_UNSUPPORTED_PARAM;
+      return CHROME_RESULT_CODE_UNSUPPORTED_PARAM;
     }
     headless_mode_handle = headless::InitHeadlessMode();
   } else {
@@ -221,7 +221,8 @@ int ChromeMain(int argc, const char** argv) {
 
   int rv = content::ContentMain(std::move(params));
 
-  if (chrome::IsNormalResultCode(static_cast<chrome::ResultCode>(rv)))
+  if (IsNormalResultCode(static_cast<ResultCode>(rv))) {
     return content::RESULT_CODE_NORMAL_EXIT;
+  }
   return rv;
 }

chrome/app/chrome_main_delegate.cc

@@ -476,10 +476,10 @@ std::optional<int> HandlePackExtensionSwitches(
     if (!error_message.empty()) {
       LOG(ERROR) << error_message.c_str();
     }
-    return chrome::RESULT_CODE_PACK_EXTENSION_ERROR;
+    return CHROME_RESULT_CODE_PACK_EXTENSION_ERROR;
   }
 
-  return chrome::RESULT_CODE_NORMAL_EXIT_PACK_EXTENSION_SUCCESS;
+  return CHROME_RESULT_CODE_NORMAL_EXIT_PACK_EXTENSION_SUCCESS;
 }
 #endif  // !BUILDFLAG(ENABLE_EXTENSIONS)
 
@@ -520,11 +520,11 @@ std::optional<int> AcquireProcessSingleton(
                          base::UTF16ToWide(l10n_util::GetStringUTF16(
                              IDS_USED_EXISTING_BROWSER)))
                          .c_str());
-      return chrome::RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED;
+      return CHROME_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED;
     }
 
     case ProcessSingleton::PROFILE_IN_USE:
-      return chrome::RESULT_CODE_PROFILE_IN_USE;
+      return CHROME_RESULT_CODE_PROFILE_IN_USE;
 
     case ProcessSingleton::LOCK_ERROR:
       LOG(ERROR) << "Failed to create a ProcessSingleton for your profile "
@@ -532,7 +532,7 @@ std::optional<int> AcquireProcessSingleton(
                     "would start multiple browser processes rather than "
                     "opening a new window in the existing process. Aborting "
                     "now to avoid profile corruption.";
-      return chrome::RESULT_CODE_PROFILE_IN_USE;
+      return CHROME_RESULT_CODE_PROFILE_IN_USE;
   }
 
   return std::nullopt;
@@ -695,7 +695,7 @@ void OnResourceExhausted() {
     ::MessageBox(nullptr, kOnResourceExhaustedMessage, kMessageBoxTitle, MB_OK);
   }
   base::Process::TerminateCurrentProcessImmediately(
-      chrome::RESULT_CODE_SYSTEM_RESOURCE_EXHAUSTED);
+      CHROME_RESULT_CODE_SYSTEM_RESOURCE_EXHAUSTED);
 }
 
 // Alternate version of the above handler that is used when running in headless
@@ -1088,13 +1088,14 @@ std::optional<int> ChromeMainDelegate::BasicStartupComplete() {
       !pipes_are_specified_explicitly &&
       !devtools_pipe::AreFileDescriptorsOpen()) {
     LOG(ERROR) << "Remote debugging pipe file descriptors are not open.";
-    return chrome::RESULT_CODE_UNSUPPORTED_PARAM;
+    return CHROME_RESULT_CODE_UNSUPPORTED_PARAM;
   }
 
 #if BUILDFLAG(IS_WIN)
   // Browser should not be sandboxed.
-  if (is_browser && IsSandboxedProcess())
-    return chrome::RESULT_CODE_INVALID_SANDBOX_STATE;
+  if (is_browser && IsSandboxedProcess()) {
+    return CHROME_RESULT_CODE_INVALID_SANDBOX_STATE;
+  }
 #endif
 
 #if BUILDFLAG(IS_MAC)

chrome/app/main_dll_loader_win.cc

@@ -183,7 +183,7 @@ int MainDllLoader::Launch(HINSTANCE instance,
   dll_ =
       Load(&file, cmd_line, is_browser, preread_begin_ticks, preread_end_ticks);
   if (!dll_)
-    return chrome::RESULT_CODE_MISSING_DATA;
+    return CHROME_RESULT_CODE_MISSING_DATA;
 
   if (!is_browser) {
     // Set non-browser processes up to be killed by the system after the

chrome/browser/chrome_browser_main.cc

@@ -831,11 +831,11 @@ int ChromeBrowserMainParts::PreEarlyInitialization() {
       chrome_feature_list_creator->TakeMetricsServicesManager(),
       chrome_feature_list_creator->GetMetricsServicesManagerClient());
 
-  if (load_local_state_result == chrome::RESULT_CODE_MISSING_DATA &&
+  if (load_local_state_result == CHROME_RESULT_CODE_MISSING_DATA &&
       failed_to_load_resource_bundle) {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kNoErrorDialogs)) {
-      return chrome::RESULT_CODE_MISSING_DATA;
+      return CHROME_RESULT_CODE_MISSING_DATA;
     }
     // Continue on and show error later (once UI has been initialized and main
     // message loop is running).
@@ -853,7 +853,7 @@ int ChromeBrowserMainParts::PreEarlyInitialization() {
 
     // Note, cannot return RESULT_CODE_NORMAL_EXIT here as this code needs to
     // result in browser startup bailing.
-    return chrome::RESULT_CODE_NORMAL_EXIT_UPGRADE_RELAUNCHED;
+    return CHROME_RESULT_CODE_NORMAL_EXIT_UPGRADE_RELAUNCHED;
   }
 #endif  // BUILDFLAG(IS_WIN)
 
@@ -952,7 +952,7 @@ int ChromeBrowserMainParts::OnLocalStateLoaded(
     bool* failed_to_load_resource_bundle) {
   *failed_to_load_resource_bundle = false;
   if (!base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir_))
-    return chrome::RESULT_CODE_MISSING_DATA;
+    return CHROME_RESULT_CODE_MISSING_DATA;
 
   auto* platform_management_service =
       policy::ManagementServiceFactory::GetForPlatform();
@@ -979,7 +979,7 @@ int ChromeBrowserMainParts::OnLocalStateLoaded(
       startup_data_->chrome_feature_list_creator()->actual_locale();
   if (locale.empty()) {
     *failed_to_load_resource_bundle = true;
-    return chrome::RESULT_CODE_MISSING_DATA;
+    return CHROME_RESULT_CODE_MISSING_DATA;
   }
   browser_process_->SetApplicationLocale(locale);
 
@@ -1019,7 +1019,7 @@ int ChromeBrowserMainParts::ApplyFirstRunPrefs() {
                                            std::move(installer_initial_prefs),
                                            master_prefs_.get());
   if (pip_result == first_run::EULA_EXIT_NOW)
-    return chrome::RESULT_CODE_EULA_REFUSED;
+    return CHROME_RESULT_CODE_EULA_REFUSED;
 
   // TODO(macourteau): refactor preferences that are copied from
   // master_preferences into local_state, as a "local_state" section in
@@ -1048,7 +1048,7 @@ int ChromeBrowserMainParts::PreCreateThreadsImpl() {
 
   if (browser_process_->GetApplicationLocale().empty()) {
     ShowMissingLocaleMessageBox();
-    return chrome::RESULT_CODE_MISSING_DATA;
+    return CHROME_RESULT_CODE_MISSING_DATA;
   }
 
 #if !BUILDFLAG(IS_ANDROID)
@@ -1532,7 +1532,7 @@ int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
   if (!g_browser_process->local_state()->GetBoolean(
           prefs::kChromeForTestingAllowed)) {
     LOG(ERROR) << "Chrome for Testing is disallowed by the system admin.";
-    return static_cast<int>(chrome::RESULT_CODE_ACTION_DISALLOWED_BY_POLICY);
+    return static_cast<int>(CHROME_RESULT_CODE_ACTION_DISALLOWED_BY_POLICY);
   }
 #endif  // BUILDFLAG(CHROME_FOR_TESTING)
 
@@ -1542,12 +1542,12 @@ int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
         prefs::kDefaultBrowserSettingEnabled);
     if (is_managed && !g_browser_process->local_state()->GetBoolean(
         prefs::kDefaultBrowserSettingEnabled)) {
-      return static_cast<int>(chrome::RESULT_CODE_ACTION_DISALLOWED_BY_POLICY);
+      return static_cast<int>(CHROME_RESULT_CODE_ACTION_DISALLOWED_BY_POLICY);
     }
 
     return shell_integration::SetAsDefaultBrowser()
                ? static_cast<int>(content::RESULT_CODE_NORMAL_EXIT)
-               : static_cast<int>(chrome::RESULT_CODE_SHELL_INTEGRATION_FAILED);
+               : static_cast<int>(CHROME_RESULT_CODE_SHELL_INTEGRATION_FAILED);
   }
 
 #if defined(USE_AURA)
@@ -1559,7 +1559,7 @@ int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
   // We must call DoUpgradeTasks now that we own the browser singleton to
   // finish upgrade tasks (swap) and relaunch if necessary.
   if (upgrade_util::DoUpgradeTasks(*base::CommandLine::ForCurrentProcess()))
-    return chrome::RESULT_CODE_NORMAL_EXIT_UPGRADE_RELAUNCHED;
+    return CHROME_RESULT_CODE_NORMAL_EXIT_UPGRADE_RELAUNCHED;
 #endif  // BUILDFLAG(IS_WIN)
 
 #if !BUILDFLAG(IS_ANDROID) && BUILDFLAG(ENABLE_DOWNGRADE_PROCESSING)
@@ -1567,7 +1567,7 @@ int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
   // to handle a version downgrade.
   if (downgrade_manager_.PrepareUserDataDirectoryForCurrentVersion(
           user_data_dir_)) {
-    return chrome::RESULT_CODE_DOWNGRADE_AND_RELAUNCH;
+    return CHROME_RESULT_CODE_DOWNGRADE_AND_RELAUNCH;
   }
   downgrade_manager_.UpdateLastVersion(user_data_dir_);
 #endif  // !BUILDFLAG(IS_ANDROID) && BUILDFLAG(ENABLE_DOWNGRADE_PROCESSING)
@@ -1595,7 +1595,7 @@ int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
   if (!browser_process_->browser_policy_connector()
            ->chrome_browser_cloud_management_controller()
            ->WaitUntilPolicyEnrollmentFinished()) {
-    return chrome::RESULT_CODE_CLOUD_POLICY_ENROLLMENT_FAILED;
+    return CHROME_RESULT_CODE_CLOUD_POLICY_ENROLLMENT_FAILED;
   }
 #endif  // !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_CHROMEOS)
 
@@ -1607,7 +1607,7 @@ int ChromeBrowserMainParts::PreMainMessageLoopRunImpl() {
   // Note this check needs to happen here (after the process singleton was
   // obtained but before potentially creating the first run sentinel).
   if (ChromeBrowserMainPartsWin::CheckMachineLevelInstall())
-    return chrome::RESULT_CODE_MACHINE_LEVEL_INSTALL_EXISTS;
+    return CHROME_RESULT_CODE_MACHINE_LEVEL_INSTALL_EXISTS;
 #endif  // BUILDFLAG(IS_WIN)
 
   // Desktop construction occurs here, (required before profile creation).
@@ -2009,7 +2009,7 @@ void ChromeBrowserMainParts::PostDestroyThreads() {
 #endif  // BUILDFLAG(IS_CHROMEOS_ASH)
 
 #if BUILDFLAG(ENABLE_DOWNGRADE_PROCESSING)
-  if (result_code_ == chrome::RESULT_CODE_DOWNGRADE_AND_RELAUNCH) {
+  if (result_code_ == CHROME_RESULT_CODE_DOWNGRADE_AND_RELAUNCH) {
     // Process a pending User Data downgrade before restarting.
     downgrade_manager_.ProcessDowngrade(user_data_dir_);
 

chrome/browser/chrome_browser_main_win.cc

@@ -484,15 +484,15 @@ int DoUninstallTasks(bool chrome_still_running) {
   // check once again after user acknowledges Uninstall dialog.
   if (chrome_still_running) {
     ShowCloseBrowserFirstMessageBox();
-    return chrome::RESULT_CODE_UNINSTALL_CHROME_ALIVE;
+    return CHROME_RESULT_CODE_UNINSTALL_CHROME_ALIVE;
   }
   int result = chrome::ShowUninstallBrowserPrompt();
   if (browser_util::IsBrowserAlreadyRunning()) {
     ShowCloseBrowserFirstMessageBox();
-    return chrome::RESULT_CODE_UNINSTALL_CHROME_ALIVE;
+    return CHROME_RESULT_CODE_UNINSTALL_CHROME_ALIVE;
   }
 
-  if (result != chrome::RESULT_CODE_UNINSTALL_USER_CANCEL) {
+  if (result != CHROME_RESULT_CODE_UNINSTALL_USER_CANCEL) {
     // The following actions are just best effort.
     VLOG(1) << "Executing uninstall actions";
     // Remove shortcuts targeting chrome.exe or chrome_proxy.exe.
@@ -771,7 +771,7 @@ int ChromeBrowserMainPartsWin::HandleIconsCommands(
     return content::RESULT_CODE_NORMAL_EXIT;
   }
   // We don't hide icons so we shouldn't do anything special to show them
-  return chrome::RESULT_CODE_UNSUPPORTED_PARAM;
+  return CHROME_RESULT_CODE_UNSUPPORTED_PARAM;
 }
 
 // static

chrome/browser/downgrade/user_data_downgrade_browsertest.cc

@@ -165,7 +165,7 @@ class UserDataDowngradeBrowserCopyAndCleanTest
               mock_relaunch_callback_->Get());
 
       // Expect that browser startup short-circuits into a relaunch.
-      set_expected_exit_code(chrome::RESULT_CODE_DOWNGRADE_AND_RELAUNCH);
+      set_expected_exit_code(CHROME_RESULT_CODE_DOWNGRADE_AND_RELAUNCH);
 
       // Prepare to check histograms during the restart.
       histogram_tester_ = std::make_unique<base::HistogramTester>();

chrome/browser/downgrade/user_data_snapshot_browsertest.cc

@@ -159,7 +159,7 @@ class UserDataSnapshotBrowserTestBase : public InProcessBrowserTest {
               mock_relaunch_callback_->Get());
 
       // Expect that browser startup short-circuits into a relaunch.
-      set_expected_exit_code(chrome::RESULT_CODE_DOWNGRADE_AND_RELAUNCH);
+      set_expected_exit_code(CHROME_RESULT_CODE_DOWNGRADE_AND_RELAUNCH);
     }
   }
 

chrome/browser/extensions/pack_extension_browsertest.cc

@@ -51,7 +51,7 @@ class PackExtensionOnStartupBrowserTest : public InProcessBrowserTest {
 
     // Packing extensions has a different exit code.
     set_expected_exit_code(
-        chrome::RESULT_CODE_NORMAL_EXIT_PACK_EXTENSION_SUCCESS);
+        CHROME_RESULT_CODE_NORMAL_EXIT_PACK_EXTENSION_SUCCESS);
   }
 
  protected:

chrome/browser/policy/cloud/chrome_browser_cloud_management_browsertest.cc

@@ -504,8 +504,7 @@ class ChromeBrowserCloudManagementEnrollmentTest
     observer_.SetShouldDisplayErrorMessage(should_display_error_message());
 
     if (!is_enrollment_token_valid() && should_display_error_message()) {
-      set_expected_exit_code(
-          chrome::RESULT_CODE_CLOUD_POLICY_ENROLLMENT_FAILED);
+      set_expected_exit_code(CHROME_RESULT_CODE_CLOUD_POLICY_ENROLLMENT_FAILED);
     }
   }
 

chrome/browser/policy/policy_startup_browsertest.cc

@@ -24,7 +24,7 @@ class PolicyMakeDefaultBrowserTest : public InProcessBrowserTest {
 
  protected:
   PolicyMakeDefaultBrowserTest() : InProcessBrowserTest() {
-    set_expected_exit_code(chrome::RESULT_CODE_ACTION_DISALLOWED_BY_POLICY);
+    set_expected_exit_code(CHROME_RESULT_CODE_ACTION_DISALLOWED_BY_POLICY);
   }
 
   void SetUpInProcessBrowserTestFixture() override {

chrome/browser/process_singleton_browsertest.cc

@@ -312,10 +312,9 @@ IN_PROC_BROWSER_TEST_F(ProcessSingletonTest, MAYBE_StartupRaceCondition) {
         // exit code, which we also allow, though it would be ideal if that
         // never happened.
         // TODO(mattm): investigate why PROFILE_IN_USE occurs sometimes.
-        EXPECT_THAT(
-            chrome_starters_[starter_index]->exit_code_,
-            AnyOf(Eq(chrome::RESULT_CODE_PROFILE_IN_USE),
-                  Eq(chrome::RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED)));
+        EXPECT_THAT(chrome_starters_[starter_index]->exit_code_,
+                    AnyOf(Eq(CHROME_RESULT_CODE_PROFILE_IN_USE),
+                          Eq(CHROME_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED)));
       } else {
         // But we let the last loop turn finish so that we can properly
         // kill all remaining processes. Starting with this one...

chrome/browser/ui/views/uninstall_view.cc

@@ -126,7 +126,7 @@ void UninstallView::SetupControls() {
 void UninstallView::OnDialogAccepted() {
   *user_selection_ = content::RESULT_CODE_NORMAL_EXIT;
   if (delete_profile_->GetChecked()) {
-    *user_selection_ = chrome::RESULT_CODE_UNINSTALL_DELETE_PROFILE;
+    *user_selection_ = CHROME_RESULT_CODE_UNINSTALL_DELETE_PROFILE;
   }
   if (change_default_browser_ && change_default_browser_->GetChecked()) {
     BrowsersMap::const_iterator i = browsers_->begin();
@@ -138,7 +138,7 @@ void UninstallView::OnDialogAccepted() {
 }
 
 void UninstallView::OnDialogCancelled() {
-  *user_selection_ = chrome::RESULT_CODE_UNINSTALL_USER_CANCEL;
+  *user_selection_ = CHROME_RESULT_CODE_UNINSTALL_USER_CANCEL;
 }
 
 size_t UninstallView::GetItemCount() const {

chrome/browser/ui/views/uninstall_view_unittest.cc

@@ -22,12 +22,12 @@ TEST_F(UninstallViewTest, Cancel) {
   int result = -1;
   UninstallView view(&result, base::DoNothing());
   view.Cancel();
-  EXPECT_EQ(result, chrome::RESULT_CODE_UNINSTALL_USER_CANCEL);
+  EXPECT_EQ(result, CHROME_RESULT_CODE_UNINSTALL_USER_CANCEL);
 }
 
 TEST_F(UninstallViewTest, Close) {
   int result = -1;
   UninstallView view(&result, base::DoNothing());
   view.Close();
-  EXPECT_EQ(result, chrome::RESULT_CODE_UNINSTALL_USER_CANCEL);
+  EXPECT_EQ(result, CHROME_RESULT_CODE_UNINSTALL_USER_CANCEL);
 }

chrome/common/chrome_result_codes.cc

@@ -4,20 +4,17 @@
 
 #include "chrome/common/chrome_result_codes.h"
 
-namespace chrome {
-
 bool IsNormalResultCode(ResultCode code) {
   // These result codes are normal exit, but are needed to signal to content
   // that the process should terminate early. These result codes should be
   // translated back to the normal exit code to indicate nothing went wrong
   // here.
-  if (code == RESULT_CODE_NORMAL_EXIT_UPGRADE_RELAUNCHED ||
-      code == RESULT_CODE_NORMAL_EXIT_PACK_EXTENSION_SUCCESS ||
-      code == RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED) {
+  if (code == CHROME_RESULT_CODE_NORMAL_EXIT_UPGRADE_RELAUNCHED ||
+      code == CHROME_RESULT_CODE_NORMAL_EXIT_PACK_EXTENSION_SUCCESS ||
+      code == CHROME_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED) {
     return true;
   }
 
   return false;
 }
 
-}  // namespace chrome

chrome/common/chrome_result_codes.h

@@ -8,140 +8,132 @@
 #include "build/chromeos_buildflags.h"
 #include "content/public/common/result_codes.h"
 
-#if BUILDFLAG(IS_CHROMEOS_LACROS)
-#include "chromeos/startup/startup.h"  // nogncheck
-#endif
-
-namespace chrome {
-
 // IMPORTANT: This needs to stay in sync with <enum name="CrashExitCodes"> and
 // <enum name="WindowsExitCode"> in tools/metrics/histograms/enums.xml. So do
 // not remove any entries, and always append entries to the bottom just above
 // RESULT_CODE_CHROME_LAST_CODE.
 
 enum ResultCode {
-  RESULT_CODE_CHROME_START = content::RESULT_CODE_LAST_CODE,
+  CHROME_RESULT_CODE_CHROME_START = content::RESULT_CODE_LAST_CODE,
 
   // An invalid command line url was given.
-  RESULT_CODE_INVALID_CMDLINE_URL = RESULT_CODE_CHROME_START,
+  CHROME_RESULT_CODE_INVALID_CMDLINE_URL = CHROME_RESULT_CODE_CHROME_START,
 
   // The process is of an unknown type.
-  RESULT_CODE_BAD_PROCESS_TYPE,
+  CHROME_RESULT_CODE_BAD_PROCESS_TYPE,
 
   // A critical chrome file is missing.
-  RESULT_CODE_MISSING_DATA,
+  CHROME_RESULT_CODE_MISSING_DATA,
 
   // Failed to make Chrome default browser (not used?).
-  RESULT_CODE_SHELL_INTEGRATION_FAILED,
+  CHROME_RESULT_CODE_SHELL_INTEGRATION_FAILED,
 
   // Machine level install exists
-  RESULT_CODE_MACHINE_LEVEL_INSTALL_EXISTS,
+  CHROME_RESULT_CODE_MACHINE_LEVEL_INSTALL_EXISTS,
 
   // Uninstall detected another chrome instance.
-  RESULT_CODE_UNINSTALL_CHROME_ALIVE,
+  CHROME_RESULT_CODE_UNINSTALL_CHROME_ALIVE,
 
   // The user changed their mind.
-  RESULT_CODE_UNINSTALL_USER_CANCEL,
+  CHROME_RESULT_CODE_UNINSTALL_USER_CANCEL,
 
   // Delete profile as well during uninstall.
-  RESULT_CODE_UNINSTALL_DELETE_PROFILE,
+  CHROME_RESULT_CODE_UNINSTALL_DELETE_PROFILE,
 
   // Command line parameter is not supported.
-  RESULT_CODE_UNSUPPORTED_PARAM,
+  CHROME_RESULT_CODE_UNSUPPORTED_PARAM,
 
   // Browser import hung and was killed.
-  RESULT_CODE_IMPORTER_HUNG,
+  CHROME_RESULT_CODE_IMPORTER_HUNG,
 
   // Trying to restart the browser we crashed.
-  RESULT_CODE_RESPAWN_FAILED,
+  CHROME_RESULT_CODE_RESPAWN_FAILED,
 
   // The EXP1, EXP2, EXP3, EXP4 are generic codes used to communicate some
   // simple outcome back to the process that launched us. This is used for
   // experiments and the actual meaning depends on the experiment.
   // (only EXP2 is used?)
-  RESULT_CODE_NORMAL_EXIT_EXP1,
-  RESULT_CODE_NORMAL_EXIT_EXP2,
-  RESULT_CODE_NORMAL_EXIT_EXP3,
-  RESULT_CODE_NORMAL_EXIT_EXP4,
+  CHROME_RESULT_CODE_NORMAL_EXIT_EXP1,
+  CHROME_RESULT_CODE_NORMAL_EXIT_EXP2,
+  CHROME_RESULT_CODE_NORMAL_EXIT_EXP3,
+  CHROME_RESULT_CODE_NORMAL_EXIT_EXP4,
 
   // For experiments this return code means that the user canceled causes the
   // did_run "dr" signal to be reset soi this chrome run does not count as
   // active chrome usage.
-  RESULT_CODE_NORMAL_EXIT_CANCEL,
+  CHROME_RESULT_CODE_NORMAL_EXIT_CANCEL,
 
   // The profile was in use on another host.
-  RESULT_CODE_PROFILE_IN_USE,
+  CHROME_RESULT_CODE_PROFILE_IN_USE,
 
   // Failed to pack an extension via the cmd line.
-  RESULT_CODE_PACK_EXTENSION_ERROR,
+  CHROME_RESULT_CODE_PACK_EXTENSION_ERROR,
 
   // Failed to silently uninstall an extension.
-  RESULT_CODE_UNINSTALL_EXTENSION_ERROR,
+  CHROME_RESULT_CODE_UNINSTALL_EXTENSION_ERROR,
 
   // The browser process exited early by passing the command line to another
   // running browser.
-  RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED,
+  CHROME_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED,
 
   // A dummy value we should not use. See crbug.com/152285.
-  RESULT_CODE_NOTUSED_1,
+  CHROME_RESULT_CODE_NOTUSED_1,
 
   // Failed to install an item from the webstore when the
   // kInstallEphemeralAppFromWebstore command line flag was present.
   // As this flag is no longer supported, this return code should never be
   // returned.
-  RESULT_CODE_INSTALL_FROM_WEBSTORE_ERROR_2,
+  CHROME_RESULT_CODE_INSTALL_FROM_WEBSTORE_ERROR_2,
 
   // A dummy value we should not use. See crbug.com/152285.
-  RESULT_CODE_NOTUSED_2,
+  CHROME_RESULT_CODE_NOTUSED_2,
 
   // Returned when the user has not yet accepted the EULA.
-  RESULT_CODE_EULA_REFUSED,
+  CHROME_RESULT_CODE_EULA_REFUSED,
 
   // Failed to migrate user data directory for side-by-side package support
   // (Linux-only).
-  RESULT_CODE_SXS_MIGRATION_FAILED_NOT_USED,
+  CHROME_RESULT_CODE_SXS_MIGRATION_FAILED_NOT_USED,
 
   // The action is not allowed by a policy.
-  RESULT_CODE_ACTION_DISALLOWED_BY_POLICY,
+  CHROME_RESULT_CODE_ACTION_DISALLOWED_BY_POLICY,
 
   // An browser process was sandboxed. This should never happen.
-  RESULT_CODE_INVALID_SANDBOX_STATE,
+  CHROME_RESULT_CODE_INVALID_SANDBOX_STATE,
 
   // Cloud policy enrollment is failed or given up by user.
-  RESULT_CODE_CLOUD_POLICY_ENROLLMENT_FAILED,
+  CHROME_RESULT_CODE_CLOUD_POLICY_ENROLLMENT_FAILED,
 
   // Chrome was downgraded since the last launch. Perform downgrade processing
   // and relaunch.
-  RESULT_CODE_DOWNGRADE_AND_RELAUNCH,
+  CHROME_RESULT_CODE_DOWNGRADE_AND_RELAUNCH,
 
   // The GPU process was terminated due to context lost. This is in sync with
   // viz::ExitCode in components/viz/service/gl/gpu_service_impl.h.
-  RESULT_CODE_GPU_EXIT_ON_CONTEXT_LOST,
+  CHROME_RESULT_CODE_GPU_EXIT_ON_CONTEXT_LOST,
 
   // Chrome detected that there was a new version waiting to launch and renamed
   // the files and launched the new version. This result code is never returned
   // from the main process, but is instead used as a signal for early
   // termination of browser. See `IsNormalResultCode` below.
-  RESULT_CODE_NORMAL_EXIT_UPGRADE_RELAUNCHED,
+  CHROME_RESULT_CODE_NORMAL_EXIT_UPGRADE_RELAUNCHED,
 
   // An early startup command was executed and the browser must exit.
-  RESULT_CODE_NORMAL_EXIT_PACK_EXTENSION_SUCCESS,
+  CHROME_RESULT_CODE_NORMAL_EXIT_PACK_EXTENSION_SUCCESS,
 
   // The browser process exited because system resource are exhausted. The
   // system state can't be recovered and will be unstable.
-  RESULT_CODE_SYSTEM_RESOURCE_EXHAUSTED,
+  CHROME_RESULT_CODE_SYSTEM_RESOURCE_EXHAUSTED,
 
   // Last return code (keep this last).
-  RESULT_CODE_CHROME_LAST_CODE
+  CHROME_RESULT_CODE_CHROME_LAST_CODE
 };
 
-static_assert(RESULT_CODE_CHROME_LAST_CODE == 38,
+static_assert(CHROME_RESULT_CODE_CHROME_LAST_CODE == 38,
               "Please make sure the enum values are in sync with enums.xml");
 
 // Returns true if the result code should be treated as a normal exit code i.e.
 // content::RESULT_CODE_NORMAL_EXIT.
 bool IsNormalResultCode(ResultCode code);
 
-}  // namespace chrome
-
 #endif  // CHROME_COMMON_CHROME_RESULT_CODES_H_

chrome/installer/setup/uninstall.cc

@@ -375,13 +375,15 @@ InstallStatus IsChromeActiveOrUserCancelled(
   if (LaunchChromeAndWait(installer_state.target_path(), options, &exit_code)) {
     VLOG(1) << "chrome.exe launched for uninstall confirmation returned: "
             << exit_code;
-    if ((exit_code == chrome::RESULT_CODE_UNINSTALL_CHROME_ALIVE) ||
-        (exit_code == chrome::RESULT_CODE_UNINSTALL_USER_CANCEL) ||
-        (exit_code == content::RESULT_CODE_HUNG))
+    if ((exit_code == CHROME_RESULT_CODE_UNINSTALL_CHROME_ALIVE) ||
+        (exit_code == CHROME_RESULT_CODE_UNINSTALL_USER_CANCEL) ||
+        (exit_code == content::RESULT_CODE_HUNG)) {
       return installer::UNINSTALL_CANCELLED;
+    }
 
-    if (exit_code == chrome::RESULT_CODE_UNINSTALL_DELETE_PROFILE)
+    if (exit_code == CHROME_RESULT_CODE_UNINSTALL_DELETE_PROFILE) {
       return installer::UNINSTALL_DELETE_PROFILE;
+    }
   } else {
     PLOG(ERROR) << "Failed to launch chrome.exe for uninstall confirmation.";
   }

chrome/test/chromedriver/chrome_launcher.cc

@@ -714,7 +714,7 @@ Status LaunchDesktopChrome(network::mojom::URLLoaderFactory* factory,
 #else
     const int chrome_exit_code = WEXITSTATUS(exit_code);
 #endif
-    if (chrome_exit_code == chrome::RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED ||
+    if (chrome_exit_code == CHROME_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED ||
         chrome_exit_code == content::RESULT_CODE_NORMAL_EXIT) {
       return Status(kSessionNotCreated,
                     "probably user data directory is already in use, "