Add non-logging OpenFileForWrite() and OpenFileForReadAndWrite()

util/file/file_io.h

 // 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,
@@ skipping 184 matching lines @@
 //!
 //! Attempts to read a single byte from \a file, expecting no data to be read.
 //! If the underlying ReadFile() fails, or if a byte actually is read, this
 //! function causes execution to terminate without returning.
 //!
 //! \sa CheckedReadFile
 //! \sa ReadFile
 void CheckedReadFileAtEOF(FileHandle file);
 
 //! \brief Wraps `open()` or `CreateFile()`, opening an existing file for
-//!     reading. Logs an error if the operation fails.
+//!     reading.
 //!
 //! \return The newly opened FileHandle, or an invalid FileHandle on failure.
 //!
 //! \sa ScopedFileHandle
-FileHandle LoggingOpenFileForRead(const base::FilePath& path);
+//! \sa OpenFileForWrite
+//! \sa OpenFileForReadAndWrite
+//! \sa LoggingOpenFileForRead
+FileHandle OpenFileForRead(const base::FilePath& path);
 
-//! \brief Wraps `open()` or `CreateFile()`, creating a file for output. Logs
-//!     an error if the operation fails.
+//! \brief Wraps `open()` or `CreateFile()`, creating a file for output.
 //!
 //! \a mode determines the style (truncate, reuse, etc.) that is used to open
 //! the file. On POSIX, \a permissions determines the value that is passed as
 //! `mode` to `open()`. On Windows, the file is always opened in binary mode
 //! (that is, no CRLF translation). On Windows, the file is opened for sharing,
 //! see LoggingLockFile() and LoggingUnlockFile() to control concurrent access.
 //!
 //! \return The newly opened FileHandle, or an invalid FileHandle on failure.
 //!
-//! \sa FileWriteMode
-//! \sa FilePermissions
 //! \sa ScopedFileHandle
-FileHandle LoggingOpenFileForWrite(const base::FilePath& path,
-                                   FileWriteMode mode,
-                                   FilePermissions permissions);
+//! \sa OpenFileForRead
+//! \sa OpenFileForReadAndWrite
+//! \sa LoggingOpenFileForWrite
+FileHandle OpenFileForWrite(const base::FilePath& path,
+                            FileWriteMode mode,
+                            FilePermissions permissions);
 
 //! \brief Wraps `open()` or `CreateFile()`, creating a file for both input and
-//!     output. Logs an error if the operation fails.
+//!     output.
 //!
 //! \a mode determines the style (truncate, reuse, etc.) that is used to open
 //! the file. On POSIX, \a permissions determines the value that is passed as
 //! `mode` to `open()`. On Windows, the file is always opened in binary mode
 //! (that is, no CRLF translation). On Windows, the file is opened for sharing,
 //! see LoggingLockFile() and LoggingUnlockFile() to control concurrent access.
 //!
 //! \return The newly opened FileHandle, or an invalid FileHandle on failure.
 //!
-//! \sa FileWriteMode
-//! \sa FilePermissions
 //! \sa ScopedFileHandle
+//! \sa OpenFileForRead
+//! \sa OpenFileForWrite
+//! \sa LoggingOpenFileForReadAndWrite
+FileHandle OpenFileForReadAndWrite(const base::FilePath& path,
+                                   FileWriteMode mode,
+                                   FilePermissions permissions);
+
+//! \brief Wraps OpenFileForRead(), logging an error if the operation fails.
+//!
+//! \return The newly opened FileHandle, or an invalid FileHandle on failure.
+//!
+//! \sa ScopedFileHandle
+//! \sa LoggingOpenFileForWrite
+//! \sa LoggingOpenFileForReadAndWrite
+FileHandle LoggingOpenFileForRead(const base::FilePath& path);
+
+//! \brief Wraps OpenFileForWrite(), logging an error if the operation fails.
+//!
+//! \return The newly opened FileHandle, or an invalid FileHandle on failure.
+//!
+//! \sa ScopedFileHandle
+//! \sa LoggingOpenFileForRead
+//! \sa LoggingOpenFileForReadAndWrite
+FileHandle LoggingOpenFileForWrite(const base::FilePath& path,
+                                   FileWriteMode mode,
+                                   FilePermissions permissions);
+
+//! \brief Wraps OpenFileForReadAndWrite(), logging an error if the operation
+//!     fails.
+//!
+//! \return The newly opened FileHandle, or an invalid FileHandle on failure.
+//!
+//! \sa ScopedFileHandle
+//! \sa LoggingOpenFileForRead
+//! \sa LoggingOpenFileForWrite
 FileHandle LoggingOpenFileForReadAndWrite(const base::FilePath& path,
                                           FileWriteMode mode,
                                           FilePermissions permissions);
 
 //! \brief Locks the given \a file using `flock()` on POSIX or `LockFileEx()` on
 //!     Windows.
 //!
 //! It is an error to attempt to lock a file in a different mode when it is
 //! already locked. This call will block until the lock is acquired. The
 //! entire file is locked.
@@ skipping 45 matching lines @@
 
 //! \brief Wraps `close()` or `CloseHandle()`, ensuring that it succeeds.
 //!
 //! If the underlying function fails, this function causes execution to
 //! terminate without returning.
 void CheckedCloseFile(FileHandle file);
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_UTIL_FILE_FILE_IO_H_