The Tor Browser: comparison toolkit/components/osfile/modules/osfile_win

--1:000000000000
+:22309564d719
+/* 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 module defines the thread-agnostic components of the Win version
+* of OS.File. It depends on the thread-agnostic cross-platform components
+* of OS.File.
+*
+* It serves the following purposes:
+* - open kernel32;
+* - define OS.Shared.Win.Error;
+* - define a few constants and types that need to be defined on all platforms.
+*
+* This module can be:
+* - opened from the main thread as a jsm module;
+* - opened from a chrome worker through require().
+*/
+"use strict";
+let SharedAll;
+if (typeof Components != "undefined") {
+let Cu = Components.utils;
+// Module is opened as a jsm module
+Cu.import("resource://gre/modules/ctypes.jsm", this);
+SharedAll = {};
+Cu.import("resource://gre/modules/osfile/osfile_shared_allthreads.jsm", SharedAll);
+this.exports = {};
+} else if (typeof "module" != "undefined" && typeof "require" != "undefined") {
+// Module is loaded with require()
+SharedAll = require("resource://gre/modules/osfile/osfile_shared_allthreads.jsm");
+} else {
+throw new Error("Please open this module with Component.utils.import or with require()");
+}
+let LOG = SharedAll.LOG.bind(SharedAll, "Win", "allthreads");
+let Const = SharedAll.Constants.Win;
+// Open libc
+let libc = new SharedAll.Library("libc", "kernel32.dll");
+exports.libc = libc;
+// Define declareFFI
+let declareFFI = SharedAll.declareFFI.bind(null, libc);
+exports.declareFFI = declareFFI;
+let Scope = {};
+// Define Error
+libc.declareLazy(Scope, "FormatMessage",
+"FormatMessageW", ctypes.winapi_abi,
+/*return*/ ctypes.uint32_t,
+/*flags*/  ctypes.uint32_t,
+/*source*/ ctypes.voidptr_t,
+/*msgid*/  ctypes.uint32_t,
+/*langid*/ ctypes.uint32_t,
+/*buf*/    ctypes.jschar.ptr,
+/*size*/   ctypes.uint32_t,
+/*Arguments*/ctypes.voidptr_t);
+/**
+* A File-related error.
+*
+* To obtain a human-readable error message, use method |toString|.
+* To determine the cause of the error, use the various |becauseX|
+* getters. To determine the operation that failed, use field
+* |operation|.
+*
+* Additionally, this implementation offers a field
+* |winLastError|, which holds the OS-specific error
+* constant. If you need this level of detail, you may match the value
+* of this field against the error constants of |OS.Constants.Win|.
+*
+* @param {string=} operation The operation that failed. If unspecified,
+* the name of the calling function is taken to be the operation that
+* failed.
+* @param {number=} lastError The OS-specific constant detailing the
+* reason of the error. If unspecified, this is fetched from the system
+* status.
+* @param {string=} path The file path that manipulated. If unspecified,
+* assign the empty string.
+*
+* @constructor
+* @extends {OS.Shared.Error}
+*/
+let OSError = function OSError(operation = "unknown operation",
+lastError = ctypes.winLastError, path = "") {
+operation = operation;
+SharedAll.OSError.call(this, operation, path);
+this.winLastError = lastError;
+};
+OSError.prototype = Object.create(SharedAll.OSError.prototype);
+OSError.prototype.toString = function toString() {
+let buf = new (ctypes.ArrayType(ctypes.jschar, 1024))();
+let result = Scope.FormatMessage(
+Const.FORMAT_MESSAGE_FROM_SYSTEM |
+Const.FORMAT_MESSAGE_IGNORE_INSERTS,
+null,
+/* The error number */ this.winLastError,
+/* Default language */ 0,
+/* Output buffer*/     buf,
+/* Minimum size of buffer */ 1024,
+/* Format args*/       null
+);
+if (!result) {
+buf = "additional error " +
+ctypes.winLastError +
+" while fetching system error message";
+}
+return "Win error " + this.winLastError + " during operation "
++ this.operation + (this.path? " on file " + this.path : "") +
+" (" + buf.readString() + ")";
+};
+/**
+* |true| if the error was raised because a file or directory
+* already exists, |false| otherwise.
+*/
+Object.defineProperty(OSError.prototype, "becauseExists", {
+get: function becauseExists() {
+return this.winLastError == Const.ERROR_FILE_EXISTS ||
+this.winLastError == Const.ERROR_ALREADY_EXISTS;
+}
+});
+/**
+* |true| if the error was raised because a file or directory
+* does not exist, |false| otherwise.
+*/
+Object.defineProperty(OSError.prototype, "becauseNoSuchFile", {
+get: function becauseNoSuchFile() {
+return this.winLastError == Const.ERROR_FILE_NOT_FOUND ||
+this.winLastError == Const.ERROR_PATH_NOT_FOUND;
+}
+});
+/**
+* |true| if the error was raised because a directory is not empty
+* does not exist, |false| otherwise.
+*/
+Object.defineProperty(OSError.prototype, "becauseNotEmpty", {
+get: function becauseNotEmpty() {
+return this.winLastError == Const.ERROR_DIR_NOT_EMPTY;
+}
+});
+/**
+* |true| if the error was raised because a file or directory
+* is closed, |false| otherwise.
+*/
+Object.defineProperty(OSError.prototype, "becauseClosed", {
+get: function becauseClosed() {
+return this.winLastError == Const.ERROR_INVALID_HANDLE;
+}
+});
+/**
+* |true| if the error was raised because permission is denied to
+* access a file or directory, |false| otherwise.
+*/
+Object.defineProperty(OSError.prototype, "becauseAccessDenied", {
+get: function becauseAccessDenied() {
+return this.winLastError == Const.ERROR_ACCESS_DENIED;
+}
+});
+/**
+* |true| if the error was raised because some invalid argument was passed,
+* |false| otherwise.
+*/
+Object.defineProperty(OSError.prototype, "becauseInvalidArgument", {
+get: function becauseInvalidArgument() {
+return this.winLastError == Const.ERROR_NOT_SUPPORTED ||
+this.winLastError == Const.ERROR_BAD_ARGUMENTS;
+}
+});
+/**
+* Serialize an instance of OSError to something that can be
+* transmitted across threads (not necessarily a string).
+*/
+OSError.toMsg = function toMsg(error) {
+return {
+operation: error.operation,
+winLastError: error.winLastError,
+path: error.path
+};
+};
+/**
+* Deserialize a message back to an instance of OSError
+*/
+OSError.fromMsg = function fromMsg(msg) {
+return new OSError(msg.operation, msg.winLastError, msg.path);
+};
+exports.Error = OSError;
+/**
+* Code shared by implementation of File.Info on Windows
+*
+* @constructor
+*/
+let AbstractInfo = function AbstractInfo(path, isDir, isSymLink, size,
+winBirthDate,
+lastAccessDate, lastWriteDate) {
+this._path = path;
+this._isDir = isDir;
+this._isSymLink = isSymLink;
+this._size = size;
+this._winBirthDate = winBirthDate;
+this._lastAccessDate = lastAccessDate;
+this._lastModificationDate = lastWriteDate;
+};
+AbstractInfo.prototype = {
+/**
+* The path of the file, used for error-reporting.
+*
+* @type {string}
+*/
+get path() {
+return this._path;
+},
+/**
+* |true| if this file is a directory, |false| otherwise
+*/
+get isDir() {
+return this._isDir;
+},
+/**
+* |true| if this file is a symbolic link, |false| otherwise
+*/
+get isSymLink() {
+return this._isSymLink;
+},
+/**
+* The size of the file, in bytes.
+*
+* Note that the result may be |NaN| if the size of the file cannot be
+* represented in JavaScript.
+*
+* @type {number}
+*/
+get size() {
+return this._size;
+},
+// Deprecated
+get creationDate() {
+return this._winBirthDate;
+},
+/**
+* The date of creation of this file.
+*
+* @type {Date}
+*/
+get winBirthDate() {
+return this._winBirthDate;
+},
+/**
+* The date of last access to this file.
+*
+* Note that the definition of last access may depend on the underlying
+* operating system and file system.
+*
+* @type {Date}
+*/
+get lastAccessDate() {
+return this._lastAccessDate;
+},
+/**
+* The date of last modification of this file.
+*
+* Note that the definition of last access may depend on the underlying
+* operating system and file system.
+*
+* @type {Date}
+*/
+get lastModificationDate() {
+return this._lastModificationDate;
+}
+};
+exports.AbstractInfo = AbstractInfo;
+/**
+* Code shared by implementation of File.DirectoryIterator.Entry on Windows
+*
+* @constructor
+*/
+let AbstractEntry = function AbstractEntry(isDir, isSymLink, name,
+winCreationDate, winLastWriteDate,
+winLastAccessDate, path) {
+this._isDir = isDir;
+this._isSymLink = isSymLink;
+this._name = name;
+this._winCreationDate = winCreationDate;
+this._winLastWriteDate = winLastWriteDate;
+this._winLastAccessDate = winLastAccessDate;
+this._path = path;
+};
+AbstractEntry.prototype = {
+/**
+* |true| if the entry is a directory, |false| otherwise
+*/
+get isDir() {
+return this._isDir;
+},
+/**
+* |true| if the entry is a symbolic link, |false| otherwise
+*/
+get isSymLink() {
+return this._isSymLink;
+},
+/**
+* The name of the entry.
+* @type {string}
+*/
+get name() {
+return this._name;
+},
+/**
+* The creation time of this file.
+* @type {Date}
+*/
+get winCreationDate() {
+return this._winCreationDate;
+},
+/**
+* The last modification time of this file.
+* @type {Date}
+*/
+get winLastWriteDate() {
+return this._winLastWriteDate;
+},
+/**
+* The last access time of this file.
+* @type {Date}
+*/
+get winLastAccessDate() {
+return this._winLastAccessDate;
+},
+/**
+* The full path of the entry
+* @type {string}
+*/
+get path() {
+return this._path;
+}
+};
+exports.AbstractEntry = AbstractEntry;
+// Special constants that need to be defined on all platforms
+exports.POS_START = Const.FILE_BEGIN;
+exports.POS_CURRENT = Const.FILE_CURRENT;
+exports.POS_END = Const.FILE_END;
+// Special types that need to be defined for communication
+// between threads
+let Type = Object.create(SharedAll.Type);
+exports.Type = Type;
+/**
+* Native paths
+*
+* Under Windows, expressed as wide strings
+*/
+Type.path = Type.wstring.withName("[in] path");
+Type.out_path = Type.out_wstring.withName("[out] path");
+// Special constructors that need to be defined on all threads
+OSError.closed = function closed(operation, path) {
+return new OSError(operation, Const.ERROR_INVALID_HANDLE, path);
+};
+OSError.exists = function exists(operation, path) {
+return new OSError(operation, Const.ERROR_FILE_EXISTS, path);
+};
+OSError.noSuchFile = function noSuchFile(operation, path) {
+return new OSError(operation, Const.ERROR_FILE_NOT_FOUND, path);
+};
+OSError.invalidArgument = function invalidArgument(operation) {
+return new OSError(operation, Const.ERROR_NOT_SUPPORTED);
+};
+let EXPORTED_SYMBOLS = [
+"declareFFI",
+"libc",
+"Error",
+"AbstractInfo",
+"AbstractEntry",
+"Type",
+"POS_START",
+"POS_CURRENT",
+"POS_END"
+];
+//////////// Boilerplate
+if (typeof Components != "undefined") {
+this.EXPORTED_SYMBOLS = EXPORTED_SYMBOLS;
+for (let symbol of EXPORTED_SYMBOLS) {
+this[symbol] = exports[symbol];
+}
+}

The Tor Browser / file comparison

comparison: toolkit/components/osfile/modules/osfile_win_allthreads.jsm

toolkit/components/osfile/modules/osfile_win_allthreads.jsm