Make CopyDirectory() not copy the read only bit on Windows.

base/file_util_posix.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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <libgen.h>
@@ skipping 242 matching lines @@
   return false;
 }
 
 bool CopyDirectory(const FilePath& from_path,
                    const FilePath& to_path,
                    bool recursive) {
   ThreadRestrictions::AssertIOAllowed();
   // Some old callers of CopyDirectory want it to support wildcards.
   // After some discussion, we decided to fix those callers.
   // Break loudly here if anyone tries to do this.
-  // TODO(evanm): remove this once we're sure it's ok.
   DCHECK(to_path.value().find('*') == std::string::npos);
   DCHECK(from_path.value().find('*') == std::string::npos);
 
-  char top_dir[PATH_MAX];
-  if (strlcpy(top_dir, from_path.value().c_str(),

[M-A Ruel, 2014/01/24 19:52:31]

There was no point in doing a strlcpy just to get the length of the string...

-              arraysize(top_dir)) >= arraysize(top_dir)) {
+  if (strlen(from_path.value().c_str()) >= PATH_MAX) {

[grt (UTC plus 2), 2014/01/24 20:50:07]

no need for strlen, either, is there?
  if (from_path.value().size() >= PATH_MAX)

[M-A Ruel, 2014/01/24 21:32:57]

Done.

     return false;
   }
 
   // This function does not properly handle destinations within the source
   FilePath real_to_path = to_path;
   if (PathExists(real_to_path)) {
     real_to_path = MakeAbsoluteFilePath(real_to_path);
     if (real_to_path.empty())
       return false;
   } else {
     real_to_path = MakeAbsoluteFilePath(real_to_path.DirName());
     if (real_to_path.empty())
       return false;
   }
   FilePath real_from_path = MakeAbsoluteFilePath(from_path);
   if (real_from_path.empty())
     return false;
   if (real_to_path.value().size() >= real_from_path.value().size() &&
       real_to_path.value().compare(0, real_from_path.value().size(),
       real_from_path.value()) == 0)
     return false;
 
-  bool success = true;
   int traverse_type = FileEnumerator::FILES | FileEnumerator::SHOW_SYM_LINKS;
   if (recursive)
     traverse_type |= FileEnumerator::DIRECTORIES;
   FileEnumerator traversal(from_path, recursive, traverse_type);
 
   // We have to mimic windows behavior here. |to_path| may not exist yet,
   // start the loop with |to_path|.
   struct stat from_stat;
   FilePath current = from_path;
   if (stat(from_path.value().c_str(), &from_stat) < 0) {
     DLOG(ERROR) << "CopyDirectory() couldn't stat source directory: "
                 << from_path.value() << " errno = " << errno;
-    success = false;
+    return false;
   }
   struct stat to_path_stat;
   FilePath from_path_base = from_path;
   if (recursive && stat(to_path.value().c_str(), &to_path_stat) == 0 &&
       S_ISDIR(to_path_stat.st_mode)) {
     // 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();
   }
 
   // The Windows version of this function assumes that non-recursive calls
   // will always have a directory for from_path.
+  // TODO(maruel): This is not necessary anymore.
   DCHECK(recursive || S_ISDIR(from_stat.st_mode));
 
+  bool success = true;
   while (success && !current.empty()) {
     // current is the source path, including from_path, so append
     // the suffix after from_path to to_path to create the target_path.
     FilePath target_path(to_path);
     if (from_path_base != current) {
       if (!from_path_base.AppendRelativePath(current, &target_path)) {
         success = false;
         break;
       }
     }
@@ skipping 628 matching lines @@
     result = false;
   if (IGNORE_EINTR(close(outfile)) < 0)
     result = false;
 
   return result;
 }
 #endif  // !defined(OS_MACOSX)
 
 }  // namespace internal
 }  // namespace base