Invoke setup.exe to reenable updates when the update bubble is clicked.

chrome/installer/util/google_update_util.cc

 // Copyright (c) 2012 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/installer/util/google_update_util.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/environment.h"
+#include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/path_service.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
+#include "base/win/win_util.h"
+#include "base/win/windows_version.h"
 #include "chrome/installer/launcher_support/chrome_launcher_support.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
+#include "chrome/installer/util/install_util.h"
 
 using base::win::RegKey;
 
 namespace google_update {
 
 namespace {
 
 const int kGoogleUpdateTimeoutMs = 20 * 1000;
 
 const char kEnvVariableUntrustedData[] = "GoogleUpdateUntrustedData";
@@ skipping 173 matching lines @@
       GoogleUpdateSettings::GetUninstallCommandLine(system_install));
   if (cmd_string.empty()) {
     success = true;  // Nothing to; vacuous success.
   } else {
     success = LaunchProcessAndWaitWithTimeout(cmd_string,
         base::TimeDelta::FromMilliseconds(kGoogleUpdateTimeoutMs));
   }
   return success;
 }
 
+void ElevateIfNeededToReenableUpdates() {
+  base::FilePath chrome_exe;

[grt (UTC plus 2), 2014/03/28 21:22:21]

i think you can replace a bunch of this code with something like:
  base::FilePath setup_path;
  ProductState chrome_state;
  if (chrome_state.Initialize(!IsPerUserInstall(...),
BrowserDistribution::CHROME_BROWSER))
    setup_path = chrome_state.GetSetupPath();
  if (setup_path.empty())
    handle the error case

also, i think it makes sense to add --multi-install here if
chrome_state.is_multi_install() so that setup doesn't need to try to figure that
stuff out.

+  PathService::Get(base::FILE_EXE, &chrome_exe);
+  base::FilePath exe_path =
+      base::FilePath(chrome_exe).DirName().Append(installer::kSetupExe);
+  if (!base::PathExists(exe_path)) {
+    HKEY reg_root = InstallUtil::IsPerUserInstall(chrome_exe.value().c_str()) ?
+        HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
+    BrowserDistribution* dist =
+        BrowserDistribution::GetSpecificDistribution(
+            BrowserDistribution::CHROME_BROWSER);
+    RegKey key(reg_root, dist->GetUninstallRegPath().c_str(), KEY_READ);
+    base::string16 uninstall_string;
+    key.ReadValue(installer::kUninstallStringField, &uninstall_string);
+    CommandLine command_line = CommandLine::FromString(uninstall_string);
+    exe_path = command_line.GetProgram();
+  }
+
+  if (!base::PathExists(exe_path)) {
+    LOG(ERROR) << "Could not find setup.exe to reenable updates.";
+    return;
+  }
+
+  CommandLine cmd(exe_path);
+  cmd.AppendSwitch(installer::switches::kReenableAutoupdates);
+
+  if (!InstallUtil::IsPerUserInstall(chrome_exe.value().c_str()))
+    cmd.AppendSwitch(installer::switches::kSystemLevel);
+
+  base::LaunchOptions launch_options;
+  launch_options.force_breakaway_from_job_ = true;
+
+  if (base::win::GetVersion() >= base::win::VERSION_VISTA &&
+      base::win::UserAccountControlIsEnabled()) {
+    base::LaunchElevatedProcess(cmd, launch_options, NULL);
+  } else {
+    base::LaunchProcess(cmd, launch_options, NULL);
+  }
+}
+
 std::string GetUntrustedDataValue(const std::string& key) {
   std::map<std::string, std::string> untrusted_data;
   if (GetGoogleUpdateUntrustedData(&untrusted_data)) {
     std::map<std::string, std::string>::const_iterator data_it(
         untrusted_data.find(key));
     if (data_it != untrusted_data.end())
       return data_it->second;
   }
 
   return std::string();
 }
 
 std::string GetUntrustedDataValueFromTag(const std::string& tag,
                                          const std::string& key) {
   std::map<std::string, std::string> untrusted_data;
   if (ParseUntrustedData(tag, &untrusted_data))
     return untrusted_data[key];
 
   return std::string();
 }
 
 }  // namespace google_update