Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 230 insertions, 0 deletions

diff --git a/testing/web-platform/tests/file-system-access/resources/messaging-serialize-helpers.js b/testing/web-platform/tests/file-system-access/resources/messaging-serialize-helpers.js
new file mode 100644
index 0000000000..ada68f43db
--- /dev/null
+++ b/testing/web-platform/tests/file-system-access/resources/messaging-serialize-helpers.js
@@ -0,0 +1,230 @@
+'use strict';
+
+// This script depends on the following script:
+//    /file-system-access/resources/test-helpers.js
+
+// Serializes an array of FileSystemHandles where each element can be either a
+// FileSystemFileHandle or FileSystemDirectoryHandle.
+async function serialize_handles(handle_array) {
+  const serialized_handle_array = [];
+  for (let i = 0; i < handle_array.length; ++i) {
+    serialized_handle_array.push(await serialize_handle(handle_array[i]));
+  }
+  return serialized_handle_array;
+}
+
+// Serializes either a FileSystemFileHandle or FileSystemDirectoryHandle.
+async function serialize_handle(handle) {
+  switch (handle.kind) {
+    case 'directory':
+      return await serialize_file_system_directory_handle(handle);
+    case 'file':
+      return await serialize_file_system_file_handle(handle);
+    default:
+      throw 'Object is not a FileSystemFileHandle or ' +
+          `FileSystemDirectoryHandle ${handle}`;
+  }
+}
+
+// Creates a dictionary for a FileSystemHandle base, which contains
+// serialized properties shared by both FileSystemFileHandle and
+// FileSystemDirectoryHandle.
+async function serialize_file_system_handle(handle) {
+  const read_permission =
+    await handle.queryPermission({ mode: 'read' });
+
+  const write_permission =
+    await handle.queryPermission({ mode: 'readwrite' })
+
+  return {
+    kind: handle.kind,
+    name: handle.name,
+    read_permission,
+    write_permission
+  };
+}
+
+// Create a dictionary with each property value in FileSystemFileHandle.
+// Also, reads the contents of the file to include with the returned
+// dictionary.  Example output:
+// {
+//   kind: "file",
+//   name: "example-file-name"
+//   read_permission: "granted",
+//   write_permission: "granted",
+//   contents: "example-file-contents"
+// }
+async function serialize_file_system_file_handle(file_handle) {
+  const contents = await getFileContents(file_handle);
+
+  const serialized_file_system_handle =
+    await serialize_file_system_handle(file_handle);
+
+  return Object.assign(serialized_file_system_handle, { contents });
+}
+
+// Create a dictionary with each property value in FileSystemDirectoryHandle.
+// Example output:
+// {
+//   kind: "directory",
+//   name: "example-directory-name"
+//   read_permission: "granted",
+//   write_permission: "granted",
+//   files: [<first serialized file>, ...]
+//   directories: [<first serialized subdirectory>, ...]
+// }
+async function serialize_file_system_directory_handle(directory_handle) {
+  // Serialize the contents of the directory.
+  const serialized_files = [];
+  const serialized_directories = [];
+  for await (const child_handle of directory_handle.values()) {
+    const serialized_child_handle = await serialize_handle(child_handle);
+    if (child_handle.kind === "directory") {
+      serialized_directories.push(serialized_child_handle);
+    } else {
+      serialized_files.push(serialized_child_handle);
+    }
+  }
+
+  // Order the serialized contents of the directory by name.
+  serialized_files.sort((left, right) => {
+    return left.name.localeCompare(right.name);
+  });
+  serialized_directories.sort((left, right) => {
+    return left.name.localeCompare(right.name);
+  });
+
+  // Serialize the directory's common properties shared by all
+  // FileSystemHandles.
+  const serialized_file_system_handle =
+    await serialize_file_system_handle(directory_handle);
+
+  return Object.assign(
+    serialized_file_system_handle,
+    { files: serialized_files, directories: serialized_directories });
+}
+
+// Verifies |left_array| is a clone of |right_array| where each element
+// is a cloned FileSystemHandle with the same properties and contents.
+async function assert_equals_cloned_handles(left_array, right_array) {
+  assert_equals(left_array.length, right_array.length,
+    'Each array of FileSystemHandles must have the same length');
+
+  for (let i = 0; i < left_array.length; ++i) {
+    assert_not_equals(left_array[i], right_array[i],
+      'Clones must create new FileSystemHandle instances.');
+
+    const left_serialized = await serialize_handle(left_array[i]);
+    const right_serialized = await serialize_handle(right_array[i]);
+    assert_equals_serialized_handle(left_serialized, right_serialized);
+  }
+}
+
+// Verifies |left_array| is the same as |right_array| where each element
+// is a serialized FileSystemHandle with the same properties.
+function assert_equals_serialized_handles(left_array, right_array) {
+  assert_equals(left_array.length, right_array.length,
+    'Each array of serialized handles must have the same length');
+
+  for (let i = 0; i < left_array.length; ++i) {
+    assert_equals_serialized_handle(left_array[i], right_array[i]);
+  }
+}
+
+// Verifies each property of a serialized FileSystemFileHandle or
+// FileSystemDirectoryHandle.
+function assert_equals_serialized_handle(left, right) {
+  switch (left.kind) {
+    case 'directory':
+      assert_equals_serialized_file_system_directory_handle(left, right);
+      break;
+    case 'file':
+      assert_equals_serialized_file_system_file_handle(left, right);
+      break;
+    default:
+      throw 'Object is not a FileSystemFileHandle or ' +
+          `FileSystemDirectoryHandle ${left}`;
+  }
+}
+
+// Compares the output of serialize_file_system_handle() for
+// two FileSystemHandles.
+function assert_equals_serialized_file_system_handle(left, right) {
+  assert_equals(left.kind, right.kind,
+    'Each FileSystemHandle instance must use the expected "kind".');
+
+  assert_equals(left.name, right.name,
+    'Each FileSystemHandle instance must use the expected "name" ' +
+    ' property.');
+
+  assert_equals(left.read_permission, right.read_permission,
+    'Each FileSystemHandle instance must have the expected read ' +
+    ' permission.');
+
+  assert_equals(left.write_permission, right.write_permission,
+    'Each FileSystemHandle instance must have the expected write ' +
+    ' permission.');
+}
+
+// Compares the output of serialize_file_system_file_handle()
+// for two FileSystemFileHandle.
+function assert_equals_serialized_file_system_file_handle(left, right) {
+  assert_equals_serialized_file_system_handle(left, right);
+  assert_equals(left.contents, right.contents,
+    'Each FileSystemFileHandle instance must have the same contents.');
+}
+
+// Compares the output of serialize_file_system_directory_handle()
+// for two FileSystemDirectoryHandles.
+function assert_equals_serialized_file_system_directory_handle(left, right) {
+  assert_equals_serialized_file_system_handle(left, right);
+
+  assert_equals(left.files.length, right.files.length,
+    'Each FileSystemDirectoryHandle must contain the same number of ' +
+    'file children');
+
+  for (let i = 0; i < left.files.length; ++i) {
+    assert_equals_serialized_file_system_file_handle(
+      left.files[i], right.files[i]);
+  }
+
+  assert_equals(left.directories.length, right.directories.length,
+    'Each FileSystemDirectoryHandle must contain the same number of ' +
+    'directory children');
+
+  for (let i = 0; i < left.directories.length; ++i) {
+    assert_equals_serialized_file_system_directory_handle(
+      left.directories[i], right.directories[i]);
+  }
+}
+
+// Creates a dictionary with interesting property values from MessageEvent.
+function serialize_message_error_event(message_error_event) {
+  return {
+    data: message_error_event.data,
+    origin: message_error_event.origin,
+    last_event_id: message_error_event.lastEventId,
+    has_source: (message_error_event.source !== null),
+    ports_length: message_error_event.ports.length
+  };
+}
+
+// Compares the output of serialize_message_error_event() with an
+// expected result.
+function assert_equals_serialized_message_error_event(
+  serialized_event, expected_origin, expected_has_source) {
+  assert_equals(serialized_event.data, null,
+    'The message error event must set the "data" property to null.');
+
+  assert_equals(serialized_event.origin, expected_origin,
+    'The message error event must have the expected "origin" property.');
+
+  assert_equals(serialized_event.last_event_id, "",
+    'The message error event must set the "lastEventId" property to the empty string.');
+
+  assert_equals(serialized_event.has_source, expected_has_source,
+    'The message error event must have the expected "source" property.');
+
+  assert_equals(serialized_event.ports_length, 0,
+    'The message error event must not contain any message ports.');
+}