Move temp file 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 213 matching lines @@
   // trailing slash.  We duplicate this here, but it shouldn't be necessary
   // when everyone is using the appropriate FilePath APIs.
   *path = FilePath(temp_path).StripTrailingSeparators();
   return true;
 }
 
 bool GetShmemTempDir(bool executable, FilePath* path) {
   return GetTempDir(path);
 }
 
-}  // namespace base
-
-// -----------------------------------------------------------------------------
-
-namespace file_util {
-
-using base::DirectoryExists;
-using base::FilePath;
-using base::kFileShareAll;
-
 bool CreateTemporaryFile(FilePath* path) {
-  base::ThreadRestrictions::AssertIOAllowed();
+  ThreadRestrictions::AssertIOAllowed();
 
   FilePath temp_file;
 
   if (!GetTempDir(path))
     return false;
 
   if (CreateTemporaryFileInDir(*path, &temp_file)) {
     *path = temp_file;
     return true;
   }
 
   return false;
 }
 
 FILE* CreateAndOpenTemporaryShmemFile(FilePath* path, bool executable) {
-  base::ThreadRestrictions::AssertIOAllowed();
+  ThreadRestrictions::AssertIOAllowed();
   return CreateAndOpenTemporaryFile(path);
 }
 
 // On POSIX we have semantics to create and open a temporary file
 // atomically.
 // TODO(jrg): is there equivalent call to use on Windows instead of
 // going 2-step?
 FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir, FilePath* path) {
-  base::ThreadRestrictions::AssertIOAllowed();
+  ThreadRestrictions::AssertIOAllowed();
   if (!CreateTemporaryFileInDir(dir, path)) {
     return NULL;
   }
   // Open file in binary mode, to avoid problems with fwrite. On Windows
   // it replaces \n's with \r\n's, which may surprise you.
   // Reference: http://msdn.microsoft.com/en-us/library/h9t88zwz(VS.71).aspx
-  return OpenFile(*path, "wb+");
+  return file_util::OpenFile(*path, "wb+");
 }
 
-bool CreateTemporaryFileInDir(const FilePath& dir,
-                              FilePath* temp_file) {
-  base::ThreadRestrictions::AssertIOAllowed();
+bool CreateTemporaryFileInDir(const FilePath& dir, FilePath* temp_file) {
+  ThreadRestrictions::AssertIOAllowed();
 
   wchar_t temp_name[MAX_PATH + 1];
 
   if (!GetTempFileName(dir.value().c_str(), L"", 0, temp_name)) {
-    DPLOG(WARNING) << "Failed to get temporary file name in " << dir.value();
+    DPLOG(WARNING) << "Failed to get temporary file name in "
+                   << UTF16ToUTF8(dir.value());
     return false;
   }
 
   wchar_t long_temp_name[MAX_PATH + 1];
   DWORD long_name_len = GetLongPathName(temp_name, long_temp_name, MAX_PATH);
   if (long_name_len > MAX_PATH || long_name_len == 0) {
     // GetLongPathName() failed, but we still have a temporary file.
     *temp_file = FilePath(temp_name);
     return true;
   }
 
   FilePath::StringType long_temp_name_str;
   long_temp_name_str.assign(long_temp_name, long_name_len);
   *temp_file = FilePath(long_temp_name_str);
   return true;
 }
 
 bool CreateTemporaryDirInDir(const FilePath& base_dir,
                              const FilePath::StringType& prefix,
                              FilePath* new_dir) {
-  base::ThreadRestrictions::AssertIOAllowed();
+  ThreadRestrictions::AssertIOAllowed();
 
   FilePath path_to_create;
 
   for (int count = 0; count < 50; ++count) {
     // Try create a new temporary directory with random generated name. If
     // the one exists, keep trying another path name until we reach some limit.
     string16 new_dir_name;
     new_dir_name.assign(prefix);
-    new_dir_name.append(base::IntToString16(::base::GetCurrentProcId()));
+    new_dir_name.append(IntToString16(GetCurrentProcId()));
     new_dir_name.push_back('_');
-    new_dir_name.append(base::IntToString16(base::RandInt(0, kint16max)));
+    new_dir_name.append(IntToString16(RandInt(0, kint16max)));
 
     path_to_create = base_dir.Append(new_dir_name);
     if (::CreateDirectory(path_to_create.value().c_str(), NULL)) {
       *new_dir = path_to_create;
       return true;
     }
   }
 
   return false;
 }
 
 bool CreateNewTempDirectory(const FilePath::StringType& prefix,
                             FilePath* new_temp_path) {
-  base::ThreadRestrictions::AssertIOAllowed();
+  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();
 
   // 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 << "), "
@@ skipping 392 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