Move file_util::Delete to the base namespace

chrome/browser/net/url_fixer_upper_unittest.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 <stdlib.h>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
@@ skipping 441 matching lines @@
      "file://" HOME "foo"},
     {"~x/blah", "",
      "file://" HOME "x/blah"},
   };
 #endif
   for (size_t i = 0; i < arraysize(file_cases); i++) {
     EXPECT_EQ(file_cases[i].output, URLFixerUpper::FixupURL(file_cases[i].input,
         file_cases[i].desired_tld).possibly_invalid_spec());
   }
 
-  EXPECT_TRUE(file_util::Delete(original, false));
+  EXPECT_TRUE(base::Delete(original, false));
 }
 
 TEST(URLFixerUpperTest, FixupRelativeFile) {
   base::FilePath full_path, dir;
   base::FilePath file_part(
       FILE_PATH_LITERAL("url_fixer_upper_existing_file.txt"));
   ASSERT_TRUE(PathService::Get(chrome::DIR_APP, &dir));
   ASSERT_TRUE(MakeTempFile(dir, file_part, &full_path));
   full_path = base::MakeAbsoluteFilePath(full_path);
   ASSERT_FALSE(full_path.empty());
 
   // make sure we pass through good URLs
   for (size_t i = 0; i < arraysize(fixup_cases); ++i) {
     FixupCase value = fixup_cases[i];
     base::FilePath input = base::FilePath::FromUTF8Unsafe(value.input);
     EXPECT_EQ(value.output,
         URLFixerUpper::FixupRelativeFile(dir, input).possibly_invalid_spec());
   }
 
   // make sure the existing file got fixed-up to a file URL, and that there
   // are no backslashes
   EXPECT_TRUE(IsMatchingFileURL(URLFixerUpper::FixupRelativeFile(dir,
       file_part).possibly_invalid_spec(), full_path));
-  EXPECT_TRUE(file_util::Delete(full_path, false));
+  EXPECT_TRUE(base::Delete(full_path, false));
 
   // create a filename we know doesn't exist and make sure it doesn't get
   // fixed up to a file URL
   base::FilePath nonexistent_file(
       FILE_PATH_LITERAL("url_fixer_upper_nonexistent_file.txt"));
   std::string fixedup(URLFixerUpper::FixupRelativeFile(dir,
       nonexistent_file).possibly_invalid_spec());
   EXPECT_NE(std::string("file:///"), fixedup.substr(0, 8));
   EXPECT_FALSE(IsMatchingFileURL(fixedup, nonexistent_file));
 
@@ skipping 23 matching lines @@
       base::FilePath(relative_file_str)).possibly_invalid_spec(), full_path));
 
   // test relative directories and duplicate slashes
   // (should resolve to the same file as above)
   relative_file_str = sub_dir.value() + FILE_PATH_LITERAL("/../") +
       sub_dir.value() + FILE_PATH_LITERAL("///./") + sub_file.value();
   EXPECT_TRUE(IsMatchingFileURL(URLFixerUpper::FixupRelativeFile(dir,
       base::FilePath(relative_file_str)).possibly_invalid_spec(), full_path));
 
   // done with the subdir
-  EXPECT_TRUE(file_util::Delete(full_path, false));
-  EXPECT_TRUE(file_util::Delete(new_dir, true));
+  EXPECT_TRUE(base::Delete(full_path, false));
+  EXPECT_TRUE(base::Delete(new_dir, true));
 
   // Test that an obvious HTTP URL isn't accidentally treated as an absolute
   // file path (on account of system-specific craziness).
   base::FilePath empty_path;
   base::FilePath http_url_path(FILE_PATH_LITERAL("http://../"));
   EXPECT_TRUE(URLFixerUpper::FixupRelativeFile(
       empty_path, http_url_path).SchemeIs("http"));
 }