Add m-esr52 at 52.6.0

1 files changed, 437 insertions, 0 deletions

diff --git a/toolkit/components/osfile/modules/osfile_win_back.jsm b/toolkit/components/osfile/modules/osfile_win_back.jsm
new file mode 100644
index 000000000..21172b6bf
--- /dev/null
+++ b/toolkit/components/osfile/modules/osfile_win_back.jsm
@@ -0,0 +1,437 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * This file can be used in the following contexts:
+ *
+ *  1. included from a non-osfile worker thread using importScript
+ *   (it serves to define a synchronous API for that worker thread)
+ *   (bug 707681)
+ *
+ *  2. included from the main thread using Components.utils.import
+ *   (it serves to define the asynchronous API, whose implementation
+ *    resides in the worker thread)
+ *   (bug 729057)
+ *
+ * 3. included from the osfile worker thread using importScript
+ *   (it serves to define the implementation of the asynchronous API)
+ *   (bug 729057)
+ */
+
+{
+  if (typeof Components != "undefined") {
+    // We do not wish osfile_win.jsm to be used directly as a main thread
+    // module yet. When time comes, it will be loaded by a combination of
+    // a main thread front-end/worker thread implementation that makes sure
+    // that we are not executing synchronous IO code in the main thread.
+
+    throw new Error("osfile_win.jsm cannot be used from the main thread yet");
+  }
+
+  (function(exports) {
+     "use strict";
+     if (exports.OS && exports.OS.Win && exports.OS.Win.File) {
+       return; // Avoid double initialization
+     }
+
+     let SharedAll = require("resource://gre/modules/osfile/osfile_shared_allthreads.jsm");
+     let SysAll = require("resource://gre/modules/osfile/osfile_win_allthreads.jsm");
+     let LOG = SharedAll.LOG.bind(SharedAll, "Unix", "back");
+     let libc = SysAll.libc;
+     let advapi32 = new SharedAll.Library("advapi32", "advapi32.dll");
+     let Const = SharedAll.Constants.Win;
+
+     /**
+      * Initialize the Windows module.
+      *
+      * @param {function=} declareFFI
+      */
+     // FIXME: Both |init| and |aDeclareFFI| are deprecated, we should remove them
+     let init = function init(aDeclareFFI) {
+       let declareFFI;
+       if (aDeclareFFI) {
+         declareFFI = aDeclareFFI.bind(null, libc);
+       } else {
+         declareFFI = SysAll.declareFFI;
+       }
+       let declareLazyFFI = SharedAll.declareLazyFFI;
+
+       // Initialize types that require additional OS-specific
+       // support - either finalization or matching against
+       // OS-specific constants.
+       let Type = Object.create(SysAll.Type);
+       let SysFile = exports.OS.Win.File = { Type: Type };
+
+       // Initialize types
+
+       /**
+        * A C integer holding INVALID_HANDLE_VALUE in case of error or
+        * a file descriptor in case of success.
+        */
+       Type.HANDLE =
+         Type.voidptr_t.withName("HANDLE");
+       Type.HANDLE.importFromC = function importFromC(maybe) {
+         if (Type.int.cast(maybe).value == INVALID_HANDLE) {
+           // Ensure that API clients can effectively compare against
+           // Const.INVALID_HANDLE_VALUE. Without this cast,
+           // == would always return |false|.
+           return INVALID_HANDLE;
+         }
+         return ctypes.CDataFinalizer(maybe, this.finalizeHANDLE);
+       };
+       Type.HANDLE.finalizeHANDLE = function placeholder() {
+         throw new Error("finalizeHANDLE should be implemented");
+       };
+       let INVALID_HANDLE = Const.INVALID_HANDLE_VALUE;
+
+       Type.file_HANDLE = Type.HANDLE.withName("file HANDLE");
+       SharedAll.defineLazyGetter(Type.file_HANDLE,
+         "finalizeHANDLE",
+         function() {
+           return SysFile._CloseHandle;
+         });
+
+       Type.find_HANDLE = Type.HANDLE.withName("find HANDLE");
+       SharedAll.defineLazyGetter(Type.find_HANDLE,
+         "finalizeHANDLE",
+         function() {
+           return SysFile._FindClose;
+         });
+
+       Type.DWORD = Type.uint32_t.withName("DWORD");
+
+       /* A special type used to represent flags passed as DWORDs to a function.
+        * In JavaScript, bitwise manipulation of numbers, such as or-ing flags,
+        * can produce negative numbers. Since DWORD is unsigned, these negative
+        * numbers simply cannot be converted to DWORD. For this reason, whenever
+        * bit manipulation is called for, you should rather use DWORD_FLAGS,
+        * which is represented as a signed integer, hence has the correct
+        * semantics.
+        */
+       Type.DWORD_FLAGS = Type.int32_t.withName("DWORD_FLAGS");
+
+       /**
+        * A C integer holding 0 in case of error or a positive integer
+        * in case of success.
+        */
+       Type.zero_or_DWORD =
+         Type.DWORD.withName("zero_or_DWORD");
+
+       /**
+        * A C integer holding 0 in case of error, any other value in
+        * case of success.
+        */
+       Type.zero_or_nothing =
+         Type.int.withName("zero_or_nothing");
+
+       /**
+        * A C integer holding flags related to NTFS security.
+        */
+       Type.SECURITY_ATTRIBUTES =
+         Type.void_t.withName("SECURITY_ATTRIBUTES");
+
+       /**
+        * A C integer holding pointers related to NTFS security.
+        */
+       Type.PSID =
+         Type.voidptr_t.withName("PSID");
+
+       Type.PACL =
+         Type.voidptr_t.withName("PACL");
+
+       Type.PSECURITY_DESCRIPTOR =
+         Type.voidptr_t.withName("PSECURITY_DESCRIPTOR");
+
+       /**
+        * A C integer holding Win32 local memory handle.
+        */
+       Type.HLOCAL =
+         Type.voidptr_t.withName("HLOCAL");
+
+       Type.FILETIME =
+         new SharedAll.Type("FILETIME",
+                  ctypes.StructType("FILETIME", [
+                  { lo: Type.DWORD.implementation },
+                  { hi: Type.DWORD.implementation }]));
+
+       Type.FindData =
+         new SharedAll.Type("FIND_DATA",
+                  ctypes.StructType("FIND_DATA", [
+                    { dwFileAttributes: ctypes.uint32_t },
+                    { ftCreationTime:   Type.FILETIME.implementation },
+                    { ftLastAccessTime: Type.FILETIME.implementation },
+                    { ftLastWriteTime:  Type.FILETIME.implementation },
+                    { nFileSizeHigh:    Type.DWORD.implementation },
+                    { nFileSizeLow:     Type.DWORD.implementation },
+                    { dwReserved0:      Type.DWORD.implementation },
+                    { dwReserved1:      Type.DWORD.implementation },
+                    { cFileName:        ctypes.ArrayType(ctypes.char16_t, Const.MAX_PATH) },
+                    { cAlternateFileName: ctypes.ArrayType(ctypes.char16_t, 14) }
+                      ]));
+
+       Type.FILE_INFORMATION =
+         new SharedAll.Type("FILE_INFORMATION",
+                  ctypes.StructType("FILE_INFORMATION", [
+                    { dwFileAttributes: ctypes.uint32_t },
+                    { ftCreationTime:   Type.FILETIME.implementation },
+                    { ftLastAccessTime: Type.FILETIME.implementation },
+                    { ftLastWriteTime:  Type.FILETIME.implementation },
+                    { dwVolumeSerialNumber: ctypes.uint32_t },
+                    { nFileSizeHigh:    Type.DWORD.implementation },
+                    { nFileSizeLow:     Type.DWORD.implementation },
+                    { nNumberOfLinks:   ctypes.uint32_t },
+                    { nFileIndex: ctypes.uint64_t }
+                   ]));
+
+       Type.SystemTime =
+         new SharedAll.Type("SystemTime",
+                  ctypes.StructType("SystemTime", [
+                  { wYear:      ctypes.int16_t },
+                  { wMonth:     ctypes.int16_t },
+                  { wDayOfWeek: ctypes.int16_t },
+                  { wDay:       ctypes.int16_t },
+                  { wHour:      ctypes.int16_t },
+                  { wMinute:    ctypes.int16_t },
+                  { wSecond:    ctypes.int16_t },
+                  { wMilliSeconds: ctypes.int16_t }
+                  ]));
+
+       // Special case: these functions are used by the
+       // finalizer
+       libc.declareLazy(SysFile, "_CloseHandle",
+                        "CloseHandle", ctypes.winapi_abi,
+                        /*return */ctypes.bool,
+                        /*handle*/ ctypes.voidptr_t);
+
+       SysFile.CloseHandle = function(fd) {
+         if (fd == INVALID_HANDLE) {
+           return true;
+         } else {
+           return fd.dispose(); // Returns the value of |CloseHandle|.
+         }
+       };
+
+       libc.declareLazy(SysFile, "_FindClose",
+                        "FindClose", ctypes.winapi_abi,
+                        /*return */ctypes.bool,
+                        /*handle*/ ctypes.voidptr_t);
+
+       SysFile.FindClose = function(handle) {
+         if (handle == INVALID_HANDLE) {
+           return true;
+         } else {
+           return handle.dispose(); // Returns the value of |FindClose|.
+         }
+       };
+
+       // Declare libc functions as functions of |OS.Win.File|
+
+       libc.declareLazyFFI(SysFile, "CopyFile",
+         "CopyFileW", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*sourcePath*/ Type.path,
+                    /*destPath*/   Type.path,
+                    /*bailIfExist*/Type.bool);
+
+       libc.declareLazyFFI(SysFile, "CreateDirectory",
+         "CreateDirectoryW", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*name*/   Type.char16_t.in_ptr,
+                    /*security*/Type.SECURITY_ATTRIBUTES.in_ptr);
+
+       libc.declareLazyFFI(SysFile, "CreateFile",
+         "CreateFileW", ctypes.winapi_abi,
+                    /*return*/  Type.file_HANDLE,
+                    /*name*/    Type.path,
+                    /*access*/  Type.DWORD_FLAGS,
+                    /*share*/   Type.DWORD_FLAGS,
+                    /*security*/Type.SECURITY_ATTRIBUTES.in_ptr,
+                    /*creation*/Type.DWORD_FLAGS,
+                    /*flags*/   Type.DWORD_FLAGS,
+                    /*template*/Type.HANDLE);
+
+       libc.declareLazyFFI(SysFile, "DeleteFile",
+         "DeleteFileW", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*path*/   Type.path);
+
+       libc.declareLazyFFI(SysFile, "FileTimeToSystemTime",
+         "FileTimeToSystemTime", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*filetime*/Type.FILETIME.in_ptr,
+                    /*systime*/ Type.SystemTime.out_ptr);
+
+       libc.declareLazyFFI(SysFile, "SystemTimeToFileTime",
+         "SystemTimeToFileTime", ctypes.winapi_abi,
+                    /*return*/   Type.zero_or_nothing,
+                    /*systime*/  Type.SystemTime.in_ptr,
+                    /*filetime*/ Type.FILETIME.out_ptr);
+
+       libc.declareLazyFFI(SysFile, "FindFirstFile",
+         "FindFirstFileW", ctypes.winapi_abi,
+                    /*return*/ Type.find_HANDLE,
+                    /*pattern*/Type.path,
+                    /*data*/   Type.FindData.out_ptr);
+
+       libc.declareLazyFFI(SysFile, "FindNextFile",
+         "FindNextFileW", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*prev*/   Type.find_HANDLE,
+                    /*data*/   Type.FindData.out_ptr);
+
+       libc.declareLazyFFI(SysFile, "FormatMessage",
+         "FormatMessageW", ctypes.winapi_abi,
+                    /*return*/ Type.DWORD,
+                    /*flags*/  Type.DWORD_FLAGS,
+                    /*source*/ Type.void_t.in_ptr,
+                    /*msgid*/  Type.DWORD_FLAGS,
+                    /*langid*/ Type.DWORD_FLAGS,
+                    /*buf*/    Type.out_wstring,
+                    /*size*/   Type.DWORD,
+                    /*Arguments*/Type.void_t.in_ptr
+                   );
+
+       libc.declareLazyFFI(SysFile, "GetCurrentDirectory",
+         "GetCurrentDirectoryW", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_DWORD,
+                    /*length*/ Type.DWORD,
+                    /*buf*/    Type.out_path
+                   );
+
+       libc.declareLazyFFI(SysFile, "GetFullPathName",
+         "GetFullPathNameW", ctypes.winapi_abi,
+                    /*return*/   Type.zero_or_DWORD,
+                    /*fileName*/ Type.path,
+                    /*length*/   Type.DWORD,
+                    /*buf*/      Type.out_path,
+                    /*filePart*/ Type.DWORD
+                   );
+
+       libc.declareLazyFFI(SysFile, "GetDiskFreeSpaceEx",
+         "GetDiskFreeSpaceExW", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*directoryName*/ Type.path,
+                    /*freeBytesForUser*/ Type.uint64_t.out_ptr,
+                    /*totalBytesForUser*/ Type.uint64_t.out_ptr,
+                    /*freeTotalBytesOnDrive*/ Type.uint64_t.out_ptr);
+
+       libc.declareLazyFFI(SysFile, "GetFileInformationByHandle",
+         "GetFileInformationByHandle", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*handle*/ Type.HANDLE,
+                    /*info*/   Type.FILE_INFORMATION.out_ptr);
+
+       libc.declareLazyFFI(SysFile, "MoveFileEx",
+         "MoveFileExW", ctypes.winapi_abi,
+                    /*return*/   Type.zero_or_nothing,
+                    /*sourcePath*/ Type.path,
+                    /*destPath*/ Type.path,
+                    /*flags*/    Type.DWORD
+                   );
+
+       libc.declareLazyFFI(SysFile, "ReadFile",
+         "ReadFile", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*file*/   Type.HANDLE,
+                    /*buffer*/ Type.voidptr_t,
+                    /*nbytes*/ Type.DWORD,
+                    /*nbytes_read*/Type.DWORD.out_ptr,
+                    /*overlapped*/Type.void_t.inout_ptr // FIXME: Implement?
+         );
+
+       libc.declareLazyFFI(SysFile, "RemoveDirectory",
+         "RemoveDirectoryW", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*path*/   Type.path);
+
+       libc.declareLazyFFI(SysFile, "SetCurrentDirectory",
+         "SetCurrentDirectoryW", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*path*/   Type.path
+                   );
+
+       libc.declareLazyFFI(SysFile, "SetEndOfFile",
+         "SetEndOfFile", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*file*/   Type.HANDLE);
+
+       libc.declareLazyFFI(SysFile, "SetFilePointer",
+         "SetFilePointer", ctypes.winapi_abi,
+                    /*return*/ Type.DWORD,
+                    /*file*/   Type.HANDLE,
+                    /*distlow*/Type.long,
+                    /*disthi*/ Type.long.in_ptr,
+                    /*method*/ Type.DWORD);
+
+       libc.declareLazyFFI(SysFile, "SetFileTime",
+         "SetFileTime",  ctypes.winapi_abi,
+                    /*return*/   Type.zero_or_nothing,
+                    /*file*/     Type.HANDLE,
+                    /*creation*/ Type.FILETIME.in_ptr,
+                    /*access*/   Type.FILETIME.in_ptr,
+                    /*write*/    Type.FILETIME.in_ptr);
+
+
+       libc.declareLazyFFI(SysFile, "WriteFile",
+         "WriteFile", ctypes.winapi_abi,
+                    /*return*/ Type.zero_or_nothing,
+                    /*file*/   Type.HANDLE,
+                    /*buffer*/ Type.voidptr_t,
+                    /*nbytes*/ Type.DWORD,
+                    /*nbytes_wr*/Type.DWORD.out_ptr,
+                    /*overlapped*/Type.void_t.inout_ptr // FIXME: Implement?
+         );
+
+        libc.declareLazyFFI(SysFile, "FlushFileBuffers",
+          "FlushFileBuffers", ctypes.winapi_abi,
+                     /*return*/ Type.zero_or_nothing,
+                     /*file*/   Type.HANDLE);
+
+        libc.declareLazyFFI(SysFile, "GetFileAttributes",
+          "GetFileAttributesW", ctypes.winapi_abi,
+                     /*return*/   Type.DWORD_FLAGS,
+                     /*fileName*/ Type.path);
+
+        libc.declareLazyFFI(SysFile, "SetFileAttributes",
+          "SetFileAttributesW", ctypes.winapi_abi,
+                     /*return*/         Type.zero_or_nothing,
+                     /*fileName*/       Type.path,
+                     /*fileAttributes*/ Type.DWORD_FLAGS);
+
+        advapi32.declareLazyFFI(SysFile, "GetNamedSecurityInfo",
+          "GetNamedSecurityInfoW", ctypes.winapi_abi,
+                     /*return*/       Type.DWORD,
+                     /*objectName*/   Type.path,
+                     /*objectType*/   Type.DWORD,
+                     /*securityInfo*/ Type.DWORD,
+                     /*sidOwner*/     Type.PSID.out_ptr,
+                     /*sidGroup*/     Type.PSID.out_ptr,
+                     /*dacl*/         Type.PACL.out_ptr,
+                     /*sacl*/         Type.PACL.out_ptr,
+                     /*securityDesc*/ Type.PSECURITY_DESCRIPTOR.out_ptr);
+
+        advapi32.declareLazyFFI(SysFile, "SetNamedSecurityInfo",
+          "SetNamedSecurityInfoW", ctypes.winapi_abi,
+                     /*return*/       Type.DWORD,
+                     /*objectName*/   Type.path,
+                     /*objectType*/   Type.DWORD,
+                     /*securityInfo*/ Type.DWORD,
+                     /*sidOwner*/     Type.PSID,
+                     /*sidGroup*/     Type.PSID,
+                     /*dacl*/         Type.PACL,
+                     /*sacl*/         Type.PACL);
+
+        libc.declareLazyFFI(SysFile, "LocalFree",
+          "LocalFree", ctypes.winapi_abi,
+                     /*return*/       Type.HLOCAL,
+                     /*mem*/          Type.HLOCAL);
+     };
+
+     exports.OS.Win = {
+       File: {
+           _init:  init
+       }
+     };
+   })(this);
+}