Copy Crashpad into the Chrome tree instead of importing it via DEPS

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

Index: third_party/crashpad/crashpad/util/file/file_io_posix.cc
diff --git a/third_party/crashpad/crashpad/util/file/file_io_posix.cc b/third_party/crashpad/crashpad/util/file/file_io_posix.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ce08a3960c5b39c591efa9c599670129bfcd839b
--- /dev/null
+++ b/third_party/crashpad/crashpad/util/file/file_io_posix.cc
@@ -0,0 +1,190 @@
+// 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 <unistd.h>
+
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/posix/eintr_wrapper.h"
+
+namespace {
+
+struct ReadTraits {
+  using VoidBufferType = void*;
+  using CharBufferType = char*;
+  static crashpad::FileOperationResult Operate(int fd,
+                                               CharBufferType 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) {
+    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);
+
+  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;
+  }
+
+  return total_bytes;
+}
+
+}  // namespace
+
+namespace crashpad {
+
+namespace {
+
+FileHandle OpenFileForOutput(int rdwr_or_wronly,
+                             const base::FilePath& path,
+                             FileWriteMode mode,
+                             FilePermissions permissions) {
+  DCHECK(rdwr_or_wronly & (O_RDWR | O_WRONLY));
+  DCHECK_EQ(rdwr_or_wronly & ~(O_RDWR | O_WRONLY), 0);
+
+  int flags = rdwr_or_wronly;
+
+  switch (mode) {
+    case FileWriteMode::kReuseOrFail:
+      break;
+    case FileWriteMode::kReuseOrCreate:
+      flags |= O_CREAT;
+      break;
+    case FileWriteMode::kTruncateOrCreate:
+      flags |= O_CREAT | O_TRUNC;
+      break;
+    case FileWriteMode::kCreateOrFail:
+      flags |= O_CREAT | O_EXCL;
+      break;
+  }
+
+  return HANDLE_EINTR(
+      open(path.value().c_str(),
+           flags,
+           permissions == FilePermissions::kWorldReadable ? 0644 : 0600));
+}
+
+}  // namespace
+
+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));
+}
+
+FileHandle OpenFileForWrite(const base::FilePath& path,
+                            FileWriteMode mode,
+                            FilePermissions permissions) {
+  return OpenFileForOutput(O_WRONLY, path, mode, permissions);
+}
+
+FileHandle OpenFileForReadAndWrite(const base::FilePath& path,
+                                   FileWriteMode mode,
+                                   FilePermissions permissions) {
+  return OpenFileForOutput(O_RDWR, path, mode, permissions);
+}
+
+FileHandle LoggingOpenFileForRead(const base::FilePath& path) {
+  FileHandle fd = OpenFileForRead(path);
+  PLOG_IF(ERROR, fd < 0) << "open " << path.value();
+  return fd;
+}
+
+FileHandle LoggingOpenFileForWrite(const base::FilePath& path,
+                                   FileWriteMode mode,
+                                   FilePermissions permissions) {
+  FileHandle fd = OpenFileForWrite(path, mode, permissions);
+  PLOG_IF(ERROR, fd < 0) << "open " << path.value();
+  return fd;
+}
+
+FileHandle LoggingOpenFileForReadAndWrite(const base::FilePath& path,
+                                          FileWriteMode mode,
+                                          FilePermissions permissions) {
+  FileHandle fd = OpenFileForReadAndWrite(path, mode, permissions);
+  PLOG_IF(ERROR, fd < 0) << "open " << path.value();
+  return fd;
+}
+
+bool LoggingLockFile(FileHandle file, FileLocking locking) {
+  int operation = (locking == FileLocking::kShared) ? LOCK_SH : LOCK_EX;
+  int rv = HANDLE_EINTR(flock(file, operation));
+  PLOG_IF(ERROR, rv != 0) << "flock";
+  return rv == 0;
+}
+
+bool LoggingUnlockFile(FileHandle file) {
+  int rv = flock(file, LOCK_UN);
+  PLOG_IF(ERROR, rv != 0) << "flock";
+  return rv == 0;
+}
+
+FileOffset LoggingSeekFile(FileHandle file, FileOffset offset, int whence) {
+  off_t rv = lseek(file, offset, whence);
+  PLOG_IF(ERROR, rv < 0) << "lseek";
+  return rv;
+}
+
+bool LoggingTruncateFile(FileHandle file) {
+  if (HANDLE_EINTR(ftruncate(file, 0)) != 0) {
+    PLOG(ERROR) << "ftruncate";
+    return false;
+  }
+  return true;
+}
+
+bool LoggingCloseFile(FileHandle file) {
+  int rv = IGNORE_EINTR(close(file));
+  PLOG_IF(ERROR, rv != 0) << "close";
+  return rv == 0;
+}
+
+}  // namespace crashpad