[battor agent] Add 'read more bytes' logic in the BattOr connection

tools/battor_agent/battor_connection_impl.cc

 // Copyright 2015 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 "tools/battor_agent/battor_connection_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 130 matching lines @@
   data.push_back(BATTOR_CONTROL_BYTE_END);
 
   LogSerial(StringPrintf("Bytes sent: %s.", CharVectorToString(data).c_str()));
 
   pending_write_length_ = data.size();
   io_handler_->Write(base::WrapUnique(new device::SendBuffer(
       data, base::Bind(&BattOrConnectionImpl::OnBytesSent, AsWeakPtr()))));
 }
 
 void BattOrConnectionImpl::ReadMessage(BattOrMessageType type) {
+  LogSerial("Read requested.");
+
   pending_read_message_type_ = type;
-  size_t max_bytes_to_read = GetMaxBytesForMessageType(type);
+  size_t message_max_bytes = GetMaxBytesForMessageType(type);
 
-  // Check the left-over bytes from the last read to make sure that we don't
-  // already have a full message.
+  LogSerial(
+      "Before doing a serial read, checking to see if we already have a "
+      "complete message in the 'already read' buffer.");
+
   BattOrMessageType parsed_type;
   std::unique_ptr<vector<char>> bytes(new vector<char>());
-  bytes->reserve(max_bytes_to_read);
-
-  LogSerial("Checking if a complete message is in the 'already read' buffer.");
-  if (ParseMessage(&parsed_type, bytes.get())) {
+  bytes->reserve(message_max_bytes);
+  ParseMessageError parse_message_error =
+      ParseMessage(&parsed_type, bytes.get());
+  if (parse_message_error == ParseMessageError::NONE) {
     LogSerial("Complete message found.");
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(&Listener::OnMessageRead, base::Unretained(listener_), true,
-                   parsed_type, base::Passed(std::move(bytes))));
+    EndReadBytes(true, parsed_type, std::move(bytes));
     return;
   }
 
-  LogSerial("No complete message found.");
-  BeginReadBytes(max_bytes_to_read - already_read_buffer_.size());
+  if (parse_message_error != ParseMessageError::NOT_ENOUGH_BYTES) {
+    LogSerial(StringPrintf(
+        "Read failed because, before performing a serial read, the message in "
+        "the 'already read' buffer had an irrecoverable error with code: %d.",
+        parse_message_error));
+    EndReadBytes(false, BATTOR_MESSAGE_TYPE_CONTROL, nullptr);
+    return;
+  }
+
+  LogSerial("No complete message found in the 'already read' buffer.");
+  BeginReadBytes(message_max_bytes - already_read_buffer_.size());
 }
 
 void BattOrConnectionImpl::Flush() {
   io_handler_->Flush();
   already_read_buffer_.clear();
 }
 
 scoped_refptr<device::SerialIoHandler> BattOrConnectionImpl::CreateIoHandler() {
   return device::SerialIoHandler::Create(file_thread_task_runner_,
                                          ui_thread_task_runner_);
@@ skipping 10 matching lines @@
       base::Bind(&BattOrConnectionImpl::OnBytesRead, AsWeakPtr());
 
   io_handler_->Read(base::WrapUnique(new device::ReceiveBuffer(
       pending_read_buffer_, static_cast<uint32_t>(max_bytes_to_read),
       on_receive_buffer_filled)));
 }
 
 void BattOrConnectionImpl::OnBytesRead(int bytes_read,
                                        device::serial::ReceiveError error) {
   if (error != device::serial::ReceiveError::NONE) {
-    LogSerial(StringPrintf("Read failed with error code: %d.",
-                           static_cast<int>(error)));
+    LogSerial(StringPrintf(
+        "Read failed due to serial read failure with error code: %d.",
+        static_cast<int>(error)));
     EndReadBytes(false, BATTOR_MESSAGE_TYPE_CONTROL, nullptr);
     return;
   }
 
   if (bytes_read == 0) {
     // If we didn't have a message before, and we weren't able to read any
     // additional bytes, then there's no valid message available.
     LogSerial("Read failed due to no bytes being read.");
     EndReadBytes(false, BATTOR_MESSAGE_TYPE_CONTROL, nullptr);
     return;
   }
 
   LogSerial(StringPrintf(
       "%d more bytes read: %s.", bytes_read,
       CharArrayToString(pending_read_buffer_->data(), bytes_read).c_str()));
 
   already_read_buffer_.insert(already_read_buffer_.end(),
                               pending_read_buffer_->data(),
                               pending_read_buffer_->data() + bytes_read);
 
   BattOrMessageType type;
+  size_t message_max_bytes =
+      GetMaxBytesForMessageType(pending_read_message_type_);
   std::unique_ptr<vector<char>> bytes(new vector<char>());
-  bytes->reserve(GetMaxBytesForMessageType(pending_read_message_type_));
+  bytes->reserve(message_max_bytes);
 
-  if (!ParseMessage(&type, bytes.get())) {
-    LogSerial(
-        "Read failed due to having no complete message after max read length.");
+  ParseMessageError parse_message_error = ParseMessage(&type, bytes.get());
+  if (parse_message_error == ParseMessageError::NOT_ENOUGH_BYTES) {
+    if (already_read_buffer_.size() >= message_max_bytes) {
+      LogSerial(
+          "Read failed due to no complete message after max read length.");
+      EndReadBytes(false, BATTOR_MESSAGE_TYPE_CONTROL, nullptr);
+      return;
+    }
+
+    LogSerial("(Message still incomplete: reading more bytes.)");
+    BeginReadBytes(message_max_bytes - already_read_buffer_.size());
+    return;
+  }
+
+  if (parse_message_error != ParseMessageError::NONE) {
+    LogSerial(StringPrintf(
+        "Read failed due to the message containing an irrecoverable error: %d.",
+        parse_message_error));
     EndReadBytes(false, BATTOR_MESSAGE_TYPE_CONTROL, nullptr);
     return;
   }
 
   if (type != pending_read_message_type_) {
     LogSerial("Read failed due to receiving a message of the wrong type.");
     EndReadBytes(false, BATTOR_MESSAGE_TYPE_CONTROL, nullptr);
     return;
   }
 
   EndReadBytes(true, type, std::move(bytes));
 }
 
 void BattOrConnectionImpl::EndReadBytes(bool success,
                                         BattOrMessageType type,
                                         std::unique_ptr<vector<char>> bytes) {
   LogSerial(StringPrintf("Read finished with success: %d.", success));
 
   pending_read_buffer_ = nullptr;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&Listener::OnMessageRead, base::Unretained(listener_), success,
                  type, base::Passed(std::move(bytes))));
 }
 
-bool BattOrConnectionImpl::ParseMessage(BattOrMessageType* type,
-                                        vector<char>* bytes) {
+BattOrConnectionImpl::ParseMessageError BattOrConnectionImpl::ParseMessage(
+    BattOrMessageType* type,
+    vector<char>* bytes) {
   if (already_read_buffer_.size() <= 3)
-    return false;
+    return ParseMessageError::NOT_ENOUGH_BYTES;
 
   // The first byte is the start byte.
-  if (already_read_buffer_[0] != BATTOR_CONTROL_BYTE_START) {
-    return false;
-  }
+  if (already_read_buffer_[0] != BATTOR_CONTROL_BYTE_START)
+    return ParseMessageError::MISSING_START_BYTE;
 
   // The second byte specifies the message type.
   *type = static_cast<BattOrMessageType>(already_read_buffer_[1]);
 
   if (*type < static_cast<uint8_t>(BATTOR_MESSAGE_TYPE_CONTROL) ||
-      *type > static_cast<uint8_t>(BATTOR_MESSAGE_TYPE_PRINT)) {
-    return false;
-  }
+      *type > static_cast<uint8_t>(BATTOR_MESSAGE_TYPE_PRINT))
+    return ParseMessageError::INVALID_MESSAGE_TYPE;
 
   // After that comes the message bytes.
   bool escape_next_byte = false;
   for (size_t i = 2; i < already_read_buffer_.size(); i++) {
     char next_byte = already_read_buffer_[i];
 
     if (escape_next_byte) {
       bytes->push_back(next_byte);
       escape_next_byte = false;
       continue;
     }
 
     switch (next_byte) {
       case BATTOR_CONTROL_BYTE_START:
         // Two start bytes in a message is invalid.
-        return false;
+        return ParseMessageError::TOO_MANY_START_BYTES;
 
       case BATTOR_CONTROL_BYTE_END:
         already_read_buffer_.erase(already_read_buffer_.begin(),
                                    already_read_buffer_.begin() + i + 1);
-        return true;
+        return ParseMessageError::NONE;
 
       case BATTOR_CONTROL_BYTE_ESCAPE:
         escape_next_byte = true;
         continue;
 
       default:
         bytes->push_back(next_byte);
     }
   }
 
   // If we made it to the end of the read buffer and no end byte was seen, then
   // we don't have a complete message.
-  return false;
+  return ParseMessageError::NOT_ENOUGH_BYTES;
 }
 
 void BattOrConnectionImpl::OnBytesSent(int bytes_sent,
                                        device::serial::SendError error) {
   bool success = (error == device::serial::SendError::NONE) &&
                  (pending_write_length_ == static_cast<size_t>(bytes_sent));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&Listener::OnBytesSent, base::Unretained(listener_), success));
 }
 
 void BattOrConnectionImpl::LogSerial(const std::string& str) {
   serial_log_ << str << std::endl << std::endl;
 }
 
 }  // namespace battor