Move Copy* into the base namespace.

chrome/installer/util/delete_tree_work_item.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.
 
 #include "chrome/installer/util/delete_tree_work_item.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/file_util.h"
@@ skipping 44 matching lines @@
   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 (!file_util::CopyFile(key_file,
+      } 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,
@@ skipping 34 matching lines @@
   // Now that we've taken care of the key files, take care of the rest.
   if (!root_path_.empty() && file_util::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 (!file_util::CopyDirectory(root_path_, backup, true)) {
+        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::Delete(root_path_, true)) {
       LOG(ERROR) << "can not delete " << root_path_.value();
@@ skipping 24 matching lines @@
           backup_dir.path().Append(key_file.BaseName());
       if (file_util::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();
       }
     }
   }
 }