Move directory creation functions 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 160 matching lines @@
 
   // The following code assumes that from path is a directory.
   DCHECK(DirectoryExists(from_path));
 
   // Instead of creating a new directory, we copy the old one to include the
   // security information of the folder as part of the copy.
   if (!PathExists(to_path)) {
     // Except that Vista fails to do that, and instead do a recursive copy if
     // the target directory doesn't exist.
     if (base::win::GetVersion() >= base::win::VERSION_VISTA)
-      file_util::CreateDirectory(to_path);
+      CreateDirectory(to_path);
     else
       ShellCopy(from_path, to_path, false);
   }
 
   FilePath directory = from_path.Append(L"*.*");
   return ShellCopy(directory, to_path, false);
 }
 
 bool PathExists(const FilePath& path) {
   ThreadRestrictions::AssertIOAllowed();
@@ skipping 130 matching lines @@
                             FilePath* new_temp_path) {
   ThreadRestrictions::AssertIOAllowed();
 
   FilePath system_temp_dir;
   if (!GetTempDir(&system_temp_dir))
     return false;
 
   return CreateTemporaryDirInDir(system_temp_dir, prefix, new_temp_path);
 }
 
-}  // namespace base
-
-// -----------------------------------------------------------------------------
-
-namespace file_util {
-
-using base::DirectoryExists;
-using base::FilePath;
-using base::kFileShareAll;
-
 bool CreateDirectoryAndGetError(const FilePath& full_path,
-                                base::PlatformFileError* error) {
-  base::ThreadRestrictions::AssertIOAllowed();
+                                PlatformFileError* error) {
+  ThreadRestrictions::AssertIOAllowed();
 
   // If the path exists, we've succeeded if it's a directory, failed otherwise.
   const wchar_t* full_path_str = full_path.value().c_str();
   DWORD fileattr = ::GetFileAttributes(full_path_str);
   if (fileattr != INVALID_FILE_ATTRIBUTES) {
     if ((fileattr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
       DVLOG(1) << "CreateDirectory(" << full_path_str << "), "
                << "directory already exists.";
       return true;
     }
     DLOG(WARNING) << "CreateDirectory(" << full_path_str << "), "
                   << "conflicts with existing file.";
     if (error) {
-      *error = base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+      *error = PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
     }
     return false;
   }
 
   // Invariant:  Path does not exist as file or directory.
 
   // Attempt to create the parent recursively.  This will immediately return
   // true if it already exists, otherwise will create all required parent
   // directories starting with the highest-level missing parent.
   FilePath parent_path(full_path.DirName());
   if (parent_path.value() == full_path.value()) {
     if (error) {
-      *error = base::PLATFORM_FILE_ERROR_NOT_FOUND;
+      *error = PLATFORM_FILE_ERROR_NOT_FOUND;
     }
     return false;
   }
   if (!CreateDirectoryAndGetError(parent_path, error)) {
     DLOG(WARNING) << "Failed to create one of the parent directories.";
     if (error) {
-      DCHECK(*error != base::PLATFORM_FILE_OK);
+      DCHECK(*error != PLATFORM_FILE_OK);
     }
     return false;
   }
 
   if (!::CreateDirectory(full_path_str, NULL)) {
     DWORD error_code = ::GetLastError();
     if (error_code == ERROR_ALREADY_EXISTS && DirectoryExists(full_path)) {
       // This error code ERROR_ALREADY_EXISTS doesn't indicate whether we
       // were racing with someone creating the same directory, or a file
       // with the same path.  If DirectoryExists() returns true, we lost the
       // race to create the same directory.
       return true;
     } else {
       if (error)
-        *error = base::LastErrorToPlatformFileError(error_code);
+        *error = LastErrorToPlatformFileError(error_code);
       DLOG(WARNING) << "Failed to create directory " << full_path_str
                     << ", last error is " << error_code << ".";
       return false;
     }
   } else {
     return true;
   }
 }
 
+}  // namespace base
+
+// -----------------------------------------------------------------------------
+
+namespace file_util {
+
+using base::DirectoryExists;
+using base::FilePath;
+using base::kFileShareAll;
+
 // TODO(rkc): Work out if we want to handle NTFS junctions here or not, handle
 // them if we do decide to.
 bool IsLink(const FilePath& file_path) {
   return false;
 }
 
 bool GetFileInfo(const FilePath& file_path, base::PlatformFileInfo* results) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   WIN32_FILE_ATTRIBUTE_DATA attr;
@@ skipping 331 matching lines @@
     // Like Move, this function is not transactional, so we just
     // leave the copied bits behind if deleting from_path fails.
     // If to_path exists previously then we have already overwritten
     // it by now, we don't get better off by deleting the new bits.
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace base