Change data pipe wrappers used by SerialConnection to use message pipe.

device/serial/data_stream.mojom

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 module device.serial {
 
 [Client=DataSourceClient]
 interface DataSource {
-  // Initializes this DataSource with a data pipe handle to use for data
-  // transmission.
-  Init(handle<data_pipe_producer> producer_handle);
+  // Initializes this DataSource with the amount of data its client will
+  // buffer.
+  Init(uint32 buffer_size);
 
   // Resumes sending data after it has been stopped due to an error.
   Resume();
+
+  AckData(uint32 bytes_received);

[raymes, 2014/10/17 02:11:09]

Please add a comment here. Does it make more sense to have this as a callback on
OnData?

[raymes, 2014/10/17 04:04:45]

Also should we name this consistently with ReportBytesSent(uint32 bytes_sent)?

[Sam McNally, 2014/10/20 05:12:59]

It does, but there could be a stash before the response would be sent.

[Sam McNally, 2014/10/20 05:12:59]

Done.

 };
 
 interface DataSourceClient {
-  // Invoked to report |error| from the DataSource, at |error_location| bytes
-  // into the data stream. No further bytes beyond |error_location| will be
+  // Invoked to report |error| from the DataSource. No further bytes will be
   // transmitted from the DataSource until Resume() is called.
-  OnError(uint32 error_location, int32 error);
+  OnError(int32 error);
+
+  // Invoked to transmit data from the DataSource.
+  OnData(array<uint8> data);
 };
 
 [Client=DataSinkClient]
 interface DataSink {
-  // Initializes this DataSink with a data pipe handle to use for data
-  // transmission.
-  Init(handle<data_pipe_consumer> consumer_handle);
+  // Initializes this DataSink with the amount of data it is expected to
+  // buffer.
+  Init(uint32 buffer_size);
 
   // Requests the cancellation of any data that has been written to the pipe,
   // but has not yet been sent to the sink.
   Cancel(int32 error);
+
+  // Invoked to pass |data| to the sink.
+  AcceptData(array<uint8> data);

[raymes, 2014/10/17 02:11:10]

nit, optional: should we name this consistently with DataSourceClient::OnData. I
realize you named them differently on purpose but both serve a similar purpose. 

[Sam McNally, 2014/10/20 05:12:59]

Done.

 };
 
 interface DataSinkClient {
   // Reports that the sink has successfully received |bytes_sent| bytes of data.
   ReportBytesSent(uint32 bytes_sent);
 
   // Reports that the sink has received |bytes_sent| bytes of data (possibly 0)
   // and encountered an error: |error|. The client should respond with
   // |bytes_to_flush|, the number of bytes enqueued in the data pipe but not yet

[raymes, 2014/10/17 02:11:10]

This comment is out of date now. I'm curious why is it still useful to receive
the callback?

[raymes, 2014/10/17 03:16:24]

I guess the callback basically ensures that all the sends in the pipe have been
transmitted before it is received and that the DataSender isn't going to send
anymore. Is that correct?

[Sam McNally, 2014/10/20 05:12:59]

The sends in the pipeline are all cancelled. Otherwise, you're correct. It
ensures the sink knows which OnData messages were sent before the error and
which were after.

   // acked so the correct number of bytes can be flushed from the pipe.
-  ReportBytesSentAndError(uint32 bytes_sent, int32 error) => (uint32 bytes_to_flush);
+  ReportBytesSentAndError(uint32 bytes_sent, int32 error) => ();
 };
 
 }