Makes the BattOrConnection read messages instead of bytes

tools/battor_agent/battor_agent_unittest.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_agent.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 32 matching lines @@
   MockBattOrConnection(BattOrConnection::Listener* listener)
       : BattOrConnection(listener) {}
   ~MockBattOrConnection() override {}
 
   MOCK_METHOD0(Open, void());
   MOCK_METHOD0(Close, void());
   MOCK_METHOD3(SendBytes,
                void(BattOrMessageType type,
                     const void* buffer,
                     size_t bytes_to_send));
-  MOCK_METHOD1(ReadBytes, void(size_t bytes_to_read));
+  MOCK_METHOD1(ReadMessage, void(size_t bytes_to_read));
   MOCK_METHOD0(Flush, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBattOrConnection);
 };
 
 }  // namespace
 
 // TestableBattOrAgent uses a fake BattOrConnection to be testable.
 class TestableBattOrAgent : public BattOrAgent {
@@ skipping 57 matching lines @@
 
     if (end_state == BattOrAgentState::RESET_SENT)
       return;
 
     GetAgent()->OnBytesSent(true);
     GetTaskRunner()->RunUntilIdle();
 
     if (end_state == BattOrAgentState::INIT_SENT)
       return;
 
-    GetAgent()->OnBytesRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
-                            AckToCharVector(kInitAck));
+    GetAgent()->OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                              AckToCharVector(kInitAck));
     GetTaskRunner()->RunUntilIdle();
 
     if (end_state == BattOrAgentState::INIT_ACKED)
       return;
 
     GetAgent()->OnBytesSent(true);
     GetTaskRunner()->RunUntilIdle();
 
     if (end_state == BattOrAgentState::SET_GAIN_SENT)
       return;
 
-    GetAgent()->OnBytesRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
-                            AckToCharVector(kSetGainAck));
+    GetAgent()->OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                              AckToCharVector(kSetGainAck));
     GetTaskRunner()->RunUntilIdle();
 
     if (end_state == BattOrAgentState::GAIN_ACKED)
       return;
 
     GetAgent()->OnBytesSent(true);
     GetTaskRunner()->RunUntilIdle();
 
     if (end_state == BattOrAgentState::START_TRACING_SENT)
       return;
 
     // Make sure that we're actually forwarding to a state in the start tracing
     // state machine.
     DCHECK(end_state == BattOrAgentState::START_TRACING_COMPLETE);
 
-    GetAgent()->OnBytesRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
-                            AckToCharVector(kStartTracingAck));
+    GetAgent()->OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                              AckToCharVector(kStartTracingAck));
     GetTaskRunner()->RunUntilIdle();
   }
 
   TestableBattOrAgent* GetAgent() { return agent_.get(); }
 
   scoped_refptr<base::TestSimpleTaskRunner> GetTaskRunner() {
     return task_runner_;
   }
 
   BattOrError GetStartTracingError() { return start_tracing_error_; }
@@ skipping 21 matching lines @@
       SendBytes(BATTOR_MESSAGE_TYPE_CONTROL,
                 BufferEq(&reset_msg, sizeof(reset_msg)), sizeof(reset_msg)));
 
   EXPECT_CALL(*GetAgent()->GetConnection(), Flush());
   BattOrControlMessage init_msg{BATTOR_CONTROL_MESSAGE_TYPE_INIT, 0, 0};
   EXPECT_CALL(
       *GetAgent()->GetConnection(),
       SendBytes(BATTOR_MESSAGE_TYPE_CONTROL,
                 BufferEq(&init_msg, sizeof(init_msg)), sizeof(init_msg)));
 
-  EXPECT_CALL(*GetAgent()->GetConnection(), ReadBytes(sizeof(kInitAck)));
+  EXPECT_CALL(*GetAgent()->GetConnection(), ReadMessage(sizeof(kInitAck)));
 
   BattOrControlMessage set_gain_msg{BATTOR_CONTROL_MESSAGE_TYPE_SET_GAIN,
                                     BATTOR_GAIN_LOW, 0};
   EXPECT_CALL(*GetAgent()->GetConnection(),
               SendBytes(BATTOR_MESSAGE_TYPE_CONTROL,
                         BufferEq(&set_gain_msg, sizeof(set_gain_msg)),
                         sizeof(set_gain_msg)));
 
-  EXPECT_CALL(*GetAgent()->GetConnection(), ReadBytes(sizeof(kSetGainAck)));
+  EXPECT_CALL(*GetAgent()->GetConnection(), ReadMessage(sizeof(kSetGainAck)));
 
   BattOrControlMessage start_tracing_msg{
       BATTOR_CONTROL_MESSAGE_TYPE_START_SAMPLING_SD, 0, 0};
   EXPECT_CALL(*GetAgent()->GetConnection(),
               SendBytes(BATTOR_MESSAGE_TYPE_CONTROL,
                         BufferEq(&start_tracing_msg, sizeof(start_tracing_msg)),
                         sizeof(start_tracing_msg)));
 
   EXPECT_CALL(*GetAgent()->GetConnection(),
-              ReadBytes(sizeof(kStartTracingAck)));
+              ReadMessage(sizeof(kStartTracingAck)));
 
   RunStartTracingTo(BattOrAgentState::START_TRACING_COMPLETE);
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_NONE, GetStartTracingError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsWithoutConnection) {
   GetAgent()->StartTracing();
   GetTaskRunner()->RunUntilIdle();
 
@@ skipping 17 matching lines @@
   RunStartTracingTo(BattOrAgentState::RESET_SENT);
   GetAgent()->OnBytesSent(false);
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_SEND_ERROR, GetStartTracingError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfInitAckReadFails) {
   RunStartTracingTo(BattOrAgentState::INIT_SENT);
-  GetAgent()->OnBytesRead(false, BATTOR_MESSAGE_TYPE_CONTROL_ACK, nullptr);
+  GetAgent()->OnMessageRead(false, BATTOR_MESSAGE_TYPE_CONTROL_ACK, nullptr);
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_RECEIVE_ERROR, GetStartTracingError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfInitWrongAckRead) {
   RunStartTracingTo(BattOrAgentState::INIT_SENT);
-  GetAgent()->OnBytesRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
-                          AckToCharVector(kStartTracingAck));
+  GetAgent()->OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                            AckToCharVector(kStartTracingAck));
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_UNEXPECTED_MESSAGE, GetStartTracingError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfSetGainSendFails) {
   RunStartTracingTo(BattOrAgentState::RESET_SENT);
   GetAgent()->OnBytesSent(false);
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_SEND_ERROR, GetStartTracingError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfSetGainAckReadFails) {
   RunStartTracingTo(BattOrAgentState::SET_GAIN_SENT);
-  GetAgent()->OnBytesRead(false, BATTOR_MESSAGE_TYPE_CONTROL_ACK, nullptr);
+  GetAgent()->OnMessageRead(false, BATTOR_MESSAGE_TYPE_CONTROL_ACK, nullptr);
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_RECEIVE_ERROR, GetStartTracingError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfSetGainWrongAckRead) {
   RunStartTracingTo(BattOrAgentState::SET_GAIN_SENT);
-  GetAgent()->OnBytesRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
-                          AckToCharVector(kStartTracingAck));
+  GetAgent()->OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                            AckToCharVector(kStartTracingAck));
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_UNEXPECTED_MESSAGE, GetStartTracingError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfStartTracingSendFails) {
   RunStartTracingTo(BattOrAgentState::RESET_SENT);
   GetAgent()->OnBytesSent(false);
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_SEND_ERROR, GetStartTracingError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfStartTracingAckReadFails) {
   RunStartTracingTo(BattOrAgentState::START_TRACING_SENT);
-  GetAgent()->OnBytesRead(false, BATTOR_MESSAGE_TYPE_CONTROL_ACK, nullptr);
+  GetAgent()->OnMessageRead(false, BATTOR_MESSAGE_TYPE_CONTROL_ACK, nullptr);
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_RECEIVE_ERROR, GetStartTracingError());
 }
 
 TEST_F(BattOrAgentTest, StartTracingFailsIfStartTracingWrongAckRead) {
   RunStartTracingTo(BattOrAgentState::START_TRACING_SENT);
-  GetAgent()->OnBytesRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
-                          AckToCharVector(kInitAck));
+  GetAgent()->OnMessageRead(true, BATTOR_MESSAGE_TYPE_CONTROL_ACK,
+                            AckToCharVector(kInitAck));
   GetTaskRunner()->RunUntilIdle();
 
   EXPECT_TRUE(IsStartTracingComplete());
   EXPECT_EQ(BATTOR_ERROR_UNEXPECTED_MESSAGE, GetStartTracingError());
 }
 
 }  // namespace battor