This change will split the result codes between content and chrome.

chrome/browser/browser_main.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.
 
 #include "chrome/browser/browser_main.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 60 matching lines @@
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/service/service_process_control.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/translate/translate_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_init.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager_backend.h"
 #include "chrome/browser/web_resource/gpu_blacklist_updater.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/common/json_pref_store.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/net/net_resource_provider.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/profiling.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/common/child_process.h"
 #include "content/common/content_client.h"
 #include "content/common/hi_res_timer_manager.h"
 #include "content/common/main_function_params.h"
-#include "content/common/result_codes.h"
 #include "grit/app_locale_settings.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/platform_locale_settings.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/net_module.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_stream_factory.h"
@@ skipping 1313 matching lines @@
       // It seems that we don't need to run the experiment since chrome
       // in the same profile is already running.
       VLOG(1) << "Retention experiment not required";
       return TryChromeDialogView::NOT_NOW;
     }
     int try_chrome_int;
     base::StringToInt(try_chrome, &try_chrome_int);
     TryChromeDialogView::Result answer =
         TryChromeDialogView::Show(try_chrome_int, &process_singleton);
     if (answer == TryChromeDialogView::NOT_NOW)
-      return ResultCodes::NORMAL_EXIT_CANCEL;
+      return chrome::RESULT_CODE_NORMAL_EXIT_CANCEL;
     if (answer == TryChromeDialogView::UNINSTALL_CHROME)
-      return ResultCodes::NORMAL_EXIT_EXP2;
+      return chrome::RESULT_CODE_NORMAL_EXIT_EXP2;
 #else
     // We don't support retention experiments on Mac or Linux.
-    return ResultCodes::NORMAL_EXIT;
+    return content::RESULT_CODE_NORMAL_EXIT;
 #endif  // defined(OS_WIN)
   }
 
 #if defined(OS_CHROMEOS)
   // This needs to be called after the locale has been set.
   RegisterTranslateableItems();
 #endif
 
 #if defined(TOOLKIT_VIEWS)
   views::Widget::SetPureViews(
@@ skipping 101 matching lines @@
   // unless we detect another chrome browser running.
   if (parsed_command_line.HasSwitch(switches::kUninstall))
     return DoUninstallTasks(already_running);
 #endif
 
   if (parsed_command_line.HasSwitch(switches::kHideIcons) ||
       parsed_command_line.HasSwitch(switches::kShowIcons))
     return HandleIconsCommands(parsed_command_line);
   if (parsed_command_line.HasSwitch(switches::kMakeDefaultBrowser)) {
     return ShellIntegration::SetAsDefaultBrowser() ?
-        ResultCodes::NORMAL_EXIT : ResultCodes::SHELL_INTEGRATION_FAILED;
+        static_cast<int>(content::RESULT_CODE_NORMAL_EXIT) :

[jam, 2011/07/15 19:42:43]

I don't think the casts are needed?

[Dirk Pranke, 2011/07/15 20:02:23]

content::ResultCode and chrome::ResultCode are two different enum types; both
arms of the conditional expression have to be the same type, and the compiler
doesn't know how to automatically cast one to the other. (At least, I got a
compiler warning about this and it matches my understanding :). Dunno if there's
a better way to work around this.

+        static_cast<int>(chrome::RESULT_CODE_SHELL_INTEGRATION_FAILED);
   }
 
   // If the command line specifies --pack-extension, attempt the pack extension
   // startup action and exit.
   if (parsed_command_line.HasSwitch(switches::kPackExtension)) {
     ExtensionsStartupUtil extension_startup_util;
     if (extension_startup_util.PackExtension(parsed_command_line)) {
-      return ResultCodes::NORMAL_EXIT;
+      return content::RESULT_CODE_NORMAL_EXIT;
     } else {
-      return ResultCodes::PACK_EXTENSION_ERROR;
+      return chrome::RESULT_CODE_PACK_EXTENSION_ERROR;
     }
   }
 
 #if !defined(OS_MACOSX)
   // In environments other than Mac OS X we support import of settings
   // from other browsers. In case this process is a short-lived "import"
   // process that another browser runs just to import the settings, we
   // don't want to be checking for another browser process, by design.
   if (!(parsed_command_line.HasSwitch(switches::kImport) ||
         parsed_command_line.HasSwitch(switches::kImportFromFile))) {
 #endif
     // When another process is running, use that process instead of starting a
     // new one. NotifyOtherProcess will currently give the other process up to
     // 20 seconds to respond. Note that this needs to be done before we attempt
     // to read the profile.
     switch (process_singleton.NotifyOtherProcessOrCreate()) {
       case ProcessSingleton::PROCESS_NONE:
         // No process already running, fall through to starting a new one.
         break;
 
       case ProcessSingleton::PROCESS_NOTIFIED:
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
         printf("%s\n", base::SysWideToNativeMB(UTF16ToWide(
             l10n_util::GetStringUTF16(IDS_USED_EXISTING_BROWSER))).c_str());
 #endif
-        return ResultCodes::NORMAL_EXIT;
+        return content::RESULT_CODE_NORMAL_EXIT;
 
       case ProcessSingleton::PROFILE_IN_USE:
-        return ResultCodes::PROFILE_IN_USE;
+        return chrome::RESULT_CODE_PROFILE_IN_USE;
 
       case ProcessSingleton::LOCK_ERROR:
         LOG(ERROR) << "Failed to create a ProcessSingleton for your profile "
                       "directory. This means that running multiple instances "
                       "would start multiple browser processes rather than "
                       "opening a new window in the existing process. Aborting "
                       "now to avoid profile corruption.";
-        return ResultCodes::PROFILE_IN_USE;
+        return chrome::RESULT_CODE_PROFILE_IN_USE;
 
       default:
         NOTREACHED();
     }
 #if !defined(OS_MACOSX)  // closing brace for if
   }
 #endif
 
 #if defined(USE_X11)
   SetBrowserX11ErrorHandlers();
@@ skipping 27 matching lines @@
     VLOG(1) << "Relaunching browser for user: " << username;
     chromeos::UserManager::Get()->UserLoggedIn(username);
 
     // Redirects Chrome logging to the user data dir.
     logging::RedirectChromeLogging(parsed_command_line);
   }
 #endif
 
   Profile* profile = CreateProfile(parameters, user_data_dir);
   if (!profile)
-    return ResultCodes::NORMAL_EXIT;
+    return content::RESULT_CODE_NORMAL_EXIT;
 
   // Post-profile init ---------------------------------------------------------
 
 #if defined(OS_CHROMEOS)
   // Handling the user cloud policy initialization for case 2 mentioned above.
   // We do this after the profile creation since we need the TokenService.
   if (parsed_command_line.HasSwitch(switches::kLoginUser) &&
       !parsed_command_line.HasSwitch(switches::kLoginPassword)) {
     std::string username =
         parsed_command_line.GetSwitchValueASCII(switches::kLoginUser);
@@ skipping 21 matching lines @@
   //             replace this implementation. http://crbug.com/22142
   if (parsed_command_line.HasSwitch(switches::kImport) ||
       parsed_command_line.HasSwitch(switches::kImportFromFile)) {
     return FirstRun::ImportNow(profile, parsed_command_line);
   }
 #endif
 
 #if defined(OS_WIN)
   // Do the tasks if chrome has been upgraded while it was last running.
   if (!already_running && upgrade_util::DoUpgradeTasks(parsed_command_line))
-    return ResultCodes::NORMAL_EXIT;
+    return content::RESULT_CODE_NORMAL_EXIT;
 #endif
 
   // Check if there is any machine level Chrome installed on the current
   // machine. If yes and the current Chrome process is user level, we do not
   // allow the user level Chrome to run. So we notify the user and uninstall
   // user level Chrome.
   // Note this check should only happen here, after all the checks above
   // (uninstall, resource bundle initialization, other chrome browser
   // processes etc).
   // Do not allow this to occur for Chrome Frame user-to-system handoffs.
   if (!parsed_command_line.HasSwitch(switches::kChromeFrame) &&
       CheckMachineLevelInstall())
-    return ResultCodes::MACHINE_LEVEL_INSTALL_EXISTS;
+    return chrome::RESULT_CODE_MACHINE_LEVEL_INSTALL_EXISTS;
 
   // Create the TranslateManager singleton.
   TranslateManager* translate_manager = TranslateManager::GetInstance();
   DCHECK(translate_manager != NULL);
 
 #if defined(OS_MACOSX)
   if (!parsed_command_line.HasSwitch(switches::kNoFirstRun)) {
     // Disk image installation is sort of a first-run task, so it shares the
     // kNoFirstRun switch.
     if (MaybeInstallFromDiskImage()) {
       // The application was installed and the installed copy has been
       // launched.  This process is now obsolete.  Exit.
-      return ResultCodes::NORMAL_EXIT;
+      return content::RESULT_CODE_NORMAL_EXIT;
     }
   }
 #endif
 
   // Show the First Run UI if this is the first time Chrome has been run on
   // this computer, or we're being compelled to do so by a command line flag.
   // Note that this be done _after_ the PrefService is initialized and all
   // preferences are registered, since some of the code that the importer
   // touches reads preferences.
   if (is_first_run) {
@@ skipping 171 matching lines @@
     // See issue 40144.
     profile->GetExtensionService()->InitEventRouters();
   }
 
   // The extension service may be available at this point. If the command line
   // specifies --uninstall-extension, attempt the uninstall extension startup
   // action.
   if (parsed_command_line.HasSwitch(switches::kUninstallExtension)) {
     ExtensionsStartupUtil ext_startup_util;
     if (ext_startup_util.UninstallExtension(parsed_command_line, profile)) {
-      return ResultCodes::NORMAL_EXIT;
+      return content::RESULT_CODE_NORMAL_EXIT;
     } else {
-      return ResultCodes::UNINSTALL_EXTENSION_ERROR;
+      return chrome::RESULT_CODE_UNINSTALL_EXTENSION_ERROR;
     }
   }
 
 #if defined(OS_WIN)
   // We check this here because if the profile is OTR (chromeos possibility)
   // it won't still be accessible after browser is destroyed.
   bool record_search_engine = is_first_run && !profile->IsOffTheRecord();
 #endif
 
   // ChildProcess:: is a misnomer unless you consider context.  Use
@@ skipping 24 matching lines @@
       new GpuBlacklistUpdater();
   // Don't start auto update in tests.
   if (parsed_command_line.GetSwitchValueASCII(switches::kUseGL) !=
           gfx::kGLImplementationOSMesaName) {
     gpu_blacklist_updater->StartAfterDelay();
   }
 
   // Start watching all browser threads for responsiveness.
   ThreadWatcherList::StartWatchingAll(parsed_command_line);
 
-  int result_code = ResultCodes::NORMAL_EXIT;
+  int result_code = content::RESULT_CODE_NORMAL_EXIT;
   if (parameters.ui_task) {
     // We are in test mode. Run one task and enter the main message loop.
     if (pool)
       pool->Recycle();
     parameters.ui_task->Run();
     delete parameters.ui_task;
   } else {
     // Most general initialization is behind us, but opening a
     // tab and/or session restore and such is still to be done.
     base::TimeTicks browser_open_start = base::TimeTicks::Now();
@@ skipping 106 matching lines @@
 #if defined(OS_CHROMEOS)
   // To be precise, logout (browser shutdown) is not yet done, but the
   // remaining work is negligible, hence we say LogoutDone here.
   chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker("LogoutDone",
                                                         false);
   chromeos::BootTimesLoader::Get()->WriteLogoutTimes();
 #endif
   TRACE_EVENT_END_ETW("BrowserMain", 0, 0);
   return result_code;
 }