Add support for file locking

runtime/bin/file_win.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/file.h"
 
 #include <fcntl.h>  // NOLINT
 #include <io.h>  // NOLINT
 #include <stdio.h>  // NOLINT
 #include <string.h>  // NOLINT
 #include <sys/stat.h>  // NOLINT
 #include <WinIoCtl.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/log.h"
 #include "bin/utils.h"
+#include "platform/utils.h"
 
 
 namespace dart {
 namespace bin {
 
 class FileHandle {
  public:
   explicit FileHandle(int fd) : fd_(fd) { }
   ~FileHandle() { }
   int fd() const { return fd_; }
@@ skipping 68 matching lines @@
   return _chsize_s(handle_->fd(), length) == 0;
 }
 
 
 bool File::Flush() {
   ASSERT(handle_->fd());
   return _commit(handle_->fd()) != -1;
 }
 
 
+bool File::Lock(File::LockType lock, int64_t start, int64_t end) {
+  ASSERT(handle_->fd() >= 0);
+  ASSERT(end == -1 || end > start);
+  HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(handle_->fd()));
+  OVERLAPPED overlapped;
+  ZeroMemory(&overlapped, sizeof(OVERLAPPED));
+
+  overlapped.Offset = Utils::Low32Bits(start);
+  overlapped.OffsetHigh = Utils::High32Bits(start);
+
+  int64_t length = end == -1 ? 0 : end - start;
+  if (length == 0) length = kMaxInt64;
+  int32_t length_low = Utils::Low32Bits(length);
+  int32_t length_high = Utils::High32Bits(length);
+
+
+  BOOL rc;
+  switch (lock) {
+    case File::kLockUnlock:
+      rc = UnlockFileEx(handle, 0, length_low, length_high, &overlapped);
+      break;
+    case File::kLockShared:
+    case File::kLockExclusive: {
+      DWORD flags = LOCKFILE_FAIL_IMMEDIATELY;
+      if (lock == File::kLockExclusive) {
+        flags |= LOCKFILE_EXCLUSIVE_LOCK;
+      }
+      rc = LockFileEx(handle, flags, 0,
+                      length_low, length_high, &overlapped);
+      break;
+    }
+    default:
+      UNREACHABLE();
+  }
+  return rc;
+}
+
+
 int64_t File::Length() {
   ASSERT(handle_->fd() >= 0);
   struct __stat64 st;
   if (_fstat64(handle_->fd(), &st) == 0) {
     return st.st_size;
   }
   return -1;
 }
 
 
@@ skipping 312 matching lines @@
     SetLastError(ERROR_NOT_A_REPARSE_POINT);
     return NULL;
   }
 
   target_offset /= sizeof(wchar_t);  // Offset and length are in bytes.
   target_length /= sizeof(wchar_t);
   target += target_offset;
   // Remove "\??\" from beginning of target.
   if (target_length > 4 && wcsncmp(L"\\??\\", target, 4) == 0) {
     target += 4;
-    target_length -=4;
+    target_length -= 4;
   }
   int utf8_length = WideCharToMultiByte(CP_UTF8,
                                         0,
                                         target,
                                         target_length,
                                         NULL,
                                         0,
                                         NULL,
                                         NULL);
   char* utf8_target = reinterpret_cast<char*>(malloc(utf8_length + 1));
@@ skipping 194 matching lines @@
     return kIdentical;
   } else {
     return kDifferent;
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)