Disable fd/handle sharing in base::ReadFileToString.

base/files/file_util.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/files/file_util.h"
 
 #if defined(OS_WIN)
 #include <io.h>
 #endif
 #include <stdio.h>
@@ skipping 113 matching lines @@
 }
 #endif  // !defined(OS_NACL_NONSFI)
 
 bool ReadFileToStringWithMaxSize(const FilePath& path,
                                  std::string* contents,
                                  size_t max_size) {
   if (contents)
     contents->clear();
   if (path.ReferencesParent())
     return false;
-  FILE* file = OpenFile(path, "rb");
+  FILE* file = OpenFile(path, "rb" FONE);
   if (!file) {
     return false;
   }
 
   const size_t kBufferSize = 1 << 16;
   std::unique_ptr<char[]> buf(new char[kBufferSize]);
   size_t len;
   size_t size = 0;
   bool read_status = true;
 
   // Many files supplied in |path| have incorrect size (proc files etc).
   // Hence, the file is read sequentially as opposed to a one-shot read.
   while ((len = fread(buf.get(), 1, kBufferSize, file)) > 0) {
     if (contents)
       contents->append(buf.get(), std::min(len, max_size - size));
 
     if ((max_size - size) < len) {
       read_status = false;
       break;
     }
 
     size += len;
   }
   read_status = read_status && !ferror(file);
   CloseFile(file);

[gab, 2017/02/06 21:13:19]

Since we CloseFile here, is the issue that |file| can be inherited by child
processes created by another thread while it happens to be open? i.e. this is
racy?

Sounds like such inheritance is pretty much never desired..?

[grt (UTC plus 2), 2017/02/06 21:51:21]

Yes, racy and actively happening in tests due to the aggressive parallelism of
the test launcher.
That's my thinking, but it is the default on POSIX, so likely the default on
Windows as well. I think it makes sense to flip Chromium's default around (see
internal thread), but this incremental change here is at least in the right
direction.

 
   return read_status;
 }
 
 bool ReadFileToString(const FilePath& path, std::string* contents) {
   return ReadFileToStringWithMaxSize(path, contents,
                                      std::numeric_limits<size_t>::max());
 }
 
 #if !defined(OS_NACL_NONSFI)
@@ skipping 84 matching lines @@
         (!have_suffix || !PathExists(FilePath(new_path.value() + suffix)))) {
       return count;
     }
   }
 
   return -1;
 }
 #endif  // !defined(OS_NACL_NONSFI)
 
 }  // namespace base