Move file_util::Delete to the base namespace

chrome/common/extensions/extension_file_util.cc

 // Copyright (c) 2013 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/common/extensions/extension_file_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 107 matching lines @@
   }
 
   return version_dir;
 }
 
 void UninstallExtension(const base::FilePath& extensions_dir,
                         const std::string& id) {
   // We don't care about the return value. If this fails (and it can, due to
   // plugins that aren't unloaded yet), it will get cleaned up by
   // ExtensionService::GarbageCollectExtensions.
-  file_util::Delete(extensions_dir.AppendASCII(id), true);  // recursive.
+  base::Delete(extensions_dir.AppendASCII(id), true);  // recursive.
 }
 
 scoped_refptr<Extension> LoadExtension(const base::FilePath& extension_path,
                                        Manifest::Location location,
                                        int flags,
                                        std::string* error) {
   return LoadExtension(extension_path, std::string(), location, flags, error);
 }
 
 scoped_refptr<Extension> LoadExtension(const base::FilePath& extension_path,
@@ skipping 199 matching lines @@
                                   base::FileEnumerator::DIRECTORIES);
   base::FilePath extension_path;
   for (extension_path = enumerator.Next(); !extension_path.value().empty();
        extension_path = enumerator.Next()) {
     std::string extension_id;
 
     base::FilePath basename = extension_path.BaseName();
     // Clean up temporary files left if Chrome crashed or quit in the middle
     // of an extension install.
     if (basename.value() == kTempDirectoryName) {
-      file_util::Delete(extension_path, true);  // Recursive
+      base::Delete(extension_path, true);  // Recursive
       continue;
     }
 
     // Parse directory name as a potential extension ID.
     if (IsStringASCII(basename.value())) {
       extension_id = UTF16ToASCII(basename.LossyDisplayName());
       if (!Extension::IdIsValid(extension_id))
         extension_id.clear();
     }
 
     // Delete directories that aren't valid IDs.
     if (extension_id.empty()) {
       DLOG(WARNING) << "Invalid extension ID encountered in extensions "
                        "directory: " << basename.value();
       DVLOG(1) << "Deleting invalid extension directory "
                << extension_path.value() << ".";
-      file_util::Delete(extension_path, true);  // Recursive.
+      base::Delete(extension_path, true);  // Recursive.
       continue;
     }
 
     typedef std::multimap<std::string, base::FilePath>::const_iterator Iter;
     std::pair<Iter, Iter> iter_pair = extension_paths.equal_range(extension_id);
 
     // If there is no entry in the prefs file, just delete the directory and
     // move on. This can legitimately happen when an uninstall does not
     // complete, for example, when a plugin is in use at uninstall time.
     if (iter_pair.first == iter_pair.second) {
       DVLOG(1) << "Deleting unreferenced install for directory "
                << extension_path.LossyDisplayName() << ".";
-      file_util::Delete(extension_path, true);  // Recursive.
+      base::Delete(extension_path, true);  // Recursive.
       continue;
     }
 
     // Clean up old version directories.
     base::FileEnumerator versions_enumerator(
         extension_path,
         false,  // Not recursive.
         base::FileEnumerator::DIRECTORIES);
     for (base::FilePath version_dir = versions_enumerator.Next();
          !version_dir.value().empty();
          version_dir = versions_enumerator.Next()) {
       bool knownVersion = false;
       for (Iter it = iter_pair.first; it != iter_pair.second; ++it)
         if (version_dir.BaseName() == it->second.BaseName()) {
           knownVersion = true;
           break;
         }
       if (!knownVersion) {
         DVLOG(1) << "Deleting old version for directory "
                  << version_dir.LossyDisplayName() << ".";
-        file_util::Delete(version_dir, true);  // Recursive.
+        base::Delete(version_dir, true);  // Recursive.
       }
     }
   }
 }
 
 extensions::MessageBundle* LoadMessageBundle(
     const base::FilePath& extension_path,
     const std::string& default_locale,
     std::string* error) {
   error->clear();
@@ skipping 153 matching lines @@
 
   // Directory doesn't exist, so create it.
   if (!file_util::CreateDirectory(temp_path)) {
     DLOG(WARNING) << "Couldn't create directory: " << temp_path.value();
     return base::FilePath();
   }
   return temp_path;
 }
 
 void DeleteFile(const base::FilePath& path, bool recursive) {
-  file_util::Delete(path, recursive);
+  base::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util