Various cleanups.

chrome/installer/mini_installer/mini_installer.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.
 
 // mini_installer.exe is the first exe that is run when chrome is being
 // installed or upgraded. It is designed to be extremely small (~5KB with no
 // extra resources linked) and it has two main jobs:
 //   1) unpack the resources (possibly decompressing some)
 //   2) run the real installer (setup.exe) with appropriate flags.
 //
@@ skipping 19 matching lines @@
 // http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx
 #define SystemFunction036 NTAPI SystemFunction036
 #include <NTSecAPI.h>
 #undef SystemFunction036
 
 #include <sddl.h>
 #include <shellapi.h>
 #include <stdlib.h>
 #include <stddef.h>
 
+#include <initializer_list>
+
 #include "chrome/installer/mini_installer/appid.h"
 #include "chrome/installer/mini_installer/configuration.h"
 #include "chrome/installer/mini_installer/decompress.h"
 #include "chrome/installer/mini_installer/mini_installer_constants.h"
 #include "chrome/installer/mini_installer/pe_resource.h"
 #include "chrome/installer/mini_installer/regkey.h"
 
 namespace mini_installer {
 
 typedef StackString<MAX_PATH> PathString;
 
 // This structure passes data back and forth for the processing
 // of resource callbacks.
 struct Context {
   // Input to the call back method. Specifies the dir to save resources.
   const wchar_t* base_path;
   // First output from call back method. Full path of Chrome archive.
   PathString* chrome_resource_path;
   // Second output from call back method. Full path of Setup archive/exe.
   PathString* setup_resource_path;
 };
 
+// TODO(grt): Frame this in terms of whether or not the brand supports
+// integation with Omaha, where Google Update is the Google-specific fork of
+// the open-source Omaha project.
 #if defined(GOOGLE_CHROME_BUILD)
 // Opens the Google Update ClientState key. If |binaries| is false, opens the
 // key for Google Chrome or Chrome SxS (canary). If |binaries| is true and an
 // existing multi-install Chrome is being updated, opens the key for the
-// binaries; otherwise, returns false.
+// multi-install binaries; otherwise, returns false.
 bool OpenInstallStateKey(const Configuration& configuration,
                          bool binaries,
                          RegKey* key) {
   if (binaries && !configuration.is_updating_multi_chrome())
     return false;
   const HKEY root_key =
       configuration.is_system_level() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   const wchar_t* app_guid = binaries ? google_update::kMultiInstallAppGuid
                                      : configuration.chrome_app_guid();
   const REGSAM key_access = KEY_QUERY_VALUE | KEY_SET_VALUE;
 
   return OpenClientStateKey(root_key, app_guid, key_access, key) ==
          ERROR_SUCCESS;
 }
 
 // Writes install results into the registry where it is read by Google Update.
 // Don't write anything if there is already a result present, likely
 // written by setup.exe.
 void WriteInstallResults(const Configuration& configuration,
                          ProcessExitResult result) {
   // Calls to setup.exe will write a "success" result if everything was good
   // so we don't need to write anything from here.
   if (result.IsSuccess())
     return;
 
   // Write the value in Chrome ClientState key and in the binaries' if an
   // existing multi-install Chrome is being updated.
-  for (int i = 0; i < 2; ++i) {
+  for (bool binaries : {false, true}) {
     RegKey key;
     DWORD value;
-    if (OpenInstallStateKey(configuration, i != 0, &key)) {
+    if (OpenInstallStateKey(configuration, binaries, &key)) {
       if (key.ReadDWValue(kInstallerResultRegistryValue, &value) !=
               ERROR_SUCCESS ||
           value == 0) {
         key.WriteDWValue(kInstallerResultRegistryValue,
                          result.exit_code ? 1 /* FAILED_CUSTOM_ERROR */
                                           : 0 /* SUCCESS */);
         key.WriteDWValue(kInstallerErrorRegistryValue, result.exit_code);
         key.WriteDWValue(kInstallerExtraCode1RegistryValue,
                          result.windows_error);
       }
     }
   }
 }
 
 // This function sets the flag in registry to indicate that Google Update
 // should try full installer next time. If the current installer works, this
 // flag is cleared by setup.exe at the end of install.
 void SetInstallerFlags(const Configuration& configuration) {
   StackString<128> value;
 
-  for (int i = 0; i < 2; ++i) {
+  for (bool binaries : {false, true}) {
     RegKey key;
-    if (!OpenInstallStateKey(configuration, i != 0, &key))
+    if (!OpenInstallStateKey(configuration, binaries, &key))
       continue;
 
     LONG ret = key.ReadSZValue(kApRegistryValue, value.get(), value.capacity());
 
     // The conditions below are handling two cases:
     // 1. When ap value is present, we want to add the required tag only if it
     //    is not present.
     // 2. When ap value is missing, we are going to create it with the required
     //    tag.
     if ((ret == ERROR_SUCCESS) || (ret == ERROR_FILE_NOT_FOUND)) {
@@ skipping 723 matching lines @@
     DeleteExtractedFiles(base_path.get(), archive_path.get(), setup_path.get());
 
 #if defined(GOOGLE_CHROME_BUILD)
   WriteInstallResults(configuration, exit_code);
 #endif
 
   return exit_code;
 }
 
 }  // namespace mini_installer