Update Crashpad to 8e37886d418dd042c3c7bfadac99214739ee4d98

third_party/crashpad/crashpad/util/file/file_io_posix.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/file/file_io.h"
 
 #include <fcntl.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include <algorithm>
+#include <limits>
+
 #include "base/files/file_path.h"
 #include "base/logging.h"
-#include "base/numerics/safe_conversions.h"
 #include "base/posix/eintr_wrapper.h"
 
+namespace crashpad {
+
 namespace {
 
 struct ReadTraits {
-  using VoidBufferType = void*;
-  using CharBufferType = char*;
-  static crashpad::FileOperationResult Operate(int fd,
-                                               CharBufferType buffer,
-                                               size_t size) {
+  using BufferType = void*;
+  static FileOperationResult Operate(int fd, BufferType buffer, size_t size) {
     return read(fd, buffer, size);
   }
 };
 
 struct WriteTraits {
-  using VoidBufferType = const void*;
-  using CharBufferType = const char*;
-  static crashpad::FileOperationResult Operate(int fd,
-                                               CharBufferType buffer,
-                                               size_t size) {
+  using BufferType = const void*;
+  static FileOperationResult Operate(int fd, BufferType buffer, size_t size) {
     return write(fd, buffer, size);
   }
 };
 
 template <typename Traits>
-crashpad::FileOperationResult
-ReadOrWrite(int fd, typename Traits::VoidBufferType buffer, size_t size) {
-  typename Traits::CharBufferType buffer_c =
-      reinterpret_cast<typename Traits::CharBufferType>(buffer);
+FileOperationResult ReadOrWrite(int fd,
+                                typename Traits::BufferType buffer,
+                                size_t size) {
+  constexpr size_t kMaxReadWriteSize =
+      static_cast<size_t>(std::numeric_limits<ssize_t>::max());
+  const size_t requested_bytes = std::min(size, kMaxReadWriteSize);
 
-  crashpad::FileOperationResult total_bytes = 0;
-  while (size > 0) {
-    crashpad::FileOperationResult bytes =
-        HANDLE_EINTR(Traits::Operate(fd, buffer_c, size));
-    if (bytes < 0) {
-      return bytes;
-    } else if (bytes == 0) {
-      break;
-    }
-
-    buffer_c += bytes;
-    size -= bytes;
-    total_bytes += bytes;
+  FileOperationResult transacted_bytes =
+      HANDLE_EINTR(Traits::Operate(fd, buffer, requested_bytes));
+  if (transacted_bytes < 0) {
+    return -1;
   }
 
-  return total_bytes;
+  DCHECK_LE(static_cast<size_t>(transacted_bytes), requested_bytes);
+  return transacted_bytes;
 }
 
-}  // namespace
-
-namespace crashpad {
-
-namespace {
-
 FileHandle OpenFileForOutput(int rdwr_or_wronly,
                              const base::FilePath& path,
                              FileWriteMode mode,
                              FilePermissions permissions) {
   int flags = O_NOCTTY | O_CLOEXEC;
 
   DCHECK(rdwr_or_wronly & (O_RDWR | O_WRONLY));
   DCHECK_EQ(rdwr_or_wronly & ~(O_RDWR | O_WRONLY), 0);
   flags |= rdwr_or_wronly;
 
@@ skipping 12 matching lines @@
   }
 
   return HANDLE_EINTR(
       open(path.value().c_str(),
            flags,
            permissions == FilePermissions::kWorldReadable ? 0644 : 0600));
 }
 
 }  // namespace
 
+namespace internal {
+
+const char kNativeReadFunctionName[] = "read";
+const char kNativeWriteFunctionName[] = "write";
+
+FileOperationResult NativeWriteFile(FileHandle file,
+                                    const void* buffer,
+                                    size_t size) {
+  return ReadOrWrite<WriteTraits>(file, buffer, size);
+}
+
+}  // namespace internal
+
 FileOperationResult ReadFile(FileHandle file, void* buffer, size_t size) {
   return ReadOrWrite<ReadTraits>(file, buffer, size);
 }
 
-FileOperationResult WriteFile(FileHandle file,
-                              const void* buffer,
-                              size_t size) {
-  return ReadOrWrite<WriteTraits>(file, buffer, size);
-}
-
 FileHandle OpenFileForRead(const base::FilePath& path) {
   return HANDLE_EINTR(
       open(path.value().c_str(), O_RDONLY | O_NOCTTY | O_CLOEXEC));
 }
 
 FileHandle OpenFileForWrite(const base::FilePath& path,
                             FileWriteMode mode,
                             FilePermissions permissions) {
   return OpenFileForOutput(O_WRONLY, path, mode, permissions);
 }
@@ skipping 61 matching lines @@
 
 FileOffset LoggingFileSizeByHandle(FileHandle file) {
   struct stat st;
   if (fstat(file, &st) != 0) {
     PLOG(ERROR) << "fstat";
     return -1;
   }
   return st.st_size;
 }
 
+FileHandle StdioFileHandle(StdioStream stdio_stream) {
+  switch (stdio_stream) {
+    case StdioStream::kStandardInput:
+      return STDIN_FILENO;
+    case StdioStream::kStandardOutput:
+      return STDOUT_FILENO;
+    case StdioStream::kStandardError:
+      return STDERR_FILENO;
+  }
+
+  NOTREACHED();
+  return kInvalidFileHandle;
+}
+
 }  // namespace crashpad