Return version of the generated file in GenerateAlternatePEFileVersion.

chrome/installer/test/alternate_version_generator.cc

 // 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:
@@ skipping 38 matching lines @@
 #include "base/version.h"
 #include "base/win/pe_image.h"
 #include "base/win/scoped_handle.h"
 #include "chrome/installer/test/pe_image_resources.h"
 #include "chrome/installer/test/resource_loader.h"
 #include "chrome/installer/test/resource_updater.h"
 #include "chrome/installer/util/lzma_util.h"
 
 namespace {
 
-const wchar_t k7zaExe[] = L"7za.exe";
-const wchar_t k7zaPathRelative[] = L"..\\..\\third_party\\lzma_sdk\\Executable";
-const wchar_t kB7[] = L"B7";
-const wchar_t kBl[] = L"BL";
-const wchar_t kChromeBin[] = L"Chrome-bin";
-const wchar_t kChromePacked7z[] = L"CHROME.PACKED.7Z";
-const wchar_t kChrome7z[] = L"CHROME.7Z";
-const wchar_t kExe[] = L"exe";
-const wchar_t kExpandExe[] = L"expand.exe";
-const wchar_t kExtDll[] = L".dll";
-const wchar_t kExtExe[] = L".exe";
-const wchar_t kMakeCab[] = L"makecab.exe";
-const wchar_t kSetupEx_[] = L"setup.ex_";
-const wchar_t kSetupExe[] = L"setup.exe";
+const base::char16 k7zaExe[] = L"7za.exe";
+const base::char16 k7zaPathRelative[] =
+    L"..\\..\\third_party\\lzma_sdk\\Executable";
+const base::char16 kB7[] = L"B7";
+const base::char16 kBl[] = L"BL";
+const base::char16 kChromeBin[] = L"Chrome-bin";
+const base::char16 kChromePacked7z[] = L"CHROME.PACKED.7Z";
+const base::char16 kChrome7z[] = L"CHROME.7Z";
+const base::char16 kExe[] = L"exe";
+const base::char16 kExpandExe[] = L"expand.exe";
+const base::char16 kExtDll[] = L".dll";
+const base::char16 kExtExe[] = L".exe";
+const base::char16 kMakeCab[] = L"makecab.exe";
+const base::char16 kSetupEx_[] = L"setup.ex_";
+const base::char16 kSetupExe[] = L"setup.exe";
 const char kSwitch7zaPath[] = "7za_path";
-const wchar_t kTempDirPrefix[] = L"mini_installer_test_temp";
+const base::char16 kTempDirPrefix[] = L"mini_installer_test_temp";
 
 // A helper class for creating and cleaning a temporary directory.  A temporary
 // directory is created in Initialize and destroyed (along with all of its
 // contents) when the guard instance is destroyed.
 class ScopedTempDirectory {
  public:
   ScopedTempDirectory() { }
   ~ScopedTempDirectory() {
     if (!directory_.empty() && !base::DeleteFile(directory_, true)) {
       LOG(DFATAL) << "Failed deleting temporary directory \""
@@ skipping 39 matching lines @@
   ChromeVersion() { }
   explicit ChromeVersion(ULONGLONG value) : version_(value) { }
   WORD major() const { return static_cast<WORD>(version_ >> 48); }
   WORD minor() const { return static_cast<WORD>(version_ >> 32); }
   WORD build() const { return static_cast<WORD>(version_ >> 16); }
   WORD patch() const { return static_cast<WORD>(version_); }
   DWORD high() const { return static_cast<DWORD>(version_ >> 32); }
   DWORD low() const { return static_cast<DWORD>(version_); }
   ULONGLONG value() const { return version_; }
   void set_value(ULONGLONG value) { version_ = value; }
-  std::wstring ToString() const;
+  base::string16 ToString() const;
   std::string ToASCII() const;
 
  private:
   ULONGLONG version_;
 };  // class ChromeVersion
 
-std::wstring ChromeVersion::ToString() const {
-  wchar_t buffer[24];
+base::string16 ChromeVersion::ToString() const {
+  base::char16 buffer[24];
   int string_len =
       swprintf_s(&buffer[0], arraysize(buffer), L"%hu.%hu.%hu.%hu",
                  major(), minor(), build(), patch());
   DCHECK_NE(-1, string_len);
   DCHECK_GT(static_cast<int>(arraysize(buffer)), string_len);
-  return std::wstring(&buffer[0], string_len);
+  return base::string16(&buffer[0], string_len);
 }
 
 std::string ChromeVersion::ToASCII() const {
   char buffer[24];
   int string_len = sprintf_s(&buffer[0], arraysize(buffer), "%hu.%hu.%hu.%hu",
                              major(), minor(), build(), patch());
   DCHECK_NE(-1, string_len);
   DCHECK_GT(static_cast<int>(arraysize(buffer)), string_len);
   return std::string(&buffer[0], string_len);
 }
@@ skipping 51 matching lines @@
     }
   } else {
     PLOG(DFATAL) << "file.GetInfo failed";
   }
   file_ = std::move(file);
   return result;
 }
 
 // Calls CreateProcess with good default parameters and waits for the process
 // to terminate returning the process exit code.
-bool RunProcessAndWait(const wchar_t* exe_path, const std::wstring& cmdline,
+bool RunProcessAndWait(const base::char16* exe_path,
+                       const base::string16& cmdline,
                        int* exit_code) {
   bool result = true;
   base::LaunchOptions options;
   options.wait = true;
   options.start_hidden = true;
   base::Process process = base::LaunchProcess(cmdline, options);
   if (process.IsValid()) {
     if (exit_code) {
       if (!GetExitCodeProcess(process.Handle(),
                               reinterpret_cast<DWORD*>(exit_code))) {
@@ skipping 76 matching lines @@
 
   if (replacements_made != NULL)
     *replacements_made = changed;
 
   return result;
 }
 
 // A context structure in support of our EnumResource_Fn callback.
 struct VisitResourceContext {
   ChromeVersion current_version;
-  std::wstring current_version_str;
+  base::string16 current_version_str;
   ChromeVersion new_version;
-  std::wstring new_version_str;
+  base::string16 new_version_str;
 };  // struct VisitResourceContext
 
 // Replaces the old version with the new in a resource.  A first pass is made to
 // replace the string form (e.g., "9.0.584.0").  If any replacements are made, a
 // second pass is made to replace the binary form (e.g., 0x0000024800000009).
 // A final pass is made to replace the ASCII string form.
 void VisitResource(const upgrade_test::EntryPath& path,
                    uint8_t* data,
                    DWORD size,
                    DWORD code_page,
@@ skipping 120 matching lines @@
 
   return true;
 }
 
 // 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 base::FilePath& work_dir,
                            upgrade_test::Direction direction,
-                           std::wstring* original_version,
-                           std::wstring* new_version) {
+                           base::string16* original_version,
+                           base::string16* new_version) {
   VisitResourceContext ctx;
   if (!GetSetupExeVersion(work_dir, &ctx.current_version))
     return false;
   ctx.current_version_str = ctx.current_version.ToString();
 
   if (!IncrementNewVersion(direction, &ctx))
     return false;
 
   // Modify all .dll and .exe files with the current version.
   base::FileEnumerator all_files(work_dir, true, base::FileEnumerator::FILES);
   while (true) {
     base::FilePath file = all_files.Next();
     if (file.empty())
       break;
-    std::wstring extension = file.Extension();
+    base::string16 extension = file.Extension();
     if ((extension == &kExtExe[0] || extension == &kExtDll[0]) &&
         !UpdateVersionIfMatch(file, &ctx)) {
       return false;
     }
   }
 
   // Change the versioned directory.
   base::FilePath chrome_bin = work_dir.Append(&kChromeBin[0]);
   if (!base::Move(chrome_bin.Append(ctx.current_version_str),
                   chrome_bin.Append(ctx.new_version_str))) {
@@ skipping 40 matching lines @@
   return l7za_path;
 }
 
 bool CreateArchive(const base::FilePath& output_file,
                    const base::FilePath& input_path,
                    int compression_level) {
   DCHECK(compression_level == 0 ||
          compression_level >= 1 && compression_level <= 9 &&
          (compression_level & 0x01) != 0);
 
-  std::wstring command_line(1, L'"');
+  base::string16 command_line(1, L'"');
   command_line
       .append(Get7zaPath().Append(&k7zaExe[0]).value())
       .append(L"\" a -bd -t7z \"")
       .append(output_file.value())
       .append(L"\" \"")
       .append(input_path.value())
       .append(L"\" -mx")
       .append(1, L'0' + compression_level);
   int exit_code;
   if (!RunProcessAndWait(NULL, command_line, &exit_code))
     return false;
   if (exit_code != 0) {
     LOG(DFATAL) << Get7zaPath().Append(&k7zaExe[0]).value()
                 << " exited with code " << exit_code
                 << " while creating " << output_file.value();
     return false;
   }
   return true;
 }
 
 }  // namespace
 
 namespace upgrade_test {
 
 bool GenerateAlternateVersion(const base::FilePath& original_installer_path,
                               const base::FilePath& target_path,
                               Direction direction,
-                              std::wstring* original_version,
-                              std::wstring* new_version) {
+                              base::string16* original_version,
+                              base::string16* 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.
   base::FilePath mini_installer =
       work_dir.directory().Append(original_installer_path.BaseName());
   if (!base::CopyFile(original_installer_path, mini_installer)) {
     LOG(DFATAL) << "Failed copying \"" << original_installer_path.value()
                 << "\" to \"" << mini_installer.value() << "\"";
     return false;
   }
 
   base::FilePath setup_ex_ = work_dir.directory().Append(&kSetupEx_[0]);
   base::FilePath chrome_packed_7z;  // Empty for component builds.
   base::FilePath chrome_7z;
-  const wchar_t* archive_resource_name = nullptr;
+  const base::char16* archive_resource_name = nullptr;
   base::FilePath* archive_file = nullptr;
   // Load the original file and extract setup.ex_ and chrome.packed.7z
   {
     ResourceLoader resource_loader;
     std::pair<const uint8_t*, DWORD> resource_data;
 
     if (!resource_loader.Initialize(mini_installer))
       return false;
 
     // Write out setup.ex_
@@ skipping 27 matching lines @@
         *archive_file, reinterpret_cast<const char*>(resource_data.first),
         static_cast<int>(resource_data.second));
     if (written != static_cast<int>(resource_data.second)) {
       LOG(DFATAL) << "Failed writing \"" << archive_file->value() << "\"";
       return false;
     }
   }
 
   // Expand setup.ex_
   base::FilePath setup_exe = setup_ex_.ReplaceExtension(&kExe[0]);
-  std::wstring command_line;
+  base::string16 command_line;
   command_line.append(1, L'"')
     .append(&kExpandExe[0])
     .append(L"\" \"")
     .append(setup_ex_.value())
     .append(L"\" \"")
     .append(setup_exe.value())
     .append(1, L'\"');
   int exit_code;
   if (!RunProcessAndWait(NULL, command_line, &exit_code))
     return false;
@@ skipping 73 matching lines @@
     LOG(ERROR) << "It is common for this step to fail for very large resources,"
                   " as is the case for Debug component=shared_library builds. "
                   "Try with a Release or component=static_library build.";
     return false;
   }
 
   // Finally, move the updated mini_installer into place.
   return base::Move(mini_installer, target_path);
 }
 
-bool GenerateAlternatePEFileVersion(const base::FilePath& original_file,
-                                    const base::FilePath& target_file,
-                                    Direction direction) {
+base::string16 GenerateAlternatePEFileVersion(
+    const base::FilePath& original_file,
+    const base::FilePath& target_file,
+    Direction direction) {
   VisitResourceContext ctx;
   if (!GetFileVersion(original_file, &ctx.current_version)) {
     LOG(DFATAL) << "Failed reading version from \"" << original_file.value()
                 << "\"";
-    return false;
+    return base::string16();
   }
   ctx.current_version_str = ctx.current_version.ToString();
 
   if (!IncrementNewVersion(direction, &ctx)) {
     LOG(DFATAL) << "Failed to increment version from \""
                 << original_file.value() << "\"";
-    return false;
+    return base::string16();
   }
 
   base::Version new_version(base::UTF16ToASCII(ctx.new_version_str));
   GenerateSpecificPEFileVersion(original_file, target_file, new_version);
 
-  return true;
+  return ctx.new_version_str;
 }
 
 bool GenerateSpecificPEFileVersion(const base::FilePath& original_file,
                                    const base::FilePath& target_file,
                                    const base::Version& version) {
   // First copy original_file to target_file.
   if (!base::CopyFile(original_file, target_file)) {
     LOG(DFATAL) << "Failed copying \"" << original_file.value()
                 << "\" to \"" << target_file.value() << "\"";
     return false;
   }
 
   VisitResourceContext ctx;
   if (!GetFileVersion(target_file, &ctx.current_version)) {
     LOG(DFATAL) << "Failed reading version from \"" << target_file.value()
                 << "\"";
     return false;
   }
   ctx.current_version_str = ctx.current_version.ToString();
   ctx.new_version = ChromeVersion::FromString(version.GetString());
   ctx.new_version_str = ctx.new_version.ToString();
 
   return UpdateVersionIfMatch(target_file, &ctx);
 }
 
 }  // namespace upgrade_test