Add serial bulk reads.

chrome/browser/extensions/api/serial/serial_api.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/extensions/api/serial/serial_api.h"
 
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/api/serial/serial_connection.h"
 #include "chrome/browser/extensions/api/serial/serial_port_enumerator.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 
 const char kConnectionIdKey[] = "connectionId";
 const char kPortsKey[] = "ports";
 const char kDataKey[] = "data";
 const char kBytesReadKey[] = "bytesRead";
+const char kBytesToReadKey[] = "bytesToRead";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kBitrateKey[] = "bitrate";
 const char kOptionsKey[] = "options";
 const char kSuccessKey[] = "success";
 const char kDtrKey[] = "dtr";
 const char kRtsKey[] = "rts";
 const char kDcdKey[] = "dcd";
 const char kCtsKey[] = "cts";
 
 const char kErrorGetControlSignalsFailed[] = "Failed to get control signals.";
 const char kErrorSetControlSignalsFailed[] = "Failed to set control signals.";
+const char kSerialReadInvalidBytesToRead[] = "Number of bytes to read must "
+    "be a positive number.";
 
 SerialAsyncApiFunction::SerialAsyncApiFunction()
     : manager_(NULL) {
 }
 
 SerialAsyncApiFunction::~SerialAsyncApiFunction() {
 }
 
 bool SerialAsyncApiFunction::PrePrepare() {
   manager_ = ExtensionSystem::Get(profile())->serial_connection_manager();
@@ skipping 147 matching lines @@
 }
 
 SerialReadFunction::~SerialReadFunction() {
 }
 
 bool SerialReadFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::experimental_serial::Read::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
+  if (params_->bytes_to_read <= 0) {
+    error_ = kSerialReadInvalidBytesToRead;
+    return false;
+  }
 
   return true;
 }
 
 void SerialReadFunction::Work() {
-  uint8 byte = '\0';
   int bytes_read = -1;
-  SerialConnection* serial_connection = manager_->Get(params_->connection_id);
+  scoped_refptr<net::IOBufferWithSize> io_buffer(
+      new net::IOBufferWithSize(params_->bytes_to_read));

[asargent_no_longer_on_chrome, 2012/08/02 19:58:07]

nit: does IOBufferWithSize already properly handle the case of being passed an
absurdly large number of bytes? If not we should impose some reasonable upper
limit (a megabyte maybe?)

+  SerialConnection* serial_connection(manager_->Get(params_->connection_id));
+
   if (serial_connection)
-    bytes_read = serial_connection->Read(&byte);
+    bytes_read = serial_connection->Read(io_buffer);
 
   DictionaryValue* result = new DictionaryValue();
 
   // The API is defined to require a 'data' value, so we will always
   // create a BinaryValue, even if it's zero-length.
   if (bytes_read < 0)
     bytes_read = 0;
   result->SetInteger(kBytesReadKey, bytes_read);
   result->Set(kDataKey, base::BinaryValue::CreateWithCopiedBuffer(
-      reinterpret_cast<char*>(&byte), bytes_read));
+      io_buffer->data(), bytes_read));
   SetResult(result);
 }
 
 bool SerialReadFunction::Respond() {
   return true;
 }
 
 SerialWriteFunction::SerialWriteFunction()
     : io_buffer_(NULL), io_buffer_size_(0) {
 }
@@ skipping 136 matching lines @@
     error_ = kSerialConnectionNotFoundError;
     SetResult(Value::CreateBooleanValue(false));
   }
 }
 
 bool SerialSetControlSignalsFunction::Respond() {
   return true;
 }
 
 }  // namespace extensions