Move file_util::Delete to the base namespace

chrome/browser/chromeos/policy/app_pack_updater.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.
 
 #include "chrome/browser/chromeos/policy/app_pack_updater.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
@@ skipping 243 matching lines @@
       base::FileEnumerator::SHOW_SYM_LINKS;
   base::FileEnumerator enumerator(dir, false /* recursive */, types);
 
   for (base::FilePath path = enumerator.Next();
        !path.empty(); path = enumerator.Next()) {
     base::FileEnumerator::FileInfo info = enumerator.GetInfo();
     std::string basename = path.BaseName().value();
 
     if (info.IsDirectory() || file_util::IsLink(info.GetName())) {
       LOG(ERROR) << "Erasing bad file in AppPack directory: " << basename;
-      file_util::Delete(path, true /* recursive */);
+      base::Delete(path, true /* recursive */);
       continue;
     }
 
     // crx files in the cache are named <extension-id>-<version>.crx.
     std::string id;
     std::string version;
 
     if (EndsWith(basename, kCRXFileExtension, false /* case-sensitive */)) {
       size_t n = basename.find('-');
       if (n != std::string::npos && n + 1 < basename.size() - 4) {
@@ skipping 12 matching lines @@
       id.clear();
     }
 
     if (!Version(version).IsValid()) {
       LOG(ERROR) << "Bad AppPack extension version in cache: " << version;
       version.clear();
     }
 
     if (id.empty() || version.empty()) {
       LOG(ERROR) << "Invalid file in AppPack cache, erasing: " << basename;
-      file_util::Delete(path, true /* recursive */);
+      base::Delete(path, true /* recursive */);
       continue;
     }
 
     // Enforce a lower-case id.
     id = StringToLowerASCII(id);
 
     // File seems good so far. Make sure there isn't another entry with the
     // same id but a different version.
 
     if (ContainsKey(*entries, id)) {
       LOG(ERROR) << "Found two AppPack files for the same extension, will "
                     "erase the oldest version";
       CacheEntry& entry = (*entries)[id];
       Version vEntry(entry.cached_version);
       Version vCurrent(version);
       DCHECK(vEntry.IsValid());
       DCHECK(vCurrent.IsValid());
       if (vEntry.CompareTo(vCurrent) < 0) {
-        file_util::Delete(base::FilePath(entry.path), true /* recursive */);
+        base::Delete(base::FilePath(entry.path), true /* recursive */);
         entry.path = path.value();
       } else {
-        file_util::Delete(path, true /* recursive */);
+        base::Delete(path, true /* recursive */);
       }
       continue;
     }
 
     // This is the only file for this |id| so far, add it.
 
     CacheEntry& entry = (*entries)[id];
     entry.path = path.value();
     entry.cached_version = version;
   }
@@ skipping 133 matching lines @@
 // static
 void AppPackUpdater::BlockingInstallCacheEntry(
     base::WeakPtr<AppPackUpdater> app_pack_updater,
     const std::string& id,
     const base::FilePath& path,
     const std::string& version) {
   Version version_validator(version);
   if (!version_validator.IsValid()) {
     LOG(ERROR) << "AppPack downloaded extension " << id << " but got bad "
                << "version: " << version;
-    file_util::Delete(path, true /* recursive */);
+    base::Delete(path, true /* recursive */);
     return;
   }
 
   std::string basename = id + "-" + version + kCRXFileExtension;
   base::FilePath cache_dir(kAppPackCacheDir);
   base::FilePath cached_crx_path = cache_dir.Append(basename);
 
   if (file_util::PathExists(cached_crx_path)) {
     LOG(WARNING) << "AppPack downloaded a crx whose filename will overwrite "
                  << "an existing cached crx.";
-    file_util::Delete(cached_crx_path, true /* recursive */);
+    base::Delete(cached_crx_path, true /* recursive */);
   }
 
   if (!file_util::DirectoryExists(cache_dir)) {
     LOG(ERROR) << "AppPack cache directory does not exist, creating now: "
                << cache_dir.value();
     if (!file_util::CreateDirectory(cache_dir)) {
       LOG(ERROR) << "Failed to create the AppPack cache dir!";
-      file_util::Delete(path, true /* recursive */);
+      base::Delete(path, true /* recursive */);
       return;
     }
   }
 
   if (!file_util::Move(path, cached_crx_path)) {
     LOG(ERROR) << "Failed to move AppPack crx from " << path.value()
                << " to " << cached_crx_path.value();
-    file_util::Delete(path, true /* recursive */);
+    base::Delete(path, true /* recursive */);
     return;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&AppPackUpdater::OnCacheEntryInstalled,
                                      app_pack_updater,
                                      std::string(id),
                                      cached_crx_path.value(),
                                      std::string(version)));
 }
@@ skipping 21 matching lines @@
        it != cached_extensions_.end(); ++it) {
     if (it->second.path == path.value()) {
       LOG(ERROR) << "AppPack extension at " << path.value() << " failed to "
                  << "install, deleting it.";
       cached_extensions_.erase(it);
       UpdateExtensionLoader();
 
       // The file will be downloaded again on the next restart.
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
-          base::Bind(base::IgnoreResult(file_util::Delete), path, true));
+          base::Bind(base::IgnoreResult(base::Delete), path, true));
 
       // Don't try to DownloadMissingExtensions() from here,
       // since it can cause a fail/retry loop.
       break;
     }
   }
 }
 
 void AppPackUpdater::PostBlockingTask(const tracked_objects::Location& location,
                                       const base::Closure& task) {
   BrowserThread::GetBlockingPool()->PostSequencedWorkerTaskWithShutdownBehavior(
       worker_pool_token_, location, task,
       base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 }
 
 void AppPackUpdater::SetScreenSaverPath(const base::FilePath& path) {
   // Don't invoke the callback if the path isn't changing.
   if (path != screen_saver_path_) {
     screen_saver_path_ = path;
     if (!screen_saver_update_callback_.is_null())
       screen_saver_update_callback_.Run(screen_saver_path_);
   }
 }
 
 }  // namespace policy