alternate_version_generator.cc revision 7dbb3d5cf0c15f500944d211057644d6a2f37371
1// Copyright (c) 2011 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5// The file contains the implementation of the mini_installer re-versioner. 6// The main function (GenerateNextVersion) does the following in a temp dir: 7// - Extracts and unpacks setup.exe and the Chrome-bin folder from 8// mini_installer.exe. 9// - Inspects setup.exe to determine the current version. 10// - Runs through all .dll and .exe files: 11// - Replacing all occurrences of the Unicode version string in the files' 12// resources with the updated string. 13// - For all resources in which the string substitution is made, the binary 14// form of the version is also replaced. 15// - Re-packs setup.exe and Chrome-bin. 16// - Inserts them into the target mini_installer.exe. 17// 18// This code assumes that the host program 1) initializes the process-wide 19// CommandLine instance, and 2) resides in the output directory of a build 20// tree. When #2 is not the case, the --7za_path command-line switch may be 21// used to provide the (relative or absolute) path to the directory containing 22// 7za.exe. 23 24#include "chrome/installer/test/alternate_version_generator.h" 25 26#include <windows.h> 27 28#include <algorithm> 29#include <limits> 30#include <sstream> 31#include <utility> 32#include <vector> 33 34#include "base/basictypes.h" 35#include "base/command_line.h" 36#include "base/file_util.h" 37#include "base/files/file_enumerator.h" 38#include "base/files/file_path.h" 39#include "base/logging.h" 40#include "base/path_service.h" 41#include "base/platform_file.h" 42#include "base/process_util.h" 43#include "base/strings/string_util.h" 44#include "base/version.h" 45#include "base/win/pe_image.h" 46#include "base/win/scoped_handle.h" 47#include "chrome/installer/test/pe_image_resources.h" 48#include "chrome/installer/test/resource_loader.h" 49#include "chrome/installer/test/resource_updater.h" 50#include "chrome/installer/util/lzma_util.h" 51 52namespace { 53 54const wchar_t k7zaExe[] = L"7za.exe"; 55const wchar_t k7zaPathRelative[] = L"..\\..\\third_party\\lzma_sdk\\Executable"; 56const wchar_t kB7[] = L"B7"; 57const wchar_t kBl[] = L"BL"; 58const wchar_t kChrome7z[] = L"chrome.7z"; 59const wchar_t kChromeBin[] = L"Chrome-bin"; 60const wchar_t kChromePacked7z[] = L"chrome.packed.7z"; 61const wchar_t kExe[] = L"exe"; 62const wchar_t kExpandExe[] = L"expand.exe"; 63const wchar_t kExtDll[] = L".dll"; 64const wchar_t kExtExe[] = L".exe"; 65const wchar_t kMakeCab[] = L"makecab.exe"; 66const wchar_t kSetupEx_[] = L"setup.ex_"; 67const wchar_t kSetupExe[] = L"setup.exe"; 68const char kSwitch7zaPath[] = "7za_path"; 69const wchar_t kTempDirPrefix[] = L"mini_installer_test_temp"; 70 71// A helper class for creating and cleaning a temporary directory. A temporary 72// directory is created in Initialize and destroyed (along with all of its 73// contents) when the guard instance is destroyed. 74class ScopedTempDirectory { 75 public: 76 ScopedTempDirectory() { } 77 ~ScopedTempDirectory() { 78 if (!directory_.empty() && !base::DeleteFile(directory_, true)) { 79 LOG(DFATAL) << "Failed deleting temporary directory \"" 80 << directory_.value() << "\""; 81 } 82 } 83 // Creates a temporary directory. 84 bool Initialize() { 85 DCHECK(directory_.empty()); 86 if (!file_util::CreateNewTempDirectory(&kTempDirPrefix[0], &directory_)) { 87 LOG(DFATAL) << "Failed creating temporary directory."; 88 return false; 89 } 90 return true; 91 } 92 const base::FilePath& directory() const { 93 DCHECK(!directory_.empty()); 94 return directory_; 95 } 96 97 private: 98 base::FilePath directory_; 99 DISALLOW_COPY_AND_ASSIGN(ScopedTempDirectory); 100}; // class ScopedTempDirectory 101 102// A helper class for manipulating a Chrome product version. 103class ChromeVersion { 104 public: 105 static ChromeVersion FromHighLow(DWORD high, DWORD low) { 106 return ChromeVersion(static_cast<ULONGLONG>(high) << 32 | 107 static_cast<ULONGLONG>(low)); 108 } 109 static ChromeVersion FromString(const std::string& version_string) { 110 Version version(version_string); 111 DCHECK(version.IsValid()); 112 const std::vector<uint16>& c(version.components()); 113 return ChromeVersion(static_cast<ULONGLONG>(c[0]) << 48 | 114 static_cast<ULONGLONG>(c[1]) << 32 | 115 static_cast<ULONGLONG>(c[2]) << 16 | 116 static_cast<ULONGLONG>(c[3])); 117 } 118 119 ChromeVersion() { } 120 explicit ChromeVersion(ULONGLONG value) : version_(value) { } 121 WORD major() const { return static_cast<WORD>(version_ >> 48); } 122 WORD minor() const { return static_cast<WORD>(version_ >> 32); } 123 WORD build() const { return static_cast<WORD>(version_ >> 16); } 124 WORD patch() const { return static_cast<WORD>(version_); } 125 DWORD high() const { return static_cast<DWORD>(version_ >> 32); } 126 DWORD low() const { return static_cast<DWORD>(version_); } 127 ULONGLONG value() const { return version_; } 128 void set_value(ULONGLONG value) { version_ = value; } 129 std::wstring ToString() const; 130 private: 131 ULONGLONG version_; 132}; // class ChromeVersion 133 134std::wstring ChromeVersion::ToString() const { 135 wchar_t buffer[24]; 136 int string_len = 137 swprintf_s(&buffer[0], arraysize(buffer), L"%hu.%hu.%hu.%hu", 138 major(), minor(), build(), patch()); 139 DCHECK_NE(-1, string_len); 140 DCHECK_GT(static_cast<int>(arraysize(buffer)), string_len); 141 return std::wstring(&buffer[0], string_len); 142} 143 144 145// A read/write mapping of a file. 146// Note: base::MemoryMappedFile is not used because it doesn't support 147// read/write mappings. Adding such support across all platforms for this 148// Windows-only test code seems like overkill. 149class MappedFile { 150 public: 151 MappedFile() : size_(), mapping_(), view_() { } 152 ~MappedFile(); 153 bool Initialize(base::PlatformFile file); 154 void* data() const { return view_; } 155 size_t size() const { return size_; } 156 private: 157 size_t size_; 158 HANDLE mapping_; 159 void* view_; 160 DISALLOW_COPY_AND_ASSIGN(MappedFile); 161}; // class MappedFile 162 163MappedFile::~MappedFile() { 164 if (view_ != NULL) { 165 if (UnmapViewOfFile(view_) == 0) { 166 PLOG(DFATAL) << "MappedFile failed to unmap view."; 167 } 168 } 169 if (mapping_ != NULL) { 170 if (CloseHandle(mapping_) == 0) { 171 PLOG(DFATAL) << "Could not close file mapping handle."; 172 } 173 } 174} 175 176bool MappedFile::Initialize(base::PlatformFile file) { 177 DCHECK(mapping_ == NULL); 178 bool result = false; 179 base::PlatformFileInfo file_info; 180 181 if (base::GetPlatformFileInfo(file, &file_info)) { 182 if (file_info.size <= 183 static_cast<int64>(std::numeric_limits<DWORD>::max())) { 184 mapping_ = CreateFileMapping(file, NULL, PAGE_READWRITE, 0, 185 static_cast<DWORD>(file_info.size), NULL); 186 if (mapping_ != NULL) { 187 view_ = MapViewOfFile(mapping_, FILE_MAP_WRITE, 0, 0, 188 static_cast<size_t>(file_info.size)); 189 if (view_ != NULL) { 190 result = true; 191 } else { 192 PLOG(DFATAL) << "MapViewOfFile failed"; 193 } 194 } else { 195 PLOG(DFATAL) << "CreateFileMapping failed"; 196 } 197 } else { 198 LOG(DFATAL) << "Files larger than " << std::numeric_limits<DWORD>::max() 199 << " are not supported."; 200 } 201 } else { 202 PLOG(DFATAL) << "GetPlatformFileInfo failed"; 203 } 204 return result; 205} 206 207// Calls CreateProcess with good default parameters and waits for the process 208// to terminate returning the process exit code. 209bool RunProcessAndWait(const wchar_t* exe_path, const std::wstring& cmdline, 210 int* exit_code) { 211 bool result = true; 212 base::ProcessHandle process; 213 base::LaunchOptions options; 214 options.wait = true; 215 options.start_hidden = true; 216 if (base::LaunchProcess(cmdline, options, &process)) { 217 if (exit_code) { 218 if (!GetExitCodeProcess(process, 219 reinterpret_cast<DWORD*>(exit_code))) { 220 PLOG(DFATAL) << "Failed getting the exit code for \"" 221 << cmdline << "\"."; 222 result = false; 223 } else { 224 DCHECK_NE(*exit_code, STILL_ACTIVE); 225 } 226 } 227 } else { 228 result = false; 229 } 230 231 CloseHandle(process); 232 return result; 233} 234 235// Retrieves the version number of |pe_file| from its version 236// resource, placing the value in |version|. Returns true on success. 237bool GetFileVersion(const base::FilePath& pe_file, ChromeVersion* version) { 238 DCHECK(version); 239 bool result = false; 240 upgrade_test::ResourceLoader pe_file_loader; 241 std::pair<const uint8*, DWORD> version_info_data; 242 243 if (pe_file_loader.Initialize(pe_file) && 244 pe_file_loader.Load(VS_VERSION_INFO, reinterpret_cast<WORD>(RT_VERSION), 245 &version_info_data)) { 246 const VS_FIXEDFILEINFO* fixed_file_info; 247 UINT ver_info_len; 248 if (VerQueryValue(version_info_data.first, L"\\", 249 reinterpret_cast<void**>( 250 const_cast<VS_FIXEDFILEINFO**>(&fixed_file_info)), 251 &ver_info_len) != 0) { 252 DCHECK_EQ(sizeof(VS_FIXEDFILEINFO), static_cast<size_t>(ver_info_len)); 253 *version = ChromeVersion::FromHighLow(fixed_file_info->dwFileVersionMS, 254 fixed_file_info->dwFileVersionLS); 255 result = true; 256 } else { 257 LOG(DFATAL) << "VerQueryValue failed to retrieve VS_FIXEDFILEINFO"; 258 } 259 } 260 261 return result; 262} 263 264// Retrieves the version number of setup.exe in |work_dir| from its version 265// resource, placing the value in |version|. Returns true on success. 266bool GetSetupExeVersion(const base::FilePath& work_dir, 267 ChromeVersion* version) { 268 return GetFileVersion(work_dir.Append(&kSetupExe[0]), version); 269} 270 271 272// Replace all occurrences in the sequence [|dest_first|, |dest_last) that 273// equals [|src_first|, |src_last) with the sequence at |replacement_first| of 274// the same length. Returns true on success. If non-NULL, |replacements_made| 275// is set to true/false accordingly. 276bool ReplaceAll(uint8* dest_first, uint8* dest_last, 277 const uint8* src_first, const uint8* src_last, 278 const uint8* replacement_first, bool* replacements_made) { 279 bool result = true; 280 bool changed = false; 281 do { 282 dest_first = std::search(dest_first, dest_last, src_first, src_last); 283 if (dest_first == dest_last) { 284 break; 285 } 286 changed = true; 287 if (memcpy_s(dest_first, dest_last - dest_first, 288 replacement_first, src_last - src_first) != 0) { 289 result = false; 290 break; 291 } 292 dest_first += (src_last - src_first); 293 } while (true); 294 295 if (replacements_made != NULL) { 296 *replacements_made = changed; 297 } 298 299 return result; 300} 301 302// A context structure in support of our EnumResource_Fn callback. 303struct VisitResourceContext { 304 ChromeVersion current_version; 305 std::wstring current_version_str; 306 ChromeVersion new_version; 307 std::wstring new_version_str; 308}; // struct VisitResourceContext 309 310// Replaces the old version with the new in a resource. A first pass is made to 311// replace the string form (e.g., "9.0.584.0"). If any replacements are made, a 312// second pass is made to replace the binary form (e.g., 0x0000024800000009). 313void VisitResource(const upgrade_test::EntryPath& path, 314 uint8* data, DWORD size, DWORD code_page, 315 uintptr_t context) { 316 VisitResourceContext& ctx = *reinterpret_cast<VisitResourceContext*>(context); 317 318 // Replace all occurrences of current_version_str with new_version_str 319 bool changing_version = false; 320 if (ReplaceAll( 321 data, 322 data + size, 323 reinterpret_cast<const uint8*>(ctx.current_version_str.c_str()), 324 reinterpret_cast<const uint8*>(ctx.current_version_str.c_str() + 325 ctx.current_version_str.size() + 1), 326 reinterpret_cast<const uint8*>(ctx.new_version_str.c_str()), 327 &changing_version) && 328 changing_version) { 329 // Replace all occurrences of current_version with new_version 330 struct VersionPair { 331 DWORD high; 332 DWORD low; 333 }; 334 VersionPair cur_ver = { 335 ctx.current_version.high(), ctx.current_version.low() 336 }; 337 VersionPair new_ver = { 338 ctx.new_version.high(), ctx.new_version.low() 339 }; 340 ReplaceAll(data, data + size, reinterpret_cast<const uint8*>(&cur_ver), 341 reinterpret_cast<const uint8*>(&cur_ver) + sizeof(cur_ver), 342 reinterpret_cast<const uint8*>(&new_ver), NULL); 343 } 344} 345 346// Updates the version strings and numbers in all of |image_file|'s resources. 347bool UpdateVersionIfMatch(const base::FilePath& image_file, 348 VisitResourceContext* context) { 349 if (!context || 350 context->current_version_str.size() < context->new_version_str.size()) { 351 return false; 352 } 353 354 bool result = false; 355 base::win::ScopedHandle image_handle(base::CreatePlatformFile( 356 image_file, 357 (base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ | 358 base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_READ | 359 base::PLATFORM_FILE_EXCLUSIVE_WRITE), NULL, NULL)); 360 // It turns out that the underlying CreateFile can fail due to unhelpful 361 // security software locking the newly created DLL. So add a few brief 362 // retries to help tests that use this pass on machines thusly encumbered. 363 int retries = 3; 364 while (!image_handle.IsValid() && retries-- > 0) { 365 LOG(WARNING) << "Failed to open \"" << image_file.value() << "\"." 366 << " Retrying " << retries << " more times."; 367 Sleep(1000); 368 image_handle.Set(base::CreatePlatformFile( 369 image_file, 370 (base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ | 371 base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_READ | 372 base::PLATFORM_FILE_EXCLUSIVE_WRITE), NULL, NULL)); 373 } 374 375 if (image_handle.IsValid()) { 376 MappedFile image_mapping; 377 if (image_mapping.Initialize(image_handle)) { 378 base::win::PEImageAsData image( 379 reinterpret_cast<HMODULE>(image_mapping.data())); 380 // PEImage class does not support other-architecture images. 381 if (image.GetNTHeaders()->OptionalHeader.Magic == 382 IMAGE_NT_OPTIONAL_HDR_MAGIC) { 383 result = upgrade_test::EnumResources( 384 image, &VisitResource, reinterpret_cast<uintptr_t>(context)); 385 } else { 386 result = true; 387 } 388 } 389 } else { 390 PLOG(DFATAL) << "Failed to open \"" << image_file.value() << "\""; 391 } 392 return result; 393} 394 395bool IncrementNewVersion(upgrade_test::Direction direction, 396 VisitResourceContext* ctx) { 397 DCHECK(ctx); 398 399 // Figure out a past or future version with the same string length as this one 400 // by decrementing or incrementing each component. 401 LONGLONG incrementer = (direction == upgrade_test::PREVIOUS_VERSION ? -1 : 1); 402 403 do { 404 if (incrementer == 0) { 405 LOG(DFATAL) << "Improbable version at the cusp of complete rollover"; 406 return false; 407 } 408 ctx->new_version.set_value(ctx->current_version.value() + incrementer); 409 ctx->new_version_str = ctx->new_version.ToString(); 410 incrementer <<= 16; 411 } while (ctx->new_version_str.size() != ctx->current_version_str.size()); 412 413 return true; 414} 415 416// Raises or lowers the version of all .exe and .dll files in |work_dir| as well 417// as the |work-dir|\Chrome-bin\w.x.y.z directory. |original_version| and 418// |new_version|, when non-NULL, are given the original and new version numbers 419// on success. 420bool ApplyAlternateVersion(const base::FilePath& work_dir, 421 upgrade_test::Direction direction, 422 std::wstring* original_version, 423 std::wstring* new_version) { 424 VisitResourceContext ctx; 425 if (!GetSetupExeVersion(work_dir, &ctx.current_version)) { 426 return false; 427 } 428 ctx.current_version_str = ctx.current_version.ToString(); 429 430 if (!IncrementNewVersion(direction, &ctx)) { 431 return false; 432 } 433 434 // Modify all .dll and .exe files with the current version. 435 bool doing_great = true; 436 base::FileEnumerator all_files(work_dir, true, base::FileEnumerator::FILES); 437 do { 438 base::FilePath file = all_files.Next(); 439 if (file.empty()) { 440 break; 441 } 442 std::wstring extension = file.Extension(); 443 if (extension == &kExtExe[0] || extension == &kExtDll[0]) { 444 doing_great = UpdateVersionIfMatch(file, &ctx); 445 } 446 } while (doing_great); 447 448 // Change the versioned directory. 449 base::FilePath chrome_bin = work_dir.Append(&kChromeBin[0]); 450 doing_great = base::Move(chrome_bin.Append(ctx.current_version_str), 451 chrome_bin.Append(ctx.new_version_str)); 452 453 if (doing_great) { 454 // Report the version numbers if requested. 455 if (original_version != NULL) 456 original_version->assign(ctx.current_version_str); 457 if (new_version != NULL) 458 new_version->assign(ctx.new_version_str); 459 } 460 461 return doing_great; 462} 463 464// Returns the path to the directory holding the 7za executable. By default, it 465// is assumed that the test resides in the tree's output directory, so the 466// relative path "..\..\third_party\lzma_sdk\Executable" is applied to the host 467// executable's directory. This can be overridden with the --7za_path 468// command-line switch. 469base::FilePath Get7zaPath() { 470 base::FilePath l7za_path = 471 CommandLine::ForCurrentProcess()->GetSwitchValuePath( 472 &kSwitch7zaPath[0]); 473 if (l7za_path.empty()) { 474 base::FilePath dir_exe; 475 if (!PathService::Get(base::DIR_EXE, &dir_exe)) 476 LOG(DFATAL) << "Failed getting directory of host executable"; 477 l7za_path = dir_exe.Append(&k7zaPathRelative[0]); 478 } 479 return l7za_path; 480} 481 482bool CreateArchive(const base::FilePath& output_file, 483 const base::FilePath& input_path, 484 int compression_level) { 485 DCHECK(compression_level == 0 || 486 compression_level >= 1 && compression_level <= 9 && 487 (compression_level & 0x01) != 0); 488 489 std::wstring command_line(1, L'"'); 490 command_line 491 .append(Get7zaPath().Append(&k7zaExe[0]).value()) 492 .append(L"\" a -bd -t7z \"") 493 .append(output_file.value()) 494 .append(L"\" \"") 495 .append(input_path.value()) 496 .append(L"\" -mx") 497 .append(1, L'0' + compression_level); 498 int exit_code; 499 if (!RunProcessAndWait(NULL, command_line, &exit_code)) 500 return false; 501 if (exit_code != 0) { 502 LOG(DFATAL) << Get7zaPath().Append(&k7zaExe[0]).value() 503 << " exited with code " << exit_code 504 << " while creating " << output_file.value(); 505 return false; 506 } 507 return true; 508} 509 510} // namespace 511 512namespace upgrade_test { 513 514bool GenerateAlternateVersion(const base::FilePath& original_installer_path, 515 const base::FilePath& target_path, 516 Direction direction, 517 std::wstring* original_version, 518 std::wstring* new_version) { 519 // Create a temporary directory in which we'll do our work. 520 ScopedTempDirectory work_dir; 521 if (!work_dir.Initialize()) 522 return false; 523 524 // Copy the original mini_installer. 525 base::FilePath mini_installer = 526 work_dir.directory().Append(original_installer_path.BaseName()); 527 if (!base::CopyFile(original_installer_path, mini_installer)) { 528 LOG(DFATAL) << "Failed copying \"" << original_installer_path.value() 529 << "\" to \"" << mini_installer.value() << "\""; 530 return false; 531 } 532 533 base::FilePath setup_ex_ = work_dir.directory().Append(&kSetupEx_[0]); 534 base::FilePath chrome_packed_7z = 535 work_dir.directory().Append(&kChromePacked7z[0]); 536 // Load the original file and extract setup.ex_ and chrome.packed.7z 537 { 538 ResourceLoader resource_loader; 539 std::pair<const uint8*, DWORD> resource_data; 540 541 if (!resource_loader.Initialize(mini_installer)) 542 return false; 543 544 // Write out setup.ex_ 545 if (!resource_loader.Load(&kSetupEx_[0], &kBl[0], &resource_data)) 546 return false; 547 int written = 548 file_util::WriteFile(setup_ex_, 549 reinterpret_cast<const char*>(resource_data.first), 550 static_cast<int>(resource_data.second)); 551 if (written != resource_data.second) { 552 LOG(DFATAL) << "Failed writing \"" << setup_ex_.value() << "\""; 553 return false; 554 } 555 556 // Write out chrome.packed.7z 557 if (!resource_loader.Load(&kChromePacked7z[0], &kB7[0], &resource_data)) 558 return false; 559 written = 560 file_util::WriteFile(chrome_packed_7z, 561 reinterpret_cast<const char*>(resource_data.first), 562 static_cast<int>(resource_data.second)); 563 if (written != resource_data.second) { 564 LOG(DFATAL) << "Failed writing \"" << chrome_packed_7z.value() << "\""; 565 return false; 566 } 567 } 568 569 // Expand setup.ex_ 570 base::FilePath setup_exe = setup_ex_.ReplaceExtension(&kExe[0]); 571 std::wstring command_line; 572 command_line.append(1, L'"') 573 .append(&kExpandExe[0]) 574 .append(L"\" \"") 575 .append(setup_ex_.value()) 576 .append(L"\" \"") 577 .append(setup_exe.value()) 578 .append(1, L'\"'); 579 int exit_code; 580 if (!RunProcessAndWait(NULL, command_line, &exit_code)) 581 return false; 582 if (exit_code != 0) { 583 LOG(DFATAL) << &kExpandExe[0] << " exited with code " << exit_code; 584 return false; 585 } 586 587 // Unpack chrome.packed.7z 588 std::wstring chrome_7z_name; 589 if (LzmaUtil::UnPackArchive(chrome_packed_7z.value(), 590 work_dir.directory().value(), 591 &chrome_7z_name) != NO_ERROR) { 592 LOG(DFATAL) << "Failed unpacking \"" << chrome_packed_7z.value() << "\""; 593 return false; 594 } 595 596 // Unpack chrome.7z 597 if (LzmaUtil::UnPackArchive(chrome_7z_name, work_dir.directory().value(), 598 NULL) != NO_ERROR) { 599 LOG(DFATAL) << "Failed unpacking \"" << chrome_7z_name << "\""; 600 return false; 601 } 602 603 // Get rid of intermediate files 604 base::FilePath chrome_7z(chrome_7z_name); 605 if (!base::DeleteFile(chrome_7z, false) || 606 !base::DeleteFile(chrome_packed_7z, false) || 607 !base::DeleteFile(setup_ex_, false)) { 608 LOG(DFATAL) << "Failed deleting intermediate files"; 609 return false; 610 } 611 612 // Increment the version in all files. 613 ApplyAlternateVersion(work_dir.directory(), direction, original_version, 614 new_version); 615 616 // Pack up files into chrome.7z 617 if (!CreateArchive(chrome_7z, work_dir.directory().Append(&kChromeBin[0]), 0)) 618 return false; 619 620 // Compress chrome.7z into chrome.packed.7z 621 if (!CreateArchive(chrome_packed_7z, chrome_7z, 9)) 622 return false; 623 624 // Compress setup.exe into setup.ex_ 625 command_line.assign(1, L'"') 626 .append(&kMakeCab[0]) 627 .append(L"\" /D CompressionType=LZX /L \"") 628 .append(work_dir.directory().value()) 629 .append(L"\" \"") 630 .append(setup_exe.value()); 631 if (!RunProcessAndWait(NULL, command_line, &exit_code)) 632 return false; 633 if (exit_code != 0) { 634 LOG(DFATAL) << &kMakeCab[0] << " exited with code " << exit_code; 635 return false; 636 } 637 638 // Replace the mini_installer's setup.ex_ and chrome.packed.7z resources. 639 ResourceUpdater updater; 640 if (!updater.Initialize(mini_installer) || 641 !updater.Update(&kSetupEx_[0], &kBl[0], 642 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), 643 setup_ex_) || 644 !updater.Update(&kChromePacked7z[0], &kB7[0], 645 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), 646 chrome_packed_7z) || 647 !updater.Commit()) { 648 return false; 649 } 650 651 // Finally, move the updated mini_installer into place. 652 return base::Move(mini_installer, target_path); 653} 654 655bool GenerateAlternatePEFileVersion(const base::FilePath& original_file, 656 const base::FilePath& target_file, 657 Direction direction) { 658 VisitResourceContext ctx; 659 if (!GetFileVersion(original_file, &ctx.current_version)) { 660 LOG(DFATAL) << "Failed reading version from \"" << original_file.value() 661 << "\""; 662 return false; 663 } 664 ctx.current_version_str = ctx.current_version.ToString(); 665 666 if (!IncrementNewVersion(direction, &ctx)) { 667 LOG(DFATAL) << "Failed to increment version from \"" 668 << original_file.value() << "\""; 669 return false; 670 } 671 672 Version new_version(WideToASCII(ctx.new_version_str)); 673 GenerateSpecificPEFileVersion(original_file, target_file, new_version); 674 675 return true; 676} 677 678bool GenerateSpecificPEFileVersion(const base::FilePath& original_file, 679 const base::FilePath& target_file, 680 const Version& version) { 681 // First copy original_file to target_file. 682 if (!base::CopyFile(original_file, target_file)) { 683 LOG(DFATAL) << "Failed copying \"" << original_file.value() 684 << "\" to \"" << target_file.value() << "\""; 685 return false; 686 } 687 688 VisitResourceContext ctx; 689 if (!GetFileVersion(target_file, &ctx.current_version)) { 690 LOG(DFATAL) << "Failed reading version from \"" << target_file.value() 691 << "\""; 692 return false; 693 } 694 ctx.current_version_str = ctx.current_version.ToString(); 695 ctx.new_version = ChromeVersion::FromString(version.GetString()); 696 ctx.new_version_str = ctx.new_version.ToString(); 697 698 return UpdateVersionIfMatch(target_file, &ctx); 699} 700 701} // namespace upgrade_test 702