Use LockFile/UnlockFile for Settings to port to Windows

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 16 matching lines @@
     // socket.
     return !GetNamedPipeInfo(file, NULL, NULL, NULL, NULL);
   }
   return false;
 }
 
 }  // namespace
 
 namespace crashpad {
 
+namespace {
+
+FileHandle LoggingOpenFileForOutput(DWORD access,
+                                    const base::FilePath& path,
+                                    FileWriteMode mode,
+                                    FilePermissions permissions) {
+  DWORD disposition = 0;
+  switch (mode) {
+    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 "
+                                               << path.value().c_str();
+  return file;
+}
+
+}  // 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;
   char* buffer_c = reinterpret_cast<char*>(buffer);
   while (size_dword > 0) {
     DWORD bytes_read;
     BOOL success = ::ReadFile(file, buffer_c, size_dword, &bytes_read, nullptr);
@@ skipping 41 matching lines @@
                            0,
                            nullptr);
   PLOG_IF(ERROR, file == INVALID_HANDLE_VALUE) << "CreateFile "
                                                << path.value().c_str();
   return file;
 }
 
 FileHandle LoggingOpenFileForWrite(const base::FilePath& path,
                                    FileWriteMode mode,
                                    FilePermissions permissions) {
-  DWORD disposition = 0;
-  switch (mode) {
-    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(),
-                           GENERIC_WRITE,
-                           FILE_SHARE_READ | FILE_SHARE_WRITE,
-                           nullptr,
-                           disposition,
-                           FILE_ATTRIBUTE_NORMAL,
-                           nullptr);
-  PLOG_IF(ERROR, file == INVALID_HANDLE_VALUE) << "CreateFile "
-                                               << path.value().c_str();
-  return file;
+  return LoggingOpenFileForOutput(GENERIC_WRITE, path, mode, permissions);
+}
+
+FileHandle LoggingOpenFileForReadAndWrite(const base::FilePath& path,
+                                          FileWriteMode mode,
+                                          FilePermissions permissions) {
+  return LoggingOpenFileForOutput(
+      GENERIC_READ | GENERIC_WRITE, path, mode, permissions);
 }
 
 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 37 matching lines @@
   distance_to_move.QuadPart = offset;
   LARGE_INTEGER new_offset;
   BOOL result = SetFilePointerEx(file, distance_to_move, &new_offset, method);
   if (!result) {
     PLOG(ERROR) << "SetFilePointerEx";
     return -1;
   }
   return new_offset.QuadPart;
 }
 
+bool LoggingTruncateFile(FileHandle file) {
+  if (LoggingSeekFile(file, 0, SEEK_SET) != 0)
+    return false;
+  if (!SetEndOfFile(file)) {
+    PLOG(ERROR) << "SetEndOfFile";
+    return false;
+  }
+  return true;
+}
+
 bool LoggingCloseFile(FileHandle file) {
   BOOL rv = CloseHandle(file);
   PLOG_IF(ERROR, !rv) << "CloseHandle";
   return rv;
 }
 
 }  // namespace crashpad