Implement the client side of Serial I/O on data pipe.

extensions/renderer/api/serial/serial_api_unittest.cc

Index: extensions/renderer/api/serial/serial_api_unittest.cc
diff --git a/extensions/renderer/api/serial/serial_api_unittest.cc b/extensions/renderer/api/serial/serial_api_unittest.cc
index 14e3156bfad8a39f2439094470b00e2d1f5fa014..5578ee3b08327ead22011662ff3ff182430aad60 100644
--- a/extensions/renderer/api/serial/serial_api_unittest.cc
+++ b/extensions/renderer/api/serial/serial_api_unittest.cc
@@ -298,6 +298,69 @@ class FailToGetInfoTestIoHandler : public TestIoHandlerBase {
   DISALLOW_COPY_AND_ASSIGN(FailToGetInfoTestIoHandler);
 };
 
+class SendErrorTestIoHandler : public TestIoHandlerBase {
+ public:
+  explicit SendErrorTestIoHandler(device::serial::SendError error)
+      : error_(error) {}
+
+  virtual void WriteImpl() OVERRIDE { QueueWriteCompleted(0, error_); }
+
+ private:
+  virtual ~SendErrorTestIoHandler() {}
+
+  device::serial::SendError error_;
+
+  DISALLOW_COPY_AND_ASSIGN(SendErrorTestIoHandler);
+};
+
+class ReceiveErrorTestIoHandler : public TestIoHandlerBase {
+ public:
+  explicit ReceiveErrorTestIoHandler(device::serial::ReceiveError error)
+      : error_(error) {}
+
+  virtual void ReadImpl() OVERRIDE { QueueReadCompleted(0, error_); }
+
+ private:
+  virtual ~ReceiveErrorTestIoHandler() {}
+
+  device::serial::ReceiveError error_;
+
+  DISALLOW_COPY_AND_ASSIGN(ReceiveErrorTestIoHandler);
+};
+
+class SendDataWithErrorIoHandler : public TestIoHandlerBase {
+ public:
+  SendDataWithErrorIoHandler() : sent_error_(false) {}
+  virtual void WriteImpl() OVERRIDE {
+    if (sent_error_) {
+      WriteCompleted(pending_write_buffer_len(),
+                     device::serial::SEND_ERROR_NONE);
+      return;
+    }
+    sent_error_ = true;
+    DCHECK_GE(pending_write_buffer_len(), 2u);

[raymes, 2014/08/29 06:07:15]

Why can you make this assumption? A comment would be helpful here.

[Sam McNally, 2014/09/01 06:35:17]

Done.

+    WriteCompleted(2, device::serial::SEND_ERROR_SYSTEM_ERROR);
+  }
+
+ private:
+  virtual ~SendDataWithErrorIoHandler() {}
+
+  bool sent_error_;
+
+  DISALLOW_COPY_AND_ASSIGN(SendDataWithErrorIoHandler);
+};
+
+class BlockSendsForeverSendIoHandler : public TestIoHandlerBase {
+ public:
+  BlockSendsForeverSendIoHandler() {}
+  virtual void WriteImpl() OVERRIDE {}
+
+ private:
+  virtual ~BlockSendsForeverSendIoHandler() {}
+
+  DISALLOW_COPY_AND_ASSIGN(BlockSendsForeverSendIoHandler);
+};
+
 }  // namespace
 
 class SerialApiTest : public ApiTestBase {
@@ -306,6 +369,9 @@ class SerialApiTest : public ApiTestBase {
 
   virtual void SetUp() OVERRIDE {
     ApiTestBase::SetUp();
+    env()->RegisterModule("async_waiter", IDR_ASYNC_WAITER_JS);
+    env()->RegisterModule("data_receiver", IDR_DATA_RECEIVER_JS);
+    env()->RegisterModule("data_sender", IDR_DATA_SENDER_JS);
     env()->RegisterModule("serial", IDR_SERIAL_CUSTOM_BINDINGS_JS);
     env()->RegisterModule("serial_service", IDR_SERIAL_SERVICE_JS);
     env()->RegisterModule("device/serial/data_stream.mojom",
@@ -418,6 +484,88 @@ TEST_F(SerialApiTest, SetPaused) {
   RunTest("serial_unittest.js", "testSetPaused");
 }
 
+TEST_F(SerialApiTest, Echo) {
+  RunTest("serial_unittest.js", "testEcho");
+}
+
+TEST_F(SerialApiTest, PausedEcho) {
+  RunTest("serial_unittest.js", "testPausedEcho");
+}
+
+TEST_F(SerialApiTest, PausedReceiveError) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST);
+  RunTest("serial_unittest.js", "testPausedReceiveError");
+}
+
+TEST_F(SerialApiTest, SendPartialSuccessWithError) {
+  io_handler_ = new SendDataWithErrorIoHandler();
+  RunTest("serial_unittest.js", "testSendPartialSuccessWithError");
+}
+
+TEST_F(SerialApiTest, SendTimeout) {
+  io_handler_ = new BlockSendsForeverSendIoHandler();
+  RunTest("serial_unittest.js", "testSendTimeout");
+}
+
+TEST_F(SerialApiTest, DisableSendTimeout) {
+  io_handler_ = new BlockSendsForeverSendIoHandler();
+  RunTest("serial_unittest.js", "testDisableSendTimeout");
+}
+
+TEST_F(SerialApiTest, LargeSend) {
+  RunTest("serial_unittest.js", "testLargeSend");
+}
+
+TEST_F(SerialApiTest, ReceiveTimeout) {
+  RunTest("serial_unittest.js", "testReceiveTimeout");
+}
+
+TEST_F(SerialApiTest, DisableReceiveTimeout) {
+  RunTest("serial_unittest.js", "testDisableReceiveTimeout");
+}
+
+TEST_F(SerialApiTest, ReceiveErrorDisconnected) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DISCONNECTED);
+  RunTest("serial_unittest.js", "testReceiveErrorDisconnected");
+}
+
+TEST_F(SerialApiTest, ReceiveErrorTimeout) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_TIMEOUT);
+  RunTest("serial_unittest.js", "testReceiveErrorTimeout");
+}
+
+TEST_F(SerialApiTest, ReceiveErrorDeviceLost) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST);
+  RunTest("serial_unittest.js", "testReceiveErrorDeviceLost");
+}
+
+TEST_F(SerialApiTest, ReceiveErrorSystemError) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_SYSTEM_ERROR);
+  RunTest("serial_unittest.js", "testReceiveErrorSystemError");
+}
+
+TEST_F(SerialApiTest, SendErrorDisconnected) {
+  io_handler_ =
+      new SendErrorTestIoHandler(device::serial::SEND_ERROR_DISCONNECTED);
+  RunTest("serial_unittest.js", "testSendErrorDisconnected");
+}
+
+TEST_F(SerialApiTest, SendErrorTimeout) {
+  io_handler_ = new SendErrorTestIoHandler(device::serial::SEND_ERROR_TIMEOUT);
+  RunTest("serial_unittest.js", "testSendErrorTimeout");
+}
+
+TEST_F(SerialApiTest, SendErrorSystemError) {
+  io_handler_ =
+      new SendErrorTestIoHandler(device::serial::SEND_ERROR_SYSTEM_ERROR);
+  RunTest("serial_unittest.js", "testSendErrorSystemError");
+}
+
 TEST_F(SerialApiTest, DisconnectUnknownConnectionId) {
   RunTest("serial_unittest.js", "testDisconnectUnknownConnectionId");
 }
@@ -446,4 +594,8 @@ TEST_F(SerialApiTest, SetPausedUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSetPausedUnknownConnectionId");
 }
 
+TEST_F(SerialApiTest, SendUnknownConnectionId) {
+  RunTest("serial_unittest.js", "testSendUnknownConnectionId");
+}
+
 }  // namespace extensions