first-run: Refactor Upgrade class into a common upgrade_util API.

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 23 matching lines @@
 #include "chrome/browser/browser_main_win.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_impl.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/extensions/extension_protocols.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extensions_startup.h"
 #include "chrome/browser/first_run/first_run.h"
-#include "chrome/browser/first_run/upgrade.h"
+#include "chrome/browser/first_run/upgrade_util.h"
 #include "chrome/browser/gpu_data_manager.h"
 #include "chrome/browser/jankometer.h"
 #include "chrome/browser/metrics/histogram_synchronizer.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/metrics/thread_watcher.h"
 #include "chrome/browser/net/blob_url_request_job_factory.h"
 #include "chrome/browser/net/chrome_dns_cert_provenance_checker.h"
 #include "chrome/browser/net/chrome_dns_cert_provenance_checker_factory.h"
 #include "chrome/browser/net/file_system_url_request_job_factory.h"
@@ skipping 990 matching lines @@
 // We use extern C for the prototype DLLEXPORT to avoid C++ name mangling.
 extern "C" {
 DLLEXPORT void __cdecl RelaunchChromeBrowserWithNewCommandLineIfNeeded();
 }
 
 DLLEXPORT void __cdecl RelaunchChromeBrowserWithNewCommandLineIfNeeded() {
   // Need an instance of AtExitManager to handle singleton creations and
   // deletions.  We need this new instance because, the old instance created
   // in ChromeMain() got destructed when the function returned.
   base::AtExitManager exit_manager;
-  Upgrade::RelaunchChromeBrowserWithNewCommandLineIfNeeded();
+  upgrade_util::RelaunchChromeBrowserWithNewCommandLineIfNeeded();
 }
 #endif
 
 #if defined(USE_LINUX_BREAKPAD)
 bool IsMetricsReportingEnabled(const PrefService* local_state) {
   // Check whether we should initialize the crash reporter. It may be disabled
   // through configuration policy or user preference.
   // The kHeadless environment variable overrides the decision, but only if the
   // crash service is under control of the user. It is used by QA testing
   // infrastructure to switch on generation of crash reports.
@@ skipping 161 matching lines @@
   std::string try_chrome =
       parsed_command_line.GetSwitchValueASCII(switches::kTryChromeAgain);
   if (!try_chrome.empty()) {
 #if defined(OS_WIN)
     // Setup.exe has determined that we need to run a retention experiment
     // and has lauched chrome to show the experiment UI.
     if (process_singleton.FoundOtherProcessWindow()) {
       // 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 Upgrade::NOT_NOW;
+      return upgrade_util::NOT_NOW;
     }
     int try_chrome_int;
     base::StringToInt(try_chrome, &try_chrome_int);
-    Upgrade::TryResult answer =
-        Upgrade::ShowTryChromeDialog(try_chrome_int, &process_singleton);
-    if (answer == Upgrade::NOT_NOW)
+    upgrade_util::TryResult answer =
+        upgrade_util::ShowTryChromeDialog(try_chrome_int, &process_singleton);
+    if (answer == upgrade_util::NOT_NOW)
       return ResultCodes::NORMAL_EXIT_CANCEL;
-    if (answer == Upgrade::UNINSTALL_CHROME)
+    if (answer == upgrade_util::UNINSTALL_CHROME)
       return ResultCodes::NORMAL_EXIT_EXP2;
 #else
     // We don't support retention experiments on Mac or Linux.
     return ResultCodes::NORMAL_EXIT;
 #endif  // defined(OS_WIN)
   }
 
   BrowserInit browser_init;
 
   // On first run, we need to process the predictor preferences before the
@@ skipping 79 matching lines @@
   chromeos::OwnershipService::GetSharedInstance();
 #endif
 
   // Record last shutdown time into a histogram.
   browser_shutdown::ReadLastShutdownInfo();
 
 #if defined(OS_WIN)
   // On Windows, we use our startup as an opportunity to do upgrade/uninstall
   // tasks.  Those care whether the browser is already running.  On Linux/Mac,
   // upgrade/uninstall happen separately.
-  bool already_running = Upgrade::IsBrowserAlreadyRunning();
+  bool already_running = upgrade_util::IsBrowserAlreadyRunning();
 
   // If the command line specifies 'uninstall' then we need to work here
   // 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);
@@ skipping 122 matching lines @@
   // TODO(port): Port the Mac's IPC-based implementation to other platforms to
   //             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::DoUpgradeTasks(parsed_command_line))
+  if (!already_running && upgrade_util::DoUpgradeTasks(parsed_command_line))
     return ResultCodes::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).
@@ skipping 297 matching lines @@
       // the main thread. This needs to be done here because we don't want
       // to start the timer when Chrome is run inside a test harness.
       g_browser_process->StartAutoupdateTimer();
 #endif
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
       // On Linux, the running exe will be updated if an upgrade becomes
       // available while the browser is running.  We need to save the last
       // modified time of the exe, so we can compare to determine if there is
       // an upgrade while the browser is kept alive by a persistent extension.
-      Upgrade::SaveLastModifiedTimeOfExe();
+      upgrade_util::SaveLastModifiedTimeOfExe();
 #endif
 
       // Record now as the last successful chrome start.
       GoogleUpdateSettings::SetLastRunTime();
       // Call Recycle() here as late as possible, before going into the loop
       // because Start() will add things to it while creating the main window.
       if (pool)
         pool->Recycle();
       RunUIMessageLoop(browser_process.get());
     }
@@ skipping 60 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("BrowserMain", 0, 0);
   return result_code;
 }