serial: Rename dictionary members to avoid acronyms

This change renames members in the SerialOptions, SerialInputSignals and
SerialOutputSignals dictionaries so that they avoid acronyms and are in
lowerCamelCase, to match other web platform APIs.

This is a rather large breaking change which will require participants
in the Serial API Origin Trial to update their code.

Bug: 884928
Change-Id: I2424a207cc05685b5b9ab72158748cb4f28f7d57
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2347375Reviewed-by: Domenic Denicola <domenic@chromium.org>
Commit-Queue: Reilly Grant <reillyg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#797507}

third_party/blink/renderer/modules/serial/serial_input_signals.idl

@@ -6,11 +6,11 @@
 
 dictionary SerialInputSignals {
   // DCD (Data Carrier Detect) or RLSD (Receive Line Signal Detect)
-  required boolean dcd;
+  required boolean dataCarrierDetect;
   // CTS (Clear to Send)
-  required boolean cts;
+  required boolean clearToSend;
   // RI (Ring Indicator)
-  required boolean ri;
+  required boolean ringIndicator;
   // DSR (Data Set Ready)
-  required boolean dsr;
+  required boolean dataSetReady;
 };

third_party/blink/renderer/modules/serial/serial_options.idl

@@ -10,11 +10,16 @@ enum ParityType {
   "odd",
 };
 
+enum FlowControlType {
+  "none",
+  "hardware",
+};
+
 dictionary SerialOptions {
-  required [EnforceRange] unsigned long baudrate;
-  [EnforceRange] octet databits = 8;
-  [EnforceRange] octet stopbits = 1;
+  required [EnforceRange] unsigned long baudRate;
+  [EnforceRange] octet dataBits = 8;
+  [EnforceRange] octet stopBits = 1;
   ParityType parity = "none";
-  [EnforceRange] unsigned long buffersize = 255;
-  boolean rtscts = false;
+  [EnforceRange] unsigned long bufferSize = 255;
+  FlowControlType flowControl = "none";
 };

third_party/blink/renderer/modules/serial/serial_output_signals.idl

@@ -6,9 +6,9 @@
 
 dictionary SerialOutputSignals {
   // DTR (Data Terminal Ready)
-  boolean dtr;
+  boolean dataTerminalReady;
   // RTS (Request to Send)
-  boolean rts;
-  // BRK (Break)
-  boolean brk;
+  boolean requestToSend;
+  // BRK (Break), implemented as "brk" because "break" is a C++ keyword
+  [ImplementedAs=brk] boolean break;
 };

third_party/blink/renderer/modules/serial/serial_port.cc

@@ -196,14 +196,14 @@ ScriptPromise SerialPort::open(ScriptState* script_state,
 
   auto mojo_options = device::mojom::blink::SerialConnectionOptions::New();
 
-  if (options->baudrate() == 0) {
+  if (options->baudRate() == 0) {
     exception_state.ThrowTypeError(
         "Requested baud rate must be greater than zero.");
     return ScriptPromise();
   }
-  mojo_options->bitrate = options->baudrate();
+  mojo_options->bitrate = options->baudRate();
 
-  switch (options->databits()) {
+  switch (options->dataBits()) {
     case 7:
       mojo_options->data_bits = device::mojom::blink::SerialDataBits::SEVEN;
       break;
@@ -226,7 +226,7 @@ ScriptPromise SerialPort::open(ScriptState* script_state,
     NOTREACHED();
   }
 
-  switch (options->stopbits()) {
+  switch (options->stopBits()) {
     case 1:
       mojo_options->stop_bits = device::mojom::blink::SerialStopBits::ONE;
       break;
@@ -239,24 +239,24 @@ ScriptPromise SerialPort::open(ScriptState* script_state,
       return ScriptPromise();
   }
 
-  if (options->buffersize() == 0) {
+  if (options->bufferSize() == 0) {
     exception_state.ThrowTypeError(String::Format(
         "Requested buffer size (%d bytes) must be greater than zero.",
-        options->buffersize()));
+        options->bufferSize()));
     return ScriptPromise();
   }
 
-  if (options->buffersize() > kMaxBufferSize) {
+  if (options->bufferSize() > kMaxBufferSize) {
     exception_state.ThrowTypeError(
         String::Format("Requested buffer size (%d bytes) is greater than "
                        "the maximum allowed (%d bytes).",
-                       options->buffersize(), kMaxBufferSize));
+                       options->bufferSize(), kMaxBufferSize));
     return ScriptPromise();
   }
-  buffer_size_ = options->buffersize();
+  buffer_size_ = options->bufferSize();
 
   mojo_options->has_cts_flow_control = true;
-  mojo_options->cts_flow_control = options->rtscts();
+  mojo_options->cts_flow_control = options->flowControl() == "hardware";
 
   mojo::PendingRemote<device::mojom::blink::SerialPortClient> client;
   parent_->GetPort(
@@ -360,19 +360,20 @@ ScriptPromise SerialPort::setSignals(ScriptState* script_state,
     return ScriptPromise();
   }
 
-  if (!signals->hasDtr() && !signals->hasRts() && !signals->hasBrk()) {
+  if (!signals->hasDataTerminalReady() && !signals->hasRequestToSend() &&
+      !signals->hasBrk()) {
     exception_state.ThrowTypeError(kNoSignals);
     return ScriptPromise();
   }
 
   auto mojo_signals = device::mojom::blink::SerialHostControlSignals::New();
-  if (signals->hasDtr()) {
+  if (signals->hasDataTerminalReady()) {
     mojo_signals->has_dtr = true;
-    mojo_signals->dtr = signals->dtr();
+    mojo_signals->dtr = signals->dataTerminalReady();
   }
-  if (signals->hasRts()) {
+  if (signals->hasRequestToSend()) {
     mojo_signals->has_rts = true;
-    mojo_signals->rts = signals->rts();
+    mojo_signals->rts = signals->requestToSend();
   }
   if (signals->hasBrk()) {
     mojo_signals->has_brk = true;
@@ -611,10 +612,10 @@ void SerialPort::OnGetSignals(
   }
 
   auto* signals = MakeGarbageCollected<SerialInputSignals>();
-  signals->setDcd(mojo_signals->dcd);
-  signals->setCts(mojo_signals->cts);
-  signals->setRi(mojo_signals->ri);
-  signals->setDsr(mojo_signals->dsr);
+  signals->setDataCarrierDetect(mojo_signals->dcd);
+  signals->setClearToSend(mojo_signals->cts);
+  signals->setRingIndicator(mojo_signals->ri);
+  signals->setDataSetReady(mojo_signals->dsr);
   resolver->Resolve(signals);
 }
 

third_party/blink/web_tests/wpt_internal/serial/resources/automation.js

@@ -101,8 +101,17 @@ class DataPipeSink {
 // Implementation of blink.mojom.SerialPort.
 class FakeSerialPort {
   constructor() {
-    this.inputSignals_ = { dcd: false, cts: false, ri: false, dsr: false };
-    this.outputSignals_ = { dtr: false, rts: false, brk: false };
+    this.inputSignals_ = {
+      dataCarrierDetect: false,
+      clearToSend: false,
+      ringIndicator: false,
+      dataSetReady: false
+    };
+    this.outputSignals_ = {
+      dataTerminalReady: false,
+      requestToSend: false,
+      break: false
+    };
   }
 
   bind(request) {
@@ -197,7 +206,7 @@ class FakeSerialPort {
     this.options_ = options;
     this.client_ = client;
     // OS typically sets DTR on open.
-    this.outputSignals_.dtr = true;
+    this.outputSignals_.dataTerminalReady = true;
     return { success: true };
   }
 
@@ -242,18 +251,24 @@ class FakeSerialPort {
   }
 
   async getControlSignals() {
-    return { signals: this.inputSignals_ };
+    const signals = {
+      dcd: this.inputSignals_.dataCarrierDetect,
+      cts: this.inputSignals_.clearToSend,
+      ri: this.inputSignals_.ringIndicator,
+      dsr: this.inputSignals_.dataSetReady
+    };
+    return {signals};
   }
 
   async setControlSignals(signals) {
     if (signals.hasDtr) {
-      this.outputSignals_.dtr = signals.dtr;
+      this.outputSignals_.dataTerminalReady = signals.dtr;
     }
     if (signals.hasRts) {
-      this.outputSignals_.rts = signals.rts;
+      this.outputSignals_.requestToSend = signals.rts;
     }
     if (signals.hasBrk) {
-      this.outputSignals_.brk = signals.brk;
+      this.outputSignals_.break = signals.brk;
     }
     return { success: true };
   }
@@ -276,7 +291,7 @@ class FakeSerialPort {
 
   async close() {
     // OS typically clears DTR on close.
-    this.outputSignals_.dtr = false;
+    this.outputSignals_.dataTerminalReady = false;
     if (this.writer_) {
       this.writer_.close();
       this.writer_.releaseLock();

third_party/blink/web_tests/wpt_internal/serial/serialPort_close.https.window.js

@@ -15,7 +15,7 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   await port.close();
   await promise_rejects_dom(t, 'InvalidStateError', port.close());
 }, 'A SerialPort cannot be closed if it is already closed.');
@@ -23,7 +23,7 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   const closePromise = port.close();
   await promise_rejects_dom(t, 'InvalidStateError', port.close());
   await closePromise;

third_party/blink/web_tests/wpt_internal/serial/serialPort_disconnect-manual.https.html

@@ -16,7 +16,7 @@
       manual_loopback_serial_test(async (t, port) => {
         const watcher = new EventWatcher(t, navigator.serial, ['disconnect']);
 
-        await port.open({baudrate: 115200, buffersize: 1024});
+        await port.open({baudRate: 115200, bufferSize: 1024});
 
         const disconnectPromise = watcher.wait_for(['disconnect'])
         const reader = port.readable.getReader();
@@ -50,7 +50,7 @@
       manual_loopback_serial_test(async (t, port) => {
         const watcher = new EventWatcher(t, navigator.serial, ['disconnect']);
 
-        await port.open({baudrate: 115200, buffersize: 1024});
+        await port.open({baudRate: 115200, bufferSize: 1024});
 
         const disconnectPromise = watcher.wait_for(['disconnect'])
         const writer = port.writable.getWriter();

third_party/blink/web_tests/wpt_internal/serial/serialPort_getSignals.https.window.js

@@ -13,29 +13,34 @@ serial_test(async (t, fake) => {
 
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
 
-  let expectedSignals = {dcd: false, cts: false, ri: false, dsr: false};
+  let expectedSignals = {
+    dataCarrierDetect: false,
+    clearToSend: false,
+    ringIndicator: false,
+    dataSetReady: false
+  };
   fakePort.simulateInputSignals(expectedSignals);
   let signals = await port.getSignals();
   assert_object_equals(signals, expectedSignals);
 
-  expectedSignals.dcd = true;
+  expectedSignals.dataCarrierDetect = true;
   fakePort.simulateInputSignals(expectedSignals);
   signals = await port.getSignals();
   assert_object_equals(signals, expectedSignals, 'DCD set');
 
-  expectedSignals.cts = true;
+  expectedSignals.clearToSend = true;
   fakePort.simulateInputSignals(expectedSignals);
   signals = await port.getSignals();
   assert_object_equals(signals, expectedSignals, 'CTS set');
 
-  expectedSignals.ri = true;
+  expectedSignals.ringIndicator = true;
   fakePort.simulateInputSignals(expectedSignals);
   signals = await port.getSignals();
   assert_object_equals(signals, expectedSignals, 'RI set');
 
-  expectedSignals.dsr = true;
+  expectedSignals.dataSetReady = true;
   fakePort.simulateInputSignals(expectedSignals);
   signals = await port.getSignals();
   assert_object_equals(signals, expectedSignals, 'DSR set');

third_party/blink/web_tests/wpt_internal/serial/serialPort_loopback-manual.https.html

@@ -15,9 +15,9 @@
     </p>
     <script>
       manual_loopback_serial_test(async (t, port) => {
-        await port.open({baudrate: 115200, buffersize: 1024});
+        await port.open({baudRate: 115200, bufferSize: 1024});
 
-        // Create something much smaller than buffersize above.
+        // Create something much smaller than bufferSize above.
         const data = new Uint8Array(64);
         for (let i = 0; i < data.byteLength; ++i)
           data[i] = i & 0xff;
@@ -40,9 +40,9 @@
       }, 'Can perform a series of small writes.');
 
       manual_loopback_serial_test(async (t, port) => {
-        await port.open({baudrate: 115200, buffersize: 1024});
+        await port.open({baudRate: 115200, bufferSize: 1024});
 
-        // Create something much larger than buffersize above.
+        // Create something much larger than bufferSize above.
         const data = new Uint8Array(10 * 1024);
         for (let i = 0; i < data.byteLength; ++i)
           data[i] = (i / 1024) & 0xff;
@@ -65,7 +65,7 @@
       }, 'Can perform a series of large writes.');
 
       manual_loopback_serial_test(async (t, port) => {
-        await port.open({baudrate: 115200, buffersize: 64});
+        await port.open({baudRate: 115200, bufferSize: 64});
 
         const writer = port.writable.getWriter();
         // |data| is small enough to be completely transmitted.
@@ -94,9 +94,9 @@
       }, 'Canceling the reader discards buffered data.');
 
       manual_loopback_serial_test(async (t, port) => {
-        await port.open({baudrate: 115200, buffersize: 1024});
+        await port.open({baudRate: 115200, bufferSize: 1024});
 
-        // Create something much larger than buffersize above.
+        // Create something much larger than bufferSize above.
         const data = new Uint8Array(16 * 1024);
         for (let i = 0; i < data.byteLength; ++i)
           data[i] = (i / 1024) & 0xff;
@@ -141,7 +141,7 @@
       }, 'Overflowing the receive buffer triggers an error.');
 
       manual_loopback_serial_test(async (t, port) => {
-        await port.open({baudrate: 115200, buffersize: 1024});
+        await port.open({baudRate: 115200, bufferSize: 1024});
 
         let reader = port.readable.getReader();
         let readPromise = (async () => {

third_party/blink/web_tests/wpt_internal/serial/serialPort_open.https.window.js

@@ -9,17 +9,17 @@
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   return promise_rejects_dom(
-      t, 'InvalidStateError', port.open({baudrate: 9600}));
+      t, 'InvalidStateError', port.open({baudRate: 9600}));
 }, 'A SerialPort cannot be opened if it is already open.');
 
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  const firstRequest = port.open({baudrate: 9600});
+  const firstRequest = port.open({baudRate: 9600});
   await promise_rejects_dom(
-      t, 'InvalidStateError', port.open({baudrate: 9600}));
+      t, 'InvalidStateError', port.open({baudRate: 9600}));
   await firstRequest;
 }, 'Simultaneous calls to open() are disallowed.');
 
@@ -29,21 +29,21 @@ serial_test(async (t, fake) => {
   await promise_rejects_js(t, TypeError, port.open({}));
 
   await Promise.all([-1, 0].map(
-      baudrate => {
-          return promise_rejects_js(t, TypeError, port.open({baudrate}))}));
+      baudRate => {
+          return promise_rejects_js(t, TypeError, port.open({baudRate}))}));
 }, 'Baud rate is required and must be greater than zero.');
 
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await Promise.all([-1, 0, 6, 9].map(databits => {
+  await Promise.all([-1, 0, 6, 9].map(dataBits => {
     return promise_rejects_js(
-        t, TypeError, port.open({baudrate: 9600, databits}));
+        t, TypeError, port.open({baudRate: 9600, dataBits}));
   }));
 
-  await[undefined, 7, 8].reduce(async (previousTest, databits) => {
+  await[undefined, 7, 8].reduce(async (previousTest, dataBits) => {
     await previousTest;
-    await port.open({baudrate: 9600, databits});
+    await port.open({baudRate: 9600, dataBits});
     await port.close();
   }, Promise.resolve());
 }, 'Data bits must be 7 or 8');
@@ -53,14 +53,14 @@ serial_test(async (t, fake) => {
 
   await Promise.all([0, null, 'cats'].map(parity => {
     return promise_rejects_js(
-        t, TypeError, port.open({baudrate: 9600, parity}),
+        t, TypeError, port.open({baudRate: 9600, parity}),
         `Should reject parity option "${parity}"`);
   }));
 
   await[undefined, 'none', 'even', 'odd'].reduce(
       async (previousTest, parity) => {
         await previousTest;
-        await port.open({baudrate: 9600, parity});
+        await port.open({baudRate: 9600, parity});
         await port.close();
       },
       Promise.resolve());
@@ -69,14 +69,14 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await Promise.all([-1, 0, 3, 4].map(stopbits => {
+  await Promise.all([-1, 0, 3, 4].map(stopBits => {
     return promise_rejects_js(
-        t, TypeError, port.open({baudrate: 9600, stopbits}));
+        t, TypeError, port.open({baudRate: 9600, stopBits}));
   }));
 
-  await[undefined, 1, 2].reduce(async (previousTest, stopbits) => {
+  await[undefined, 1, 2].reduce(async (previousTest, stopBits) => {
     await previousTest;
-    await port.open({baudrate: 9600, stopbits});
+    await port.open({baudRate: 9600, stopBits});
     await port.close();
   }, Promise.resolve());
 }, 'Stop bits must be 1 or 2');
@@ -85,15 +85,15 @@ serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
   await promise_rejects_js(
-      t, TypeError, port.open({baudrate: 9600, buffersize: -1}));
+      t, TypeError, port.open({baudRate: 9600, bufferSize: -1}));
   await promise_rejects_js(
-      t, TypeError, port.open({baudrate: 9600, buffersize: 0}));
+      t, TypeError, port.open({baudRate: 9600, bufferSize: 0}));
 }, 'Buffer size must be greater than zero.');
 
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  const buffersize = 1 * 1024 * 1024 * 1024 /* 1 GiB */;
+  const bufferSize = 1 * 1024 * 1024 * 1024 /* 1 GiB */;
   return promise_rejects_js(
-      t, TypeError, port.open({baudrate: 9600, buffersize}));
+      t, TypeError, port.open({baudRate: 9600, bufferSize}));
 }, 'Unreasonably large buffer sizes are rejected.');

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_cancel.https.window.js

@@ -8,7 +8,7 @@
 
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const reader = port.readable.getReader();
   const readPromise = reader.read();
@@ -22,7 +22,7 @@ serial_test(async (t, fake) => {
 
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const reader = port.readable.getReader();
 
@@ -37,7 +37,7 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
   // Select a buffer size smaller than the amount of data transferred.
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const reader = port.readable.getReader();
 

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_chain.https.window.js

@@ -9,7 +9,7 @@
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
   // Select a buffer size larger than the amount of data transferred.
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const decoder = new TextDecoderStream();
   const streamClosed = port.readable.pipeTo(decoder.writable);

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_closeLocked.https.window.js

@@ -9,7 +9,7 @@
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   assert_true(port.readable instanceof ReadableStream);
 
   const reader = port.readable.getReader();

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_disconnect.https.window.js

@@ -9,7 +9,7 @@
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
   // Select a buffer size smaller than the amount of data transferred.
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const reader = port.readable.getReader();
 

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_gc.https.window.js

@@ -14,7 +14,7 @@ serial_test(async (t, fake) => {
     ({port, fakePort} = await getFakeSerialPort(fake));
 
     // Select a buffer size larger than the amount of data transferred.
-    await port.open({baudrate: 9600, buffersize: 64});
+    await port.open({baudRate: 9600, bufferSize: 64});
 
     let writable;
     chunkReceived = new Promise(resolve => {

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_largeRead.https.window.js

@@ -9,12 +9,12 @@
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
   // Select a buffer size smaller than the amount of data transferred.
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const reader = port.readable.getReader();
 
   await fakePort.writable();
-  const data = new Uint8Array(1024);  // Much larger than buffersize above.
+  const data = new Uint8Array(1024);  // Much larger than bufferSize above.
   for (let i = 0; i < data.byteLength; ++i)
     data[i] = i & 0xff;
   fakePort.write(data);

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_open.https.window.js

@@ -11,7 +11,7 @@ serial_test(async (t, fake) => {
 
   assert_equals(port.readable, null);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   const readable = port.readable;
   assert_true(readable instanceof ReadableStream);
 

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_parityError.https.window.js

@@ -22,7 +22,7 @@ async function promise_rejects_with_parity_error(t, promise) {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
   // Select a buffer size smaller than the amount of data transferred.
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   let readable = port.readable;
   let reader = readable.getReader();

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_pipeThrough.https.window.js

@@ -9,7 +9,7 @@
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
   // Select a buffer size larger than the amount of data transferred.
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const decoder = new TextDecoderStream();
   const streamClosed = port.readable.pipeTo(decoder.writable);

third_party/blink/web_tests/wpt_internal/serial/serialPort_readable_smallRead.https.window.js

@@ -9,7 +9,7 @@
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
   // Select a buffer size larger than the amount of data transferred.
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const reader = port.readable.getReader();
 

third_party/blink/web_tests/wpt_internal/serial/serialPort_setSignals.https.window.js

@@ -13,9 +13,13 @@ serial_test(async (t, fake) => {
 
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
 
-  let expectedSignals = {dtr: true, rts: false, brk: false};
+  let expectedSignals = {
+    dataTerminalReady: true,
+    requestToSend: false,
+    break: false
+  };
   assert_object_equals(fakePort.outputSignals, expectedSignals, 'initial');
 
   await promise_rejects_js(t, TypeError, port.setSignals());
@@ -24,21 +28,22 @@ serial_test(async (t, fake) => {
   await promise_rejects_js(t, TypeError, port.setSignals({}));
   assert_object_equals(fakePort.outputSignals, expectedSignals, 'no-op');
 
-  await port.setSignals({dtr: false});
-  expectedSignals.dtr = false;
+  await port.setSignals({dataTerminalReady: false});
+  expectedSignals.dataTerminalReady = false;
   assert_object_equals(fakePort.outputSignals, expectedSignals, 'clear DTR');
 
-  await port.setSignals({rts: true});
-  expectedSignals.rts = true;
+  await port.setSignals({requestToSend: true});
+  expectedSignals.requestToSend = true;
   assert_object_equals(fakePort.outputSignals, expectedSignals, 'set RTS');
 
-  await port.setSignals({brk: true});
-  expectedSignals.brk = true;
+  await port.setSignals({break: true});
+  expectedSignals.break = true;
   assert_object_equals(fakePort.outputSignals, expectedSignals, 'set BRK');
 
-  await port.setSignals({dtr: true, rts: false, brk: false});
-  expectedSignals.dtr = true;
-  expectedSignals.rts = false;
-  expectedSignals.brk = false;
+  await port.setSignals(
+      {dataTerminalReady: true, requestToSend: false, break: false});
+  expectedSignals.dataTerminalReady = true;
+  expectedSignals.requestToSend = false;
+  expectedSignals.break = false;
   assert_object_equals(fakePort.outputSignals, expectedSignals, 'invert');
 }, 'setSignals() modifies the state of the port');

third_party/blink/web_tests/wpt_internal/serial/serialPort_writable.https.window.js

@@ -11,7 +11,7 @@ serial_test(async (t, fake) => {
 
   assert_equals(port.writable, null);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   const writable = port.writable;
   assert_true(writable instanceof WritableStream);
 
@@ -26,7 +26,7 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   assert_true(port.writable instanceof WritableStream);
 
   const writer = port.writable.getWriter();
@@ -40,7 +40,7 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   assert_true(port.writable instanceof WritableStream);
 
   const writer = port.writable.getWriter();
@@ -60,10 +60,10 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
   // Select a buffer size smaller than the amount of data transferred.
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const writer = port.writable.getWriter();
-  const data = new Uint8Array(1024);  // Much larger than buffersize above.
+  const data = new Uint8Array(1024);  // Much larger than bufferSize above.
   for (let i = 0; i < data.byteLength; ++i)
     data[i] = i & 0xff;
   writer.write(data);
@@ -78,7 +78,7 @@ serial_test(async (t, fake) => {
 
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
 
   const writable = port.writable;
   assert_true(writable instanceof WritableStream);
@@ -106,7 +106,7 @@ serial_test(async (t, fake) => {
 
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
 
   assert_true(port.writable instanceof WritableStream);
   const writer = port.writable.getWriter();
@@ -123,7 +123,7 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
   const originalWritable = port.writable;
   assert_true(originalWritable instanceof WritableStream);
 
@@ -153,10 +153,10 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
   // Select a buffer size smaller than the amount of data transferred.
-  await port.open({baudrate: 9600, buffersize: 64});
+  await port.open({baudRate: 9600, bufferSize: 64});
 
   const writer = port.writable.getWriter();
-  const data = new Uint8Array(1024);  // Much larger than buffersize above.
+  const data = new Uint8Array(1024);  // Much larger than bufferSize above.
   for (let i = 0; i < data.byteLength; ++i)
     data[i] = i & 0xff;
   writer.write(data);
@@ -181,7 +181,7 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   assert_true(port.writable instanceof WritableStream);
 
   const encoder = new TextEncoderStream();
@@ -203,7 +203,7 @@ serial_test(async (t, fake) => {
 serial_test(async (t, fake) => {
   const {port, fakePort} = await getFakeSerialPort(fake);
 
-  await port.open({baudrate: 9600});
+  await port.open({baudRate: 9600});
   assert_true(port.writable instanceof WritableStream);
 
   const transform = new TransformStream();