Implement serial API for Windows.

base/platform_file_posix.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/platform_file.h"
 
 #include <fcntl.h>
 #include <errno.h>
 #include <sys/stat.h>
 #include <unistd.h>
@@ skipping 60 matching lines @@
   if (flags & PLATFORM_FILE_WRITE && flags & PLATFORM_FILE_READ) {
     open_flags |= O_RDWR;
   } else if (flags & PLATFORM_FILE_WRITE) {
     open_flags |= O_WRONLY;
   } else if (!(flags & PLATFORM_FILE_READ) &&
              !(flags & PLATFORM_FILE_WRITE_ATTRIBUTES) &&
              !(flags & PLATFORM_FILE_OPEN_ALWAYS)) {
     NOTREACHED();
   }
 
+  if (flags & PLATFORM_FILE_TERMINAL_DEVICE)
+    open_flags |= O_NOCTTY | O_NDELAY;
+
   COMPILE_ASSERT(O_RDONLY == 0, O_RDONLY_must_equal_zero);
 
   int mode = S_IRUSR | S_IWUSR;
 #if defined(OS_CHROMEOS)
   mode |= S_IRGRP | S_IROTH;
 #endif
 
   int descriptor =
       HANDLE_EINTR(open(name.value().c_str(), open_flags, mode));
 
@@ skipping 77 matching lines @@
                             size - bytes_read, offset + bytes_read));
     if (rv <= 0)
       break;
 
     bytes_read += rv;
   } while (bytes_read < size);
 
   return bytes_read ? bytes_read : rv;
 }
 
+int ReadPlatformFileFromCurrentPos(PlatformFile file, char* data, int size) {
+  base::ThreadRestrictions::AssertIOAllowed();
+  if (file < 0 || size < 0)
+    return -1;
+
+  int bytes_read = 0;
+  int rv;
+  do {
+    rv = HANDLE_EINTR(read(file, data, size));
+    if (rv <= 0)
+      break;
+
+    bytes_read += rv;
+  } while (bytes_read < size);
+
+  return bytes_read ? bytes_read : rv;
+}
+
 int ReadPlatformFileNoBestEffort(PlatformFile file, int64 offset,
                                  char* data, int size) {
   base::ThreadRestrictions::AssertIOAllowed();
   if (file < 0)
     return -1;
 
   return HANDLE_EINTR(pread(file, data, size, offset));
 }
 
 int WritePlatformFile(PlatformFile file, int64 offset,
                       const char* data, int size) {
   base::ThreadRestrictions::AssertIOAllowed();
   if (file < 0 || size < 0)
     return -1;
 
   int bytes_written = 0;
   int rv;
   do {
     rv = HANDLE_EINTR(pwrite(file, data + bytes_written,
                              size - bytes_written, offset + bytes_written));
     if (rv <= 0)
       break;
 
     bytes_written += rv;
   } while (bytes_written < size);
 
   return bytes_written ? bytes_written : rv;
 }
 
+int WritePlatformFileFromCurrentPos(PlatformFile file,
+                                    const char* data, int size) {
+  base::ThreadRestrictions::AssertIOAllowed();
+  if (file < 0 || size < 0)
+    return -1;
+
+  int bytes_written = 0;
+  int rv;
+  do {
+    rv = HANDLE_EINTR(write(file, data, size));
+    if (rv <= 0)
+      break;
+
+    bytes_written += rv;
+  } while (bytes_written < size);
+
+  return bytes_written ? bytes_written : rv;
+}
+
 bool TruncatePlatformFile(PlatformFile file, int64 length) {
   base::ThreadRestrictions::AssertIOAllowed();
   return ((file >= 0) && !HANDLE_EINTR(ftruncate(file, length)));
 }
 
 bool FlushPlatformFile(PlatformFile file) {
   base::ThreadRestrictions::AssertIOAllowed();
   return !HANDLE_EINTR(fsync(file));
 }
 
@@ skipping 20 matching lines @@
   info->is_directory = S_ISDIR(file_info.st_mode);
   info->is_symbolic_link = S_ISLNK(file_info.st_mode);
   info->size = file_info.st_size;
   info->last_modified = base::Time::FromTimeT(file_info.st_mtime);
   info->last_accessed = base::Time::FromTimeT(file_info.st_atime);
   info->creation_time = base::Time::FromTimeT(file_info.st_ctime);
   return true;
 }
 
 }  // namespace base