Add Locking calls to file_io.h plus implementations and test

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 84 matching lines @@
     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, 0, nullptr,
-                           disposition, FILE_ATTRIBUTE_NORMAL, nullptr);
+  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;
 }
 
+bool LoggingLockFile(FileHandle file, FileLocking locking) {
+  DWORD flags =
+      locking == FileLocking::kExclusive ? LOCKFILE_EXCLUSIVE_LOCK : 0;

[Robert Sesek, 2015/03/12 15:28:03]

nit: () around condition

[scottmg, 2015/03/19 22:06:20]

Done.

+
+  // 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};
+  if (!LockFileEx(file, flags, 0, MAXDWORD, MAXDWORD, &overlapped)) {
+    PLOG(ERROR) << "LockFileEx";
+    return false;
+  }
+  return true;
+}
+
+bool LoggingUnlockFile(FileHandle file) {
+  // 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};
+  if (!UnlockFileEx(file, 0, MAXDWORD, MAXDWORD, &overlapped)) {
+    PLOG(ERROR) << "LockFileEx";
+    return false;
+  }
+  return true;
+}
+
 FileOffset LoggingSeekFile(FileHandle file, FileOffset offset, int whence) {
   DWORD method = 0;
   switch (whence) {
     case SEEK_SET:
       method = FILE_BEGIN;
       break;
     case SEEK_CUR:
       method = FILE_CURRENT;
       break;
     case SEEK_END:
@@ skipping 15 matching lines @@
   return new_offset.QuadPart;
 }
 
 bool LoggingCloseFile(FileHandle file) {
   BOOL rv = CloseHandle(file);
   PLOG_IF(ERROR, !rv) << "CloseHandle";
   return rv;
 }
 
 }  // namespace crashpad