Moving away from shell api to support long path names on windows for filesystem.

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>
@@ skipping 114 matching lines @@
     } 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;
+  base::PlatformFileInfo file_info;
+  if (!GetFileInfo(path, &file_info))
+    return true;
 
-  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;
+  if (!file_info.is_directory)
+    return (DeleteFile(path.value().c_str()) != 0);
 
-    // Otherwise, it's a file, wildcard or non-existant. Try DeleteFile first
-    // because it should be faster. If DeleteFile fails, then we fall through
-    // to SHFileOperation, which will do the right thing.
-    if (DeleteFile(path.value().c_str()) != 0)
-      return true;
+  if (!recursive)
+    return RemoveDirectory(path.value().c_str()) != 0;
+
+  // Matches posix version of iterating directories.
+  bool success = true;
+  std::stack<FilePath::StringType> directories;
+  directories.push(path.value());
+  FileEnumerator traversal(path, true, static_cast<FileEnumerator::FILE_TYPE>(
+      FileEnumerator::FILES | FileEnumerator::DIRECTORIES));
+
+  for (FilePath current = traversal.Next(); success && !current.empty();
+       current = traversal.Next()) {
+    FileEnumerator::FindInfo info;
+    traversal.GetFindInfo(&info);
+    if (traversal.IsDirectory(info)) {
+      directories.push(current.value());
+    } else {
+      // This is needed because DeleteFile can fail for read-only files.

[Erik does not do reviews, 2010/12/16 18:34:54]

doesn't this mean that we need the same logic above?  should we just move it
into DeleteFile?

[Kavita Kanetkar, 2010/12/17 00:59:32]

DeleteFile resolves to 
BOOL WINAPI DeleteFile(
  __in  LPCTSTR lpFileName
);

Hence I had to keep it out of DeleteFile.
On 2010/12/16 18:34:54, Erik Kay wrote:

+      DWORD attributes = ::GetFileAttributes(current.value().c_str());
+      if (attributes != INVALID_FILE_ATTRIBUTES &&
+          attributes & FILE_ATTRIBUTE_READONLY)

[Erik does not do reviews, 2010/12/16 18:34:54]

multiline conditional plus multiline body means you need {}

[Kavita Kanetkar, 2010/12/17 00:59:32]

Done.

+        ::SetFileAttributes(current.value().c_str(),
+                            attributes &~ FILE_ATTRIBUTE_READONLY);
+      success = (DeleteFile(current.value().c_str()) != 0);
+    }
   }
 
-  // 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.
-  wchar_t double_terminated_path[MAX_PATH + 1] = {0};
-#pragma warning(suppress:4996)  // don't complain about wcscpy deprecation
-  wcscpy(double_terminated_path, path.value().c_str());
-
-  SHFILEOPSTRUCT file_operation = {0};
-  file_operation.wFunc = FO_DELETE;
-  file_operation.pFrom = double_terminated_path;
-  file_operation.fFlags = FOF_NOERRORUI | FOF_SILENT | FOF_NOCONFIRMATION;
-  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);
+  while (success && !directories.empty()) {
+    FilePath dir = FilePath(directories.top());
+    directories.pop();
+    success = (RemoveDirectory(dir.value().c_str()) != 0);
+  }
+  return success;
 }
 
 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;
@@ skipping 16 matching lines @@
   // 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.
-  wchar_t double_terminated_path_from[MAX_PATH + 1] = {0};
-  wchar_t double_terminated_path_to[MAX_PATH + 1] = {0};
-#pragma warning(suppress:4996)  // don't complain about wcscpy deprecation
-  wcscpy(double_terminated_path_from, from_path.value().c_str());
-#pragma warning(suppress:4996)  // don't complain about wcscpy deprecation
-  wcscpy(double_terminated_path_to, to_path.value().c_str());
-
-  SHFILEOPSTRUCT file_operation = {0};
-  file_operation.wFunc = FO_COPY;
-  file_operation.pFrom = double_terminated_path_from;
-  file_operation.pTo = double_terminated_path_to;
-  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();
+  FilePath real_to_path = to_path;
+  if (PathExists(real_to_path)) {
+    if (!real_to_path.StartsWithExtendedPathPrefix() &&
+        !AbsolutePath(&real_to_path))

[Erik does not do reviews, 2010/12/16 18:34:54]

This seems to imply that AbsolutePath returns the wrong value with
StartsWithExtendedPathPrefix is true.  Shouldn't we fix AbsolutePath?

[Kavita Kanetkar, 2010/12/17 00:59:32]

AbsolutePath currently creates:
wchar_t file_path_buf[MAX_PATH] for it to pass to _wfullpath
And for every call to create:
wchar_t array of size 32K seemed like a bad idea. If there's any other way
around it, I can try fixing AbsolutePath()

On 2010/12/16 18:34:54, Erik Kay wrote:

+      return false;
+  } else {
+    real_to_path = real_to_path.DirName();
+    if (!real_to_path.StartsWithExtendedPathPrefix() &&
+        !AbsolutePath(&real_to_path))
+      return false;
+  }
+  FilePath real_from_path = from_path;
+  if (!real_from_path.StartsWithExtendedPathPrefix() &&
+      !AbsolutePath(&real_from_path))
+    return false;
+  if (real_to_path.value().size() >= real_from_path.value().size() &&

[Erik does not do reviews, 2010/12/16 18:34:54]

Is this just testing whether from is an ancestor of to?  if so, I think we
already have a method on FilePath to do this for you.

[Kavita Kanetkar, 2010/12/17 00:59:32]

I don't think it handles cases such as:
to_path = C:\a\b\c\d\e
from_path = C:\a\b
Since it's not a strict parent of from_path.

On 2010/12/16 18:34:54, Erik Kay wrote:
Done.

+      real_to_path.value().compare(0, real_from_path.value().size(),
+      real_from_path.value()) == 0)
+    return false;
 
+  bool success = true;
+  FileEnumerator::FILE_TYPE traverse_type =
+      static_cast<FileEnumerator::FILE_TYPE>(FileEnumerator::FILES);
   if (recursive)
-    return ShellCopy(from_path, to_path, true);
+    traverse_type = static_cast<FileEnumerator::FILE_TYPE>(
+        traverse_type | FileEnumerator::DIRECTORIES);
+  FileEnumerator traversal(from_path, recursive, traverse_type);
 
-  // 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);
+  // |to_path| may not exist yet, start the loop with |to_path|.

[Erik does not do reviews, 2010/12/16 18:34:54]

this comment doesn't seem right

[Kavita Kanetkar, 2010/12/17 00:59:32]

Done.

+  FilePath current = from_path;
+  if (!PathExists(from_path)) {
+    LOG(ERROR) << "CopyDirectory() couldn't get info on source directory: "
+               << from_path.value();
+    success = false;

[Erik does not do reviews, 2010/12/16 18:34:54]

Why does the code continue from here?  The next lines are no-ops right?  Just
return false.

[Kavita Kanetkar, 2010/12/17 00:59:32]

Done.

   }
 
-  FilePath directory = from_path.Append(L"*.*");
-  return ShellCopy(directory, to_path, false);
+  FilePath from_path_base = from_path;
+  if (recursive && DirectoryExists(to_path)) {
+    // If the destination already exists and is a directory, then the
+    // top level of source needs to be copied.
+    from_path_base = from_path.DirName();
+  }
+
+  // This matches previous shell implementation that assumed that

[Erik does not do reviews, 2010/12/16 18:34:54]

does the POSIX impl match this behavior as well?  or is there some code that
depends on this behavior that's windows-only?

[Kavita Kanetkar, 2010/12/17 00:59:32]

Yes. Actually previous shell32 implementation matches this. And posix version
was written to match it.

On 2010/12/16 18:34:54, Erik Kay wrote:

+  // non-recursive calls will always have a directory for from_path.
+  DCHECK(recursive || DirectoryExists(from_path));
+
+  while (success && !current.empty()) {
+    // current is the source path, including from_path, so paste
+    // the suffix after from_path onto to_path to create the target_path.
+    FilePath::StringType suffix(
+        &current.value().c_str()[from_path_base.value().size()]);
+    // Strip the leading '\' (if any).

[Erik does not do reviews, 2010/12/16 18:34:54]

nit: newline above //

[Kavita Kanetkar, 2010/12/17 00:59:32]

Done.

+    if (!suffix.empty()) {
+      DCHECK_EQ('\\', suffix[0]);
+      suffix.erase(0, 1);
+    }
+    const FilePath target_path = to_path.Append(suffix);
+
+    if (DirectoryExists(current)) {
+      if (::CreateDirectory(target_path.value().c_str(), NULL) == 0) {

[Erik does not do reviews, 2010/12/16 18:34:54]

doesn't this mean that if CreateDirectory fails, the copy might believe that it
succeeded when it didn't?

[Kavita Kanetkar, 2010/12/17 00:59:32]

No. This part of the code checks if target directory exists already and we're
trying to Create it. If so, count it as a success case (Matches posix code errno
!= EEXIST)

On 2010/12/16 18:34:54, Erik Kay wrote:

+        if (!DirectoryExists(target_path)) {
+          LOG(ERROR) << "CopyDirectory() couldn't create directory: "
+                     << target_path.value();
+          success = false;
+        }
+      }
+    } else {
+      if (!CopyFile(current, target_path)) {
+        LOG(ERROR) << "CopyDirectory() couldn't create file: "
+                   << target_path.value();
+        success = false;
+      }
+    }
+    current = traversal.Next();
+  }
+  return success;
 }
 
 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);
@@ skipping 803 matching lines @@
       uint8 unused = *(touch + offset);
       offset += step_size;
     }
     FreeLibrary(dll_module);
   }
 
   return true;
 }
 
 }  // namespace file_util