Take two at splitting result codes between content and chrome.

chrome/installer/setup/uninstall.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file defines the methods useful for uninstalling Chrome.
 
 #include "chrome/installer/setup/uninstall.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
+#include "chrome/common/chrome_result_codes.h"
 #include "chrome/installer/setup/install.h"
 #include "chrome/installer/setup/install_worker.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/delete_after_reboot_helper.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/logging_installer.h"
 #include "chrome/installer/util/self_cleaning_temp_dir.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
-#include "content/common/result_codes.h"
 #include "rlz/win/lib/rlz_lib.h"
 
 // Build-time generated include file.
 #include "registered_dlls.h"  // NOLINT
 
 using base::win::RegKey;
 using installer::InstallStatus;
 using installer::MasterPreferences;
 
 namespace {
@@ skipping 85 matching lines @@
   for (int j = 0; j < 4; ++j) {
     std::wstring wnd_class(L"Chrome_WidgetWin_");
     wnd_class.append(base::IntToString16(j));
     HWND window = FindWindowEx(NULL, NULL, wnd_class.c_str(), NULL);
     while (window) {
       HWND tmpWnd = window;
       window = FindWindowEx(NULL, window, wnd_class.c_str(), NULL);
       if (!SendMessageTimeout(tmpWnd, WM_CLOSE, 0, 0, SMTO_BLOCK, 3000, NULL) &&
           (GetLastError() == ERROR_TIMEOUT)) {
         base::CleanupProcesses(installer::kChromeExe, 0,
-                               ResultCodes::HUNG, NULL);
+                               content::RESULT_CODE_HUNG, NULL);
         base::CleanupProcesses(installer::kNaClExe, 0,
-                               ResultCodes::HUNG, NULL);
+                               content::RESULT_CODE_HUNG, NULL);
         return;
       }
     }
   }
 
   // If asking politely didn't work, wait for 15 seconds and then kill all
   // chrome.exe. This check is just in case Chrome is ignoring WM_CLOSE
   // messages.
   base::CleanupProcesses(installer::kChromeExe, 15000,
-                         ResultCodes::HUNG, NULL);
+                         content::RESULT_CODE_HUNG, NULL);
   base::CleanupProcesses(installer::kNaClExe, 15000,
-                         ResultCodes::HUNG, NULL);
+                         content::RESULT_CODE_HUNG, NULL);
 }
 
 // Attempts to close the Chrome Frame helper process by sending WM_CLOSE
 // messages to its window, or just killing it if that doesn't work.
 void CloseChromeFrameHelperProcess() {
   HWND window = FindWindow(installer::kChromeFrameHelperWndClass, NULL);
   if (!::IsWindow(window))
     return;
 
   const DWORD kWaitMs = 3000;
@@ skipping 14 matching lines @@
                    << " to exit failed or timed out.";
     } else {
       kill = false;
       VLOG(1) << installer::kChromeFrameHelperExe << " exited normally.";
     }
   }
 
   if (kill) {
     VLOG(1) << installer::kChromeFrameHelperExe << " hung.  Killing.";
     base::CleanupProcesses(installer::kChromeFrameHelperExe, 0,
-                           ResultCodes::HUNG, NULL);
+                           content::RESULT_CODE_HUNG, NULL);
   }
 }
 
 // This method tries to figure out if current user has registered Chrome.
 // It returns true iff:
 // - Software\Clients\StartMenuInternet\Chromium\"" key has a valid value.
 // - The value is same as chrome.exe path for the current installation.
 bool CurrentUserHasDefaultBrowser(const InstallerState& installer_state,
                                   const Product& product) {
   std::wstring reg_key(ShellUtil::kRegStartMenuInternet);
@@ skipping 232 matching lines @@
   }
   return result;
 }
 
 // This method checks if Chrome is currently running or if the user has
 // cancelled the uninstall operation by clicking Cancel on the confirmation
 // box that Chrome pops up.
 InstallStatus IsChromeActiveOrUserCancelled(
     const InstallerState& installer_state,
     const Product& product) {
-  int32 exit_code = ResultCodes::NORMAL_EXIT;
+  int32 exit_code = content::RESULT_CODE_NORMAL_EXIT;
   CommandLine options(CommandLine::NO_PROGRAM);
   options.AppendSwitch(installer::switches::kUninstall);
 
   // Here we want to save user from frustration (in case of Chrome crashes)
   // and continue with the uninstallation as long as chrome.exe process exit
   // code is NOT one of the following:
   // - UNINSTALL_CHROME_ALIVE - chrome.exe is currently running
   // - UNINSTALL_USER_CANCEL - User cancelled uninstallation
   // - HUNG - chrome.exe was killed by HuntForZombieProcesses() (until we can
   //          give this method some brains and not kill chrome.exe launched
   //          by us, we will not uninstall if we get this return code).
   VLOG(1) << "Launching Chrome to do uninstall tasks.";
   if (product.LaunchChromeAndWait(installer_state.target_path(), options,
                                   &exit_code)) {
     VLOG(1) << "chrome.exe launched for uninstall confirmation returned: "
             << exit_code;
-    if ((exit_code == ResultCodes::UNINSTALL_CHROME_ALIVE) ||
-        (exit_code == ResultCodes::UNINSTALL_USER_CANCEL) ||
-        (exit_code == ResultCodes::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 == ResultCodes::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.";
   }
 
   return installer::UNINSTALL_CONFIRMED;
 }
 
 bool ShouldDeleteProfile(const InstallerState& installer_state,
                          const CommandLine& cmd_line, InstallStatus status,
@@ skipping 382 matching lines @@
 
   // Try and delete the preserved local state once the post-install
   // operations are complete.
   if (!backup_state_file.empty())
     file_util::Delete(backup_state_file, false);
 
   return ret;
 }
 
 }  // namespace installer