Add non-logging OpenFileForWrite() and OpenFileForReadAndWrite()

util/file/file_io_win.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,
@@ skipping 19 matching lines @@
   }
   return false;
 }
 
 }  // namespace
 
 namespace crashpad {
 
 namespace {
 
-FileHandle LoggingOpenFileForOutput(DWORD access,
-                                    const base::FilePath& path,
-                                    FileWriteMode mode,
-                                    FilePermissions permissions) {
+FileHandle OpenFileForOutput(DWORD access,
+                             const base::FilePath& path,
+                             FileWriteMode mode,
+                             FilePermissions permissions) {
+  DCHECK(access & GENERIC_WRITE);
+  DCHECK_EQ(access & ~(GENERIC_READ | GENERIC_WRITE), 0u);
+
   DWORD disposition = 0;
   switch (mode) {
     case FileWriteMode::kReuseOrFail:
       disposition = OPEN_EXISTING;
       break;
     case FileWriteMode::kReuseOrCreate:
       disposition = OPEN_ALWAYS;
       break;
     case FileWriteMode::kTruncateOrCreate:
       disposition = CREATE_ALWAYS;
       break;
     case FileWriteMode::kCreateOrFail:
       disposition = CREATE_NEW;
       break;
   }
-  HANDLE file = CreateFile(path.value().c_str(),
-                           access,
-                           FILE_SHARE_READ | FILE_SHARE_WRITE,
-                           nullptr,
-                           disposition,
-                           FILE_ATTRIBUTE_NORMAL,
-                           nullptr);
-  PLOG_IF(ERROR, file == INVALID_HANDLE_VALUE)
-      << "CreateFile " << base::UTF16ToUTF8(path.value());
-  return file;
+  return CreateFile(path.value().c_str(),
+                    access,
+                    FILE_SHARE_READ | FILE_SHARE_WRITE,
+                    nullptr,
+                    disposition,
+                    FILE_ATTRIBUTE_NORMAL,
+                    nullptr);
 }
 
 }  // namespace
 
 // TODO(scottmg): Handle > DWORD sized writes if necessary.
 
 ssize_t ReadFile(FileHandle file, void* buffer, size_t size) {
   DCHECK(!IsSocketHandle(file));
   DWORD size_dword = base::checked_cast<DWORD>(size);
   DWORD total_read = 0;
@@ skipping 29 matching lines @@
   // network in the future.
   DWORD size_dword = base::checked_cast<DWORD>(size);
   DWORD bytes_written;
   BOOL rv = ::WriteFile(file, buffer, size_dword, &bytes_written, nullptr);
   if (!rv)
     return -1;
   CHECK_EQ(bytes_written, size_dword);
   return bytes_written;
 }
 
+FileHandle OpenFileForRead(const base::FilePath& path) {
+  return CreateFile(path.value().c_str(),
+                    GENERIC_READ,
+                    FILE_SHARE_READ | FILE_SHARE_WRITE,
+                    nullptr,
+                    OPEN_EXISTING,
+                    0,
+                    nullptr);
+}
+
+FileHandle OpenFileForWrite(const base::FilePath& path,
+                            FileWriteMode mode,
+                            FilePermissions permissions) {
+  return OpenFileForOutput(GENERIC_WRITE, path, mode, permissions);
+}
+
+FileHandle OpenFileForReadAndWrite(const base::FilePath& path,
+                                   FileWriteMode mode,
+                                   FilePermissions permissions) {
+  return OpenFileForOutput(
+      GENERIC_READ | GENERIC_WRITE, path, mode, permissions);
+}
+
 FileHandle LoggingOpenFileForRead(const base::FilePath& path) {
-  HANDLE file = CreateFile(path.value().c_str(),
-                           GENERIC_READ,
-                           FILE_SHARE_READ | FILE_SHARE_WRITE,
-                           nullptr,
-                           OPEN_EXISTING,
-                           0,
-                           nullptr);
+  FileHandle file = OpenFileForRead(path);
   PLOG_IF(ERROR, file == INVALID_HANDLE_VALUE)
       << "CreateFile " << base::UTF16ToUTF8(path.value());
   return file;
 }
 
 FileHandle LoggingOpenFileForWrite(const base::FilePath& path,
                                    FileWriteMode mode,
                                    FilePermissions permissions) {
-  return LoggingOpenFileForOutput(GENERIC_WRITE, path, mode, permissions);
+  FileHandle file = OpenFileForWrite(path, mode, permissions);
+  PLOG_IF(ERROR, file == INVALID_HANDLE_VALUE)
+      << "CreateFile " << base::UTF16ToUTF8(path.value());
+  return file;
 }
 
 FileHandle LoggingOpenFileForReadAndWrite(const base::FilePath& path,
                                           FileWriteMode mode,
                                           FilePermissions permissions) {
-  return LoggingOpenFileForOutput(
-      GENERIC_READ | GENERIC_WRITE, path, mode, permissions);
+  FileHandle file = OpenFileForReadAndWrite(path, mode, permissions);
+  PLOG_IF(ERROR, file == INVALID_HANDLE_VALUE)
+      << "CreateFile " << base::UTF16ToUTF8(path.value());
+  return file;
 }
 
 bool LoggingLockFile(FileHandle file, FileLocking locking) {
   DWORD flags =
       (locking == FileLocking::kExclusive) ? LOCKFILE_EXCLUSIVE_LOCK : 0;
 
   // Note that the `Offset` fields of overlapped indicate the start location for
   // locking (beginning of file in this case), and `hEvent` must be also be set
   // to 0.
   OVERLAPPED overlapped = {0};
@@ skipping 54 matching lines @@
   return true;
 }
 
 bool LoggingCloseFile(FileHandle file) {
   BOOL rv = CloseHandle(file);
   PLOG_IF(ERROR, !rv) << "CloseHandle";
   return rv;
 }
 
 }  // namespace crashpad