Do not elevate to register Chrome for system-level Win7 installs.

chrome/installer/util/shell_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.
 //
 // This file defines functions that integrate Chrome in Windows shell. These
 // functions can be used by Chrome as well as Chrome installer. All of the
 // work is done by the local functions defined in anonymous namespace in
 // this class.
 
 #include "chrome/installer/util/shell_util.h"
 
 #include <windows.h>
 #include <shlobj.h>
 #include <shobjidl.h>
 
 #include <algorithm>
 #include <iterator>
 #include <limits>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/md5.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 641 matching lines @@
                                    uint32_t look_for_in) {
   std::vector<std::unique_ptr<RegistryEntry>> entries;
   GetProtocolCapabilityEntries(suffix, protocol, &entries);
   return AreEntriesAsDesired(entries, look_for_in);
 }
 
 // This method registers Chrome by launching an elevated setup.exe. That will
 // show the user the standard elevation prompt. If the user accepts it the new
 // process will make the necessary changes and return SUCCESS that we capture
 // and return. If protocol is non-empty we will also register Chrome as being
-// capable of handling the protocol. This is most commonly used on per-user
-// installs on Windows 7 where setup.exe did not have permission to register
-// Chrome during install. It may also be used on all OSs for system-level
-// installs in case Chrome's registration is somehow broken or missing.
+// capable of handling the protocol. This is used for general browser
+// registration on Windows 7 for per-user installs where setup.exe did not have
+// permission to register Chrome during install. It may also be used on Windows
+// 7 for system-level installs to register Chrome for a specific protocol.
 bool ElevateAndRegisterChrome(BrowserDistribution* dist,
                               const base::FilePath& chrome_exe,
                               const base::string16& suffix,
                               const base::string16& protocol) {
   // Check for setup.exe in the same directory as chrome.exe, as is the case
   // when running out of a build output directory.
   base::FilePath exe_path = chrome_exe.DirName().Append(installer::kSetupExe);
 
   // Failing that, read the path to setup.exe from Chrome's ClientState key,
   // which is the canonical location of the installer for all types of installs
@@ skipping 1383 matching lines @@
   // install is also present, it will lead IsChromeRegistered() to think this
   // system-level install isn't registered properly as it is shadowed by the
   // user-level install's registrations).
   uint32_t look_for_in = user_level ? RegistryEntry::LOOK_IN_HKCU_THEN_HKLM
                                     : RegistryEntry::LOOK_IN_HKLM;
 
   // Check if chrome is already registered with this suffix.
   if (IsChromeRegistered(dist, chrome_exe, suffix, look_for_in))
     return true;
 
-  bool result = true;
+  // Ensure that the shell is notified of the mutations below. Specific exit
+  // points may disable this if no mutations are made.
+  base::ScopedClosureRunner notify_on_exit(base::Bind([] {
+    SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, nullptr, nullptr);
+  }));
+
+  // Do the full registration at user-level or if the user is an admin.
   if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
-    // Do the full registration if we can do it at user-level or if the user is
-    // an admin.
     std::vector<std::unique_ptr<RegistryEntry>> progid_and_appreg_entries;
     std::vector<std::unique_ptr<RegistryEntry>> shell_entries;
     GetChromeProgIdEntries(dist, chrome_exe, suffix,
                            &progid_and_appreg_entries);
     GetChromeAppRegistrationEntries(chrome_exe, suffix,
                                     &progid_and_appreg_entries);
     GetShellIntegrationEntries(dist, chrome_exe, suffix, &shell_entries);
-    result = (AddRegistryEntries(root, progid_and_appreg_entries) &&
-              AddRegistryEntries(root, shell_entries));
-  } else if (elevate_if_not_admin &&
-      base::win::GetVersion() >= base::win::VERSION_VISTA &&
+    return AddRegistryEntries(root, progid_and_appreg_entries) &&
+           AddRegistryEntries(root, shell_entries);
+  }
+  // The installer is responsible for registration for system-level installs, so
+  // never try to do it here. Getting to this point for a system-level install
+  // likely means that IsChromeRegistered thinks registration is broken due to
+  // localization issues (see https://crbug.com/717913#c18). It likely is not,
+  // so return success to allow Chrome to be made default.
+  if (!user_level) {
+    notify_on_exit.Release().Reset();
+    return true;
+  }
+  // Try to elevate and register if requested for per-user installs if the user
+  // is not an admin.
+  if (elevate_if_not_admin &&
       ElevateAndRegisterChrome(dist, chrome_exe, suffix, base::string16())) {
-    // If the user is not an admin and OS is between Vista and Windows 7
-    // inclusively, try to elevate and register. This is only intended for
-    // user-level installs as system-level installs should always be run with
-    // admin rights.
-    result = true;
-  } else {
-    // If we got to this point then all we can do is create ProgId and basic app
-    // registrations under HKCU.
-    std::vector<std::unique_ptr<RegistryEntry>> entries;
-    GetChromeProgIdEntries(dist, chrome_exe, base::string16(), &entries);
-    // Prefer to use |suffix|; unless Chrome's ProgIds are already registered
-    // with no suffix (as per the old registration style): in which case some
-    // other registry entries could refer to them and since we were not able to
-    // set our HKLM entries above, we are better off not altering these here.
-    if (!AreEntriesAsDesired(entries, RegistryEntry::LOOK_IN_HKCU)) {
-      if (!suffix.empty()) {
-        entries.clear();
-        GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
-        GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
-      }
-      result = AddRegistryEntries(HKEY_CURRENT_USER, entries);
-    } else {
-      // The ProgId is registered unsuffixed in HKCU, also register the app with
-      // Windows in HKCU (this was not done in the old registration style and
-      // thus needs to be done after the above check for the unsuffixed
-      // registration).
+    return true;
+  }
+  // If we got to this point then all we can do is create ProgId and basic app
+  // registrations under HKCU.
+  std::vector<std::unique_ptr<RegistryEntry>> entries;
+  GetChromeProgIdEntries(dist, chrome_exe, base::string16(), &entries);
+  // Prefer to use |suffix|; unless Chrome's ProgIds are already registered with
+  // no suffix (as per the old registration style): in which case some other
+  // registry entries could refer to them and since we were not able to set our
+  // HKLM entries above, we are better off not altering these here.
+  if (!AreEntriesAsDesired(entries, RegistryEntry::LOOK_IN_HKCU)) {
+    if (!suffix.empty()) {
       entries.clear();
-      GetChromeAppRegistrationEntries(chrome_exe, base::string16(), &entries);
-      result = AddRegistryEntries(HKEY_CURRENT_USER, entries);
+      GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
+      GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
     }
+    return AddRegistryEntries(HKEY_CURRENT_USER, entries);
   }
-  SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
-  return result;
+  // The ProgId is registered unsuffixed in HKCU, also register the app with
+  // Windows in HKCU (this was not done in the old registration style and thus
+  // needs to be done after the above check for the unsuffixed registration).
+  entries.clear();
+  GetChromeAppRegistrationEntries(chrome_exe, base::string16(), &entries);
+  return AddRegistryEntries(HKEY_CURRENT_USER, entries);
 }
 
 bool ShellUtil::RegisterChromeForProtocol(BrowserDistribution* dist,
                                           const base::FilePath& chrome_exe,
                                           const base::string16& unique_suffix,
                                           const base::string16& protocol,
                                           bool elevate_if_not_admin) {
   // Assert that this is only called with the one relevant distribution.
   // TODO(grt): Remove this when BrowserDistribution goes away.
   DCHECK_EQ(BrowserDistribution::GetDistribution(), dist);
@@ skipping 193 matching lines @@
   for (const auto& entry : entries)
     entry->AddToWorkItemList(root, items.get());
 
   // Apply all the registry changes and if there is a problem, rollback
   if (!items->Do()) {
     items->Rollback();
     return false;
   }
   return true;
 }