root/chrome/installer/util/delete_tree_work_item.cc

DEFINITIONS

1. SafeCast
2. copied_to_backup_
3. Do
4. Rollback

// 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.

#include "chrome/installer/util/delete_tree_work_item.h"

#include <algorithm>
#include <limits>

#include "base/file_util.h"
#include "base/logging.h"

namespace {

// Casts a value of an unsigned type to a signed type of the same size provided
// that there is no overflow.
template<typename L, typename R>
bool SafeCast(L left, R* right) {
  DCHECK(right);
  COMPILE_ASSERT(sizeof(left) == sizeof(right),
                 must_add_support_for_crazy_data_types);
  if (left > static_cast<L>(std::numeric_limits<R>::max()))
    return false;
  *right = static_cast<L>(left);
  return true;
}

}  // namespace

DeleteTreeWorkItem::DeleteTreeWorkItem(
    const base::FilePath& root_path,
    const base::FilePath& temp_path,
    const std::vector<base::FilePath>& key_paths)
    : root_path_(root_path),
      temp_path_(temp_path),
      copied_to_backup_(false) {
  if (!SafeCast(key_paths.size(), &num_key_files_)) {
    NOTREACHED() << "Impossibly large key_paths collection";
  } else if (num_key_files_ != 0) {
    key_paths_.reset(new base::FilePath[num_key_files_]);
    key_backup_paths_.reset(new base::ScopedTempDir[num_key_files_]);
    std::copy(key_paths.begin(), key_paths.end(), &key_paths_[0]);
  }
}

DeleteTreeWorkItem::~DeleteTreeWorkItem() {
}

// We first try to move key_path_ to backup_path. If it succeeds, we go ahead
// and move the rest.
bool DeleteTreeWorkItem::Do() {
  // Go through all the key files and see if we can open them exclusively
  // with only the FILE_SHARE_DELETE flag.  Once we know we have all of them,
  // we can delete them.
  std::vector<HANDLE> opened_key_files;
  opened_key_files.reserve(num_key_files_);
  bool abort = false;
  for (ptrdiff_t i = 0; !abort && i != num_key_files_; ++i) {
    base::FilePath& key_file = key_paths_[i];
    base::ScopedTempDir& backup = key_backup_paths_[i];
    if (!ignore_failure_) {
      if (!backup.CreateUniqueTempDirUnderPath(temp_path_)) {
        PLOG(ERROR) << "Could not create temp dir in " << temp_path_.value();
        abort = true;
      } else if (!base::CopyFile(key_file,
                     backup.path().Append(key_file.BaseName()))) {
        PLOG(ERROR) << "Could not back up " << key_file.value()
                    << " to directory " << backup.path().value();
        abort = true;
        backup.Delete();
      }
    }
    if (!abort) {
      HANDLE file = ::CreateFile(key_file.value().c_str(), FILE_ALL_ACCESS,
                                 FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0,
                                 NULL);
      if (file != INVALID_HANDLE_VALUE) {
        VLOG(1) << "Acquired exclusive lock for key file: " << key_file.value();
        opened_key_files.push_back(file);
      } else {
        if (::GetLastError() != ERROR_FILE_NOT_FOUND)
          abort = true;
        PLOG(INFO) << "Failed to open " << key_file.value();
      }
    }
  }

  if (!abort) {
    // We now hold exclusive locks with "share delete" permissions for each
    // of the key files and also have created backups of those files.
    // We can safely delete the key files now.
    for (ptrdiff_t i = 0; !abort && i != num_key_files_; ++i) {
      base::FilePath& key_file = key_paths_[i];
      if (!base::DeleteFile(key_file, true)) {
        // This should not really be possible because of the above.
        PLOG(DFATAL) << "Unexpectedly could not delete " << key_file.value();
        abort = true;
      }
    }
  }

  std::for_each(opened_key_files.begin(), opened_key_files.end(), CloseHandle);
  opened_key_files.clear();

  if (abort) {
    LOG(ERROR) << "Could not exclusively hold all key files.";
    return ignore_failure_;
  }

  // Now that we've taken care of the key files, take care of the rest.
  if (!root_path_.empty() && base::PathExists(root_path_)) {
    if (!ignore_failure_) {
      if (!backup_path_.CreateUniqueTempDirUnderPath(temp_path_)) {
        PLOG(ERROR) << "Failed to get backup path in folder "
                    << temp_path_.value();
        return false;
      } else {
        base::FilePath backup =
            backup_path_.path().Append(root_path_.BaseName());
        if (!base::CopyDirectory(root_path_, backup, true)) {
          LOG(ERROR) << "can not copy " << root_path_.value()
                     << " to backup path " << backup.value();
          return false;
        } else {
          copied_to_backup_ = true;
        }
      }
    }
    if (!base::DeleteFile(root_path_, true)) {
      LOG(ERROR) << "can not delete " << root_path_.value();
      return ignore_failure_;
    }
  }

  return true;
}

// If there are files in backup paths move them back.
void DeleteTreeWorkItem::Rollback() {
  if (ignore_failure_)
    return;

  if (copied_to_backup_) {
    DCHECK(!backup_path_.path().empty());
    base::FilePath backup = backup_path_.path().Append(root_path_.BaseName());
    if (base::PathExists(backup))
      base::Move(backup, root_path_);
  }

  for (ptrdiff_t i = 0; i != num_key_files_; ++i) {
    base::ScopedTempDir& backup_dir = key_backup_paths_[i];
    if (!backup_dir.path().empty()) {
      base::FilePath& key_file = key_paths_[i];
      base::FilePath backup_file =
          backup_dir.path().Append(key_file.BaseName());
      if (base::PathExists(backup_file) &&
          !base::Move(backup_file, key_file)) {
        // This could happen if we could not delete the key file to begin with.
        PLOG(WARNING) << "Rollback: Failed to move backup file back in place: "
                      << backup_file.value() << " to " << key_file.value();
      }
    }
  }
}