Add -multifail to the Google Update "ap" value if --multi-install is present ...

chrome/installer/mini_installer/mini_installer.cc

 // Copyright (c) 2006-2009 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 appropiate flags.
 //
@@ skipping 49 matching lines @@
 // return Windows last-error codes a la the Win32 registry API.
 class RegKey {
  public:
   RegKey() : key_(NULL) { }
   ~RegKey() { Close(); }
 
   // Opens the key named |sub_key| with given |access| rights.  Returns
   // ERROR_SUCCESS or some other error.
   LONG Open(HKEY key, const wchar_t* sub_key, REGSAM access);
 
-  // Returns true if the is open.
-  bool IsOpen() const { return key_ != NULL; }
+  // Returns true if a key is open.
+  bool is_valid() const { return key_ != NULL; }
 
   // Read a REG_SZ value from the registry into the memory indicated by |value|
   // (of |value_size| wchar_t units).  Returns ERROR_SUCCESS,
   // ERROR_FILE_NOT_FOUND, ERROR_MORE_DATA, or some other error.  |value| is
   // guaranteed to be null-terminated on success.
   LONG ReadValue(const wchar_t* value_name,
                  wchar_t* value,
                  size_t value_size) const;
 
   // Write a REG_SZ value to the registry.  |value| must be null-terminated.
@@ skipping 89 matching lines @@
 }
 
 // Safer replacement for lstrcat function.
 bool SafeStrCat(wchar_t* dest, size_t dest_size, const wchar_t* src) {
   int str_len = ::lstrlen(dest);
   return SafeStrCopy(dest + str_len, dest_size - str_len, src);
 }
 
 // Function to check if a string (specified by str) ends with another string
 // (specified by end_str).
-bool StrEndsWith(const wchar_t *str, const wchar_t *end_str) {
+bool StrEndsWith(const wchar_t* str, const wchar_t* end_str) {
   if (str == NULL || end_str == NULL)
     return false;
 
   for (int i = lstrlen(str) - 1, j = lstrlen(end_str) - 1; j >= 0; --i, --j) {
     if (i < 0 || !EqualASCIICharI(str[i], end_str[j]))
       return false;
   }
 
   return true;
 }
 
 // Function to check if a string (specified by str) starts with another string
 // (specified by start_str).
-bool StrStartsWith(const wchar_t *str, const wchar_t *start_str) {
+bool StrStartsWith(const wchar_t* str, const wchar_t* start_str) {
   if (str == NULL || start_str == NULL)
     return false;
 
   for (int i = 0; start_str[i] != L'\0'; ++i) {
     if (!EqualASCIICharI(str[i], start_str[i]))
       return false;
   }
 
   return true;
 }
 
+// Searches for |tag| within |str|.  Returns true if |tag| is found and is
+// immediately followed by '-' or is at the end of the string.  If |position|
+// is non-NULL, the location of the tag is returned in |*position| on success.
+bool FindTagInStr(const wchar_t* str,
+                  const wchar_t* tag,
+                  const wchar_t** position) {
+  int tag_length = ::lstrlen(tag);
+  const wchar_t* scan = str;
+  for (const wchar_t* tag_start = StrStrI(scan, tag); tag_start != NULL;
+       tag_start = StrStrI(scan, tag)) {
+    scan = tag_start + tag_length;
+    if (*scan == L'-' || *scan == L'\0') {
+      if (position != NULL)
+        *position = tag_start;
+      return true;
+    }
+  }
+  return false;
+}
+
 // Helper function to read a value from registry. Returns true if value
 // is read successfully and stored in parameter value. Returns false otherwise.
 // |size| is measured in wchar_t units.
 bool ReadValueFromRegistry(HKEY root_key, const wchar_t *sub_key,
                            const wchar_t *value_name, wchar_t *value,
                            size_t size) {
   RegKey key;
 
   if (key.Open(root_key, sub_key, KEY_QUERY_VALUE) == ERROR_SUCCESS &&
       key.ReadValue(value_name, value, size) == ERROR_SUCCESS) {
     return true;
   }
   return false;
 }
 
 // Opens the Google Update ClientState key for a product.
 bool OpenClientStateKey(HKEY root_key, const wchar_t* app_guid, REGSAM access,
                         RegKey* key) {
   wchar_t client_state_key[128];
 
   return SafeStrCopy(client_state_key, _countof(client_state_key),
                      kApRegistryKeyBase) &&
          SafeStrCat(client_state_key, _countof(client_state_key), app_guid) &&
          (key->Open(root_key, client_state_key, access) == ERROR_SUCCESS);
 }
 
 // TODO(grt): Write a unit test for this that uses registry virtualization.
-void SetFullInstallerFlagHelper(int args_num, const wchar_t* const* args) {
+void SetInstallerFlagsHelper(int args_num, const wchar_t* const* args) {
   bool multi_install = false;
   RegKey key;
   const REGSAM key_access = KEY_QUERY_VALUE | KEY_SET_VALUE;
   const wchar_t* app_guid = google_update::kAppGuid;
   HKEY root_key = HKEY_CURRENT_USER;
   wchar_t value[128];
   LONG ret;
 
   for (int i = 1; i < args_num; ++i) {
     if (0 == ::lstrcmpi(args[i], L"--chrome-sxs"))
@@ skipping 16 matching lines @@
   //    a ClientState key in the registry.  Only it need be modified.
   // To handle all cases, we inspect the product's ClientState to see if it
   // exists and its "ap" value does not contain "-multi".  This is case 3, so we
   // modify the product's ClientState.  Otherwise, we check the
   // multi-installer's ClientState and modify it if it exists.
   if (multi_install) {
     if (OpenClientStateKey(root_key, app_guid, key_access, &key)) {
       // The app is installed.  See if it's a single-install.
       ret = key.ReadValue(kApRegistryValueName, value, _countof(value));
       if (ret != ERROR_FILE_NOT_FOUND &&
-          (ret != ERROR_SUCCESS || StrStr(value, kMultiInstallTag) != NULL)) {
-        // Error or case 2: add "-full" to the multi-installer's value.
+          (ret != ERROR_SUCCESS ||
+           FindTagInStr(value, kMultiInstallTag, NULL))) {
+        // Error or case 2: modify the multi-installer's value.
         key.Close();
         app_guid = google_update::kMultiInstallAppGuid;
-      }  // else case 3: add "-full" to this value.
+      }  // else case 3: modify this value.
     } else {
-      // case 1 or 2: add "-full" to the multi-installer's value.
+      // case 1 or 2: modify the multi-installer's value.
       key.Close();
       app_guid = google_update::kMultiInstallAppGuid;
     }
   }
 
-  if (!key.IsOpen()) {
+  if (!key.is_valid()) {
     if (!OpenClientStateKey(root_key, app_guid, key_access, &key))
       return;
 
     ret = key.ReadValue(kApRegistryValueName, value, _countof(value));
   }
 
   // The conditions below are handling two cases:
-  // 1. When ap key is present, we want to make sure it doesn't already end
-  //    in -full and then append -full to it.
-  // 2. When ap key is missing, we are going to create it with value -full.
+  // 1. When ap key is present, we want to add the required tags only if they
+  //    are not present.
+  // 2. When ap key is missing, we are going to create it with the required
+  //    tags.
   if ((ret == ERROR_SUCCESS) || (ret == ERROR_FILE_NOT_FOUND)) {
     if (ret == ERROR_FILE_NOT_FOUND)
       value[0] = L'\0';
 
-    if (!StrEndsWith(value, kFullInstallerSuffix) &&
+    bool success = true;
+
+    if (multi_install &&
+        !FindTagInStr(value, kMultifailInstallerSuffix, NULL)) {
+      // We want -multifail to immediately precede -full.  Chop off the latter
+      // if it's already present so that we can simply do two appends.
+      if (StrEndsWith(value, kFullInstallerSuffix)) {
+        int suffix_len = ::lstrlen(kFullInstallerSuffix);
+        int value_len = ::lstrlen(value);
+        value[value_len - suffix_len] = L'\0';
+      }
+      success = SafeStrCat(value, _countof(value), kMultifailInstallerSuffix);
+    }
+    if (success && !StrEndsWith(value, kFullInstallerSuffix) &&
         (SafeStrCat(value, _countof(value), kFullInstallerSuffix)))
       key.WriteValue(kApRegistryValueName, value);
   }
 }
 
 // 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. The flag will by default
 // be written to HKCU, but if --system-level is included in the command line,
 // it will be written to HKLM instead.
-void SetFullInstallerFlag() {
+void SetInstallerFlags() {
   int args_num;
   wchar_t* cmd_line = ::GetCommandLine();
   wchar_t** args = ::CommandLineToArgvW(cmd_line, &args_num);
 
-  SetFullInstallerFlagHelper(args_num, args);
+  SetInstallerFlagsHelper(args_num, args);
 
   ::LocalFree(args);
 }
 
 // Gets the setup.exe path from Registry by looking the value of Uninstall
 // string, strips the arguments for uninstall and returns only the full path
 // to setup.exe.  |size| is measured in wchar_t units.
 bool GetSetupExePathFromRegistry(wchar_t *path, size_t size) {
   if (!ReadValueFromRegistry(HKEY_CURRENT_USER, kUninstallRegistryKey,
       kUninstallRegistryValueName, path, size)) {
@@ skipping 317 matching lines @@
   // First get a path where we can extract payload
   wchar_t base_path[MAX_PATH];
   if (!GetWorkDir(module, base_path))
     return 101;
 
 #if defined(GOOGLE_CHROME_BUILD)
   // Set the magic suffix in registry to try full installer next time. We ignore
   // any errors here and we try to set the suffix for user level unless
   // --system-level is on the command line in which case we set it for system
   // level instead. This only applies to the Google Chrome distribution.
-  // TODO(grt): also add -multifail if --multi-install.
-  SetFullInstallerFlag();
+  SetInstallerFlags();
 #endif
 
   wchar_t archive_path[MAX_PATH] = {0};
   wchar_t setup_path[MAX_PATH] = {0};
   if (!UnpackBinaryResources(module, base_path, archive_path, MAX_PATH,
                              setup_path, MAX_PATH))
     return 102;
 
   int exit_code = 103;
   if (!RunSetup(archive_path, setup_path, &exit_code))
     return exit_code;
 
   wchar_t value[2];
   if ((!ReadValueFromRegistry(HKEY_CURRENT_USER, kCleanupRegistryKey,
                               kCleanupRegistryValueName, value,
                               _countof(value))) ||
       (value[0] != L'0'))
     DeleteExtractedFiles(base_path, archive_path, setup_path);
 
   return exit_code;
 }
+
 }  // namespace mini_installer
 
 
 int MainEntryPoint() {
   int result = mini_installer::WMain(::GetModuleHandle(NULL));
   ::ExitProcess(result);
 }