Initial version of new file wrapper

webrtc/base/file.cc

Index: webrtc/base/file.cc
diff --git a/webrtc/base/file.cc b/webrtc/base/file.cc
new file mode 100644
index 0000000000000000000000000000000000000000..37585446a7f83a4063338de0e7d4509e1cf587d2
--- /dev/null
+++ b/webrtc/base/file.cc
@@ -0,0 +1,184 @@
+/*
+ *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "webrtc/base/file.h"
+
+#include <limits>
+
+#if defined(WEBRTC_WIN)
+#include <io.h>
+#else
+#include <unistd.h>
+#include <errno.h>
+#endif
+
+namespace rtc {
+
+File::File(rtc::PlatformFile file) : file_(file) {}
+
+File::~File() {
+  Close();
+}
+
+size_t File::Write(const char* data, size_t length) {
+  size_t total_written = 0;
+  do {
+    size_t written =
+        WriteNoBestEffort(data + total_written, length - total_written);
+    if (written == 0)
+      break;
+    total_written += written;
+  } while (total_written < length);
+  return total_written;
+}

[sprang_webrtc, 2016/08/05 14:45:14]

nit: empty line between methods
here and elsewhere

[palmkvist, 2016/08/08 11:15:35]

Done.

+size_t File::Read(char* buffer, size_t length) {
+  size_t total_read = 0;
+  do {
+    size_t read = ReadNoBestEffort(buffer + total_read, length - total_read);
+    if (read == 0)
+      break;
+    total_read += read;
+  } while (total_read < length);
+  return total_read;
+}
+
+size_t File::WriteAt(const char* data, size_t length, size_t offset) {
+  size_t total_written = 0;
+  do {
+    size_t written = WriteAtNoBestEffort(
+        data + total_written, length - total_written, offset + total_written);
+    if (written == 0)
+      break;
+    total_written += written;
+  } while (total_written < length);
+  return total_written;
+}
+size_t File::ReadAt(char* buffer, size_t length, size_t offset) {
+  size_t total_read = 0;
+  do {
+    size_t read = ReadAtNoBestEffort(buffer + total_read, length - total_read,
+                                     offset + total_read);
+    if (read == 0)
+      break;
+    total_read += read;
+  } while (total_read < length);
+  return total_read;
+}
+
+#if defined(WEBRTC_WIN)

[sprang_webrtc, 2016/08/05 14:45:14]

If there's a large amount of code different between platforms, you may want to
have separate files for the implementations

[palmkvist, 2016/08/08 11:15:35]

Done.

+
+size_t File::WriteNoBestEffort(const char* data, size_t length) {
+  RTC_CHECK(length < std::numeric_limits<DWORD>::max());

[sprang_webrtc, 2016/08/05 14:45:14]

RTC_CHECK_LT

[palmkvist, 2016/08/08 11:15:35]

Done.

+  DWORD bytes_written;
+  if (::WriteFile(file_, data, static_cast<DWORD>(length), &bytes_written,
+                  NULL))

[sprang_webrtc, 2016/08/05 14:45:14]

nullptr

[palmkvist, 2016/08/08 11:15:35]

Done.

+    return size_t{bytes_written};

[sprang_webrtc, 2016/08/05 14:45:14]

wrap in {} if if-statement is multi-line

Don't think you need cast

+  return 0;
+}
+size_t File::ReadNoBestEffort(char* buffer, size_t length) {
+  RTC_CHECK(length < std::numeric_limits<DWORD>::max());
+  DWORD bytes_read;
+  if (::ReadFile(file_, buffer, static_cast<DWORD>(length), &bytes_read, NULL))
+    return size_t{bytes_read};
+  return 0;
+}
+
+size_t File::WriteAtNoBestEffort(const char* data,
+                                 size_t length,
+                                 size_t offset) {
+  RTC_CHECK(length < std::numeric_limits<DWORD>::max());
+  LARGE_INTEGER offset_li;
+  offset_li.QuadPart = offset;
+
+  OVERLAPPED overlapped = {0};
+  overlapped.Offset = offset_li.LowPart;
+  overlapped.OffsetHigh = offset_li.HighPart;
+
+  DWORD bytes_written;
+  if (::WriteFile(file_, data, static_cast<DWORD>(length), &bytes_written,
+                  &overlapped))
+    return size_t{bytes_written};
+  return 0;
+}
+size_t File::ReadAtNoBestEffort(char* data, size_t length, size_t offset) {
+  LARGE_INTEGER offest_li;
+  offset_li.QuadPart = offset;
+
+  OVERLAPPED overlapped = {0};
+  overlapped.Offset = offset_li.LowPart;
+  overlapped.OffsetHigh = offset_li.HighPart;
+
+  DWORD bytes_read;
+  if (::ReadFile(file_, data, length, &bytes_read, &overlapped))
+    return size_t{bytes_read};
+  return 0;
+}
+
+bool File::Seek(size_t offset) {
+  LARGE_INTEGER distance;
+  distance.QuadPart = offset;
+  return SetFilePointerEx(file_, distance, NULL, FILE_BEGIN) != 1;
+}
+
+bool File::Close() {
+  if (file_ == rtc::kInvalidPlatformFileValue)
+    return false;
+  bool ret = CloseHandle(file_) != 0;
+  file_ = rtc::kInvalidPlatformFileValue;
+  return ret;
+}
+
+#else
+
+#define HANDLE_EINTR(x)                                     \
+  ({                                                        \
+    decltype(x) eintr_wrapper_result;                       \
+    do {                                                    \
+      eintr_wrapper_result = (x);                           \
+    } while (eintr_wrapper_result == -1 && errno == EINTR); \
+    eintr_wrapper_result;                                   \
+  })

[sprang_webrtc, 2016/08/05 14:45:14]

Avoid macros if possible

[palmkvist, 2016/08/08 11:15:35]

It is possible, with some repetition (four times, so not a lot, but still). I
also intend to add logging if the loop runs too many times in debug mode
(whenever I figure out what the defined flag is), all of which obscures the
otherwise rather simple methods.

Are these strong enough arguments, or should I duplicate the code? (lambdas
would add unnecessary overhead, and since this is supposed to be an efficient
base wrapper I figure that's not ideal)

+
+size_t File::WriteNoBestEffort(const char* data, size_t length) {
+  ssize_t rv = HANDLE_EINTR(write(file_, data, length));
+  return rv < 0 ? 0 : size_t{rv};
+}
+size_t File::ReadNoBestEffort(char* buffer, size_t length) {
+  ssize_t rv = HANDLE_EINTR(read(file_, buffer, length));
+  return rv < 0 ? 0 : size_t{rv};
+}
+
+size_t File::WriteAtNoBestEffort(const char* data,
+                                 size_t length,
+                                 size_t offset) {
+  ssize_t rv = HANDLE_EINTR(pwrite(file_, data, length, offset));
+  return rv < 0 ? 0 : size_t{rv};
+}
+size_t File::ReadAtNoBestEffort(char* data, size_t length, size_t offset) {
+  ssize_t rv = HANDLE_EINTR(pread(file_, data, length, offset));
+  return rv < 0 ? 0 : size_t{rv};
+}
+
+bool File::Seek(size_t offset) {
+  static_assert(sizeof(size_t) <= sizeof(off_t), "size_t must fit in off_t");
+  return lseek(file_, off_t{offset}, SEEK_SET) != ((off_t)-1);
+}
+
+bool File::Close() {
+  if (file_ == rtc::kInvalidPlatformFileValue)
+    return false;
+  bool ret = close(file_) == 0;
+  file_ = rtc::kInvalidPlatformFileValue;
+  return ret;
+}
+
+#endif
+
+}  // namespace rtc