Turn on file access checks on Win.

base/file_util_win.cc

 // Copyright (c) 2010 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 <propvarutil.h>
 #include <psapi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <time.h>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/win/pe_image.h"
 #include "base/win/scoped_handle.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "base/thread_restrictions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/win_util.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 
 namespace file_util {
 
 namespace {
 
 const DWORD kFileShareAll =
     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
 
 // Helper for NormalizeFilePath(), defined below.
 bool DevicePathToDriveLetterPath(const FilePath& device_path,
                                  FilePath* drive_letter_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   // Get the mapping of drive letters to device paths.
   const int kDriveMappingSize = 1024;
   wchar_t drive_mapping[kDriveMappingSize] = {'\0'};
   if (!::GetLogicalDriveStrings(kDriveMappingSize - 1, drive_mapping)) {
     LOG(ERROR) << "Failed to get drive mapping.";
     return false;
   }
 
   // The drive mapping is a sequence of null terminated strings.
   // The last string is empty.
@@ skipping 20 matching lines @@
 
   // No drive matched.  The path does not start with a device junction
   // that is mounted as a drive letter.  This means there is no drive
   // letter path to the volume that holds |device_path|, so fail.
   return false;
 }
 
 }  // namespace
 
 std::wstring GetDirectoryFromPath(const std::wstring& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   wchar_t path_buffer[MAX_PATH];
   wchar_t* file_ptr = NULL;
   if (GetFullPathName(path.c_str(), MAX_PATH, path_buffer, &file_ptr) == 0)
     return L"";
 
   std::wstring::size_type length =
       file_ptr ? file_ptr - path_buffer : path.length();
   std::wstring directory(path, 0, length);
   return FilePath(directory).StripTrailingSeparators().value();
 }
 
 bool AbsolutePath(FilePath* path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   wchar_t file_path_buf[MAX_PATH];
   if (!_wfullpath(file_path_buf, path->value().c_str(), MAX_PATH))
     return false;
   *path = FilePath(file_path_buf);
   return true;
 }
 
 int CountFilesCreatedAfter(const FilePath& path,
                            const base::Time& comparison_time) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   int file_count = 0;
   FILETIME comparison_filetime(comparison_time.ToFileTime());
 
   WIN32_FIND_DATA find_file_data;
   // All files in given dir
   std::wstring filename_spec = path.Append(L"*").value();
   HANDLE find_handle = FindFirstFile(filename_spec.c_str(), &find_file_data);
   if (find_handle != INVALID_HANDLE_VALUE) {
     do {
       // Don't count current or parent directories.
       if ((wcscmp(find_file_data.cFileName, L"..") == 0) ||
           (wcscmp(find_file_data.cFileName, L".") == 0))
         continue;
 
       long result = CompareFileTime(&find_file_data.ftCreationTime,
                                     &comparison_filetime);
       // File was created after or on comparison time
       if ((result == 1) || (result == 0))
         ++file_count;
     } while (FindNextFile(find_handle,  &find_file_data));
     FindClose(find_handle);
   }
 
   return file_count;
 }
 
 bool Delete(const FilePath& path, bool recursive) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   if (path.value().length() >= MAX_PATH)
     return false;
 
   if (!recursive) {
     // If not recursing, then first check to see if |path| is a directory.
     // If it is, then remove it with RemoveDirectory.
     base::PlatformFileInfo file_info;
     if (GetFileInfo(path, &file_info) && file_info.is_directory)
       return RemoveDirectory(path.value().c_str()) != 0;
 
@@ skipping 18 matching lines @@
   if (!recursive)
     file_operation.fFlags |= FOF_NORECURSION | FOF_FILESONLY;
   int err = SHFileOperation(&file_operation);
   // 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);
 }
 
 bool DeleteAfterReboot(const FilePath& path) {
+  base::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 Move(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;
   }
   if (MoveFileEx(from_path.value().c_str(), to_path.value().c_str(),
                  MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING) != 0)
     return true;
   if (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.
     return CopyAndDeleteDirectory(from_path, to_path);
   }
   return false;
 }
 
 bool ReplaceFile(const FilePath& from_path, const FilePath& to_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   // Make sure that the target file exists.
   HANDLE target_file = ::CreateFile(
       to_path.value().c_str(),
       0,
       FILE_SHARE_READ | FILE_SHARE_WRITE,
       NULL,
       CREATE_NEW,
       FILE_ATTRIBUTE_NORMAL,
       NULL);
   if (target_file != INVALID_HANDLE_VALUE)
     ::CloseHandle(target_file);
   // When writing to a network share, we may not be able to change the ACLs.
   // Ignore ACL errors then (REPLACEFILE_IGNORE_MERGE_ERRORS).
   return ::ReplaceFile(to_path.value().c_str(),
       from_path.value().c_str(), NULL,
       REPLACEFILE_IGNORE_MERGE_ERRORS, NULL, NULL) ? true : false;
 }
 
 bool CopyFile(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(),
                      false) != 0);
 }
 
 bool ShellCopy(const FilePath& from_path, const FilePath& to_path,
                bool recursive) {
+  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;
   }
 
   // SHFILEOPSTRUCT wants the path to be terminated with two NULLs,
   // so we have to use wcscpy because wcscpy_s writes non-NULLs
   // into the rest of the buffer.
@@ skipping 11 matching lines @@
   file_operation.fFlags = FOF_NOERRORUI | FOF_SILENT | FOF_NOCONFIRMATION |
                           FOF_NOCONFIRMMKDIR;
   if (!recursive)
     file_operation.fFlags |= FOF_NORECURSION | FOF_FILESONLY;
 
   return (SHFileOperation(&file_operation) == 0);
 }
 
 bool CopyDirectory(const FilePath& from_path, const FilePath& to_path,
                    bool recursive) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   if (recursive)
     return ShellCopy(from_path, to_path, true);
 
   // 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)
       CreateDirectory(to_path);
     else
       ShellCopy(from_path, to_path, false);
   }
 
   FilePath directory = from_path.Append(L"*.*");
   return ShellCopy(directory, to_path, false);
 }
 
 bool CopyAndDeleteDirectory(const FilePath& from_path,
                             const FilePath& to_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   if (CopyDirectory(from_path, to_path, true)) {
     if (Delete(from_path, true)) {
       return true;
     }
     // 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;
 }
 
 
 bool PathExists(const FilePath& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   return (GetFileAttributes(path.value().c_str()) != INVALID_FILE_ATTRIBUTES);
 }
 
 bool PathIsWritable(const FilePath& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   HANDLE dir =
       CreateFile(path.value().c_str(), FILE_ADD_FILE, kFileShareAll,
                  NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 
   if (dir == INVALID_HANDLE_VALUE)
     return false;
 
   CloseHandle(dir);
   return true;
 }
 
 bool DirectoryExists(const FilePath& path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   DWORD fileattr = GetFileAttributes(path.value().c_str());
   if (fileattr != INVALID_FILE_ATTRIBUTES)
     return (fileattr & FILE_ATTRIBUTE_DIRECTORY) != 0;
   return false;
 }
 
 bool GetFileCreationLocalTimeFromHandle(HANDLE file_handle,
                                         LPSYSTEMTIME creation_time) {
+  base::ThreadRestrictions::AssertIOAllowed();
   if (!file_handle)
     return false;
 
   FILETIME utc_filetime;
   if (!GetFileTime(file_handle, &utc_filetime, NULL, NULL))
     return false;
 
   FILETIME local_filetime;
   if (!FileTimeToLocalFileTime(&utc_filetime, &local_filetime))
     return false;
 
   return !!FileTimeToSystemTime(&local_filetime, creation_time);
 }
 
 bool GetFileCreationLocalTime(const std::wstring& filename,
                               LPSYSTEMTIME creation_time) {
+  base::ThreadRestrictions::AssertIOAllowed();
   base::win::ScopedHandle file_handle(
       CreateFile(filename.c_str(), GENERIC_READ, kFileShareAll, NULL,
                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL));
   return GetFileCreationLocalTimeFromHandle(file_handle.Get(), creation_time);
 }
 
 bool ResolveShortcut(FilePath* path) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   HRESULT result;
   base::win::ScopedComPtr<IShellLink> i_shell_link;
   bool is_resolved = false;
 
   // Get pointer to the IShellLink interface
   result = i_shell_link.CreateInstance(CLSID_ShellLink, NULL,
                                        CLSCTX_INPROC_SERVER);
   if (SUCCEEDED(result)) {
     base::win::ScopedComPtr<IPersistFile> persist;
     // Query IShellLink for the IPersistFile interface
@@ skipping 15 matching lines @@
     }
   }
 
   return is_resolved;
 }
 
 bool CreateShortcutLink(const wchar_t *source, const wchar_t *destination,
                         const wchar_t *working_dir, const wchar_t *arguments,
                         const wchar_t *description, const wchar_t *icon,
                         int icon_index, const wchar_t* app_id) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   // Length of arguments and description must be less than MAX_PATH.
   DCHECK(lstrlen(arguments) < MAX_PATH);
   DCHECK(lstrlen(description) < MAX_PATH);
 
   base::win::ScopedComPtr<IShellLink> i_shell_link;
   base::win::ScopedComPtr<IPersistFile> i_persist_file;
 
   // Get pointer to the IShellLink interface
   HRESULT result = i_shell_link.CreateInstance(CLSID_ShellLink, NULL,
                                                CLSCTX_INPROC_SERVER);
@@ skipping 31 matching lines @@
 
   result = i_persist_file->Save(destination, TRUE);
   return SUCCEEDED(result);
 }
 
 
 bool UpdateShortcutLink(const wchar_t *source, const wchar_t *destination,
                         const wchar_t *working_dir, const wchar_t *arguments,
                         const wchar_t *description, const wchar_t *icon,
                         int icon_index, const wchar_t* app_id) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   // Length of arguments and description must be less than MAX_PATH.
   DCHECK(lstrlen(arguments) < MAX_PATH);
   DCHECK(lstrlen(description) < MAX_PATH);
 
   // Get pointer to the IPersistFile interface and load existing link
   base::win::ScopedComPtr<IShellLink> i_shell_link;
   if (FAILED(i_shell_link.CreateInstance(CLSID_ShellLink, NULL,
                                          CLSCTX_INPROC_SERVER)))
     return false;
 
@@ skipping 26 matching lines @@
 
     if (!win_util::SetAppIdForPropertyStore(property_store, app_id))
       return false;
   }
 
   HRESULT result = i_persist_file->Save(destination, TRUE);
   return SUCCEEDED(result);
 }
 
 bool TaskbarPinShortcutLink(const wchar_t* shortcut) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   // "Pin to taskbar" is only supported after Win7.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return false;
 
   int result = reinterpret_cast<int>(ShellExecute(NULL, L"taskbarpin", shortcut,
       NULL, NULL, 0));
   return result > 32;
 }
 
 bool TaskbarUnpinShortcutLink(const wchar_t* shortcut) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   // "Unpin from taskbar" is only supported after Win7.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return false;
 
   int result = reinterpret_cast<int>(ShellExecute(NULL, L"taskbarunpin",
       shortcut, NULL, NULL, 0));
   return result > 32;
 }
 
 bool GetTempDir(FilePath* path) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   wchar_t temp_path[MAX_PATH + 1];
   DWORD path_len = ::GetTempPath(MAX_PATH, temp_path);
   if (path_len >= MAX_PATH || path_len <= 0)
     return false;
   // TODO(evanm): the old behavior of this function was to always strip the
   // 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(FilePath* path) {
   return GetTempDir(path);
 }
 
 bool CreateTemporaryFile(FilePath* path) {
+  base::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) {
+  base::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();
   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+");
 }
 
 bool CreateTemporaryFileInDir(const FilePath& dir,
                               FilePath* temp_file) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   wchar_t temp_name[MAX_PATH + 1];
 
   if (!GetTempFileName(dir.value().c_str(), L"", 0, temp_name)) {
     PLOG(WARNING) << "Failed to get temporary file name in " << dir.value();
     return false;
   }
 
   DWORD path_len = GetLongPathName(temp_name, temp_name, MAX_PATH);
   if (path_len > MAX_PATH + 1 || path_len == 0) {
     PLOG(WARNING) << "Failed to get long path name for " << temp_name;
     return false;
   }
 
   std::wstring temp_file_str;
   temp_file_str.assign(temp_name, path_len);
   *temp_file = FilePath(temp_file_str);
   return true;
 }
 
 bool CreateTemporaryDirInDir(const FilePath& base_dir,
                              const FilePath::StringType& prefix,
                              FilePath* new_dir) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   FilePath path_to_create;
   srand(static_cast<uint32>(time(NULL)));
 
   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.
     path_to_create = base_dir;
 
     string16 new_dir_name;
     new_dir_name.assign(prefix);
     new_dir_name.append(base::IntToString16(rand() % kint16max));
 
     path_to_create = path_to_create.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();
+
   FilePath system_temp_dir;
   if (!GetTempDir(&system_temp_dir))
     return false;
 
   return CreateTemporaryDirInDir(system_temp_dir, prefix, new_temp_path);
 }
 
 bool CreateDirectory(const FilePath& full_path) {
+  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 << "), "
                << "directory already exists.";
       return true;
     }
     LOG(WARNING) << "CreateDirectory(" << full_path_str << "), "
@@ skipping 26 matching lines @@
       LOG(WARNING) << "Failed to create directory " << full_path_str
                    << ", last error is " << error_code << ".";
       return false;
     }
   } else {
     return true;
   }
 }
 
 bool GetFileInfo(const FilePath& file_path, base::PlatformFileInfo* results) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   WIN32_FILE_ATTRIBUTE_DATA attr;
   if (!GetFileAttributesEx(file_path.value().c_str(),
                            GetFileExInfoStandard, &attr)) {
     return false;
   }
 
   ULARGE_INTEGER size;
   size.HighPart = attr.nFileSizeHigh;
   size.LowPart = attr.nFileSizeLow;
   results->size = size.QuadPart;
 
   results->is_directory =
       (attr.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
   results->last_modified = base::Time::FromFileTime(attr.ftLastWriteTime);
   results->last_accessed = base::Time::FromFileTime(attr.ftLastAccessTime);
   results->creation_time = base::Time::FromFileTime(attr.ftCreationTime);
 
   return true;
 }
 
 FILE* OpenFile(const FilePath& filename, const char* mode) {
+  base::ThreadRestrictions::AssertIOAllowed();
   std::wstring w_mode = ASCIIToWide(std::string(mode));
   return _wfsopen(filename.value().c_str(), w_mode.c_str(), _SH_DENYNO);
 }
 
 FILE* OpenFile(const std::string& filename, const char* mode) {
+  base::ThreadRestrictions::AssertIOAllowed();
   return _fsopen(filename.c_str(), mode, _SH_DENYNO);
 }
 
 int ReadFile(const FilePath& filename, char* data, int size) {
+  base::ThreadRestrictions::AssertIOAllowed();
   base::win::ScopedHandle file(CreateFile(filename.value().c_str(),
                                           GENERIC_READ,
                                           FILE_SHARE_READ | FILE_SHARE_WRITE,
                                           NULL,
                                           OPEN_EXISTING,
                                           FILE_FLAG_SEQUENTIAL_SCAN,
                                           NULL));
   if (!file)
     return -1;
 
   DWORD read;
   if (::ReadFile(file, data, size, &read, NULL) &&
       static_cast<int>(read) == size)
     return read;
   return -1;
 }
 
 int WriteFile(const FilePath& filename, const char* data, int size) {
+  base::ThreadRestrictions::AssertIOAllowed();
   base::win::ScopedHandle file(CreateFile(filename.value().c_str(),
                                           GENERIC_WRITE,
                                           0,
                                           NULL,
                                           CREATE_ALWAYS,
                                           0,
                                           NULL));
   if (!file) {
     LOG(WARNING) << "CreateFile failed for path " << filename.value() <<
         " error code=" << GetLastError() <<
@@ skipping 14 matching lines @@
   } else {
     // Didn't write all the bytes.
     LOG(WARNING) << "wrote" << written << " bytes to " <<
         filename.value() << " expected " << size;
   }
   return -1;
 }
 
 bool RenameFileAndResetSecurityDescriptor(const FilePath& source_file_path,
                                           const FilePath& target_file_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   // The parameters to SHFileOperation must be terminated with 2 NULL chars.
   std::wstring source = source_file_path.value();
   std::wstring target = target_file_path.value();
 
   source.append(1, L'\0');
   target.append(1, L'\0');
 
   SHFILEOPSTRUCT move_info = {0};
   move_info.wFunc = FO_MOVE;
   move_info.pFrom = source.c_str();
   move_info.pTo = target.c_str();
   move_info.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI |
                      FOF_NOCONFIRMMKDIR | FOF_NOCOPYSECURITYATTRIBS;
 
   if (0 != SHFileOperation(&move_info))
     return false;
 
   return true;
 }
 
 // Gets the current working directory for the process.
 bool GetCurrentDirectory(FilePath* dir) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   wchar_t system_buffer[MAX_PATH];
   system_buffer[0] = 0;
   DWORD len = ::GetCurrentDirectory(MAX_PATH, system_buffer);
   if (len == 0 || len > MAX_PATH)
     return false;
   // TODO(evanm): the old behavior of this function was to always strip the
   // trailing slash.  We duplicate this here, but it shouldn't be necessary
   // when everyone is using the appropriate FilePath APIs.
   std::wstring dir_str(system_buffer);
   *dir = FilePath(dir_str).StripTrailingSeparators();
   return true;
 }
 
 // Sets the current working directory for the process.
 bool SetCurrentDirectory(const FilePath& directory) {
+  base::ThreadRestrictions::AssertIOAllowed();
   BOOL ret = ::SetCurrentDirectory(directory.value().c_str());
   return ret != 0;
 }
 
 ///////////////////////////////////////////////
 // FileEnumerator
 
 FileEnumerator::FileEnumerator(const FilePath& root_path,
                                bool recursive,
                                FileEnumerator::FILE_TYPE file_type)
@@ skipping 37 matching lines @@
 bool FileEnumerator::IsDirectory(const FindInfo& info) {
   return (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 }
 
 // static
 FilePath FileEnumerator::GetFilename(const FindInfo& find_info) {
   return FilePath(find_info.cFileName);
 }
 
 FilePath FileEnumerator::Next() {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   while (has_find_data_ || !pending_paths_.empty()) {
     if (!has_find_data_) {
       // The last find FindFirstFile operation is done, prepare a new one.
       root_path_ = pending_paths_.top();
       pending_paths_.pop();
 
       // Start a new find operation.
       FilePath src = root_path_;
 
       if (pattern_.empty())
@@ skipping 51 matching lines @@
 // MemoryMappedFile
 
 MemoryMappedFile::MemoryMappedFile()
     : file_(INVALID_HANDLE_VALUE),
       file_mapping_(INVALID_HANDLE_VALUE),
       data_(NULL),
       length_(INVALID_FILE_SIZE) {
 }
 
 bool MemoryMappedFile::MapFileToMemoryInternal() {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   if (file_ == INVALID_HANDLE_VALUE)
     return false;
 
   length_ = ::GetFileSize(file_, NULL);
   if (length_ == INVALID_FILE_SIZE)
     return false;
 
   // length_ value comes from GetFileSize() above. GetFileSize() returns DWORD,
   // therefore the cast here is safe.
   file_mapping_ = ::CreateFileMapping(file_, NULL, PAGE_READONLY,
@@ skipping 23 matching lines @@
   if (file_ != INVALID_HANDLE_VALUE)
     ::CloseHandle(file_);
 
   data_ = NULL;
   file_mapping_ = file_ = INVALID_HANDLE_VALUE;
   length_ = INVALID_FILE_SIZE;
 }
 
 bool HasFileBeenModifiedSince(const FileEnumerator::FindInfo& find_info,
                               const base::Time& cutoff_time) {
+  base::ThreadRestrictions::AssertIOAllowed();
   long result = CompareFileTime(&find_info.ftLastWriteTime,
                                 &cutoff_time.ToFileTime());
   return result == 1 || result == 0;
 }
 
 bool NormalizeFilePath(const FilePath& path, FilePath* real_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   FilePath mapped_file;
   if (!NormalizeToNativeFilePath(path, &mapped_file))
     return false;
   // NormalizeToNativeFilePath() will return a path that starts with
   // "\Device\Harddisk...".  Helper DevicePathToDriveLetterPath()
   // will find a drive letter which maps to the path's device, so
   // that we return a path starting with a drive letter.
   return DevicePathToDriveLetterPath(mapped_file, real_path);
 }
 
 bool NormalizeToNativeFilePath(const FilePath& path, FilePath* nt_path) {
+  base::ThreadRestrictions::AssertIOAllowed();
   // In Vista, GetFinalPathNameByHandle() would give us the real path
   // from a file handle.  If we ever deprecate XP, consider changing the
   // code below to a call to GetFinalPathNameByHandle().  The method this
   // function uses is explained in the following msdn article:
   // http://msdn.microsoft.com/en-us/library/aa366789(VS.85).aspx
   base::win::ScopedHandle file_handle(
       ::CreateFile(path.value().c_str(),
                    GENERIC_READ,
                    kFileShareAll,
                    NULL,
@@ skipping 35 matching lines @@
   if (::GetMappedFileNameW(cp, file_view, mapped_file_path, kMaxPathLength)) {
     *nt_path = FilePath(mapped_file_path);
     success = true;
   }
   ::UnmapViewOfFile(file_view);
   return success;
 }
 
 bool PreReadImage(const wchar_t* file_path, size_t size_to_read,
                   size_t step_size) {
+  base::ThreadRestrictions::AssertIOAllowed();
   if (base::win::GetVersion() > base::win::VERSION_XP) {
     // Vista+ branch. On these OSes, the forced reads through the DLL actually
     // slows warm starts. The solution is to sequentially read file contents
     // with an optional cap on total amount to read.
     base::win::ScopedHandle file(
         CreateFile(file_path,
                    GENERIC_READ,
                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                    NULL,
                    OPEN_EXISTING,
@@ skipping 44 matching lines @@
       uint8 unused = *(touch + offset);
       offset += step_size;
     }
     FreeLibrary(dll_module);
   }
 
   return true;
 }
 
 }  // namespace file_util