Command-line tool to generate a newly versioned mini_installer.exe

chrome/installer/test/alternate_version_generator.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
 // The file contains the implementation of the mini_installer re-versioner.
 // The main function (GenerateNextVersion) does the following in a temp dir:
 // - Extracts and unpacks setup.exe and the Chrome-bin folder from
 //   mini_installer.exe.
 // - Inspects setup.exe to determine the current version.
 // - Runs through all .dll and .exe files:
 //   - Replacing all occurrences of the Unicode version string in the files'
@@ skipping 324 matching lines @@
       } else {
         result = true;
       }
     }
   } else {
     PLOG(DFATAL) << "Failed to open \"" << image_file.value() << "\"";
   }
   return result;
 }
 
-// Bumps the version of all .exe and .dll files in |work_dir| as well as the
-// |work-dir|\Chrome-bin\w.x.y.z directory.
-bool ApplyNextVersion(const FilePath& work_dir) {
+// Raises or lowers the version of all .exe and .dll files in |work_dir| as well
+// as the |work-dir|\Chrome-bin\w.x.y.z directory.  |original_version| and
+// |new_version|, when non-NULL, are given the original and new version numbers
+// on success.
+bool ApplyAlternateVersion(const FilePath& work_dir,
+                           upgrade_test::Direction direction,
+                           std::wstring* original_version,
+                           std::wstring* new_version) {
   VisitResourceContext ctx;
   if (!GetSetupExeVersion(work_dir, &ctx.current_version)) {
     return false;
   }
   ctx.current_version_str = ctx.current_version.ToString();
 
-  // Figure out a future version with the same string length as this one by
-  // incrementing each component.
-  ULONGLONG incrementer = 1;
+  // Figure out a past or future version with the same string length as this one
+  // by decrementing or incrementing each component.
+  LONGLONG incrementer = (direction == upgrade_test::PREVIOUS_VERSION ? -1 : 1);
 
   do {
     if (incrementer == 0) {
-      LOG(DFATAL) << "Improbable version composed of only 9s and/or USHRT_MAX";
+      LOG(DFATAL) << "Improbable version at the cusp of complete rollover";
       return false;
     }
     ctx.new_version.set_value(ctx.current_version.value() + incrementer);
     ctx.new_version_str = ctx.new_version.ToString();
     incrementer <<= 16;
   } while (ctx.new_version_str.size() != ctx.current_version_str.size());
 
   // Modify all .dll and .exe files with the current version.
   bool doing_great = true;
   file_util::FileEnumerator all_files(work_dir, true,
                                       file_util::FileEnumerator::FILES);
   do {
     FilePath file = all_files.Next();
     if (file.empty()) {
       break;
     }
     std::wstring extension = file.Extension();
     if (extension == &kExtExe[0] || extension == &kExtDll[0]) {
       doing_great = UpdateVersionIfMatch(file, &ctx);
     }
   } while (doing_great);
 
   // Change the versioned directory.
   FilePath chrome_bin = work_dir.Append(&kChromeBin[0]);
   doing_great = file_util::Move(chrome_bin.Append(ctx.current_version_str),
                                 chrome_bin.Append(ctx.new_version_str));
 
+  if (doing_great) {
+    // Report the version numbers if requested.
+    if (original_version != NULL)
+      original_version->assign(ctx.current_version_str);
+    if (new_version != NULL)
+      new_version->assign(ctx.new_version_str);
+  }
+
   return doing_great;
 }
 
 // Returns the path to the directory holding the 7za executable.  By default, it
 // is assumed that the test resides in the tree's output directory, so the
 // relative path "..\..\third_party\lzma_sdk\Executable" is applied to the host
 // executable's directory.  This can be overridden with the --7za_path
 // command-line switch.
 FilePath Get7zaPath() {
   FilePath l7za_path = CommandLine::ForCurrentProcess()->GetSwitchValuePath(
@@ skipping 31 matching lines @@
                 << " while creating " << output_file.value();
     return false;
   }
   return true;
 }
 
 }  // namespace
 
 namespace upgrade_test {
 
-bool GenerateNextVersion(const FilePath& original_installer_path,
-                         const FilePath& target_path) {
+bool GenerateAlternateVersion(const FilePath& original_installer_path,
+                              const FilePath& target_path,
+                              Direction direction,
+                              std::wstring* original_version,
+                              std::wstring* new_version) {
   // Create a temporary directory in which we'll do our work.
   ScopedTempDirectory work_dir;
   if (!work_dir.Initialize())
     return false;
 
   // Copy the original mini_installer.
   FilePath mini_installer =
       work_dir.directory().Append(original_installer_path.BaseName());
   if (!file_util::CopyFile(original_installer_path, mini_installer)) {
     LOG(DFATAL) << "Failed copying \"" << original_installer_path.value()
@@ skipping 73 matching lines @@
   // Get rid of intermediate files
   FilePath chrome_7z(chrome_7z_name);
   if (!file_util::Delete(chrome_7z, false) ||
       !file_util::Delete(chrome_packed_7z, false) ||
       !file_util::Delete(setup_ex_, false)) {
     LOG(DFATAL) << "Failed deleting intermediate files";
     return false;
   }
 
   // Increment the version in all files.
-  ApplyNextVersion(work_dir.directory());
+  ApplyAlternateVersion(work_dir.directory(), direction, original_version,
+                        new_version);
 
   // Pack up files into chrome.7z
   if (!CreateArchive(chrome_7z, work_dir.directory().Append(&kChromeBin[0]), 0))
     return false;
 
   // Compress chrome.7z into chrome.packed.7z
   if (!CreateArchive(chrome_packed_7z, chrome_7z, 9))
     return false;
 
   // Compress setup.exe into setup.ex_
@@ skipping 21 matching lines @@
                       chrome_packed_7z) ||
       !updater.Commit()) {
     return false;
   }
 
   // Finally, move the updated mini_installer into place.
   return file_util::Move(mini_installer, target_path);
 }
 
 }  // namespace upgrade_test