import {NDEFErrorType, NDEFRecordTypeCategory, NFC, NFCReceiver} from '/gen/services/device/public/mojom/nfc.mojom.m.js';
// Converts between NDEFMessageInit https://w3c.github.io/web-nfc/#dom-ndefmessage
// and mojom.NDEFMessage structure, so that watch function can be tested.
function toMojoNDEFMessage(message) {
let ndefMessage = {data: []};
for (let record of message.records) {
ndefMessage.data.push(toMojoNDEFRecord(record));
}
return ndefMessage;
}
function toMojoNDEFRecord(record) {
let nfcRecord = {};
// Simply checks the existence of ':' to decide whether it's an external
// type or a local type. As a mock, no need to really implement the validation
// algorithms for them.
if (record.recordType.startsWith(':')) {
nfcRecord.category = NDEFRecordTypeCategory.kLocal;
} else if (record.recordType.search(':') != -1) {
nfcRecord.category = NDEFRecordTypeCategory.kExternal;
} else {
nfcRecord.category = NDEFRecordTypeCategory.kStandardized;
}
nfcRecord.recordType = record.recordType;
nfcRecord.mediaType = record.mediaType;
nfcRecord.id = record.id;
if (record.recordType == 'text') {
nfcRecord.encoding = record.encoding == null? 'utf-8': record.encoding;
nfcRecord.lang = record.lang == null? 'en': record.lang;
}
nfcRecord.data = toByteArray(record.data);
if (record.data != null && record.data.records !== undefined) {
// |record.data| may be an NDEFMessageInit, i.e. the payload is a message.
nfcRecord.payloadMessage = toMojoNDEFMessage(record.data);
}
return nfcRecord;
}
// Converts JS objects to byte array.
function toByteArray(data) {
if (data instanceof ArrayBuffer)
return new Uint8Array(data);
else if (ArrayBuffer.isView(data))
return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
let byteArray = new Uint8Array(0);
let tmpData = data;
if (typeof tmpData === 'object' || typeof tmpData === 'number')
tmpData = JSON.stringify(tmpData);
if (typeof tmpData === 'string')
byteArray = new TextEncoder().encode(tmpData);
return byteArray;
}
// Compares NDEFRecords that were provided / received by the mock service.
// TODO: Use different getters to get received record data,
// see spec changes at https://github.com/w3c/web-nfc/pull/243.
self.compareNDEFRecords = function(providedRecord, receivedRecord) {
assert_equals(providedRecord.recordType, receivedRecord.recordType);
if (providedRecord.id === undefined) {
assert_equals(null, receivedRecord.id);
} else {
assert_equals(providedRecord.id, receivedRecord.id);
}
if (providedRecord.mediaType === undefined) {
assert_equals(null, receivedRecord.mediaType);
} else {
assert_equals(providedRecord.mediaType, receivedRecord.mediaType);
}
assert_not_equals(providedRecord.recordType, 'empty');
if (providedRecord.recordType == 'text') {
assert_equals(
providedRecord.encoding == null? 'utf-8': providedRecord.encoding,
receivedRecord.encoding);
assert_equals(providedRecord.lang == null? 'en': providedRecord.lang,
receivedRecord.lang);
} else {
assert_equals(null, receivedRecord.encoding);
assert_equals(null, receivedRecord.lang);
}
assert_array_equals(toByteArray(providedRecord.data),
new Uint8Array(receivedRecord.data));
}
// Compares NDEFWriteOptions structures that were provided to API and
// received by the mock mojo service.
self.assertNDEFWriteOptionsEqual = function(provided, received) {
if (provided.overwrite !== undefined)
assert_equals(provided.overwrite, !!received.overwrite);
else
assert_equals(!!received.overwrite, true);
}
// Compares NDEFReaderOptions structures that were provided to API and
// received by the mock mojo service.
self.assertNDEFReaderOptionsEqual = function(provided, received) {
if (provided.url !== undefined)
assert_equals(provided.url, received.url);
else
assert_equals(received.url, '');
if (provided.mediaType !== undefined)
assert_equals(provided.mediaType, received.mediaType);
else
assert_equals(received.mediaType, '');
if (provided.recordType !== undefined) {
assert_equals(provided.recordType, received.recordType);
}
}
function createNDEFError(type) {
return {error: (type != null ? {errorType: type, errorMessage: ''} : null)};
}
self.WebNFCTest = (() => {
class MockNFC {
constructor() {
this.receiver_ = new NFCReceiver(this);
this.interceptor_ = new MojoInterfaceInterceptor(NFC.$interfaceName);
this.interceptor_.oninterfacerequest = e => {
if (this.should_close_pipe_on_request_)
e.handle.close();
else
this.receiver_.$.bindHandle(e.handle);
}
this.interceptor_.start();
this.hw_status_ = NFCHWStatus.ENABLED;
this.pushed_message_ = null;
this.pending_write_options_ = null;
this.pending_push_promise_func_ = null;
this.push_completed_ = true;
this.pending_make_read_only_promise_func_ = null;
this.make_read_only_completed_ = true;
this.client_ = null;
this.watchers_ = [];
this.reading_messages_ = [];
this.operations_suspended_ = false;
this.is_formatted_tag_ = false;
this.data_transfer_failed_ = false;
this.should_close_pipe_on_request_ = false;
}
// NFC delegate functions.
async push(message, options) {
const error = this.getHWError();
if (error)
return error;
// Cancels previous pending push operation.
if (this.pending_push_promise_func_) {
this.cancelPendingPushOperation();
}
this.pushed_message_ = message;
this.pending_write_options_ = options;
return new Promise(resolve => {
if (this.operations_suspended_ || !this.push_completed_) {
// Leaves the push pending.
this.pending_push_promise_func_ = resolve;
} else if (this.is_formatted_tag_ && !options.overwrite) {
// Resolves with NotAllowedError if there are NDEF records on the device
// and overwrite is false.
resolve(createNDEFError(NDEFErrorType.NOT_ALLOWED));
} else if (this.data_transfer_failed_) {
// Resolves with NetworkError if data transfer fails.
resolve(createNDEFError(NDEFErrorType.IO_ERROR));
} else {
resolve(createNDEFError(null));
}
});
}
async cancelPush() {
this.cancelPendingPushOperation();
return createNDEFError(null);
}
async makeReadOnly(options) {
const error = this.getHWError();
if (error)
return error;
// Cancels previous pending makeReadOnly operation.
if (this.pending_make_read_only_promise_func_) {
this.cancelPendingMakeReadOnlyOperation();
}
if (this.operations_suspended_ || !this.make_read_only_completed_) {
// Leaves the makeReadOnly pending.
return new Promise(resolve => {
this.pending_make_read_only_promise_func_ = resolve;
});
} else if (this.data_transfer_failed_) {
// Resolves with NetworkError if data transfer fails.
return createNDEFError(NDEFErrorType.IO_ERROR);
} else {
return createNDEFError(null);
}
}
async cancelMakeReadOnly() {
this.cancelPendingMakeReadOnlyOperation();
return createNDEFError(null);
}
setClient(client) {
this.client_ = client;
}
async watch(id) {
assert_true(id > 0);
const error = this.getHWError();
if (error) {
return error;
}
this.watchers_.push({id: id});
// Ignores reading if NFC operation is suspended
// or the NFC tag does not expose NDEF technology.
if (!this.operations_suspended_) {
// Triggers onWatch if the new watcher matches existing messages.
for (let message of this.reading_messages_) {
this.client_.onWatch(
[id], fake_tag_serial_number, toMojoNDEFMessage(message));
}
}
return createNDEFError(null);
}
cancelWatch(id) {
let index = this.watchers_.findIndex(value => value.id === id);
if (index !== -1) {
this.watchers_.splice(index, 1);
}
}
getHWError() {
if (this.hw_status_ === NFCHWStatus.DISABLED)
return createNDEFError(NDEFErrorType.NOT_READABLE);
if (this.hw_status_ === NFCHWStatus.NOT_SUPPORTED)
return createNDEFError(NDEFErrorType.NOT_SUPPORTED);
return null;
}
setHWStatus(status) {
this.hw_status_ = status;
}
pushedMessage() {
return this.pushed_message_;
}
writeOptions() {
return this.pending_write_options_;
}
watchOptions() {
assert_not_equals(this.watchers_.length, 0);
return this.watchers_[this.watchers_.length - 1].options;
}
setPendingPushCompleted(result) {
this.push_completed_ = result;
}
setPendingMakeReadOnlyCompleted(result) {
this.make_read_only_completed_ = result;
}
reset() {
this.hw_status_ = NFCHWStatus.ENABLED;
this.watchers_ = [];
this.reading_messages_ = [];
this.operations_suspended_ = false;
this.cancelPendingPushOperation();
this.cancelPendingMakeReadOnlyOperation();
this.is_formatted_tag_ = false;
this.data_transfer_failed_ = false;
this.should_close_pipe_on_request_ = false;
}
cancelPendingPushOperation() {
if (this.pending_push_promise_func_) {
this.pending_push_promise_func_(
createNDEFError(NDEFErrorType.OPERATION_CANCELLED));
this.pending_push_promise_func_ = null;
}
this.pushed_message_ = null;
this.pending_write_options_ = null;
this.push_completed_ = true;
}
cancelPendingMakeReadOnlyOperation() {
if (this.pending_make_read_only_promise_func_) {
this.pending_make_read_only_promise_func_(
createNDEFError(NDEFErrorType.OPERATION_CANCELLED));
this.pending_make_read_only_promise_func_ = null;
}
this.make_read_only_completed_ = true;
}
// Sets message that is used to deliver NFC reading updates.
setReadingMessage(message) {
this.reading_messages_.push(message);
// Ignores reading if NFC operation is suspended.
if(this.operations_suspended_) return;
// when overwrite is false, the write algorithm will read the NFC tag
// to determine if it has NDEF records on it.
if (this.pending_write_options_ && this.pending_write_options_.overwrite)
return;
// Triggers onWatch if the new message matches existing watchers.
for (let watcher of this.watchers_) {
this.client_.onWatch(
[watcher.id], fake_tag_serial_number,
toMojoNDEFMessage(message));
}
}
// Suspends all pending NFC operations. Could be used when web page
// visibility is lost.
suspendNFCOperations() {
this.operations_suspended_ = true;
}
// Resumes all suspended NFC operations.
resumeNFCOperations() {
this.operations_suspended_ = false;
// Resumes pending NFC reading.
for (let watcher of this.watchers_) {
for (let message of this.reading_messages_) {
this.client_.onWatch(
[watcher.id], fake_tag_serial_number,
toMojoNDEFMessage(message));
}
}
// Resumes pending push operation.
if (this.pending_push_promise_func_ && this.push_completed_) {
this.pending_push_promise_func_(createNDEFError(null));
this.pending_push_promise_func_ = null;
}
// Resumes pending makeReadOnly operation.
if (this.pending_make_read_only_promise_func_ &&
this.make_read_only_completed_) {
this.pending_make_read_only_promise_func_(createNDEFError(null));
this.pending_make_read_only_promise_func_ = null;
}
}
// Simulates the device coming in proximity does not expose NDEF technology.
simulateNonNDEFTagDiscovered() {
// Notify NotSupportedError to all active readers.
if (this.watchers_.length != 0) {
this.client_.onError({
errorType: NDEFErrorType.NOT_SUPPORTED,
errorMessage: ''
});
}
// Reject the pending push with NotSupportedError.
if (this.pending_push_promise_func_) {
this.pending_push_promise_func_(
createNDEFError(NDEFErrorType.NOT_SUPPORTED));
this.pending_push_promise_func_ = null;
}
// Reject the pending makeReadOnly with NotSupportedError.
if (this.pending_make_read_only_promise_func_) {
this.pending_make_read_only_promise_func_(
createNDEFError(NDEFErrorType.NOT_SUPPORTED));
this.pending_make_read_only_promise_func_ = null;
}
}
setIsFormattedTag(isFormatted) {
this.is_formatted_tag_ = isFormatted;
}
simulateDataTransferFails() {
this.data_transfer_failed_ = true;
}
simulateClosedPipe() {
this.should_close_pipe_on_request_ = true;
}
}
let testInternal = {
initialized: false,
mockNFC: null
}
class NFCTestChromium {
constructor() {
Object.freeze(this); // Makes it immutable.
}
async initialize() {
if (testInternal.initialized)
throw new Error('Call reset() before initialize().');
// Grant nfc permissions for Chromium testdriver.
await test_driver.set_permission({ name: 'nfc' }, 'granted');
if (testInternal.mockNFC == null) {
testInternal.mockNFC = new MockNFC();
}
testInternal.initialized = true;
}
// Reuses the nfc mock but resets its state between test runs.
async reset() {
if (!testInternal.initialized)
throw new Error('Call initialize() before reset().');
testInternal.mockNFC.reset();
testInternal.initialized = false;
await new Promise(resolve => setTimeout(resolve, 0));
}
getMockNFC() {
return testInternal.mockNFC;
}
}
return NFCTestChromium;
})();
Codebase Browser
chromium