FileAPI: Blob 'endings' option is now standardized.

The 'endings' option for the Blob (and File) constructor has now
been standardized in the spec[1]. Remove TODOs and align the IDL with
the spec. No behavior changes.

[1] https://w3c.github.io/FileAPI

Bug: 605710, 509793
Change-Id: I26a1694eb56e415b6a50cc90148d10393b88b8d2
Reviewed-on: https://chromium-review.googlesource.com/802621
Commit-Queue: Joshua Bell <[email protected]>
Reviewed-by: Marijn Kruisselbrink <[email protected]>
Cr-Commit-Position: refs/heads/master@{#521537}

Author: inexorabletash

FileAPI/blob/Blob-constructor.html

@@ -74,6 +74,20 @@
   type: "",
   desc: "A plain object with @@iterator should be treated as a sequence for the blobParts argument."
 });
+test(t => {
+  const blob = new Blob({
+    [Symbol.iterator]() {
+      var i = 0;
+      return {next: () => [
+        {done:false, value:'ab'},
+        {done:false, value:'cde'},
+        {done:true}
+      ][i++]
+      };
+    }
+  });
+  assert_equals(blob.size, 5, 'Custom @@iterator should be treated as a sequence');
+}, "A plain object with custom @@iterator should be treated as a sequence for the blobParts argument.");
 test_blob(function() {
   return new Blob({
     [Symbol.iterator]: Array.prototype[Symbol.iterator],
@@ -443,13 +457,26 @@
   });
 });
 
+[
+  123,
+  123.4,
+  true,
+  'abc'
+].forEach(arg => {
+  test(t => {
+    assert_throws(new TypeError(), () => new Blob([], arg),
+                  'Blob constructor should throw with invalid property bag');
+  }, `Passing ${JSON.stringify(arg)} for options should throw`);
+});
+
 var type_tests = [
   // blobParts, type, expected type
   [[], '', ''],
   [[], 'a', 'a'],
   [[], 'A', 'a'],
   [[], 'text/html', 'text/html'],
   [[], 'TEXT/HTML', 'text/html'],
+  [[], 'text/plain;charset=utf-8', 'text/plain;charset=utf-8'],
   [[], '\u00E5', ''],
   [[], '\uD801\uDC7E', ''], // U+1047E
   [[], ' image/gif ', ' image/gif '],

FileAPI/file/File-constructor.html

@@ -6,10 +6,20 @@
 <script src="/resources/testharnessreport.js"></script>
 <div id="log"></div>
 <script>
+const to_string_obj = { toString: () => 'a string' };
+const to_string_throws = { toString: () => { throw new Error('expected'); } };
+
 test(function() {
   assert_true("File" in window, "window should have a File property.");
 }, "File interface object exists");
 
+test(t => {
+  assert_throws(new TypeError(), () => new File(),
+                'Bits argument is required');
+  assert_throws(new TypeError(), () => new File([]),
+                'Name argument is required');
+}, 'Required arguments');
+
 function test_first_argument(arg1, expectedSize, testName) {
   test(function() {
     var file = new File(arg1, "dummy");
@@ -22,14 +32,48 @@
   }, testName);
 }
 
+test_first_argument([], 0, "empty fileBits");
 test_first_argument(["bits"], 4, "DOMString fileBits");
 test_first_argument(["𝓽𝓮𝔁𝓽"], 16, "Unicode DOMString fileBits");
+test_first_argument([new String('string object')], 13, "String object fileBits");
 test_first_argument([new Blob()], 0, "Empty Blob fileBits");
 test_first_argument([new Blob(["bits"])], 4, "Blob fileBits");
+test_first_argument([new File([], 'world.txt')], 0, "Empty File fileBits");
+test_first_argument([new File(["bits"], 'world.txt')], 4, "File fileBits");
 test_first_argument([new ArrayBuffer(8)], 8, "ArrayBuffer fileBits");
 test_first_argument([new Uint8Array([0x50, 0x41, 0x53, 0x53])], 4, "Typed array fileBits");
 test_first_argument(["bits", new Blob(["bits"]), new Blob(), new Uint8Array([0x50, 0x41]),
                      new Uint16Array([0x5353]), new Uint32Array([0x53534150])], 16, "Various fileBits");
+test_first_argument([12], 2, "Number in fileBits");
+test_first_argument([[1,2,3]], 5, "Array in fileBits");
+test_first_argument([{}], 15, "Object in fileBits"); // "[object Object]"
+test_first_argument([document], 21, "HTMLDocument in fileBits"); // "[object HTMLDocument]"
+test_first_argument([to_string_obj], 8, "Object with toString in fileBits");
+test_first_argument({[Symbol.iterator]() {
+  let i = 0;
+  return {next: () => [
+    {done:false, value:'ab'},
+    {done:false, value:'cde'},
+    {done:true}
+  ][i++]};
+}}, 5, 'Custom @@iterator');
+
+[
+  'hello',
+  0,
+  null
+].forEach(arg => {
+  test(t => {
+    assert_throws(new TypeError(), () => new File(arg, 'world.html'),
+                  'Constructor should throw for invalid bits argument');
+  }, `Invalid bits argument: ${JSON.stringify(arg)}`);
+});
+
+test(t => {
+  assert_throws(new Error(), () => new File([to_string_throws], 'name.txt'),
+                'Constructor should propagate exceptions');
+}, 'Bits argument: object that throws');
+
 
 function test_second_argument(arg2, expectedFileName, testName) {
   test(function() {
@@ -41,23 +85,29 @@
 
 test_second_argument("dummy", "dummy", "Using fileName");
 test_second_argument("dummy/foo", "dummy:foo", "Using special character in fileName");
+test_second_argument(null, "null", "Using null fileName");
+test_second_argument(1, "1", "Using number fileName");
+test_second_argument('', '', "Using empty string fileName");
+test_second_argument(document, '[object HTMLDocument]', "Using object fileName");
 
 // testing the third argument
-test(function() {
-  var file = new File(["bits"], "dummy", { type: "text/plain"});
-  assert_true(file instanceof File);
-  assert_equals(file.type, "text/plain");
-}, "Using type on the File constructor");
-test(function() {
-  var file = new File(["bits"], "dummy", { type: "TEXT/PLAIN"});
-  assert_true(file instanceof File);
-  assert_equals(file.type, "text/plain");
-}, "Using uppercase characters in type");
-test(function() {
-  var file = new File(["bits"], "dummy", { type: "𝓽𝓮𝔁𝓽/𝔭𝔩𝔞𝔦𝔫"});
-  assert_true(file instanceof File);
-  assert_equals(file.type, "");
-}, "Using illegal character for type");
+[
+  {type: 'text/plain', expected: 'text/plain'},
+  {type: 'text/plain;charset=UTF-8', expected: 'text/plain;charset=utf-8'},
+  {type: 'TEXT/PLAIN', expected: 'text/plain'},
+  {type: '𝓽𝓮𝔁𝓽/𝔭𝔩𝔞𝔦𝔫', expected: ''},
+  {type: 'ascii/nonprintable\u001F', expected: ''},
+  {type: 'ascii/nonprintable\u007F', expected: ''},
+  {type: 'nonascii\u00EE', expected: ''},
+  {type: 'nonascii\u1234', expected: ''},
+  {type: 'nonparsable', expected: 'nonparsable'}
+].forEach(testCase => {
+  test(t => {
+    var file = new File(["bits"], "dummy", { type: testCase.type});
+    assert_true(file instanceof File);
+    assert_equals(file.type, testCase.expected);
+  }, `Using type in File constructor: ${testCase.type}`);
+});
 test(function() {
   var file = new File(["bits"], "dummy", { lastModified: 42 });
   assert_true(file instanceof File);
@@ -68,5 +118,41 @@
   assert_true(file instanceof File);
   assert_equals(file.name, "dummy");
 }, "Misusing name");
+test(function() {
+  var file = new File(["bits"], "dummy", { unknownKey: "value" });
+  assert_true(file instanceof File);
+  assert_equals(file.name, "dummy");
+}, "Unknown properties are ignored");
+
+[
+  123,
+  123.4,
+  true,
+  'abc'
+].forEach(arg => {
+  test(t => {
+    assert_throws(new TypeError(), () => new File(['bits'], 'name.txt', arg),
+                  'Constructor should throw for invalid property bag type');
+  }, `Invalid property bag: ${JSON.stringify(arg)}`);
+});
+
+[
+  null,
+  undefined,
+  [1,2,3],
+  /regex/,
+  function() {}
+].forEach(arg => {
+  test(t => {
+    assert_equals(new File(['bits'], 'name.txt', arg).size, 4,
+                  'Constructor should accept object-ish property bag type');
+  }, `Unusual but valid property bag: ${arg}`);
+});
+
+test(t => {
+  assert_throws(new Error(),
+                () => new File(['bits'], 'name.txt', {type: to_string_throws}),
+                'Constructor should propagate exceptions');
+}, 'Property bag propagates exceptions');
 
 </script>