Differential updates for components.

chrome/installer/setup/setup_util.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.
 //
 // This file declares util functions for setup project.
 
 #include "chrome/installer/setup/setup_util.h"
 
 #include <windows.h>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/strings/string_util.h"
 #include "base/version.h"
 #include "base/win/windows_version.h"
 #include "chrome/installer/util/copy_tree_work_item.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item.h"
 #include "courgette/courgette.h"
+#include "courgette/third_party/bsdiff.h"
 #include "third_party/bspatch/mbspatch.h"
 
 namespace installer {
 
 namespace {
 
 // Launches |setup_exe| with |command_line|, save --install-archive and its
 // value if present. Returns false if the process failed to launch. Otherwise,
 // waits indefinitely for it to exit and populates |exit_code| as expected. On
 // the off chance that waiting itself fails, |exit_code| is set to
@@ skipping 42 matching lines @@
 
 // Returns true if product |type| cam be meaningfully installed without the
 // --multi-install flag.
 bool SupportsSingleInstall(BrowserDistribution::Type type) {
   return (type == BrowserDistribution::CHROME_BROWSER ||
           type == BrowserDistribution::CHROME_FRAME);
 }
 
 }  // namespace
 
+int CourgettePatchFiles(const base::FilePath& src,
+                        const base::FilePath& patch,
+                        const base::FilePath& dest) {
+  LOG(WARNING) << "Applying Courgette patch " << patch.value() << " to file "

[grt (UTC plus 2), 2013/06/20 14:04:14]

Seems like an "installer logging" style guide is in order. :-)

My inclination is for status messages like this to be VLOG(1), and for true
errors to be LOG(ERROR). That in mind, please change this, line 114, and line
133 back to VLOG(1). Apologies for the lack of clarity.

[Sorin Jianu, 2013/06/20 17:40:15]

Done.

+          << src.value() << " and generating file " << dest.value();
+
+  if (src.empty() || patch.empty() || dest.empty())
+     return installer::PATCH_INVALID_ARGUMENTS;

[grt (UTC plus 2), 2013/06/20 14:04:14]

nit: only indent two spaces

[Sorin Jianu, 2013/06/20 17:40:15]

Done.

+
+  const courgette::Status patch_status =
+      courgette::ApplyEnsemblePatch(src.value().c_str(),
+                                    patch.value().c_str(),
+                                    dest.value().c_str());
+  const int exit_code = (patch_status != courgette::C_OK) ?
+      static_cast<int>(patch_status) + kCourgetteErrorOffset : 0;
+
+  LOG_IF(ERROR, exit_code) << "Failed to apply patch " << patch.value()
+                           << ". err=" << exit_code;
+  return exit_code;
+}
+
+int BsdiffPatchFiles(const base::FilePath& src,
+                     const base::FilePath& patch,
+                     const base::FilePath& dest) {
+  LOG(WARNING) << "Applying bsdiff patch " << patch.value() << " to file "
+               << src.value() << " and generating file " << dest.value();
+
+  if (src.empty() || patch.empty() || dest.empty())
+     return installer::PATCH_INVALID_ARGUMENTS;

[grt (UTC plus 2), 2013/06/20 14:04:14]

nit: only indent two spaces

[Sorin Jianu, 2013/06/20 17:40:15]

Done.

+
+  const int patch_status = courgette::ApplyBinaryPatch(src, patch, dest);
+  const int exit_code = patch_status ?
+                        patch_status + kBsdiffErrorOffset : 0;
+
+  LOG_IF(ERROR, exit_code) << "Failed to apply patch " << patch.value()
+                           << ". err=" << exit_code;
+  return exit_code;
+}
+
 int ApplyDiffPatch(const base::FilePath& src,
                    const base::FilePath& patch,
                    const base::FilePath& dest,
                    const InstallerState* installer_state) {
-  VLOG(1) << "Applying patch " << patch.value() << " to file " << src.value()
-          << " and generating file " << dest.value();
+  LOG(WARNING) << "Applying patch " << patch.value() << " to file "
+               << src.value() << " and generating file " << dest.value();
 
   if (installer_state != NULL)
     installer_state->UpdateStage(installer::ENSEMBLE_PATCHING);
 
   // Try Courgette first.  Courgette checks the patch file first and fails
   // quickly if the patch file does not have a valid Courgette header.
   courgette::Status patch_status =
       courgette::ApplyEnsemblePatch(src.value().c_str(),
                                     patch.value().c_str(),
                                     dest.value().c_str());
   if (patch_status == courgette::C_OK)
     return 0;
 
-  VLOG(1) << "Failed to apply patch " << patch.value()
-          << " using courgette. err=" << patch_status;
+  LOG(ERROR) << "Failed to apply patch " << patch.value()
+             << " using courgette. err=" << patch_status;
 
   // If we ran out of memory or disk space, then these are likely the errors
   // we will see.  If we run into them, return an error and stay on the
   // 'ENSEMBLE_PATCHING' update stage.
   if (patch_status == courgette::C_DISASSEMBLY_FAILED ||
       patch_status == courgette::C_STREAM_ERROR) {
     return MEM_ERROR;
   }
 
   if (installer_state != NULL)
     installer_state->UpdateStage(installer::BINARY_PATCHING);
 
-  return ApplyBinaryPatch(src.value().c_str(), patch.value().c_str(),
-                          dest.value().c_str());
+  int binary_patch_status = ApplyBinaryPatch(src.value().c_str(),
+                                             patch.value().c_str(),
+                                             dest.value().c_str());
+
+  LOG_IF(ERROR, binary_patch_status != OK) << "Failed to apply patch "
+      << patch.value() << " using bsdiff. err=" << binary_patch_status;
+
+  return binary_patch_status;
 }
 
 Version* GetMaxVersionFromArchiveDir(const base::FilePath& chrome_path) {
   VLOG(1) << "Looking for Chrome version folder under " << chrome_path.value();
   Version* version = NULL;
   base::FileEnumerator version_enum(chrome_path, false,
       base::FileEnumerator::DIRECTORIES);
   // TODO(tommi): The version directory really should match the version of
   // setup.exe.  To begin with, we should at least DCHECK that that's true.
 
@@ skipping 228 matching lines @@
 }
 
 ScopedTokenPrivilege::~ScopedTokenPrivilege() {
   if (is_enabled_ && previous_privileges_.PrivilegeCount != 0) {
     ::AdjustTokenPrivileges(token_, FALSE, &previous_privileges_,
                             sizeof(TOKEN_PRIVILEGES), NULL, NULL);
   }
 }
 
 }  // namespace installer