Revert 207805 "Differential updates for components. We are addin..."

trunk/src/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) {
-  VLOG(1) << "Applying Courgette patch " << patch.value()
-          << " to file " << src.value()
-          << " and generating file " << dest.value();
-
-  if (src.empty() || patch.empty() || dest.empty())
-    return installer::PATCH_INVALID_ARGUMENTS;
-
-  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 Courgette patch " << patch.value()
-      << " to file " << src.value() << " and generating file " << dest.value()
-      << ". err=" << exit_code;
-
-  return exit_code;
-}
-
-int BsdiffPatchFiles(const base::FilePath& src,
-                     const base::FilePath& patch,
-                     const base::FilePath& dest) {
-  VLOG(1) << "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;
-
-  const int patch_status = courgette::ApplyBinaryPatch(src, patch, dest);
-  const int exit_code = patch_status != OK ?
-                        patch_status + kBsdiffErrorOffset : 0;
-
-  LOG_IF(ERROR, exit_code)
-      << "Failed to apply bsdiff patch " << patch.value()
-      << " to file " << src.value() << " and generating file " << dest.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();
+  VLOG(1) << "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;
 
-  LOG(ERROR)
-        << "Failed to apply patch " << patch.value()
-        << " to file " << src.value() << " and generating file " << dest.value()
-        << " using courgette. err=" << patch_status;
+  VLOG(1) << "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);
 
-  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()
-      << " to file " << src.value() << " and generating file " << dest.value()
-      << " using bsdiff. err=" << binary_patch_status;
-
-  return binary_patch_status;
+  return ApplyBinaryPatch(src.value().c_str(), patch.value().c_str(),
+                          dest.value().c_str());
 }
 
 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