Move DeleteAfterReboot and Move to base namespace

base/file_util_win.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 "base/file_util.h"
 
 #include <windows.h>
 #include <psapi.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 80 matching lines @@
   // happen).  See MSDN for SHFileOperation and SHFILEOPTSTRUCT.
   if (file_operation.fAnyOperationsAborted)
     return false;
 
   // Some versions of Windows return ERROR_FILE_NOT_FOUND (0x2) when deleting
   // an empty directory and some return 0x402 when they should be returning
   // ERROR_FILE_NOT_FOUND. MSDN says Vista and up won't return 0x402.
   return (err == 0 || err == ERROR_FILE_NOT_FOUND || err == 0x402);
 }
 
-}  // namespace base
-
-namespace file_util {
-
-using base::FilePath;
-using base::kFileShareAll;
-
 bool DeleteAfterReboot(const FilePath& path) {
-  base::ThreadRestrictions::AssertIOAllowed();
+  ThreadRestrictions::AssertIOAllowed();
 
   if (path.value().length() >= MAX_PATH)
     return false;
 
   return MoveFileEx(path.value().c_str(), NULL,
                     MOVEFILE_DELAY_UNTIL_REBOOT |
                         MOVEFILE_REPLACE_EXISTING) != FALSE;
 }
 
 bool MoveUnsafe(const FilePath& from_path, const FilePath& to_path) {
-  base::ThreadRestrictions::AssertIOAllowed();
+  ThreadRestrictions::AssertIOAllowed();
 
   // NOTE: I suspect we could support longer paths, but that would involve
   // analyzing all our usage of files.
   if (from_path.value().length() >= MAX_PATH ||
       to_path.value().length() >= MAX_PATH) {
     return false;
   }
   if (MoveFileEx(from_path.value().c_str(), to_path.value().c_str(),
                  MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING) != 0)
     return true;
 
   // Keep the last error value from MoveFileEx around in case the below
   // fails.
   bool ret = false;
   DWORD last_error = ::GetLastError();
 
-  if (DirectoryExists(from_path)) {
+  if (file_util::DirectoryExists(from_path)) {
     // MoveFileEx fails if moving directory across volumes. We will simulate
     // the move by using Copy and Delete. Ideally we could check whether
     // from_path and to_path are indeed in different volumes.
-    ret = CopyAndDeleteDirectory(from_path, to_path);
+    ret = file_util::CopyAndDeleteDirectory(from_path, to_path);
   }
 
   if (!ret) {
     // Leave a clue about what went wrong so that it can be (at least) picked
     // up by a PLOG entry.
     ::SetLastError(last_error);
   }
 
   return ret;
 }
 
-bool ReplaceFileAndGetError(const FilePath& from_path,
-                            const FilePath& to_path,
-                            base::PlatformFileError* error) {
-  base::ThreadRestrictions::AssertIOAllowed();
+bool ReplaceFile(const FilePath& from_path,
+                 const FilePath& to_path,
+                 PlatformFileError* error) {
+  ThreadRestrictions::AssertIOAllowed();
   // Try a simple move first.  It will only succeed when |to_path| doesn't
   // already exist.
   if (::MoveFile(from_path.value().c_str(), to_path.value().c_str()))
     return true;
   // Try the full-blown replace if the move fails, as ReplaceFile will only
   // succeed when |to_path| does exist. When writing to a network share, we may
   // not be able to change the ACLs. Ignore ACL errors then
   // (REPLACEFILE_IGNORE_MERGE_ERRORS).
   if (::ReplaceFile(to_path.value().c_str(), from_path.value().c_str(), NULL,
                     REPLACEFILE_IGNORE_MERGE_ERRORS, NULL, NULL)) {
     return true;
   }
   if (error)
-    *error = base::LastErrorToPlatformFileError(GetLastError());
+    *error = LastErrorToPlatformFileError(GetLastError());
   return false;
 }
 
+}  // namespace base
+
+// -----------------------------------------------------------------------------
+
+namespace file_util {
+
+using base::FilePath;
+using base::kFileShareAll;
+
 bool CopyFileUnsafe(const FilePath& from_path, const FilePath& to_path) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   // NOTE: I suspect we could support longer paths, but that would involve
   // analyzing all our usage of files.
   if (from_path.value().length() >= MAX_PATH ||
       to_path.value().length() >= MAX_PATH) {
     return false;
   }
   return (::CopyFile(from_path.value().c_str(), to_path.value().c_str(),
@@ skipping 557 matching lines @@
 
   // Length of |path| with path separator appended.
   size_t prefix = path.StripTrailingSeparators().value().size() + 1;
   // The whole path string must be shorter than MAX_PATH. That is, it must be
   // prefix + component_length < MAX_PATH (or equivalently, <= MAX_PATH - 1).
   int whole_path_limit = std::max(0, MAX_PATH - 1 - static_cast<int>(prefix));
   return std::min(whole_path_limit, static_cast<int>(max_length));
 }
 
 }  // namespace file_util